PulserDBModule.cxx

Go to the documentation of this file.

//
// $Id: PulserDBModule.cxx,v 1.16 2007/08/28 18:42:32 tjyang Exp $
//
// PulserDBModule
//
// Write Gaincurve and Drift Points to database
//
// Replaces PulserCollector Module, which will be killed off in due course
//
// $Log: PulserDBModule.cxx,v $
// Revision 1.16  2007/08/28 18:42:32  tjyang
// add protection to ND
//
// Revision 1.15  2006/06/26 23:07:54  murgia
// PULSERGAINLOG table is now aggregate data:
// Set PULSERGAINLOG dbiwriter aggregate number = aggno.
// Change PulserGainLog GetAggNo() to  GetAggregateNo()
//
// Revision 1.14  2006/01/23 12:09:20  cpw1
// Stop writing drift points
//
// Revision 1.13  2005/09/19 17:07:21  murgia
// Replace DbiWriters to use Overlay creation date
//
// Revision 1.12  2005/08/16 15:51:50  tjyang
// Save the last point in the last subrun if the run stopped between two LED pulses. This bug was pointed out by Pat Ward. Thanks Robert H. for showing how to pass an object between two modules.
//
// Revision 1.11  2005/03/04 20:09:50  murgia
// Print run  number when starting new run.
//
// Revision 1.10  2004/11/10 17:06:57  murgia
// WriteGC and WriteTempGC at the end of run, not at the end of file.
//
// Revision 1.9  2004/11/04 04:22:11  phil.adamson
// Extra bits for new calibration
//
// Revision 1.8  2004/10/25 20:00:36  murgia
// Set numPoints equal to expected number of points
//
// Revision 1.7  2004/10/14 21:31:42  phil.adamson
// Fix EndFile() bug
//
// Revision 1.6  2004/10/05 21:39:48  murgia
// Fixed code to write points with low light levels. Added call to EndFile.
//
// Revision 1.5  2004/09/17 18:33:40  phil.adamson
// Revert breakage again! I must stop doing this.
//
// Revision 1.4  2004/09/17 16:58:37  phil.adamson
// Try to fix aggregate number and stripend missing bugs
//
// Revision 1.3  2004/09/14 22:02:30  phil.adamson
// Revert breakage!
//
// Revision 1.2  2004/09/14 22:01:46  phil.adamson
//
//
// A couple of minor fixes
//
// Revision 1.1  2004/09/10 16:51:21  pa
// Add some files that I missed before
//
//

#include "JobControl/JobCModuleRegistry.h"
#include "JobControl/JobCommand.h"
#include "PulserCalibration/PulserDBModule.h"
#include "MessageService/MsgService.h"
#include "MinosObjectMap/MomNavigator.h"
#include "PulserCalibration/PulserSummaryList.h"
#include "PulserCalibration/PulserSummary.h"
#include "Validity/VldContext.h"
#include "Validity/VldRange.h"
#include "Validity/VldTimeStamp.h"
#include "DatabaseInterface/DbiWriter.h"
#include "DatabaseInterface/DbiResultPtr.h"
#include "DatabaseInterface/DbiTableProxy.h"
#include "DatabaseInterface/DbiDBProxy.h"
#include "DatabaseInterface/DbiCache.h"
#include "PulserCalibration/PulserDrift.h"
#include "PulserCalibration/PulserDriftPin.h"
#include "PulserCalibration/PulserConventions.h"
#include "RawData/RawRecord.h"
#include "RawData/RawHeader.h"
#include "RawData/RawDaqHeader.h"

#include "TROOT.h"
#include "TFolder.h"

ClassImp(PulserDBModule)

  // ............

CVSID("$Id: PulserDBModule.cxx,v 1.16 2007/08/28 18:42:32 tjyang Exp $");
JOBMODULE(PulserDBModule,"PulserDBModule","Collate summaries, write to DB");

//......................

