SpillServerMonFinder.cxx

Go to the documentation of this file.

#include "SpillServerMonFinder.h"
#include "MessageService/MsgService.h"
#include "DatabaseInterface/DbiSqlContext.h"
#include <cmath>

ClassImp(SpillServerMonFinder)

CVSID("$Id: SpillServerMonFinder.cxx,v 1.5 2007/08/14 16:48:00 blake Exp $");

static SpillServerMon kDefaultSpillFD_BeginningOfTime(0,0,-1,0,0,0,0,-999,0,0,0);

static SpillServerMon kDefaultSpillFD_EndOfTime(1556150400,0,-1,1556150400,0,1556150400,0,-999,0,0,0);    

SpillServerMonFinder* SpillServerMonFinder::fMyInstance = 0;

SpillServerMonFinder& SpillServerMonFinder::Instance()
{
  MSG("SpillServerMon", Msg::kDebug) << " *** SpillServerMonFinder::Instance() *** " << endl;

  // Cleaner destructor calls SpillServerMonFinder dtor
  static Cleaner cleaner;

  // create singleton instance of spillfinder
  if(!fMyInstance){
    MSG("SpillServerMon", Msg::kDebug) << "  Creating new instance of SpillServerMonFinder " << endl;
    cleaner.UseMe();
    fMyInstance = new SpillServerMonFinder();
  }

  // die if finder hasn't actually been created
  if(!fMyInstance){
    MSG("SpillServerMon", Msg::kFatal) << "  No SpillServerMonFinder Instance - aagghhh, I'm going to die!!!." << endl;
    assert(fMyInstance);
  }

  // can do re-setting here
  if(fMyInstance){

  }
  
  return *fMyInstance;
}  

SpillServerMonFinder::SpillServerMonFinder() :
  fPrevTable(0),
  fNextTable(0),
  fLastQueryPrev(kDefaultSpillFD_EndOfTime),
  fLastQueryNext(kDefaultSpillFD_BeginningOfTime),
  fTask(0)
{
  MSG("SpillServerMon", Msg::kVerbose) << " *** SpillServerMonFinder::SpillServerMonFinder() *** " << endl;
}
  
SpillServerMonFinder::~SpillServerMonFinder()
{
  MSG("SpillServerMon", Msg::kVerbose) << " *** SpillServerMonFinder::~SpillServerMonFinder() *** " << endl;

  if(fPrevTable) delete fPrevTable;
  if(fNextTable) delete fNextTable;
}

Bool_t SpillServerMonFinder::DataIsAvailable(const VldContext& context)
{
  MSG("SpillServerMon", Msg::kDebug) << " *** SpillServerMonFinder::DataIsAvailable(...) *** " << endl;

  // check whether there is a database entry covering this vldcontext  

  fCurrentTable.NewQuery(context,fTask);

  const DbiValidityRec* vldRec = fCurrentTable.GetValidityRec();
  const VldRange& vldRange = vldRec->GetVldRange();
  VldTimeStamp start = vldRange.GetTimeStart();
  VldTimeStamp end = vldRange.GetTimeEnd();

  MSG("SpillServerMon", Msg::kVerbose) << "   timestamp = " << context.GetTimeStamp().GetSec() << endl;  
  MSG("SpillServerMon", Msg::kVerbose) << "   range = " << start.GetSec() << "->" << end.GetSec() << endl;

  if ( vldRec->IsGap () ){
    MSG("SpillServerMon", Msg::kDebug) << "   NO data is available " << endl;
    return false;
  }
  else{
    MSG("SpillServerMon", Msg::kDebug) << "   data is available " << endl;
    return true;
  }
}

const SpillServerMon& SpillServerMonFinder::GetPreviousSpill(const VldContext& context)
{
  MSG("SpillServerMon", Msg::kDebug) << " *** SpillServerMonFinder::GetPreviousSpill(...) *** " << endl;

  const SpillServerMon* prev;
  const SpillServerMon* next;
  this->FindClosestEntries(context,prev,next);
  if(prev) return *prev;

  MSG("SpillServerMon", Msg::kWarning) << " can't find the previous spill, defaulting to the beginning of time! " << endl;
  return kDefaultSpillFD_BeginningOfTime;
}

