SpillTimeFinder.cxx

Go to the documentation of this file.

#include "SpillTimeFinder.h"
#include "Conventions/Munits.h"
#include "MessageService/MsgService.h"
#include "DatabaseInterface/DbiSqlContext.h"
#include <cmath>

CVSID( "$Id: SpillTimeFinder.cxx,v 1.35 2008/05/30 18:35:43 tagg Exp $" );

SpillTimeFinder* SpillTimeFinder::fgInstance = 0;

static SpillTimeND kSpillTime_VeryOld(VldTimeStamp(0,0));             // 1970
static SpillTimeND kSpillTime_Future(VldTimeStamp(2147480000,0));    // 2038

SpillTimeFinder& SpillTimeFinder::Instance()
{

  // Cleaner destructor calls DigitSpillTimeFinder dtor
  static Cleaner cleaner;
  
  // SpillTimeFinder mode "1" the default.  This is hardwired for now.
  if (!fgInstance) {
    cleaner.UseMe();
    fgInstance = new SpillTimeFinder();
    if (!fgInstance) {
      MSG("SpillTime", Msg::kError)
        << "No DigitSpillTimeFinder Instance - fatal." << endl;
      assert(fgInstance);               // Kill job is there is no instance
    }
  }
  return *fgInstance;
}


SpillTimeFinder::SpillTimeFinder() :
  fPrevTable(0),
  fNextTable(0),
  fLastQueryPrev(kSpillTime_Future),
  fLastQueryNext(kSpillTime_VeryOld)
{
  Registry r;
  r.Set("Task",3);
  InitializeConfig(r);
}

SpillTimeFinder::~SpillTimeFinder()
{
  if(fPrevTable) delete fPrevTable;
  if(fNextTable) delete fNextTable;
}

void SpillTimeFinder::ResetCache()
{
  fLastQueryPrev=kSpillTime_Future;
  fLastQueryNext=kSpillTime_VeryOld;
}

void SpillTimeFinder::ConfigModified()
{
  bool ok = true;
  ok = ok && GetConfig().Get("Task",fTask);
  if(!ok) MSG("SpillTimeFinder",Msg::kWarning) << "Problem configuring SpillTimeFinder." << endl;  
  ResetCache();
}

Bool_t SpillTimeFinder::DataIsAvailable( const VldContext& context )
{

  // This is the relevant time at the kicker fire $74 MIBS
  VldTimeStamp kickerTime = context.GetTimeStamp();
  Double_t offset = GetOffset(context,fTask);
  kickerTime.Add(-offset); // Move requested time back to get kicker time.

  VldContext kickerContext(Detector::kNear,
                           context.GetSimFlag(),
                           kickerTime);

  // Query on the current context.
  fCurrentTable.NewQuery(kickerContext,fTask);
  
  // <Refresh cache here if any.>


  const DbiValidityRec* myVrec = fCurrentTable.GetValidityRec();
  if ( myVrec->IsGap () ) return false; // No data available
  
  return true;  // Data available.
}



