DbuDaqMonitorModule.cxx

Go to the documentation of this file.

// $Id: DbuDaqMonitorModule.cxx,v 1.30 2007/04/26 14:21:39 west Exp $
#include "DatabaseInterface/DbiExceptionLog.h"

#include "DatabaseUpdater/DbuDaqMonitorModule.h"
#include "DatabaseUpdater/DbuSignalHandler.h"

#include "DatabaseUpdater/DbuSubRunSummary.h"
#include "DatabaseUpdater/DbuVaChipPeds.h"
#include "DatabaseUpdater/DbuVaChipSpars.h"

#include "DatabaseUpdater/DbuBits.h"
#include "DatabaseUpdater/RunTypeName.h"

#include <cstdio>
// ROOT include files
#include "TObject.h"
#include "TCollection.h"
#include "TObjectTable.h"
// TString for Form function
#include "TString.h"  
#include "TSystem.h"

// MINOS include files
#include "DatabaseInterface/Dbi.h"
#include "DatabaseInterface/DbiCascader.h"
#include "DatabaseInterface/DbiStatement.h"
#include "DatabaseInterface/DbiTableProxy.h"
#include "DatabaseInterface/DbiTableProxyRegistry.h"
#include "DatabaseInterface/DbiOutRowStream.h"
#include "DatabaseInterface/DbiWriter.h"
#include "DatabaseInterface/DbiCache.h"
#include "DatabaseInterface/DbiResultPtr.h"
#include "DatabaseInterface/DbiString.h"


#include "RawData/RawRecord.h"
#include "RawData/RawDaqSnarlHeader.h"
#include "RawData/RawLIAdcSummaryBlock.h"
#include "RawData/RawLITimingSummaryBlock.h"
#include "RawData/RawRunStartBlock.h"
#include "RawData/RawRunCommentBlock.h"
#include "RawData/RawRunEndBlock.h"
#include "RawData/RawPedestalTableBlock.h"
#include "RawData/RawSparsifierTableBlock.h"

#include "JobControl/JobCommand.h"
#include "JobControl/JobCModuleRegistry.h"
#include "MinosObjectMap/MomNavigator.h"
#include "MessageService/MsgService.h"
#include "Util/UtilString.h"

#include <signal.h>
#include "OnlineUtil/msgLogLib/msgLog.h"

CVSID("$Id: DbuDaqMonitorModule.cxx,v 1.30 2007/04/26 14:21:39 west Exp $");
JOBMODULE(DbuDaqMonitorModule, 
          "DbuDaqMonitor", "Generate SubRunSummary entries in database.");

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

const Int_t sec_twoweeks = 2*7*24*60*60;
const Int_t sec_fivemin = 5*60;

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

DbuDaqMonitorModule::DbuDaqMonitorModule() :
   fURL(""), fDbNo(0), fDbiStatement(0), 
   fHeartbeatIntervalSec(sec_fivemin),
   fCurrentSubRun(0), fRecSubRunSummary(true), fRecAtStart(true),
   fCommentFieldName(""), fHasRowCounter(false),
   fRecVaChipPeds(false), fRecVaChipSpars(false), fVaChipVldSec(sec_twoweeks)
{}

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

DbuDaqMonitorModule::~DbuDaqMonitorModule() {}

//......................................................................
  
JobCResult DbuDaqMonitorModule::Ana(const MomNavigator* mom)
{
   
   JobCResult result = JobCResult::kPassed;

   // Get any and all raw records attached to the data record pointed 
   // to by "mom".  The dynamic cast from TObject is ugly but necessary
   TObject   *tobj   = 0;
   TIter reciter = const_cast<MomNavigator*>(mom)->FragmentIter();
   while ( (tobj = reciter() ) ) {
      RawRecord *rawrec = dynamic_cast<RawRecord *>(tobj);
      JobCResult aresult = ProcessRawRecord(rawrec);
      if (aresult.Failed()) result = aresult;
   }

   return result;
}

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

void DbuDaqMonitorModule::BeginJob()
{
   // 

   MSG("Dbu",Msg::kInfo)
     << "DbuDaqMonitorModule::BeginJob() " << endl;

   logInfo("DbuDaqMonitorModule::BeginJob()");

   Update_ENV_TSQL();

   InitTSQLConnection();

   GetCommentFieldName();
   CheckForRowCounterColumn();

   MSG("Dbu",Msg::kInfo) 
      << "DbuDaqMonitorModule::BeginJob  " << endl
      << " SubRunSummary: " << (fRecSubRunSummary  ? "on":"off") << endl
      << " RecordAtStart: " << (fRecAtStart        ? "on":"off") << endl
      << " HeartbeatInterval: " << fHeartbeatIntervalSec << " sec" << endl
      << " VaChipPeds: "    << (fRecVaChipPeds     ? "on":"off") << endl
      << " VaChipSpars: "   << (fRecVaChipSpars    ? "on":"off") << endl
      << " VaChipVldSec: "  << fVaChipVldSec << "s" << endl
      << " CommentFieldName: \"" << fCommentFieldName << "\"" << endl
      << " RowCounter column?  " << (fHasRowCounter?"yes":"no") << endl
      << endl;

   if (fRecSubRunSummary) {
     logInfo("DbuDaqMonitorModule::BeginJob() %s %s heartbeat %d sec",
            ((fRecSubRunSummary)?"SubRunSummary":" "),
            ((fRecAtStart)?"RecAtStart":" "),
            fHeartbeatIntervalSec);
     logInfo("DbuDaqMonitorModule::BeginJob() field name \"%s\"",
             fCommentFieldName.c_str());
   }

   if (fRecVaChipPeds||fRecVaChipSpars) {
     logInfo("DbuDaqMonitorModule::BeginJob() %s %s",
             ((fRecVaChipPeds)?"VaChipPeds":" "),
             ((fRecVaChipSpars)?"VaChipSpars":" "));
     logInfo("DbuDaqMonitorModule::BeginJob() VaChipVldSec = %d",
             fVaChipVldSec);
   }


}

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