const SpillServerMon& SpillServerMonFinder::GetNextSpill(const VldContext& context)
{
  MSG("SpillServerMon", Msg::kDebug) << " *** SpillServerMonFinder::GetNextSpill(...) *** " << endl;

  const SpillServerMon* prev;
  const SpillServerMon* next;
  this->FindClosestEntries(context,prev,next);
  if(next) return *next;

  MSG("SpillServerMon", Msg::kWarning) << " can't find the next spill, defaulting to the end of time! " << endl;
  return kDefaultSpillFD_EndOfTime;
}

const SpillServerMon& SpillServerMonFinder::GetNearestSpill(const VldContext& context)
{
  MSG("SpillServerMon", Msg::kDebug) << " *** SpillServerMonFinder::GetNearestSpill(...) *** " << endl;

  const SpillServerMon* prev;
  const SpillServerMon* next;
  this->FindClosestEntries(context,prev,next);

  if(prev && !next){
    MSG("SpillServerMon", Msg::kVerbose) << " no next entry, return previous entry " << endl;
    return *prev;
  }

  if(!prev && next){
    MSG("SpillServerMon", Msg::kVerbose) << " no previous entry, return next entry " << endl;
    return *next;
  }

  double dtNeg=-999.9;
  if(prev) dtNeg = this->GetTimeDifference( prev->GetSpillTime(),
                                            context.GetTimeStamp() );
 
  double dtPos=-999.9;
  if(next) dtPos = this->GetTimeDifference( context.GetTimeStamp(),
                                            next->GetSpillTime() );

  if( dtNeg>=0 && dtPos>=0 ){
    MSG("SpillServerMon", Msg::kVerbose) << " dtNeg=" << dtNeg << " dtPos=" << dtPos << endl;
    if( dtPos<=dtNeg ) return *next; else return *prev;
  }

  MSG("SpillServerMon", Msg::kWarning) << " can't find the nearest spill, moving back to the beginning of time! " << endl;
  return kDefaultSpillFD_BeginningOfTime;
}

Int_t SpillServerMonFinder::GetSpillTimeError(const VldContext& context, Bool_t usewindow, Double_t window)
{
  MSG("SpillServerMon", Msg::kDebug) << " *** SpillServerMonFinder::GetSpillTimeError(...) *** " << endl;

  if( usewindow ){
    // return largest GPS error within a time window
    // only use the previous/next spill (for now)
    Int_t gpserror = -999;
    Double_t gpswindow = window;
    if( gpswindow<5.0 ) gpswindow=5.0;

    const SpillServerMon& prev = this->GetPreviousSpill(context);
    MSG("SpillServerMon", Msg::kVerbose) << "  prev: time=" << prev.GetTimeStamp().GetSec() << ", delta=" << this->GetTimeDifference(context.GetTimeStamp(),prev.GetTimeStamp()) << ", error=" << prev.GetSpillTimeError() << endl;
    if( fabs(this->GetTimeDifference(context.GetTimeStamp(),prev.GetTimeStamp()))<gpswindow ){   
      if( prev.GetSpillTimeError()>gpserror ) gpserror = prev.GetSpillTimeError();
    }

    const SpillServerMon& next = this->GetNextSpill(context);
    MSG("SpillServerMon", Msg::kVerbose) << "  next: time=" << next.GetTimeStamp().GetSec() << ", delta=" << this->GetTimeDifference(context.GetTimeStamp(),next.GetTimeStamp()) << ", error=" << next.GetSpillTimeError() << endl;
    if( fabs(this->GetTimeDifference(context.GetTimeStamp(),next.GetTimeStamp()))<gpswindow ){  
      if( next.GetSpillTimeError()>gpserror ) gpserror = next.GetSpillTimeError();
    }

    return gpserror;
  }

  else{
    // use the nearest spill
    const SpillServerMon& near = this->GetNearestSpill(context);
    return near.GetSpillTimeError();
  }

  return -999;
}