void SpillTimeFinder::FindClosestEntries(const VldContext& context,
                                         const SpillTimeND* &outPrev,
                                         const SpillTimeND* &outNext )
{
  

  if(context.GetSimFlag()==SimFlag::kMC) 
      MSG("SpillTimeFinder",Msg::kError) << "MC context in SpillTimeFinder request. This will all end in tears, I know it..." << endl;

  outPrev = outNext = 0;

  // This is the relevant time at the kicker fire $74 MIBS
  VldTimeStamp kickerTime = context.GetTimeStamp();
  Double_t offset = GetOffset(context,fTask);
  kickerTime.Add(-offset); // Move requested time back to get kicker time.

  VldContext kickerContext(Detector::kNear,
                           context.GetSimFlag(),
                           kickerTime );

  MSG("SpillTimeFinder",Msg::kVerbose) 
    << "STF Query: " << context.AsString() << endl;
  MSG("SpillTimeFinder",Msg::kVerbose) 
    << "Kicker Context: " << kickerContext.AsString() << endl;
  
  
  // Optimization:
  // If this request is in (prev,next) of the last call,
  // the same prev,next results should still apply.
  if(kickerTime < fLastQueryNext.GetTimeStamp()) {
    if(kickerTime > fLastQueryPrev.GetTimeStamp()) {
      // Match! Just give the last results.
      MSG("SpillTimeFinder",Msg::kDebug) << "Using last call's cached result." << endl;
      outPrev = &fLastQueryPrev;
      outNext = &fLastQueryNext;
      MSG("SpillTimeFinder",Msg::kVerbose) << "Result: " << outPrev->GetTimeStamp().AsString() 
                                           << "  " << outNext->GetTimeStamp().AsString() << endl;

      return;
    }     
  }


  // Query on the current context.
  fCurrentTable.NewQuery(kickerContext,fTask);

  // <Refresh cache here if any.>

  MSG("SpillTimeFinder",Msg::kDebug) << "Requested context, got " << fCurrentTable.GetNumRows() << " rows" << endl;  
  // See what rows we can get.
  FindBestRows(fCurrentTable,kickerTime, outPrev, outNext);

  MSG("SpillTimeFinder",Msg::kVerbose) << "First query: Prev = "
                                       << ((outPrev==0)?"<null>":outPrev->GetTimeStamp().AsString())
                                       << "   " 
                                       << ((outNext==0)?"<null>":outNext->GetTimeStamp().AsString())
                                       << endl;



  // Are we done?
  if((outPrev)&&(outNext)) return;


  // Ok, we need to hunt for more info.

  // Default: if we didn't find a table at all, set the search param
  // as the requested param.
  VldTimeStamp curStartVldTime;
  VldTimeStamp curStopVldTime;

  // Get the time limits of the current query.
  const DbiValidityRec* curValidity = fCurrentTable.GetValidityRec();
  if(curValidity) {
    // Use the start and stop times here.
    curStartVldTime = curValidity->GetVldRange().GetTimeStart();
    curStopVldTime = curValidity->GetVldRange().GetTimeEnd();
  } else {
    curStartVldTime = kickerTime;
    curStopVldTime = kickerTime;
  }

  fLastQueryRangeBeg = curStartVldTime; 
  fLastQueryRangeBeg.Add(GetOffset(context,fTask));
  fLastQueryRangeEnd = curStopVldTime;  
  fLastQueryRangeEnd.Add(GetOffset(context,fTask));


  // Did we miss the early side?
  while(outPrev ==0) {
    if(curStartVldTime < VldTimeStamp(1975,0,0,0,0,0)){
      MSG("SpillTimeFinder",Msg::kDebug) << "Hit start of vld range. Hit starting bookend (<1975 AD)" << endl;
      outPrev = &kSpillTime_VeryOld;
      break;
    }
    
    MSG("SpillTimeFinder",Msg::kDebug) << "Hit start of vld range.. looking earlier..." << endl;
    // Look for an earlier table.
    const char* sqltxt = Form("(TIMEEND<='%s') and (TASK=%d) and (DETECTORMASK & %d) and (SIMMASK & %d) order by TIMEEND desc limit 1",
                              curStartVldTime.AsString("s"),
                              fTask,
                              kickerContext.GetDetector(),
                              kickerContext.GetSimFlag() );
    MSG("SpillTimeFinder",Msg::kDebug) << "Request: " << sqltxt << endl;
    
    DbiSqlContext myContext(sqltxt);
    if(fPrevTable) {
      fPrevTable->NewQuery(myContext,Dbi::kAnyTask);
    } else {
      fPrevTable = new DbiResultPtr<SpillTimeND>("SPILLTIMEND",myContext);
    }
    
    if(fPrevTable->GetNumRows()>0) {
      // Found a table with data! Look for the best row..
      MSG("SpillTimeFinder",Msg::kDebug) << "...earlier table gotten. Rows: " << fPrevTable->GetNumRows() << endl;
      const SpillTimeND* n;    
      FindBestRows(*fPrevTable,kickerTime,outPrev,n);
      if(n>0) MSG("SpillTimeFinder",Msg::kError) << "Conflict! Found 'next' time in 'previous' table: " << n->GetTimeStamp().AsString() << endl;    
      
    } else {
      VldTimeStamp nexttry = fPrevTable->GetValidityRec()->GetVldRange().GetTimeStart();
      if(nexttry >= curStartVldTime) nexttry = VldTimeStamp(curStartVldTime.GetSec()-1,0); // protect against infinite loop.
      curStartVldTime = nexttry;
    }
  }
 

  // Did we miss the late side?
  while(outNext ==0) {
    MSG("SpillTimeFinder",Msg::kDebug) << "Hit end of vld range.. looking later..." << endl;
    const char* sqltxt = Form("(TIMESTART>='%s') and (TASK=%d) and (DETECTORMASK & %d) and (SIMMASK & %d) order by TIMESTART asc limit 1",
                              curStopVldTime.AsString("s"),
                              fTask,
                              kickerContext.GetDetector(),
                              kickerContext.GetSimFlag()
                              );
    
    MSG("SpillTimeFinder",Msg::kDebug) << "Request: " << sqltxt << endl;
    
    DbiSqlContext myContext(sqltxt);
    if(fNextTable)
      fNextTable->NewQuery(myContext,Dbi::kAnyTask);
    else 
      fNextTable = new DbiResultPtr<SpillTimeND>("SPILLTIMEND",myContext);
    
    if(fNextTable->GetNumRows()>0) {
      // Got a table with data! Look for the best row:
      MSG("SpillTimeFinder",Msg::kDebug) << "...later table gotten. Rows: " << fNextTable->GetNumRows() << endl;
      const SpillTimeND* p;
      
      FindBestRows(*fNextTable,kickerTime,p,outNext);
      if(p>0) MSG("SpillTimeFinder",Msg::kError) << "Conflict! Found 'previous' time in 'next' table: " << p->GetTimeStamp().AsString() << endl;
      
    } else {
     VldTimeStamp nexttry = fNextTable->GetValidityRec()->GetVldRange().GetTimeStart();
     if(nexttry <= curStopVldTime) nexttry = VldTimeStamp(curStopVldTime.GetSec()+1,0); // protect against infinite loop.
     curStopVldTime = nexttry;
    }
  }

  // Sanity check.
  if(outPrev->GetTimeStamp() > kickerTime) MSG("SpillTimeFinder",Msg::kError) << "Sanity check failed. Prev time is late!";
  if(outNext->GetTimeStamp() < kickerTime) MSG("SpillTimeFinder",Msg::kError) << "Sanity check failed. Next time is early!";

  // Load the cache.
  fLastQueryPrev = *outPrev;
  fLastQueryNext = *outNext;

  MSG("SpillTimeFinder",Msg::kVerbose) << "Result: " << outPrev->GetTimeStamp().AsString() 
                                       << "  " << outNext->GetTimeStamp().AsString() << endl;

}