PulserDBModule::PulserDBModule(): fGainLog(0)
{
  fGCValid = 3600*24*62; // 2 months validity for Gaincurve
  fDPValid = 3600*24*1;  // Driftpoint valid up to a day?
  fLongTime = 3600*24*365*20; // 20 yrs
  fRunStart = false;
  fFileStart = false;
  fGainPin[0] = fGainPin[1] = 0;
}

PulserDBModule::~PulserDBModule()
{

}

//..........................

JobCResult PulserDBModule::Reco(MomNavigator *mom)
{
  //SM: Check if run and subrun are the same. If not, it means we are reading new file:
  static int runnew, subrunnew;
  static int runold=0;
  static int subrunold=0;
      //SM: Get run and subrun:

  TIter iter = mom->FragmentIter();
  while (TObject *obj = iter.Next()) {
    RawRecord *rawrec = dynamic_cast<RawRecord *>(obj);
    if (rawrec) {

      const RawDaqHeader* daqHead =
        dynamic_cast<const RawDaqHeader*>(rawrec->GetRawHeader());
      
      if (daqHead){
        runnew = daqHead->GetRun();
        subrunnew = daqHead->GetSubRun();
        MSG("Pulser",Msg::kDebug) << 
          "run, subrun: " << runnew << "' " << subrunnew <<endl;
      }
  
    if ((runold!=0) &&(runnew!=runold || subrunnew!=subrunold)){
      MSG("Pulser",Msg::kInfo) <<"Calling Endfile() with runold="<<runold<<endl;
      EndFile();
    }

    if ((runold!=0) && runnew!=runold){
      MSG("Pulser",Msg::kInfo) <<"Calling EndRun() with runold="<<runold<<endl;
      MSG("Pulser",Msg::kInfo) <<"Starting new run: "<<runnew<<endl;
      EndRun();
    }

    runold=runnew;
    subrunold=subrunnew;
    }
  }

  //Get PulserSummary...
   PulserSummaryList *psl = dynamic_cast<PulserSummaryList *>
      (mom->GetFragment("PulserSummaryList"));
   if (psl==0) {
      MSG("Pulser",Msg::kVerbose) <<"No pulser summary list here\n";
      return JobCResult::kFailed;
   }
   MSG("Pulser",Msg::kDebug) <<"Got pulser summary "<<psl->GetPointIndex()
                             <<" of "<<psl->GetExpectedPoints()<<endl;
   //   int point = psl->GetPointIndex();
   if (fRunStart) {
     
   }
   switch(psl->GetExpectedPoints()) {
   case 0:
     // noise - no pulsing
     MSG("Pulser",Msg::kInfo) <<"Dropping LI summary with "<<
       psl->GetTriggers()<<" pulses: Pulser is off!"<<endl;
     break;
   case 1: 
     // Drift Point
     // No longer write drift points. CPW 23/1/06
     MSG("Pulser",Msg::kInfo) <<"Doug Point: not written"<<endl;
     //     DriftPoint(psl);
     break;
   default:
     // Anything bigger than 1 is a gaincurve
     MSG("Pulser",Msg::kInfo) <<"GainCurve"<<endl;
     GainCurve(psl);
     break;
   };
   return JobCResult::kPassed;
   
}

void PulserDBModule::BeginRun()
{
  fRunStart = true;
  MSG("Pulser",Msg::kDebug) << "PulserDBModule::BeginRun()\n";
}