void SpillServerMonFinder::FindClosestEntries(const VldContext& context,const SpillServerMon* &prevEntry,const SpillServerMon* &nextEntry)
{
  MSG("SpillServerMon", Msg::kDebug) << " *** SpillServerMonFinder::FindClosestEntries(...) *** " << endl;

  prevEntry = 0;
  nextEntry = 0;

  VldTimeStamp timestamp = context.GetTimeStamp();

  // can we return the results of the last query?
  if( timestamp >= fLastQueryPrev.GetSpillTime() 
   && timestamp <= fLastQueryNext.GetSpillTime() ){
    MSG("SpillServerMon", Msg::kDebug) << " Returning same results as before... " << endl;
    prevEntry = &fLastQueryPrev;
    nextEntry = &fLastQueryNext;
    return;
  }
  
  // carry out a new search on the current table
  MSG("SpillServerMon", Msg::kDebug) << " Searching the database... " << endl;
  fCurrentTable.NewQuery(context,fTask);
  this->FindClosestEntries(fCurrentTable,timestamp,prevEntry,nextEntry);

  // need to go in search of a previous entry
  if( prevEntry==0 ){   
    MSG("SpillServerMon", Msg::kDebug) << " Need to find a previous entry... " << endl;
    const DbiValidityRec* vldRec = fCurrentTable.GetValidityRec();
    const VldRange& vldRange = vldRec->GetVldRange();
    VldTimeStamp newstarttime(vldRange.GetTimeStart());
    VldTimeStamp starttime(1556150400,0);

    while( prevEntry==0 && newstarttime<starttime){
      MSG("SpillServerMon",Msg::kVerbose) << " No previous entry yet..." << endl;      
      MSG("SpillServerMon",Msg::kVerbose) << "  ... try start time: " << newstarttime.AsString("s") << endl;

      starttime=newstarttime;
      const char* sqltxt = Form("(TIMEEND<='%s') and (TASK=%d) and (DETECTORMASK & %d) and (SIMMASK & %d) order by TIMEEND desc limit 1",
                              starttime.AsString("s"),
                              fTask,
                              context.GetDetector(),
                              context.GetSimFlag() );
      

      DbiSqlContext prevcontext(sqltxt);
      if(fPrevTable) {
        fPrevTable->NewQuery(prevcontext,Dbi::kAnyTask);
      } else {
        fPrevTable = new DbiResultPtr<SpillServerMon>("SPILLSERVERMON",prevcontext);
      }

      const SpillServerMon* temp;
      this->FindClosestEntries(*fPrevTable,timestamp,prevEntry,temp);

      if( prevEntry ){
        MSG("SpillServerMon",Msg::kVerbose) << " Found a previous entry" << endl;
        if( temp ) MSG("SpillServerMon",Msg::kWarning) << " potential conflict... also found a next entry! " << endl;
      }
      else{
        newstarttime = fPrevTable->GetValidityRec()->GetVldRange().GetTimeStart();   
      }
    }

    if( prevEntry==0 ){
      MSG("SpillServerMon", Msg::kWarning) << " can't find the previous entry, defaulting to the beginning of time! " << endl;
      prevEntry = &kDefaultSpillFD_BeginningOfTime;
    }
  }

  // need to go in search of the next entry
  if( nextEntry==0 ){
    MSG("SpillServerMon",Msg::kVerbose) << " Need to find a next entry..." << endl;

    const DbiValidityRec* vldRec = fCurrentTable.GetValidityRec();
    const VldRange& vldRange = vldRec->GetVldRange();
    VldTimeStamp newendtime(vldRange.GetTimeEnd());
    VldTimeStamp endtime(0,0);
  
    while( nextEntry==0 && newendtime>endtime ){
      MSG("SpillServerMon",Msg::kVerbose) << " No next entry yet... " << endl;
      MSG("SpillServerMon",Msg::kVerbose) << "  ...Try end time:" << newendtime.AsString("s") << endl;

      endtime = newendtime;
      const char* sqltxt = Form("(TIMESTART>='%s') and (TASK=%d) and (DETECTORMASK & %d) and (SIMMASK & %d) order by TIMESTART asc limit 1",
                              endtime.AsString("s"),
                              fTask,
                              context.GetDetector(),
                              context.GetSimFlag() );

      DbiSqlContext nextcontext(sqltxt);
      if(fNextTable) {
        fNextTable->NewQuery(nextcontext,Dbi::kAnyTask);
      } else {
        fNextTable = new DbiResultPtr<SpillServerMon>("SPILLSERVERMON",nextcontext);
      }

      const SpillServerMon* temp;
      this->FindClosestEntries(*fNextTable,timestamp,temp,nextEntry);

      if( nextEntry ){
        MSG("SpillServerMon",Msg::kVerbose) << " Found a next entry" << endl;
        if( temp ) MSG("SpillServerMon",Msg::kWarning) << " potential conflict... also found a previous entry! " << endl;
      }
      else{ 
        newendtime = fNextTable->GetValidityRec()->GetVldRange().GetTimeEnd();
      }
    }

    if( nextEntry==0 ){
      MSG("SpillServerMon", Msg::kWarning) << " can't find the next entry, defaulting to the end of time! " << endl;
      nextEntry = &kDefaultSpillFD_EndOfTime;
    }
  }

  // Store the results
  MSG("SpillServerMon",Msg::kVerbose) << " storing the results... " << endl;
  fLastQueryPrev = *prevEntry;
  fLastQueryNext = *nextEntry;

  return;
}