Double_t SpillTimeFinder::GetOffset(const VldContext& context, Int_t task) 
{

  Double_t offset = 0;
  
  switch(context.GetDetector()) {
  case Detector::kFar:
    offset += GetOffsetNDNuToFDNu(context); //fallthrough
  case Detector::kNear:
    if(task == SpillTimeND::kTask_Vtm) {
      offset += GetOffsetSgateToNDNu(context);
    } else {
      offset += GetOffsetKickerToNDNu(context); // Get offset from kicker to ND
    }
    break;
  default:
    break;    
  }
  return offset;
}

Double_t SpillTimeFinder::GetOffsetNDNuToFDNu(const VldContext& cx) 
{
  // paper, DocDB 1870.
  
  // A note on signs:
  // A positive offset indicates the event will appear to be later at the FD
  // A negative offset indicates the event will appear to be earlier
  // Things that make the ND clock run slow will give a positive offset
  // Things that make the FD clock run slow will give a negative offset

  // New version - May 2008. Get offset calibration from DB, if available
  
  double offset = 0;
  fCalibrationNDNuToFDNu.NewQuery(cx,0);
  if(fCalibrationNDNuToFDNu.GetNumRows()>0) {
    static int sCall = 0;
    if(sCall==0) MSG("SpillTimeFinder",Msg::kInfo) << "Initial Spill Timing Calibration constants (NDNuToFDNu):" << endl;
    for(unsigned int i = 0; i<fCalibrationNDNuToFDNu.GetNumRows(); i++) {
      if(sCall==0) MSG("SpillTimeFinder",Msg::kInfo) 
        << Form("%10.5e",fCalibrationNDNuToFDNu.GetRow(i)->GetOffset())
        << " +- "
        << fCalibrationNDNuToFDNu.GetRow(i)->GetError() 
        << "\t"
        << fCalibrationNDNuToFDNu.GetRow(i)->GetDescription() << endl;

      offset += fCalibrationNDNuToFDNu.GetRow(i)->GetOffset();
    }
    sCall++;
    return offset;
  }
  
  MAXMSG("SpillTimeFinder",Msg::kWarning,1) << "Could not find SPILLTIMECALIBRATION table." << endl;
  MAXMSG("SpillTimeFinder",Msg::kWarning,1) << "Resorting to hard-coded calibration." << endl;

  const VldTimeStamp ndSwitch(2006,7,27,14,40,0,0); // Time Alfons changed ND cable.
  
  // ND-FD time of flight, 734,298.62 meters (Wes Smart), at c
  // Error is 0.7m, or 2.3ns.  
  offset += 2.44935653818215832*Munits::millisecond;

  //--------------------------------------
  // ND latencies

  // ND antenna:
  // OLD: total guess is 300ft, with same prop. speed as FD antenna.
  // This delays counter reset at ND
  // Error is +-60%, or 0.3us. (It's unlikely to be longer than 500ft, or shorter than 200)
  //+0.5*Munits::microsecond 
  // NEW April 5,2006. measurement by Chuck Andrews, reported by Andrew Rader
  // Fibre is in fact 765ft +/- 1% between the upstairs tranciever and U/G DAQ rack.
  // Andy gives the refrativce index as 1.4677 at 1300nm. 
  // Error is is 1%, or 12ns.
  // offset += 1.1415*Munits::microsecond;
  //
  // NEW Dec 6 2006:
  // Measured again with the BOLT. Got a new length
  // of 227.5m. Multiply by 1.470/3e8 s/m (the BOLT conversion constant).
  // So offset =  1.1155us +- 28ns
  // Take difference between measurements as the error: 
  //   1.1415-1.1155 = 0.027us
  offset += 1.1147*Munits::microsecond;
  
  // ND cable run from DAQ racks to GPS reciever:
  if(cx.GetTimeStamp() < ndSwitch) {
    // Cable run from ND tranciever to reciever (DAQ rack to timing rack)
    // Cat J sez: 5 segments of 32ns RG59 unioned together. +/-10% or 16 ns.
    offset += 0.160*Munits::microsecond;
  } else {
    // Alfons: we actually replaced 2m optical patch cable in the beams division crate
    // with a 50m optical patch cable, which leads now to the timing rack.
    // The chain of N x 10' RG58 is still in the cable tray, but not used.
    // Instead, the optical->elect converter is now in the timing rack and
    // connected with a (2+/-0.5) m RG58 to the GPS receiver    
    offset += 6.7*Munits::nanosecond // 2m electrical cable
      +0.2446*Munits::microsecond; // 50m optical cable
    // Another ~5ns of error here.
  }
  
  // ND timing system latency, MCC to MTM
  // But, it takes finite time to propagate CNTRST to the front end.
  // Tom Fitzpatrick measured this too (email 23/05/05) as being 450ns
  // Take reasonable error as +-50ns
  offset += 0.450*Munits::microsecond;

  // ND timing system latency, MINDER
  // The timing signals from the PMT to the timestamper is
  // finely timed in, so as to be less than 1 bucket. --Dave Reyna
  // Take offset as 10+-10ns
  offset += 10*Munits::nanosecond;

  // CandStrip reconstruction bias.
  // The ND measures the mean time of each strip, not the time of the first digit
  // The time of the first digit is a better estimate (compared to the FD), so correct for this
  // The bias varies as a function of pulse height, but mean bias is 7ns, +- 9ns rms
  offset += -7.0*Munits::nanosecond;
    
  // FD antenna: re-measured by Dave Saranen. Fibre length ~3415ft Email 23/05/05
  //
  // This delays counter reset at FD.
  // Error is on precision of the ping measurment: +-0.1 us
  // offset += -5.1*Munits::microsecond;
  
  // Much better measurement by Alec Habig, using our custom-bought BOLT unit.
  // Email Nov 8, 2006
  // Bolt gave a measurement of 1049m for the antenna run, and uses a group velocity of 
  // n_eff=1.470 and c=3e8
  // Disagreement between Orlando (FNAL) and BOLT measurement in for the
  // multimode fibre between VAX room and rescue room is 4m.  Error on BOLT is claimed to
  // be 2.5m.  Error on Orlando's measurement was 6m. 
  // Use differences in multimode fibre to see the error.
  offset += -5140*Munits::nanosecond;
  
  // FD timing system latency. Measured by using the RawVaTimingMonitorBlock
  // which gives a stable value of 639980381 TDC counts for the PPS fiducial tick.
  // Precision is +-1.5ns, but varies from run to run within ~100 ns.
  // Negative: the FD clock is even slower because of this latency.
  offset += -30.6547*Munits::microsecond;
  
  // New, Sept 2006:FD timing system fiducial cable length.
  // Makes the above measurement just a wee 
  // bit wrong. +-6ns (the rise time of the test pulse).
  // Negative.. it means the fiducial round-trip was even longer than we thought.
  offset += -153.0 * Munits::nanosecond; 

  // New Dec 2006: Average timing constants at the FD are not exactly
  // zero, but have an average offset of -27ns. This makes the events appear to be too early.
  // Error is half the offset, 14ns.
  offset += -27 * Munits::nanosecond;
  
  
  // Differences between ND and FD transceivers and recivers.
  // Difference = 0 +/- 20ns.


  // Detector effects. Total strip half-lenth plus WLS pigtail plus clear fibre readout
  // is 5m@ND and 8m@FD. (Very roughly; depends on the actual centroid of
  // accepted events vertices.) Thus, the events will appear at the FD about
  // 16ns later than events in the ND, due to the optical transit time.
  // Error on this is about 1m, or 5ns.
  offset += 16.0*Munits::nanosecond;


  // PMT transit time difference.
  // Both M16 and M64 have a 10.9ns transit time. Error is 1ns.
  
  
  return offset;
}