void PulserDBModule::EndRun()
{
  MSG("Pulser",Msg::kDebug) << "PulserDBModule::EndRun()\n";

  if (fGainLog) {
    MergeBack(); 
    MergeForward(); 
    if (fGainLog->IsComplete()) {
      WriteGC();
      DropGC();
    }
  WriteTempGC();
  }

  PulserSummaryList *psl = dynamic_cast<PulserSummaryList *>(gROOT->GetRootFolder()->FindObject("Loon/Pulser/PulserSummaryList"));
  
  if (psl){
    MSG("Pulser",Msg::kDebug) << "PulserDBModule::EndRun(): rescue the last point"<<endl;

    switch(psl->GetExpectedPoints()) {
    case 0:
      // noise - no pulsing
      MSG("Pulser",Msg::kInfo) <<"Dropping LI summary with "<<
        psl->GetTriggers()<<" pulses: Pulser is off!"<<endl;
      break;
    case 1: 
      // Drift Point
      // No longer write drift points. CPW 23/1/06
      MSG("Pulser",Msg::kInfo) <<"Doug Point: not written"<<endl;
      //      DriftPoint(psl);
      break;
    default:
      // Anything bigger than 1 is a gaincurve
      MSG("Pulser",Msg::kInfo) <<"GainCurve"<<endl;
      GainCurve(psl);
      break;
    };
    delete psl;
  }

  TFolder *lf = dynamic_cast<TFolder *>
    (gROOT->GetRootFolder()->FindObject("Loon"));
  if (lf) {
    TObject *obj = lf->FindObject("Pulser");
    if (obj){
      lf->Remove(obj);
      MSG("Pulser",Msg::kDebug) << "PulserDBModule::EndRun(): directory Pulser removed"<<endl;
    }
  }


}

void PulserDBModule::EndJob()
{
  MSG("Pulser",Msg::kDebug) << "PulserDBModule::EndJob()\n";
  EndRun();
}

void PulserDBModule::BeginFile()
{
  fFileStart = true;
  MSG("Pulser",Msg::kDebug) << "PulserDBModule::BeginFile()\n";
}

void PulserDBModule::EndFile()
{
  MSG("Pulser",Msg::kInfo) << "PulserDBModule::EndFile()\n";
}

void PulserDBModule::DriftPoint(PulserSummaryList *psl)
{
  fCurrentContext = psl->GetVldContext();
  VldTimeStamp start = fCurrentContext.GetTimeStamp();
  VldTimeStamp end = start;
  end.Add(VldTimeStamp(fDPValid,0));
  VldRange vr(fCurrentContext.GetDetector(),fCurrentContext.GetSimFlag(),start,
              end, "PulserDBModule");
  VldTimeStamp create = start; 
  create.Add(VldTimeStamp(fCodeVersion,0));
  int aggNo = psl->GetAggregateNo();
  //  DbiWriter<PulserDrift> writer(vr,aggNo,Pulser::kNearEnd,create); // Task==1: near end
  // Use Overlay Creation date
  DbiWriter<PulserDrift> writer(vr,aggNo,Pulser::kNearEnd); // Task==1: near end
  MSG("Pulser",Msg::kDebug)<<"Writing database "<<fCurrentContext<<endl;
  for (std::map<Int_t,PulserSummary>::const_iterator it=psl->GetNearBegin();
       it!=psl->GetNearEnd(); it++) {
    const PulserSummary &ps = (*it).second;
    PulserDrift pd(psl->GetAggregateNo(),ps);
    writer<<pd;
  }
  //  DbiWriter<PulserDrift> fwriter(vr,aggNo,Pulser::kFarEnd,create); // Task==2: far end
  // Use Overlay Creation date
  DbiWriter<PulserDrift> fwriter(vr,aggNo,Pulser::kFarEnd); // Task==2: far end
  for (std::map<Int_t,PulserSummary>::const_iterator it=psl->GetFarBegin();
       it!=psl->GetFarEnd(); it++) {
    const PulserSummary &ps = (*it).second;
    PulserDrift pd(psl->GetAggregateNo(),ps);
    fwriter<<pd;
  }
  //  DbiWriter<PulserDriftPin> pwriter(vr,aggNo,Pulser::kNearEnd,create);
  // Use Overlay Creation date
  DbiWriter<PulserDriftPin> pwriter(vr,aggNo,Pulser::kNearEnd);
  PulserDriftPin pdp(psl->GetAggregateNo(),psl->GetHighPin());
  PulserDriftPin pdpl(psl->GetAggregateNo(),psl->GetLowPin());
  pwriter << pdp << pdpl;
  
  pwriter.Close();
  fwriter.Close();
  writer.Close();
}