void SpillServerMonFinder::FindClosestEntries(DbiResultPtr<SpillServerMon> &table,const VldTimeStamp& timestamp,const SpillServerMon* &prevEntry,const SpillServerMon* &nextEntry)
{
  MSG("SpillServerMon", Msg::kDebug) << " *** SpillServerMonFinder::FindClosestEntriesInDb(...) *** " << endl;

  // Find the closest entries in the current table
  // or return null if there aren't any entries.
  
  prevEntry = 0;
  nextEntry = 0;

  const DbiValidityRec* vldRec = table.GetValidityRec();

  const VldRange&  vldRange = vldRec->GetVldRange();
  VldTimeStamp start = vldRange.GetTimeStart();
  VldTimeStamp end = vldRange.GetTimeEnd();

  if( table.GetNumRows() <=0 ){
    MSG("SpillServerMon",Msg::kWarning) << " This table has no rows " << endl;
  }

  double dt;
  double dtNeg=start.GetSec()-timestamp.GetSec()-1.0;
  double dtPos=end.GetSec()-timestamp.GetSec()+1.0;

  for(unsigned int i=0; i<table.GetNumRows(); i++){
    const SpillServerMon* entry = table.GetRow(i);

    dt = this->GetTimeDifference( timestamp, entry->GetSpillTime() );

    if( dt<=0.0 && dt>dtNeg ){
      dtNeg=dt; 
      prevEntry=entry;
    }

    if( dt>=0.0 && dt<dtPos ){
      dtPos=dt;
      nextEntry=entry;
    }
  }

  if( prevEntry ){
    MSG("SpillServerMon",Msg::kDebug) << " Db Search: Found previous entry at " << dtNeg << " seconds" << endl;
  }
  else{
    MSG("SpillServerMon",Msg::kVerbose) << " Db Search: No previous entry " << endl;
  }

  if( nextEntry ){
    MSG("SpillServerMon",Msg::kDebug) << " Db Search: Found next entry at +" << dtPos << " seconds" << endl;
  }
  else{
    MSG("SpillServerMon",Msg::kVerbose) << " Db Search: No next entry " << endl;
  }

  return;
}

Double_t SpillServerMonFinder::GetTimeDifference(VldTimeStamp first, VldTimeStamp second)
{
  return  ( second.GetSec()-first.GetSec() )
    + 1.0e-9*( second.GetNanoSec()-first.GetNanoSec() );
}

---