Double_t SpillTimeFinder::GetOffsetKickerToNDNu(const VldContext& cx) 
{

  double offset = 0;
  fCalibrationKickerToNDNu.NewQuery(cx,1);
  if(fCalibrationKickerToNDNu.GetNumRows()>0) {
    static int sCall = 0;
    if(sCall==0) MSG("SpillTimeFinder",Msg::kInfo) << "Initial Spill Timing Calibration constants (KickerToNDNu):" << endl;
    for(unsigned int i = 0; i<fCalibrationKickerToNDNu.GetNumRows(); i++) {
      if(sCall==0) MSG("SpillTimeFinder",Msg::kInfo) 
        << Form("%10.5e",fCalibrationKickerToNDNu.GetRow(i)->GetOffset())
        << " +- "
        << fCalibrationKickerToNDNu.GetRow(i)->GetError() 
        << "\t"
        << fCalibrationKickerToNDNu.GetRow(i)->GetDescription() << endl;

      offset += fCalibrationKickerToNDNu.GetRow(i)->GetOffset();
    }
    sCall++;
    return offset;
  }


  const double kOffset = 
    // The following two values are taken directly from the 
    // TimeMaster control settings: SgateDelayRevs and SgateDelayFine:
    +19*11.064*Munits::microsecond // $74 MIBS until actual kicker fire, in MI turns
    +6.2*Munits::microsecond       // Fine tuning of SGATE window to $74

    // This tuning gets the first neutrinos at 1.5us into the SGATE
    // so add this on.  Error is +-0.1 us
    //+1.5*Munits::microsecond
    // Fixed 7/6/2006: retune based upon TOF study; move by -2.4 us
    -0.9*Munits::microsecond

    // This delay is not precise, because it does not truely wait an integer
    // number of turns, but rather waits for the NEXT n turns. Therefore, this 
    // delay is actually shorter. Tom Fitzpatrick measured this as being ~1us. (email 23/05/05)
    // Error not known. Estimate worst-case as 100%, or 1.0us
    - 1.0*Munits::microsecond

    // Now we have time between $74 and SGATE at the MCC. 
    // But, it takes finite time to propagate SGATE to the front end.
    // Tom Fitzpatrick measured this too (email 23/05/05) as being 450ns
    // Error is negligable compared to other offsets
    - 0.450*Munits::microsecond

  ;

  return kOffset;
}