void PulserDBModule::GainCurve(PulserSummaryList *psl)
{
  fCurrentContext = psl->GetVldContext();
  if (AddToGC(psl)) {
    // This point is OK to add to current GainCurve
    // Nothing special to do here
    MSG("Pulser",Msg::kDebug)<<"Added point to GC\n";
  } 
  else {
    if (!fFileStart) {
      // If we can't add the current point to our GainCurve, 
      // and we're not at the start of a file, then something
      // has gone pear-shaped.

      // The best we can do is to raise an Error, and then throw away the 
      // existing part-gaincurve and start from scratch. The only sensible
      // way of getting to this condition is if someone kills liMaster and 
      // restarts it in the middle of a run.
      MSG("Pulser",Msg::kError) <<"New point does not match existing gaincurve\n";
      MSG("Pulser",Msg::kError) <<"Dropping existing GC and trying to carry on\n";
      MSG("Pulser",Msg::kError) <<"Please report this error to the experts now\n";
      DropGC();
      AddToGC(psl);
    }
    if (fFileStart) {
      // This is probably OK, and just means that we're processing files 
      // out of order, or are missing a file. The current GC will have
      // been written to the temp table at the end of the previous file, 
      // so we can just drop it and run the new one.
      DropGC();
      AddToGC(psl);
    }
  }
  fFileStart = false;
  fRunStart = false;
  // Test GainCurve for completeness
  // If Gaincurve is complete, wite to DB (and then delete temp GCs)

  // I think we need a GainCurve info object, that can have all the 
  // pulse heights and so on in it.

  // Then I can do
  MergeBack(); 
  if (fGainLog->IsComplete()) {
    WriteGC();
    DropGC();
  }

}