void DbuDaqMonitorModule::EndJob()
{
   // this should make sure all entries are flushed

  MSG("Dbu",Msg::kInfo)
    << "DbuDaqMonitorModule::EndJob() " << endl;

  logInfo("DbuDaqMonitorModule::EndJob() processing begun");

  if (fCurrentSubRun) {
    if (fCurrentSubRun->fConsistency & DbuBits::kInProgress)
      fCurrentModified = true;

    fCurrentSubRun->fConsistency &= ~DbuBits::kInProgress;

    logDebug(2,"EndJob() writing summary for %c%8.8d_%4.4d",
           Detector::AsString(fCurrentSubRun->fDetector)[0],
           fCurrentSubRun->fRun,fCurrentSubRun->fSubRun);

    WriteSubRunSummaryEntry(true);

  }

  logInfo("DbuDaqMonitorModule::EndJob() finished");
}

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

const Registry& DbuDaqMonitorModule::DefaultConfig() const 
{
//======================================================================
// The default configuration for this module
//======================================================================
  static Registry r;
  
  std::string name = this->GetName();
  name += ".config.default";
  r.SetName(name.c_str());
  
  r.UnLockValues();
  r.Set("SubRunSummary",true);
  r.Set("RecordAtStart",true);
  r.Set("HeartbeatIntervalSec",sec_fivemin);
  r.Set("VaChipPeds",true);
  r.Set("VaChipSpars",true);
  r.Set("VaChipVldSec",sec_twoweeks);
  r.Set("CommentFieldName","");  //"RUN_COMMENT");
  r.LockValues();

  return r;
}

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

void DbuDaqMonitorModule::Config(const Registry& r) 
{
//======================================================================
// Configure the module using the registry r
//======================================================================

   int tmpi;
   const char* tmps;

   if (r.Get("SubRunSummary",tmpi)) fRecSubRunSummary = tmpi;

   if (r.Get("RecordAtStart",tmpi)) fRecAtStart       = tmpi;

   if (r.Get("HeartbeatIntervalSec",tmpi)) fHeartbeatIntervalSec = tmpi;

   if (r.Get("VaChipPeds",tmpi))    fRecVaChipPeds    = tmpi;

   if (r.Get("VaChipSpars",tmpi))   fRecVaChipSpars   = tmpi;

   if (r.Get("VaChipVldSec",tmpi))  fVaChipVldSec     = tmpi;

   if (r.Get("CommentFieldName",tmps)) fCommentFieldName = tmps;

}

//......................................................................
void DbuDaqMonitorModule::Update_ENV_TSQL()
{
//======================================================================
// copy ENV_TSQL_UPDATE_XXX to ENV_TSQL_XXX
//======================================================================

   fURL  = "";
   fDbNo = 0;   // This won't change as we will force "offline" to the start of the cascade.

   // find the "offline" DB from the URL (not the "temp" one)

   const char* strUrlUsed      = gSystem->Getenv("ENV_TSQL_UPDATE_URL");
   if (!strUrlUsed) strUrlUsed = gSystem->Getenv("ENV_TSQL_URL");
   string urlList = (strUrlUsed) ? strUrlUsed : "";
   while ( urlList != "") {
     UInt_t maxStringPos = urlList.size();
     string url = urlList;
     UInt_t nextStringPos = urlList.find(";");
     if ( nextStringPos < maxStringPos ) {
       url = urlList.substr(0,nextStringPos);
       urlList.erase(0,nextStringPos+1);
     }
     else urlList = "";
     
     maxStringPos = url.size();
     
     if (url.find("offline") < maxStringPos) {
       fURL = url;
       break;
     }
     
     // if not "offline" move along to next possibility
   }

   // Override ENV_TSQL_UPDATE_URL (the Dbi preferrentially 
   // takes the ENV_TSQL_UPDATE_* variables).
   gSystem->Setenv("ENV_TSQL_UPDATE_URL",fURL.c_str());

}


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

void DbuDaqMonitorModule::InitTSQLConnection()
{
//======================================================================
// Obtain a DbiStatement to the first entry in the Cascade
//======================================================================

   // assume ENV_TSQL_UPDATE_XXX have been adjusted so the "Offline" is the first entry
   if (fDbiStatement)  { delete fDbiStatement;  fDbiStatement  = 0; }
   fDbiStatement = DbiTableProxyRegistry::Instance().GetCascader().CreateStatement(fDbNo);

   if ( ! fDbiStatement ) {
     MSG("Dbu",Msg::kError)
       << "Failed to create DbiStatement for: " << fURL << endl;
     logWarn("InitTSQLConnection failed to create DBU TSQL_Statement for %s",fURL.c_str());
   }

   MSG("Dbu",Msg::kInfo)
     << "Successfully created DbiStatement to: " << fURL << endl;
   logDebug(4,"InitTSQLConnection created DBU statement to %s",fURL.c_str());

}

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