Double_t SpillTimeFinder::GetOffsetSgateToNDNu(const VldContext& cx) 
{

  double offset = 0;
  fCalibrationSgateToNDNu.NewQuery(cx,2);
  if(fCalibrationSgateToNDNu.GetNumRows()>0) {
    static int sCall = 0;
    if(sCall==0) MSG("SpillTimeFinder",Msg::kInfo) << "Initial Spill Timing Calibration constants (SgateToNDNu):" << endl;
    for(unsigned int i = 0; i<fCalibrationSgateToNDNu.GetNumRows(); i++) {
      if(sCall==0) MSG("SpillTimeFinder",Msg::kInfo) 
        << Form("%10.5e",fCalibrationSgateToNDNu.GetRow(i)->GetOffset())
        << " +- "
        << fCalibrationSgateToNDNu.GetRow(i)->GetError() 
        << "\t"
        << fCalibrationSgateToNDNu.GetRow(i)->GetDescription() << endl;

      offset += fCalibrationSgateToNDNu.GetRow(i)->GetOffset();
    }
    sCall++;
    return offset;
  }


  // This changes due to changing the fine SGATE delay at the ND.
  // Tuning this doesn' affect the offset above, but only changes
  // when the neutrinos are seen relative to the SGATE window.
   UInt_t sec = cx.GetTimeStamp().GetSec();
  if(sec < 1115450000) {
    return 0.4 * Munits::microsecond; // 400ns into the window, as reported by Peter Shannahan
  } else if(sec < 1115977300) {
    return -0.7 * Munits::microsecond; // A mistuning introduced May 6 by me
  } else {
    return 1.5 * Munits::microsecond; // The final tuning introduced May 12 to give a 1.5us window before the spill.
  }

  
}


 void SpillTimeFinder::FindBestRows(DbiResultPtr<SpillTimeND> &table,
                                   const VldTimeStamp& time, 
                                   const SpillTimeND* &outPrev,
                                   const SpillTimeND* &outNext)
{
  
  //
  outPrev = outNext = 0;

  UInt_t low = 0;
  UInt_t high= table.GetNumRows();

  if(high <= 0) return; // No rows available. (Query must have failed.)

  // Can't depend on table being sorted, so I'll just brute-force the mother.

  double dt;
  double minneg=1e99;
  double minpos=1e99;


  for(UInt_t i=low;i<high;i++) {
    const SpillTimeND* row = table.GetRow(i);
    dt = GetTimeDifference(row->GetTimeStamp(),time);
    if(dt <=0) {
      if( (-dt)<minneg ) {
        minneg = -dt;
        outPrev = row;
      }
    } else {
      if( (dt)<minpos ) {
        minpos = -dt;
        outNext = row;
      }
    }
  }

  // Throw out any solutions that are just plain stupid.
  const VldTimeStamp tooEarly(1975,0,0,0,0,0,0);

  if(outPrev) 
        if(outPrev->GetTimeStamp() < tooEarly) outPrev = 0;
  if(outNext)
        if(outNext->GetTimeStamp() < tooEarly) outNext = 0;
}