bool PulserDBModule::MergeBack()
{
  if (fGainLog->GetFirstPoint()==1) return false;
  
  // Try to merge here
  VldTimeStamp ts = fGainLog->GetTimeStart();
  ts.Add(VldTimeStamp(-2,0));
  VldContext vld(fCurrentContext.GetDetector(),
                 fCurrentContext.GetSimFlag(),ts);
  DbiResultPtr<PulserGainLog> pglrp(vld,Pulser::kTempData);
  // need to check that I haven't got a gap, and that it's the right piece
  if (pglrp.GetNumRows()==0) return false; // No valid data available
  
  const PulserGainLog *pgl = pglrp.GetRow(0);
  if (fGainLog->Add(*pgl)) {
    // Can add gain log, so let's go and add the data too
    DbiResultPtr<PulserGain> nearend(vld,Pulser::kNearEnd | Pulser::kTempData);
    if (nearend.GetNumRows()==0) {
      MSG("Pulser",Msg::kFatal)<< "Database Integrity Error."<<endl;
      MSG("Pulser",Msg::kFatal)<< "Near End Gain doesn't match GainLog"<<endl;
      return false;
    }
    for (std::map<Int_t,PulserGain>::iterator it = fGainMapNear.begin();
       it !=fGainMapNear.end(); it++) {
      PulserGain &pg = (*it).second;
      const PulserGain * otherpg = nearend.GetRowByIndex(pg.GetStripEnd());
      if (!pg.Add(*otherpg)) {
        // Inconsistency - fatal error!
        MSG("Pulser",Msg::kFatal)<<"Could add GainLog but not Gain for stripend with key "<<pg.GetStripEnd()<<endl;
        assert(0);
      }
    }

    DbiResultPtr<PulserGain> farend(vld,Pulser::kFarEnd | Pulser::kTempData);
    if (vld.GetDetector()==Detector::kFar){
      if (farend.GetNumRows()==0) {
        MSG("Pulser",Msg::kFatal)<< "Database Integrity Error."<<endl;
        MSG("Pulser",Msg::kFatal)<< "Far End Gain doesn't match GainLog"<<endl;
        return false;
      }
      for (std::map<Int_t,PulserGain>::iterator it = fGainMapFar.begin();
           it !=fGainMapFar.end(); it++) {
        PulserGain &pg = (*it).second;
        const PulserGain * otherpg = farend.GetRowByIndex(pg.GetStripEnd());
        if (!pg.Add(*otherpg)) {
          // Inconsistency - fatal error!
          MSG("Pulser",Msg::kFatal)<<"Could add GainLog but not Gain for Far stripend with key "<<pg.GetStripEnd()<<endl;
          assert(0);
        }
      }
    }

    DbiResultPtr<PulserGainPin> pins(vld,Pulser::kNearEnd | Pulser::kTempData);
    if (pins.GetNumRows()==0) {
      MSG("Pulser",Msg::kFatal)<< "Database Integrity Error."<<endl;
      MSG("Pulser",Msg::kFatal)<< "Pin Gain doesn't match GainLog"<<endl;
      return false;
    }
    const PulserGainPin * otherpin[2];
    for (int k=0;k<2;k++) {
      otherpin[k] = pins.GetRowByIndex(fGainPin[k]->GetIndex(0));
      if (!(fGainPin[k]->Add(*otherpin[k]))) {
        MSG("Pulser",Msg::kFatal)<<"Could add GainLog but not Gain for Pin "<<fGainPin[k]->GetIndex(0)<<endl;
        assert(0);
      }
    }

    // We have now successfully merged the other gain curve into our current
    // one. We should now write a new gain curve fragment and delete both old 
    // fragments from the temp DB.
    // If this merge has completed a gaincurve, write it to the real database 
    // instead.

    // Get DbiResultPtrs for an earlier version of the current objects, if they
    // exist. This is now done in WriteTempGC()

   // Now write new tables
   if (WriteTempGC()) {
     DeleteGC(&nearend);
     if (vld.GetDetector()==Detector::kFar) DeleteGC(&farend);
     DeleteGC(&pins);
     DeleteGC(&pglrp);
   }
   else {
     MSG("Pulser",Msg::kError)<< "Failed to delete old bits of gaincurve from temp DB.\n";
     return false;
   }


  } 
  else return false;

  return MergeBack();
}

bool PulserDBModule::MergeForward()
{
  if (fGainLog->GetLastPoint()==fGainLog->GetNumPoints()) return false;

  // Try to merge here
  VldTimeStamp ts = fGainLog->GetTimeEnd();
  VldContext vld(fCurrentContext.GetDetector(),
                 fCurrentContext.GetSimFlag(),ts);
  DbiResultPtr<PulserGainLog> pglrp(vld,Pulser::kTempData);
  // This will either be the current curve fragment, if it's in the database,
  // or it'll be the previous one, if it's not.
  pglrp.NextQuery();
  // This should now be the next fragment. Remember, there might not be one, 
  // so we might have a gap now,
  if (pglrp.GetNumRows()==0) return false;

  const PulserGainLog *pgl = pglrp.GetRow(0);
  if (fGainLog->Add(*pgl)) {
    // Can add gain log, so lets go and add the data too
  } 
  else return false;

  return MergeForward();
}




void PulserDBModule::DropGC()
{
  // Silently drop current gaincurve from memory
  fGainMapNear.clear();
  fGainMapFar.clear();
  delete fGainPin[0];
  delete fGainPin[1];
  delete fGainLog;
  fGainPin[0]=0;
  fGainPin[1]=0;
  fGainLog=0;
}

bool PulserDBModule::WriteGC()
{
  return DoWriteGC(Pulser::kRealData);
}