void DbuDaqMonitorModule::HandleCommand(JobCommand* cmd) 
{

   const char* c = cmd->PopCmd();
   if (c) {
      string sc(c);
      if (sc == "Record" || sc == "Disregard" ) {
         bool on = (sc=="Record");
         while (const char* opt = cmd->PopOpt()) {
            string sopt(opt);
            if      (sopt == "SubRunSummary") fRecSubRunSummary = on;
            else if (sopt == "RecordAtStart") fRecAtStart       = on;
            else if (sopt == "VaChipPeds")    fRecVaChipPeds    = on;
            else if (sopt == "VaChipSpars")   fRecVaChipSpars   = on;
            else {
               MSG("Dbu",Msg::kWarning) 
                  << "No " << sc << " available for '" << opt << "'." << endl;
            }
         }
      }
      else if (sc == "Set" ) {
         const char* opt = cmd->PopOpt();
         string sopt(opt);
         if      (sopt == "VaChipVldSec") fVaChipVldSec = cmd->PopIntOpt();
         else
               MSG("Dbu",Msg::kWarning) 
                  << "No " << sc << " available for '" << opt << "'." << endl;
      }
      else {
         MSG("Dbu",Msg::kInfo) 
            << "No Valid DbuDaqMonitorModule command '" << sc <<"'." << endl;
      }
   }
   else {
      MSG("Dbu",Msg::kInfo)
         << "Valid commands are: 'Record' and 'Disregard'" << endl
         << "Valid options are: SubRunSummary, AtStart, VaChipPeds, VaChipSpars" 
         << "  Also /Set VaChipVldSec [nsec]" << endl
         << endl;
   }
}

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

void DbuDaqMonitorModule::GetCommentFieldName()
{

  // determine the name of the "comment" field (column) of the table

  // incantation from Nick

  // Get the Singleton manager
  DbiTableProxyRegistry& tpr = DbiTableProxyRegistry::Instance();
  // Crate a "pet" object (needed if reading in order to create rows)
  DbuSubRunSummary srs;
  // Get a proxy to DBUSUBRUNSUMMARY
  DbiTableProxy& tp = tpr.GetTableProxy("DBUSUBRUNSUMMARY",&srs);
  // Acess the table's meta-data
  const DbiTableMetaData& md = tp.GetMetaData();
  // Find the right column 
  UInt_t numCols = md.NumCols();  // column numbers from 1 not zero
  for (UInt_t iCol = 1;  iCol <= numCols; ++iCol ) {
    std::string guess = md.ColName(iCol);
    if (guess.find("COMMENT") != std::string::npos)
      fCommentFieldName = guess;
  }

  // final default if all else failed
  if ( "" == fCommentFieldName ) 
    fCommentFieldName = "RUN_COMMENT"; 
}

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

void DbuDaqMonitorModule::CheckForRowCounterColumn()
{

  // determine if the table has a "ROW_COUNTER" column

  // Get the Singleton manager
  DbiTableProxyRegistry& tpr = DbiTableProxyRegistry::Instance();
  // Crate a "pet" object (needed if reading in order to create rows)
  DbuSubRunSummary srs;
  // Get a proxy to DBUSUBRUNSUMMARY
  DbiTableProxy& tp = tpr.GetTableProxy("DBUSUBRUNSUMMARY",&srs);
  // Acess the table's meta-data
  const DbiTableMetaData& md = tp.GetMetaData();
  // Find the right column 
  UInt_t numCols = md.NumCols();  // column numbers from 1 not zero
  for (UInt_t iCol = 1;  iCol <= numCols; ++iCol ) {
    std::string guess = md.ColName(iCol);
    if (guess.find("ROW_COUNTER") != std::string::npos)
      fHasRowCounter = true;
  }
}

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