Double_t SpillTimeFinder::GetTimeDifference(const VldTimeStamp& a, 
                                            const VldTimeStamp& b)
{
  // Return a-b
  double d1 = a.GetSec() - b.GetSec();
  double d2 = (a.GetNanoSec() - b.GetNanoSec())*1e-9;
  return d1+d2;  
}


// User calls.



const SpillTimeND& SpillTimeFinder::GetRecentSpill(const VldContext& context)
{
  // Return reference to most recent spill record.

  const SpillTimeND* prev;
  const SpillTimeND* next;
  FindClosestEntries(context,prev,next);
  if(prev) return *prev;
  else     return kSpillTime_VeryOld;
}

const SpillTimeND& SpillTimeFinder::GetNextSpill(const VldContext& context)
{
  // Return reference to next spill record.

  const SpillTimeND* prev;
  const SpillTimeND* next;
  FindClosestEntries(context,prev,next);
  if(next) return *next;
  else     return kSpillTime_Future;
}

const SpillTimeND& SpillTimeFinder::GetNearestSpill(const VldContext& context)
{
  // return referenct to prev or next spill record, whichever is closer.

  const SpillTimeND* prev;
  const SpillTimeND* next;
  FindClosestEntries(context,prev,next);

  if((next==0)  && (prev==0)) return kSpillTime_VeryOld;

  if(!prev) return *next;
  if(!next) return *prev;

  double offset = GetOffset(context,fTask);
  VldTimeStamp prevts = prev->GetTimeStamp();
  prevts.Add(offset);
  VldTimeStamp nextts = next->GetTimeStamp();
  nextts.Add(offset);

  double dt1 = GetTimeDifference(prevts,context.GetTimeStamp());
  double dt2 = GetTimeDifference(nextts,context.GetTimeStamp());

  if(fabs(dt1)<=fabs(dt2)) {
    return *prev;
  }
  // else
  return *next; 
}

VldTimeStamp SpillTimeFinder::GetTimeOfRecentSpill(const VldContext& cx)
{
  VldTimeStamp tspill = GetRecentSpill(cx).GetTimeStamp();
  tspill.Add(GetOffset(cx,fTask));
  return tspill;
}

VldTimeStamp SpillTimeFinder::GetTimeOfNextSpill(const VldContext& cx)
{ 
  VldTimeStamp tspill = GetNextSpill(cx).GetTimeStamp();
  tspill.Add(GetOffset(cx,fTask));
  return tspill;
}

VldTimeStamp SpillTimeFinder::GetTimeOfNearestSpill(const VldContext& cx)
{
  VldTimeStamp tspill = GetNearestSpill(cx).GetTimeStamp();
  tspill.Add(GetOffset(cx,fTask));
  return tspill;
}

---