bool PulserDBModule::WriteTempGC()
{
 VldTimeStamp ts = fGainLog->GetTimeStart();
   VldContext vld(fCurrentContext.GetDetector(),
                 fCurrentContext.GetSimFlag(),ts);
   DbiResultPtr<PulserGain> near;
   DbiResultPtr<PulserGain> far;
   DbiResultPtr<PulserGainPin> pins;
   DbiResultPtr<PulserGainLog> gainlog;

   bool del_n = GetCurrentFromDB(near,vld,Pulser::kNearEnd | Pulser::kTempData);
   bool del_f = GetCurrentFromDB(far,vld,Pulser::kFarEnd | Pulser::kTempData);
   bool del_p = GetCurrentFromDB(pins,vld,Pulser::kNearEnd | Pulser::kTempData);
   bool del_g = GetCurrentFromDB(gainlog,vld,Pulser::kNearEnd | Pulser::kTempData);

bool result = DoWriteGC(Pulser::kTempData);
  // We should delete any older versions of the current fragment here, too

 if (result && gainlog.GetValidityRec()->GetVldRange().GetTimeStart()==fGainLog->GetTimeStart()) {
   // start time of current gc and fragment in db match, so can delete from db.

  if (del_n) result &=DeleteGC(&near);
  if (del_f) result &=DeleteGC(&far);
  if (del_p) result &=DeleteGC(&pins);
  if (del_g) result &=DeleteGC(&gainlog);
 }
 return result;
}

bool PulserDBModule::DoWriteGC(int temp)
{
  VldTimeStamp start = fGainLog->GetTimeStart();
  VldTimeStamp end = start;
  end.Add(VldTimeStamp(fGCValid,0));
  VldRange vr(fCurrentContext.GetDetector(),fCurrentContext.GetSimFlag(),start,
              end, "PulserDBModule");
  VldTimeStamp create = start; 
  create.Add(VldTimeStamp(fCodeVersion,0));
  //  int aggNo = fGainLog->GetAggNo();
  int aggNo = fGainLog->GetAggregateNo();
  MSG("Pulser",Msg::kDebug)<<"In DoWriteGC. Aggregate Number: "<<aggNo<<endl;
  
  //  DbiWriter<PulserGainLog> logwriter(vr,-1,temp, create);
  // Use Overlay Creation date and write aggregateno 
  DbiWriter<PulserGainLog> logwriter(vr,aggNo,temp);
  if (temp & Pulser::kTempData) logwriter.SetDbName("litemp");
  MSG("Pulser",Msg::kDebug)<<"Writing database "<<fCurrentContext
                           <<" gaincurve starts at "<<start<<endl;
  logwriter << *fGainLog;
  //  DbiWriter<PulserGain> writer(vr,aggNo,Pulser::kNearEnd | temp, create);
  // Use Overlay Creation date
  DbiWriter<PulserGain> writer(vr,aggNo,Pulser::kNearEnd | temp);
  if (temp & Pulser::kTempData) writer.SetDbName("litemp");
  for (std::map<Int_t,PulserGain>::iterator it = fGainMapNear.begin();
       it !=fGainMapNear.end(); it++) {
    PulserGain &pg = (*it).second;
    writer << pg;
  }

  //  DbiWriter<PulserGain> fwriter(vr,aggNo,Pulser::kFarEnd | temp, create);
  //  Use Overlay Creation date
  DbiWriter<PulserGain> fwriter(vr,aggNo,Pulser::kFarEnd | temp);
  if (temp & Pulser::kTempData) fwriter.SetDbName("litemp");
   for (std::map<Int_t,PulserGain>::iterator it = fGainMapFar.begin();
       it !=fGainMapFar.end(); it++) {
    PulserGain &pg = (*it).second;
    fwriter << pg;
  }

   //  DbiWriter<PulserGainPin> pwriter(vr,aggNo,Pulser::kNearEnd | temp, create);
   //  Use Overlay Creation date
  DbiWriter<PulserGainPin> pwriter(vr,aggNo,Pulser::kNearEnd | temp);
  if (temp & Pulser::kTempData) pwriter.SetDbName("litemp");
  pwriter << *(fGainPin[0]) << *(fGainPin[1]);

  bool result=true;
  logwriter.TableProxy().GetCache()->SetStale();
  pwriter.TableProxy().GetCache()->SetStale();
  fwriter.TableProxy().GetCache()->SetStale();
  writer.TableProxy().GetCache()->SetStale();

  result &=logwriter.Close();
  result &=pwriter.Close();
  result &=fwriter.Close();
  result &=writer.Close();
  return result;
  


}