JobCResult DbuDaqMonitorModule::ProcessRawRecord(const RawRecord* rawrec)
{

   JobCResult result = JobCResult::kPassed;
   static VldTimeStamp nullTime((time_t)0,0);

   // test if the RawRecord was from the DAQ
   const RawDaqHeader* header = 
      dynamic_cast<const RawDaqHeader*>(rawrec->GetRawHeader());
   if (!header) {
      MSG("Dbu",Msg::kError)
         << "RawRecord lacked RawDaqHeader:" 
         << *(rawrec->GetRawHeader())
         << endl;
      logWarn("RawRecord lacked RawDaqHeader");
      return JobCResult::kFailed;
   }
       
   VldContext           vldc   = header->GetVldContext();
   Detector::Detector_t det    = vldc.GetDetector();
   Int_t                run    = header->GetRun();
   Short_t              subrun = header->GetSubRun();

   // this section is some (optional) heartbeat/debugging output
   const char* strmname = rawrec->GetTempTags().GetCharString("stream");
   const int   strmindx = rawrec->GetTempTags().GetInt("index");
   const char* fname    = rawrec->GetTempTags().GetCharString("file");

   Int_t this_time = vldc.GetTimeStamp().GetSec();
   static Int_t last_heartbeat = 0;
   bool pulse = ( this_time - last_heartbeat > fHeartbeatIntervalSec );

   string this_file = fname;
   static string last_file = "";
   bool newfile = ( last_file != this_file );

   if ( pulse || newfile ) {
     // send out heart beat signal
     const char* fmttime = vldc.GetTimeStamp().AsString("c");
     const char* why = ((newfile) ? "new file" : "heartbeat");
     MSG("Dbu",Msg::kDebug) 
       << why << ": " 
       << this_file << " (" << strmname << " " << strmindx << ") "
       << endl << " " << *header << endl;

     logDebug(3,"heartbeat: %c%8.8d_%4.4d %s (%s %d)",
              Detector::AsString(det)[0],
              run,subrun,fmttime,strmname,strmindx);

     last_heartbeat = this_time;
     last_file      = this_file;
   }

   if (fCurrentSubRun && !fCurrentSubRun->IsSameSubRun(det,run,subrun)) {
     // starting new subrun -- flush what we have for previous entry
     if (fCurrentSubRun->fConsistency&DbuBits::kInProgress)
       fCurrentModified = true;

     fCurrentSubRun->fConsistency &= ~DbuBits::kInProgress;

     if ( ! WriteSubRunSummaryEntry(true) ) result = JobCResult::kFailed;

   }

   if (!fCurrentSubRun) {
      // first time for this run/subrun
      fCurrentModified = true;
      fWrittenNTimes   = 0;
      fCurrentSubRun = new DbuSubRunSummary;
      fCurrentSubRun->fDetector     = det;
      fCurrentSubRun->fSimFlag      = vldc.GetSimFlag();
      fCurrentSubRun->fRun          = run;
      fCurrentSubRun->fSubRun       = subrun;
      fCurrentSubRun->fRunType      = header->GetRunType();
      fCurrentSubRun->fStartTime    = vldc.GetTimeStamp();
      fCurrentSubRun->fConsistency |= DbuBits::kRecCountUnverified;
      fCurrentSubRun->fConsistency |= DbuBits::kSawNoRunStart;
      fCurrentSubRun->fConsistency |= DbuBits::kSawNoRunComment;
      fCurrentSubRun->fConsistency |= DbuBits::kSawNoRunEnd;
      fCurrentSubRun->fConsistency |= DbuBits::kInProgress;
      MSG("Dbu",Msg::kDebug) 
        << " create new CurrentSubRun from RawDaqHeader: " << endl
        << " Run " << run << " SubRun " << subrun << endl
        << " " << *header << endl;
   }

   // continually update end time (in case of missing RunEnd)
   fCurrentSubRun->fEndTime      = vldc.GetTimeStamp();

   // For each RawBlock in the RawRecord extract what we can
   // The dynamic cast from TObject is ugly but necessary
   TIter itr = rawrec->GetRawBlockIter();
   RawDataBlock*            rdb           = 0;
   RawRunEndBlock*          runendblk     = 0;
   RawRunStartBlock*        runstartblk   = 0;
   RawRunCommentBlock*      runcommentblk = 0;
   RawLIAdcSummaryBlock*    liadcblk      = 0;
   RawLITimingSummaryBlock* litimingblk   = 0;

   // The dynamic cast from TObject is ugly but necessary
   // Careful! the itr() advances the iterator as a side effect!
   while ((rdb = dynamic_cast<RawDataBlock*>(itr()))) {

      if (!runendblk)   runendblk   = dynamic_cast<RawRunEndBlock*>(rdb);
      if (!runstartblk) runstartblk = dynamic_cast<RawRunStartBlock*>(rdb);

      runcommentblk = dynamic_cast<RawRunCommentBlock*>(rdb);
      liadcblk      = dynamic_cast<RawLIAdcSummaryBlock*>(rdb);
      litimingblk   = dynamic_cast<RawLITimingSummaryBlock*>(rdb);

      RawPedestalTableBlock* pedtblblk = 
         dynamic_cast<RawPedestalTableBlock*>(rdb);
      RawSparsifierTableBlock* sparstblblk = 
         dynamic_cast<RawSparsifierTableBlock*>(rdb);

      if      ( runstartblk ) {                 
         // this is a RunStart block
        fCurrentModified = true;
        fCurrentSubRun->fConsistency &= ~DbuBits::kSawNoRunStart;
        VldTimeStamp startTime = runstartblk->GetStartTime();

        MSG("Dbu",Msg::kDebug) << *runstartblk << endl;
        const char* fmttime = runstartblk->GetStartTime().AsString("c");
        logInfo("%-16s RUN %d SUB %d @ %s (%s %d)",
                "RunStartBlk",run,subrun,fmttime,strmname,strmindx);
      }
      else if ( runcommentblk ) {
        // this is a RunComment block
        fCurrentModified = true;
        fCurrentSubRun->fConsistency &= ~DbuBits::kSawNoRunComment;
        fCurrentSubRun->fComment = runcommentblk->GetRunComment();

         MSG("Dbu",Msg::kDebug) << *runcommentblk << endl;
         const char* fmttime = runcommentblk->GetTime().AsString("c");
         logInfo("%-16s RUN %d SUB %d @ %s (%s %d)",
                 "RunCommentBlk",run,subrun,fmttime,strmname,strmindx);
      }
      else if (pedtblblk && fRecVaChipPeds) {
         if ( ! WriteVaChipPedsEntry(pedtblblk) ) 
           result = JobCResult::kFailed;
      }
      else if (sparstblblk && fRecVaChipSpars) {
         if ( ! WriteVaChipSparsEntry(sparstblblk) ) 
           result = JobCResult::kFailed;
      }

   }

   // perform our own counts for records
   const RawDaqSnarlHeader* snarlheader = 
      dynamic_cast<const RawDaqSnarlHeader*>(header);
   if (snarlheader) {
      if (fCurrentSubRun->fSnarlRec<0) fCurrentSubRun->fSnarlRec=0;
      fCurrentModified = true;
      fCurrentSubRun->fSnarlRec++;
   }
   else {
      if (fCurrentSubRun->fMonitorRec<0) fCurrentSubRun->fMonitorRec=0;
      fCurrentModified = true;
      fCurrentSubRun->fMonitorRec++;
   }

   if (liadcblk || litimingblk) {
      if (fCurrentSubRun->fLightInjRec<0) fCurrentSubRun->fLightInjRec=0;
      fCurrentModified = true;
      fCurrentSubRun->fLightInjRec++;
   }

   // if we saw a run end block process it here after
   // any other blocks in the record
   if (runendblk) {
      //RawDataBlock::SetForceHexDump(true);
      //cout << *runendblk << endl;
      //RawDataBlock::SetForceHexDump(false);

      MSG("Dbu",Msg::kDebug) << *runendblk << endl;
      const char* fmttime = runendblk->GetEndTime().AsString("c");
      logInfo("%-16s RUN %d SUB %d @ %s (%s %d)",
              "RunEndBlk",run,subrun,fmttime,strmname,strmindx);

      fCurrentModified = true;
      fCurrentSubRun->fConsistency &= ~DbuBits::kSawNoRunEnd;

      Int_t runEndSnarls  = runendblk->GetNumberOfSnarls();
      Int_t runEndMonitor = runendblk->GetNumberOfNonSnarls();
      if (fCurrentSubRun->fSnarlRec   != runEndSnarls ||
          fCurrentSubRun->fMonitorRec != runEndMonitor   ) {
         // flag that what we saw doesn't match RunEnd
         fCurrentSubRun->fConsistency |= DbuBits::kRecCountUnverified;
         MSG("Dbu",Msg::kDebug) 
           << "Counted/Expected " 
           << fCurrentSubRun->fSnarlRec << "/" << runEndSnarls
           << " SnarlRec, "
           << fCurrentSubRun->fMonitorRec << "/" << runEndMonitor
           << " MonitorRec "
           << endl;
      }
      else
        fCurrentSubRun->fConsistency &= ~DbuBits::kRecCountUnverified;

      // no matter what, pick the larger count
      // (not necessarily replace them with "official" counts)
      // any mismatch is probably due to Dispatcher not serving all streams
      if (fCurrentSubRun->fSnarlRec   < runEndSnarls )
          fCurrentSubRun->fSnarlRec   = runEndSnarls;
      if (fCurrentSubRun->fMonitorRec < runEndMonitor )
          fCurrentSubRun->fMonitorRec = runEndMonitor;
      
      VldTimeStamp startTime = runendblk->GetStartTime();
      VldTimeStamp endTime   = runendblk->GetEndTime();

      bool bogus_time = false;

      if (startTime != nullTime)
        fCurrentSubRun->fStartTime = startTime;
      else
        bogus_time = true;

      if (endTime   != nullTime)
        fCurrentSubRun->fEndTime   = endTime;
      else
        bogus_time = true;
      
      if (bogus_time) {
        MSG("Dbu",Msg::kError) 
          << "RunEnd block for " << fCurrentSubRun->fRun
          << " had either a bad start or end time " << endl
          << *runendblk << endl;
      } 
      
      fCurrentSubRun->fTermCode      = runendblk->GetTerminationCode();
      fCurrentSubRun->fNErr          = runendblk->GetNumberOfErrors();
      fCurrentSubRun->fTimeFrames    = runendblk->GetTotalTimeFrames();
      fCurrentSubRun->fDroppedFrames = runendblk->GetDroppedTimeFrames();
      
      // one can NOT!! assume that RunEnd is the last record 
      // for this run/subrun (based on empirical evidence)
      //
      // so don't even bother? ... just wait until start of next
      // run or end of job? -- no, that could be a long wait
      //
      if ( ! WriteSubRunSummaryEntry(false) ) result = JobCResult::kFailed;

   }
   else if (runstartblk && fRecAtStart) {
      // if recording on RunStart don't delete the entry
      if (!WriteSubRunSummaryEntry(false) ) 
         result = JobCResult::kFailed;
   }
   return result;
}

//......................................................................
Bool_t DbuDaqMonitorModule::WriteSubRunSummaryEntry(Bool_t remove)
{
   // Make (or update) entry in the database
   // optionally remove the current entry if requested

   // Because SubRunSummary is "special" we'll not use the std DBI
   // writer mechanism.  DBI doesn't allow user control of the SEQNO
   // and we want a very special value for that (to ease browsing
   // by users) so excute update using the low level DbiStatement.

   // automagically successful if we're not supposed to write
   // or if there's nothing to write
   if (!fRecSubRunSummary) return true;
   if (!fCurrentSubRun)    return true;
   // and unsuccessful if statement wasn't made
   if (!fDbiStatement)   return false;

   char tmpbuf[1024];
   sprintf(tmpbuf,"writing SubRunSummary for %c%8.8d_%4.4d",
           Detector::AsString(fCurrentSubRun->fDetector)[0],
           fCurrentSubRun->fRun,fCurrentSubRun->fSubRun);

   if (!fCurrentModified) {
     logDebug(4,"%s unmodified",tmpbuf);
     MSG("Dbu",Msg::kDebug) 
       << tmpbuf << " is unmodified" << endl;;

     // remove the fCurrentSubRun if requested
     if (remove) { delete fCurrentSubRun; fCurrentSubRun = 0; }
     return true;
   }

   logDebug(2,"%s started",tmpbuf);
   
   // protect ODBC code against signals
   DbuSignalHandler::Instance().Delay();
   
   
   // prepare to make a DBI entry
   // const char* tblName  = "DBURUNSUMMARY";
   // const char* tblDescr = DbuSubRunSummary::GetTableDescr();
   
   Int_t seqno = fCurrentSubRun->GetSeqNo();
   
   // entries are valid from time when run started to
   // the end of time (2038-01-19)
   
   string tbl  = "DBUSUBRUNSUMMARY";
   string tblv = "DBUSUBRUNSUMMARYVLD";
   
   // just blast away any existing entry
   DbiString sqlrm, sqlrmv;
   
   sqlrmv  << "delete from " << tblv << " where SEQNO=" << seqno << ";\0";
   sqlrm   << "delete from " << tbl  << " where SEQNO=" << seqno << ";\0";
   Bool_t rmv = fDbiStatement->ExecuteUpdate(sqlrmv.c_str());
   Bool_t rm  = fDbiStatement->ExecuteUpdate(sqlrm.c_str());
   
   // make sure the comment doesn't have stray " or ' characters
   std::string quoted_comment;
   UtilString::MakePrintable(fCurrentSubRun->fComment.c_str(),quoted_comment);

   // 
   DbiString sqlcol, sqlval;
   sqlcol << " SEQNO";
   sqlval << seqno;
   if (fHasRowCounter) {
       sqlcol << ", ROW_COUNTER";
       sqlval << "," << 0;
   }
   sqlcol << ", DETECTOR ";
   sqlval << ",'" << Detector::AsString(fCurrentSubRun->fDetector) <<"'";
   sqlcol << ", RUN ";
   sqlval << "," << fCurrentSubRun->fRun;
   sqlcol << ", SUBRUN ";
   sqlval << "," << fCurrentSubRun->fSubRun;
   sqlcol << ", RUNTYPE ";
   sqlval << "," << fCurrentSubRun->fRunType;
   sqlcol << ", RUNTYPENAME ";
   sqlval << ",'" << RunTypeName(fCurrentSubRun->fRunType,fCurrentSubRun->fDetector,fCurrentSubRun->fRun) <<"'";
   sqlcol << ", STARTTIME ";
   sqlval << ",'" << fCurrentSubRun->fStartTime.AsString("s") << "'";
   sqlcol << ", ENDTIME ";
   sqlval << ",'" << fCurrentSubRun->fEndTime.AsString("s") << "'";
   sqlcol << ", TERMCODE ";
   sqlval << "," << fCurrentSubRun->fTermCode;
   sqlcol << ", SNARLREC ";
   sqlval << "," << fCurrentSubRun->fSnarlRec;
   sqlcol << ", MONITORREC ";
   sqlval << "," << fCurrentSubRun->fMonitorRec;
   sqlcol << ", LIGHTINJREC ";
   sqlval << "," << fCurrentSubRun->fLightInjRec;
   sqlcol << ", NERR ";
   sqlval << "," << fCurrentSubRun->fNErr;
   sqlcol << ", TIMEFRAMES ";
   sqlval << "," << fCurrentSubRun->fTimeFrames;
   sqlcol << ", DROPPEDFRAMES ";
   sqlval << "," << fCurrentSubRun->fDroppedFrames;
   sqlcol << ", CONSISTENCY ";
   sqlval << "," << fCurrentSubRun->fConsistency;
   //sqlcol << ", COMMENT ";
   sqlcol << ", " << fCommentFieldName << " ";
   sqlval << ",'" << quoted_comment << "'";
   
   DbiString sqlinsert;
   sqlinsert << "insert into " << tbl
             << " ( " << sqlcol.c_str() << " ) "
             << " VALUES ( " << sqlval.c_str() << " ) ;\0";
      
   MSG("Dbu",Msg::kDebug) 
     << "insert into " << tbl
     << " ( " << sqlcol.c_str() << " ) "
     << " VALUES ( " << sqlval.c_str() << " ) ;"
     << endl;

   VldTimeStamp  now;
   if (fWrittenNTimes) {
     // if writing multiple times, advance time by sec each time
     // to avoid using the same CREATIONDATE
     VldTimeStamp offset((time_t)fWrittenNTimes,0);
     offset.Add(offset);
   }
   fWrittenNTimes++;

   VldTimeStamp& runstart = fCurrentSubRun->fStartTime;
   const VldTimeStamp endoftime(0x7fffffff,999999999);
   const Int_t task = 0;
   Int_t aggrno = -1;
#ifdef MULTIAGGREGATE
   aggrno = seqno;
#endif
   
   DbiString sqlcolv, sqlvalv;
   sqlcolv << " SEQNO";
   sqlvalv << seqno;
   sqlcolv << ", TIMESTART ";
   sqlvalv << ",'" << runstart.AsString("s") << "'";
   sqlcolv << ", TIMEEND ";
   sqlvalv << ",'" << endoftime.AsString("s") << "'";
   sqlcolv << ", DETECTORMASK ";
   sqlvalv << "," << fCurrentSubRun->fDetector;
   sqlcolv << ", SIMMASK ";
   sqlvalv << "," << fCurrentSubRun->fSimFlag;
   sqlcolv << ", TASK ";
   sqlvalv << "," << task;
   sqlcolv << ", AGGREGATENO ";
   sqlvalv << "," << aggrno;
   sqlcolv << ", CREATIONDATE ";
   sqlvalv << ",'" << now.AsString("s") << "'" ;
   sqlcolv << ", INSERTDATE ";
   sqlvalv << ",'" << now.AsString("s") << "'";
   
   DbiString sqlinsertv;
   sqlinsertv << "insert into " << tblv
              << " ( " << sqlcolv.c_str() << " ) "
              << " VALUES ( " << sqlvalv.c_str() << " ) ;\0";
   
   MSG("Dbu",Msg::kDebug) 
     << "insert into " << tblv
     << " ( " << sqlcolv.c_str() << " ) "
     << " VALUES ( " << sqlvalv.c_str() << " ) ;"
     << endl;

   Bool_t insert  = fDbiStatement->ExecuteUpdate(sqlinsert.c_str());
   Bool_t insertv = fDbiStatement->ExecuteUpdate(sqlinsertv.c_str());

   
   MSG("Dbu",Msg::kVerbose)
     << sqlinsert.c_str() << endl;
   MSG("Dbu",Msg::kVerbose)
     << sqlinsertv.c_str() << endl;
   
   MSG("Dbu",Msg::kDebug) 
     << tmpbuf
     << " Cbits " << fCurrentSubRun->fConsistency 
     << " rm/in " 
     << rm << "," << rmv << "/"
     << insert << "," << insertv 
     << endl;
   logDebug(3,"%s rm=%d,%d in=%d,%d @ %s",
            tmpbuf,rm,rmv,insert,insertv,now.AsString("s"));

   bool success = (insert && insertv);
   if (success) fCurrentModified = false;
   
   // remove the fCurrentSubRun if requested
   if (remove) { delete fCurrentSubRun; fCurrentSubRun = 0; }
   
   // done protecting ODBC code against signals
   DbuSignalHandler::Instance().HandleDelayedSignal();
   
   return success;
}


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