bool PulserDBModule::AddToGC(PulserSummaryList *psl)
{
  // Test to see whether we can add the pulse point in the PulserSummaryList
  // to the current gaincurve

  // If we can, make the addition and return true, else return false.
  if (!fGainLog) {
    // We don't have a gaincurve object currently, either because we just started
    // running, or we just dropped a gaincurve
    // With a new gainlog, Add(psl) will always succeed
    fGainLog = new PulserGainLog(fCodeVersion);
    fGainPin[0] = new PulserGainPin();
    fGainPin[1] = new PulserGainPin();
  }
  if (fGainLog->Add(psl)) {
    //    MSG("Pulser",Msg::kDebug)<<"In AddToGC (1).  GetAggNo: " <<  ", " << fGainLog->GetAggNo() << endl; 
    MSG("Pulser",Msg::kDebug)<<"In AddToGC (1).  GetAggregateNo: " <<  ", " << fGainLog->GetAggregateNo() << endl; 

    // If we successfully add to the GainLog, we must be able to add the data
    // too, by construction. If we can't, something's gone horribly wrong.
    bool result=true;
    result &= fGainPin[0]->AddPoint(psl->GetPointIndex(),psl->GetHighPin(),psl->GetAggregateNo(),psl->GetExpectedPoints());
    result &= fGainPin[1]->AddPoint(psl->GetPointIndex(),psl->GetLowPin(),psl->GetAggregateNo(),psl->GetExpectedPoints());
    for (std::map<Int_t,PulserSummary>::const_iterator it = psl->GetNearBegin(); it!=psl->GetNearEnd() ; it++) {

      result &= fGainMapNear[(*it).first].AddPoint(psl->GetPointIndex(),(*it).second,psl->GetAggregateNo(),psl->GetExpectedPoints());
    }
    for (std::map<Int_t,PulserSummary>::const_iterator it = psl->GetFarBegin();
         it!=psl->GetFarEnd() ; it++) {

      result &= fGainMapFar[(*it).first].AddPoint(psl->GetPointIndex(),(*it).second,psl->GetAggregateNo(),psl->GetExpectedPoints());
    }
    if (!result) {
      MSG("Pulser",Msg::kFatal)<<"Internal inconsistency. This can't happen.\n"; 
      assert(0);
    }
    
    MSG("Pulser",Msg::kDebug)<<"In AddToGC. Aggregate Number(psl): " << psl->GetAggregateNo() << endl; 
    //    MSG("Pulser",Msg::kDebug)<<"In AddToGC. Aggregate Number(log): " << fGainLog->GetAggNo() << endl; 
    MSG("Pulser",Msg::kDebug)<<"In AddToGC. Aggregate Number(log): " << fGainLog->GetAggregateNo() << endl; 
    
    return result;
  }
  return false;
}

template <class T>
bool PulserDBModule::DeleteGC(DbiResultPtr<T> *p)
{
  const DbiValidityRec *vrec = p->GetValidityRec();
  int seqno = vrec->GetSeqNo();
  int dbno = vrec->GetDbNo();

  DbiTableProxy &t = p->TableProxy();
  const DbiDBProxy &dbproxy = t.GetDBProxy();

  
  bool result = dbproxy.RemoveSeqNo(seqno,dbno);
  t.GetCache()->SetStale();
  return result;
}


template <class T>
bool PulserDBModule::GetCurrentFromDB(DbiResultPtr<T> & rp, VldContext &vld,int task) 
{
  rp.NewQuery(vld,task);
  if (rp.GetNumRows()==0) return false;

  const T* obj = rp.GetRow(0);
  if (obj->GetFirstPoint()!=fGainLog->GetFirstPoint()) return false;

  return true;

}

---