Bool_t DbuDaqMonitorModule::WriteVaChipPedsEntry(const RawPedestalTableBlock* pedblk)
{
   // unpack block, build db entries
   // send entries off to database

   RawBlockId rbid = pedblk->GetBlockId();
   Detector::Detector_t     det = rbid.GetDetector();
   SimFlag::SimFlag_t   simflag = rbid.GetSimFlag();

   Int_t crate = pedblk->GetCrateStatus()->GetCrate();
   VldTimeStamp loadTime = pedblk->GetLoadTime();

   // loaded values should be good for fVaChipVldSec seconds
   const VldTimeStamp timeVld(fVaChipVldSec,0);
   VldTimeStamp guessEndTime = loadTime;
   guessEndTime.Add(timeVld);

   VldRange vldr(det,simflag,loadTime,guessEndTime,"DBU");
   VldTimeStamp creationTime;

   // protect ODBC code against signals
   DbuSignalHandler::Instance().Delay();
   logInfo("DbuDaqMonitorModule::WriteVaChipPedsEntry() started crate %d",crate);
   
   // create a DbiWriter
   Int_t aggrno = crate;  // aggregate by crate (natural)
   Dbi::Task task = 0;
   DbiWriter<DbuVaChipPeds> writer(vldr,aggrno,task,creationTime,fDbNo);

   // prepare to loop
   DbuVaChipPeds* chip_peds = 0;

   Int_t nvalues = pedblk->GetNumberOfValues();
   // go one too far to ensure that last entry gets flushed
   // this approach assumes that entries for same chip are consecutive
   for (Int_t indx=0; indx<nvalues+1; indx++) {
      RawChannelId current_rcid;
      Int_t value;
      pedblk->GetPedValue(indx,current_rcid,value);
      if (chip_peds && !chip_peds->fRawChannelId.IsSameVAChip(current_rcid)) {
         // saw new chip, output the current entry
         // cout << *chip_peds << endl;

         writer << *chip_peds;

         // destroy this one now that we're done with it
         delete chip_peds; chip_peds = 0;
      }
      
      // if we just flushed old entry, build new one
      if (!chip_peds) chip_peds = new DbuVaChipPeds(current_rcid);

      // set the value
      Int_t vachan = current_rcid.GetVaChannel();
      if (vachan>=0 && vachan<=21) chip_peds->fChanPed[vachan] = value;
      else MSG("Dbu",Msg::kWarning) 
         << "Bad Channel on " << current_rcid.AsString()
         << " " << current_rcid.AsString("e") << endl;
   }
   
   if (chip_peds) {
      RawChannelId current_rcid = chip_peds->fRawChannelId;
      if (!current_rcid.IsNull()) {
         // this shouldn't happen
         MSG("Dbu",Msg::kWarning) 
            << "Orphan DbuVaChipPeds on " << current_rcid.AsString()
            << " " << current_rcid.AsString("e") << endl;
         cout << *chip_peds << endl;

         cout << *pedblk << endl;

         writer << *chip_peds;
      }
      // avoid any memory leaks
      delete chip_peds; chip_peds = 0;
   }

   bool success = writer.Close();

   logInfo("DbuDaqMonitorModule::WriteVaChipPedsEntry() success=%d",(int)success);

   // done protecting ODBC code against signals
   DbuSignalHandler::Instance().HandleDelayedSignal();

   return success;

}

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

Bool_t DbuDaqMonitorModule::WriteVaChipSparsEntry(const RawSparsifierTableBlock* pedblk)
{
   // unpack block, build db entries
   // send entries off to database

   RawBlockId rbid = pedblk->GetBlockId();
   Detector::Detector_t     det = rbid.GetDetector();
   SimFlag::SimFlag_t   simflag = rbid.GetSimFlag();

   Int_t crate = pedblk->GetCrateStatus()->GetCrate();
   VldTimeStamp loadTime = pedblk->GetLoadTime();

   // loaded values should be good for fVaChipVldSec seconds
   const VldTimeStamp timeVld(fVaChipVldSec,0);
   VldTimeStamp guessEndTime = loadTime;
   guessEndTime.Add(timeVld);

   VldRange vldr(det,simflag,loadTime,guessEndTime,"DBU");
   VldTimeStamp creationTime;

   // protect ODBC code against signals
   DbuSignalHandler::Instance().Delay();
   logInfo("DbuDaqMonitorModule::WriteVaChipSparsEntry() started crate %d",crate);

   // create a DbiWriter
   Int_t aggrno = crate;  // aggregate by crate (natural)
   Dbi::Task task = 0;
   DbiWriter<DbuVaChipSpars> writer(vldr,aggrno,task,creationTime,fDbNo);

   // prepare to loop
   DbuVaChipSpars* chip_spars = 0;

   Int_t nvalues = pedblk->GetNumberOfValues();
   // go one too far to ensure that last entry gets flushed
   // this approach assumes that entries for same chip are consecutive
   for (Int_t indx=0; indx<nvalues+1; indx++) {
      RawChannelId current_rcid;
      Int_t value;
      pedblk->GetThresholdValue(indx,current_rcid,value);
      if (chip_spars && !chip_spars->fRawChannelId.IsSameVAChip(current_rcid)) {
         // saw new chip, output the current entry
         // cout << *chip_spars << endl;

         writer << *chip_spars;

         // destroy this one now that we're done with it
         delete chip_spars; chip_spars = 0;
      }
      
      // if we just flushed old entry, build new one
      if (!chip_spars) chip_spars = new DbuVaChipSpars(current_rcid);

      // set the value
      Int_t vachan = current_rcid.GetVaChannel();
      if (vachan>=0 && vachan<=21) chip_spars->fChanPed[vachan] = value;
      else MSG("Dbu",Msg::kWarning) 
         << "Bad Channel on " << current_rcid.AsString()
         << " " << current_rcid.AsString("e") << endl;
   }
   
   if (chip_spars) {
      RawChannelId current_rcid = chip_spars->fRawChannelId;
      if (!current_rcid.IsNull()) {
         // this shouldn't happen
         MSG("Dbu",Msg::kWarning) 
            << "Orphan DbuVaChipSpars on " << current_rcid.AsString()
            << " " << current_rcid.AsString("e") << endl;
         cout << *chip_spars << endl;

         cout << *pedblk << endl;

         writer << *chip_spars;
      }
      // avoid any memory leaks
      delete chip_spars; chip_spars = 0;
   }

   bool success = writer.Close();

   logInfo("DbuDaqMonitorModule::WriteVaChipSparsEntry() success=%d",(int)success);

   // done protecting ODBC code against signals
   DbuSignalHandler::Instance().HandleDelayedSignal();

   return success;

}

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

void DbuDaqMonitorModule::Help()
{
  const char* n = this->GetName();

  MSG("Dbu",Msg::kInfo)
     << "Help for module " << n << endl
     << endl
     << "  A Dbu for generating RunSummary, VaChipPeds, and VaChipSpars entries" << endl
     << endl
     << "  /" << n << "/Record [which] ..." << endl
     << "  /" << n << "/Disregard [which] ..." << endl
     << "     controls which information to DBU" << endl
     << "     [which] is: " << endl
     << "        SubRunSummary - make DbuSubRunSummary entries" << endl
     << "        AtStart       - record upon seeing RunStart as well as RunEnd" << endl
     << "        VaChipPeds    - make VA chip pedestals" << endl
     << "        VaChipSpars   - make VA chip sparsification thersholds" << endl
     << "  /" << n << "/Set VaChipVldSec [nsec]" << endl
     << "     control the VLD TimeEnd validity beyond load time" << endl
     << endl;
  
}

---