OltNewModule.cxx

Go to the documentation of this file.

// $Id: OltNewModule.cxx,v 1.58 2006/12/03 02:15:30 gmieg Exp $
//
// OltNewModule.cxx
//
// Makes List of averages of pulser summaries
//
// Author: Phil Adamson 5/2002
//
// $Log: OltNewModule.cxx,v $
// Revision 1.58  2006/12/03 02:15:30  gmieg
// Add ' #include <cassert>'
//
// Revision 1.57  2006/05/22 19:33:13  rhatcher
// Initialize some local variables that gcc is worried might be used
// before they are set.
//
// Revision 1.56  2006/02/01 19:22:40  rhatcher
// Convert from DetectorType:: to Detector::.  Also remove some unnecessary
// #include lines (especially Conventions/DetectorType.h).
//
// Revision 1.55  2004/11/30 07:36:50  rhatcher
// react to modified RawChannelId ctor
//
// Revision 1.54  2004/04/02 17:58:59  rhatcher
// replace poor choice of variable name "TICK" with more descriptive VATICK.
// (TICK is defined on some systems as a macro substitution for the number
// of nanoseconds per tick; use of all caps for a non-cpp macro is still
// questionable).
//
// Revision 1.53  2003/10/22 20:26:10  rhatcher
// fill in the checksum value (via OnlineUtil's rdxsum_fill()) for the
// created RawSnarlHeaderBlock, RawDigitDataBlock and RawDeadChipBlocks.
// This avoids RotoObjectifier sending messages to syslog about bad
// checksums.  Which then get seen by the farm managers when processing
// CalDet data.  Why syslog you ask?  Because syslog is the only 'sensible'
// place for output of the online rotorooter; and there's no good way
// of telling OfflineTrigger's use of RotoObjectifier that it's not
// running in a online situation.  Not without setting up some global
// flag (and setting it in OfflineTrigger) and duplicating all the
// error messages to use either syslog or MessageService.
//
// Revision 1.52  2003/10/05 10:28:56  phil.adamson
// Fix TOF mismatch logic
// CVS doesn't like pcminos01 any more...
//
// Revision 1.51  2003/10/03 14:59:00  phil.adamson
// Add trigger bit (0x80) for SGATE
//
// Revision 1.50  2003/10/03 13:40:49  phil.adamson
// BE a little less verbose...
//
// Revision 1.49  2003/10/03 13:32:58  phil.adamson
// Ignore subrun end blocks - don't get confused about what file to write to.
//
// Revision 1.48  2003/09/19 13:49:43  phil.adamson
// UberDST spawning hack for Mike and Tricia
//
// Revision 1.47  2003/09/09 12:44:13  phil.adamson
// Cosmetic only chage to TOF printout
//
// Revision 1.46  2003/09/07 17:55:34  phil.adamson
// Cosmetic improvements
//
// Revision 1.45  2003/09/04 13:10:55  phil.adamson
// Minor bug-fixes - maybe crash less...
//
// Revision 1.44  2003/08/28 10:33:34  phil.adamson
// Fast trigger, with ND dead chips...
//
// Revision 1.43  2003/08/27 12:52:06  phil.adamson
// First commit of some CalDet debug tools
//
// Speed up trigger, plus add number of plane cut for event writing
//
// Revision 1.42  2003/08/13 15:34:05  phil.adamson
// Ting bugette fixed, plus a hack to drop QIE hits with erroneously
// large timestamps
//
// Revision 1.41  2003/08/13 11:08:07  phil.adamson
// Do plane triggering on ND hits as well as FD hits.
// fAllData now respects fExcludeMask, so to get all data, set AllData to true
// and set ExcludeMask to 0.
// Fix compile warnings in OltNewModule.cxx
//
// Revision 1.40  2003/04/15 17:59:28  phil.adamson
// Don't try to trigger pedestal runs
//
// Revision 1.39  2003/04/09 19:17:12  rhatcher
// * remove incorrect declaration of various static functions as "inline"
// * #ifdef away declaration of various unimplemented static functions
//   in OltTimeScan, OltEnds, and OltBlockScan.
// * for static functions of ToChip(), ToVmm() and ToChad() in OltNewModule
//   there is no point in returning "const int" (unlike cases like "const X*")
//   as that int can be assigned to a "int" directly without extra effort
//   (so the const hasn't protected you from modifying the result unless you
//   declare the holder of the result as "const int".)
//
// Revision 1.38  2003/03/21 18:01:03  buckley
// Replace ostrstream header with sstream to fix run time error using gcc3.2. Initialize pointers for RawTofConverter to prevent core dump
//
// Revision 1.37  2003/01/20 10:13:58  west
// Adapt to the code movement: RawData -> OnlineUtil.
//
// Revision 1.36  2002/11/22 22:24:57  bv
// Update to Registry::PrintStream() method
//
// Revision 1.35  2002/11/20 11:17:50  phil.adamson
// Fix brown paper bag error in priming of chad-plane lookup table.
// A VFB has 3 chips on it!
//
// Revision 1.34  2002/10/29 17:10:34  bv
//
// Turn down the firehose of memory leaks to hopefully a mere trickle.
// When you do a
//
//     TYPE* array = new TYPE[LENGTH];
//
// you _must_ delete it like:
//
//     delete [] array;
//
// If you do "delete array" you only delete the first element.
//
// Revision 1.33  2002/10/17 05:57:22  rhatcher
// various treatments to eliminate most (but not all) of the complaints
// about comparing signed and unsigned values; this reduces the noise
// that was hiding potentially more serious problems.
//
// Revision 1.32  2002/10/01 16:53:28  phil.adamson
// Don't associate ToFs in a mismatched timeframe. Better Summaries. No Pizza.
//
// Revision 1.31  2002/09/27 17:44:57  phil.adamson
// Fix exlclusion mask.
//
// Revision 1.30  2002/09/27 14:11:57  phil.adamson
// Now write config bits in a RawRunConfigBlock, have the counter write summary
// html bits as we go, and stuff
//
// Revision 1.29  2002/09/26 13:39:48  phil.adamson
// Also put the CVS id in the comment block
//
// Revision 1.28  2002/09/26 13:17:52  phil.adamson
// Write out config in a comment block, I hope
//
// Revision 1.27  2002/09/24 09:33:46  phil.adamson
// Add a triger mask to the bits you can set via the Registry. olt_tof.C
// does a tof-only trigger. Remember to whinge at Mark about the fact
// that you can't do Set("Number = 0xff") in a .C macro.
//
// Revision 1.26  2002/09/19 15:03:52  phil.adamson
// Allow the Counter to be turned off...
//
// Revision 1.25  2002/09/12 17:16:59  phil.adamson
// Better error logging
//
// Revision 1.24  2002/09/12 17:09:59  phil.adamson
// Tweak hist push-back threshold
//
// Revision 1.23  2002/09/11 13:00:53  phil.adamson
// More stringent cut on push-back VA hits
//
// Revision 1.22  2002/09/11 09:18:00  phil.adamson
// Sheepish admission of guilt: fix the vanishing ND hits bug
//
// Revision 1.21  2002/09/11 08:04:58  phil.adamson
// Add TimeScan, cosmetic fixups
//
// Revision 1.16  2002/09/10 09:50:39  phil.adamson
// Again
//
// Revision 1.15  2002/09/10 09:46:18  phil.adamson
// Teapot
//
// Revision 1.14  2002/09/10 07:39:45  phil.adamson
// Bug hunting...
//
// Revision 1.13  2002/09/09 15:00:43  phil.adamson
// Fix the TOF counting business....
//
// Revision 1.12  2002/09/08 15:52:03  phil.adamson
// *** empty log message ***
//
// Revision 1.11  2002/09/07 10:57:01  phil.adamson
// Be less verbose
//
// Revision 1.10  2002/09/06 17:17:47  phil.adamson
// Pass Tree in the counter...
//
// Revision 1.9  2002/09/06 14:30:50  phil.adamson
// "Null Trigger" mode
//
// Revision 1.8  2002/09/06 13:22:21  phil.adamson
// More configurables
//
// Revision 1.7  2002/09/05 09:33:45  phil.adamson
// Add the Registry config for OltCounter, a few small wrinkles
//
// Revision 1.6  2002/09/04 10:28:01  phil.adamson
// Now we use the Registry config method... phil
//
// Revision 1.5  2002/08/30 08:31:22  phil.adamson
// Whoops!
//
// Revision 1.4  2002/08/30 08:29:07  phil.adamson
// Now should work for the mixed CalDet mode with far and near electronics
// We don't actually consider ND hits for the trigger, though, as there's only
// a few PMTs
//
//

#include "JobControl/JobCModuleRegistry.h"
#include "MinosObjectMap/MomNavigator.h"
#include "OfflineTrigger/OltNewModule.h"
#include "MessageService/MsgService.h"
#include "RawData/RawRecord.h"
#include "RawData/RawHeader.h"
#include "RawData/RawDataBlock.h"
#include "RawData/RawDaqHeaderBlock.h"
#include "RawData/RawSnarlHeaderBlock.h"
#include "RawData/RawChannelId.h"
#include "RawData/RawRunConfigBlock.h"
#include "RawData/RawDaqHeader.h"

#include "Persistency/PerOutputStreamManager.h"
#include "Persistency/PerOutputStream.h"
#include "Rotorooter/RotoObjectifier.h"
#include "Plex/PlexHandle.h"
#include "Plex/PlexSEIdAltL.h"

#include "TString.h"
#include "TSystem.h"
#include <string>

#include <algorithm>
#include <cassert>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <fstream>
#include <sstream>
#include <unistd.h>
#ifndef __CINT__
#include "OnlineUtil/mdBlockDefinitions.h"
#endif
#include "OnlineUtil/rdChecksum.h"
ClassImp(OltNewModule)

  // ......

CVSID("$Id: OltNewModule.cxx,v 1.58 2006/12/03 02:15:30 gmieg Exp $");
JOBMODULE(OltNewModule,"OltNewModule","The Offline Trigger");

const double OltNewModule::VATICK(1.5625);

void OltNewModule::Config(const Registry& r)
{
  const char *s;
  double d;
  int b;
  int i;
  if (r.Get("OutDir",s)) fOutDir = std::string(s);
  if (r.Get("CounterDir",s)) fCounterDir = std::string(s);
  if (r.Get("LinkDir",s)) fSymlinkDir = std::string(s);
  if (r.Get("SummaryDir",s)) fSummaryDir = std::string(s);
  if (r.Get("QieOffset",d)) fQieOffset = int(d);
  if (r.Get("SpyMode",b)) fSpyMode = bool(b);
  if (r.Get("ChadTOF",i)) chad_TOF = i;
  if (r.Get("ChadCER1",i)) chad_CER1 = i;
  if (r.Get("ChadCER2",i)) chad_CER2 = i;
  if (r.Get("ChadCER3",i)) chad_CER3 = i;
  if (r.Get("ChadTRIGPMT",i)) chad_TRIGPMT = i;
  if (r.Get("ChadNDTIMING",i)) chad_ND_TIMING = i;
  if (r.Get("AllData",b)) fAllData = bool(b);
  if (r.Get("UseCounter",b)) fUseCounter = bool(b);
  if (r.Get("TrigMask",i)) fTrigMask = i;
  if (r.Get("ExcludeMask",i)) fExcludeMask = i;
  if (r.Get("NumPlanes",i)) fNumPlanes = i;
  if (r.Get("NDFiducialADCCut",i)) fNDFiducialADCCut = i;
  if (r.Get("NewRun",b)) fNewRun = bool(b);
  if (r.Get("NewRunScript",s)) fNewRunScript = std::string(s);
}

const Registry& OltNewModule::DefaultConfig() const
{
  static Registry r;
  std::string name = this->JobCModule::GetName();
  name +=".config.default";
  r.SetName(name.c_str());

  // Set defaults
  r.UnLockValues();
  r.Set("OutDir","/data/dataout");
  r.Set("CounterDir","/data/histos");
  r.Set("LinkDir","/data");
  r.Set("SummaryDir","/data");
  r.Set("QieOffset",float(208/VATICK)); 
  r.Set("SpyMode",false);
  r.Set("ChadTOF",CHAD_TOF);
  r.Set("ChadCER1",CHAD_CER1);
  r.Set("ChadCER2",CHAD_CER2);
  r.Set("ChadCER3",CHAD_CER3);
  r.Set("ChadTRIGPMT",CHAD_TRIGPMT);
  r.Set("ChadNDTIMING",CHAD_ND_TIMING);
  r.Set("AllData",false);
  r.Set("UseCounter",true);
  r.Set("TrigMask",0xff);
  r.Set("ExcludeMask",0);
  r.Set("NumPlanes",4);
  r.Set("NDFiducialADCCut",1000);
  r.Set("NewRun",false);
  r.Set("NewRunScript","/bin/echo");
 r.LockValues();

  return r;
}


OltNewModule::OltNewModule()
{
  fOutputStreamManager = new PerOutputStreamManager();
  fSpyStreamManager = new PerOutputStreamManager();

  const char * dir = gSystem->Getenv("OLT_OUTPUT_DIR");
  if (dir) fOutDir = string(dir);
  dir = gSystem->Getenv("OLT_LINK_DIR");
  if (dir) fSymlinkDir = string(dir);
  fAccessMode = Per::kNew;
  fFileOpen = false;
  fSpyOpen = false;
  fDetector = Detector::kUnknown;
  fRun = 0;
  fSubrun = 0;
  fCounter = 0;
  fCurrentTF = 0;
  fLastTF = 1;
  fTimeframe[0] = -10;
  fTimeframe[1] = -10;
  fToFConverter[0] = 0;
  fToFConverter[1] = 0;
  fNumToFHits[0] = 0;
  fNumToFHits[1] = 0;
  fGap = 100;
  fFirst = true;
  
  fDeadChipBuffer = 0;
  fDeadChipLastBuffer = 1;
   for (int i=0;i<NCRATES;i++) {
      fExtraHits[i].reserve(4000);
      fSortedHits[i].reserve(400000);
    for (int tf=0;tf<2;tf++) {
      fQieFreeTime[tf].push_back(map<int,int>());
      fChipFreeTime[tf].push_back(map<int,int>());
      fVmmFreeTime[tf].push_back(map<int,int>());
      fHits[tf][i].reserve(400000);
      fCrateId[tf][i] = 0;
      fCrateSec[tf][i]=0;
      fCrateNsec[tf][i]=0;
      
      // And Set times in DeadChip maps to prehistory...
      for (int varc=0;varc<3;varc++) {
        for (int vmm=0;vmm<6;vmm++) {
          for (int adc=0;adc<2;adc++) {
            for (int chip=0;chip<3;chip++) {
              fChipFreeTime[tf][i][ToChad(varc,vmm,adc,chip,0)] = -1000000;   
            }
          }
          fVmmFreeTime[tf][i][ToChad(varc,vmm,0,0,0)] = -1000000;   
        }
      }
      for (int master = 0 ; master < 32 ; master++ ) {
        for (int minder = 0 ; minder < 8 ; minder+=4 ) {
          int menu=0;
          RawChannelId rcid(Detector::kCalDet, 
                            ElecType::kQIE,
                            i,master,minder,menu);
          int chadmask = rcid.GetEncoded()&0x1fff;
          fQieFreeTime[tf][i][chadmask] = -1000000;
        }
      }
    }
   }
   fBuffer = new unsigned long[200000]; //10k words should be enough
   fDeadBuf = new unsigned long[5000]; //1k words should be enough
   fToFOutputArray = new unsigned long[200]; // Will be short!
   fEventNo = 0;
   fTofIndex = 0;
   fRecord = 0;
   
   fHaveNDTimingHit = false;
}

OltNewModule::~OltNewModule()
{
  if (fFileOpen) CloseFile(fDetector,fRun,fSubrun);
  if (fSpyOpen) CloseSpy(fDetector,fRun,fSubrun);
  if (fCounter) fCounter->WriteSummary();
  if (fCounter) {
    MSG("Olt",Msg::kInfo)<<"Deleting counter"<<endl;
    delete fCounter;
    MSG("Olt",Msg::kInfo)<<"Done"<<endl;
  }
    MSG("Olt",Msg::kInfo)<<"Deleting buffer"<<endl;
  delete [] fBuffer;
  delete [] fDeadBuf;
  delete [] fToFOutputArray;
    MSG("Olt",Msg::kInfo)<<"Done"<<endl;
}

JobCResult OltNewModule::Reco(MomNavigator* mom)
{
  // Find RawRecord fragment in MOM.
  TIter iter = mom->FragmentIter();
  while (TObject *obj = iter.Next()) {
    RawRecord *rawrec = dynamic_cast<RawRecord *>(obj);
    if (rawrec) {
      ++fRecord;
      MSG("Olt",Msg::kDebug)<<"Record "<<fRecord<<endl;
      if (rawrec->FindRawBlock("RawSubRunEndBlock")) continue;
      // if (fRecord>5160) {
        {
      // Find a HeaderBlock and get Run number etc.
      int run=0,subrun=0,runtype=0;
      Detector::Detector_t detector = Detector::kUnknown;
      const RawDaqHeaderBlock *rdhb = dynamic_cast<const RawDaqHeaderBlock *>
        (rawrec->FindRawBlock("RawDaqHeaderBlock"));
      if (rdhb) {
        run = rdhb->GetRun();
        subrun = rdhb->GetSubRun();
        detector = rdhb->GetVldContext().GetDetector();
        runtype = rdhb->GetRunType();
        //MSG("Olt",Msg::kInfo)<<rdhb->GetVldContext()<<endl;
      }
      const RawSnarlHeaderBlock *rshb = dynamic_cast<const RawSnarlHeaderBlock *>(rawrec->FindRawBlock("RawSnarlHeaderBlock"));
      if (rshb) {
        run = rshb->GetRun();
        subrun = rshb->GetSubRun();
        detector = rshb->GetVldContext().GetDetector();
        //MSG("Olt",Msg::kInfo)<<rshb->GetVldContext()<<endl;
        //If first raw record, fill map for plane lookup
        //We only trigger on VA electronics at the moment.
        if (fFirst) {
          VldContext vld = rshb->GetVldContext();
          PlexHandle plex(vld);
          for (int crate = 0; crate<2;crate++) {
            for (int varc=0;varc<3;varc++) {
              for (int vmm=0;vmm<7;vmm++) {
                for (int vaadc = 0;vaadc<2;vaadc++) {
                  for (int chip=0;chip<3;chip++) {
                    for (int channel = 2; channel < 18 ; channel ++) {
                      RawChannelId rcid(Detector::kCalDet,
                                        ElecType::kVA,
                                        crate,varc,vmm,vaadc,chip,channel);
                      PlexSEIdAltL seid = plex.GetSEIdAltL(rcid);
                      int plane = seid.GetPlane();
                      fPlane[crate][channel + (chip<<5) + (vaadc<<7) +
                                   (vmm<<8) + (varc<<11)] = plane+1;
                    }
                  }
                }
              }
            }
          }
          // This is a bit of a hack - do this better later
          for (int crate = 1 ; crate < 3 ; crate++) {
            for (int master = 0 ; master < 32 ; master++ ) {
              for (int minder = 0 ; minder < 8 ; minder++ ) {
                for (int menu = 0 ; menu < 16 ; menu++ ) {
                  RawChannelId rcid(Detector::kCalDet, 
                                    ElecType::kQIE,
                                    crate,master,minder,menu);
                  PlexSEIdAltL seid = plex.GetSEIdAltL(rcid);
                  int plane = seid.GetPlane();
                  if (plane>-1&&plane<60) 
                    fQiePlane[crate][rcid.GetEncoded()&0x1fff] = plane+1;
                }
              }
            }
          }
          fFirst = false;
        }
      }
      if (rdhb || rshb) {
        //MSG("Olt",Msg::kInfo)<<"Run "<<run<<" Subrun "<<subrun<<endl;
        if (fRun == run && fSubrun == subrun && fFileOpen) {
  // OK - we have the right file open
        }
        else {
          if (fFileOpen) {
            // Process last TF before closing file.
            for (int i=0;i<fCrates;i++) {
              fSortedHits[i].resize(fHits[fLastTF][i].size());
              copy(fHits[fLastTF][i].begin(),fHits[fLastTF][i].end(),
                   fSortedHits[i].begin());
              if (fCrateId[fLastTF][i] & 0x40) {
                // QIE electronics if this bit is set
                sort(fSortedHits[i].begin(),fSortedHits[i].end(),qiesorter());
              } else {
              sort(fSortedHits[i].begin(),fSortedHits[i].end(),hitsorter());
              }    
            }
            MSG("Olt",Msg::kInfo)<<"Last Timeframe "
                                 <<fTimeframe[fLastTF]<<endl;
            string rotoStrmName = Form("%c%8.8d_%4.4d",
                                       Detector::AsString(fDetector)[0],
                                       fRun,fSubrun);
            rotoStrmName += ".DaqSnarl";
            if (fTimeframe[fLastTF] >0) FormEvents(fLastTF,rotoStrmName);
            CloseFile(fDetector,fRun,fSubrun);
            for (int i=0;i<fCrates;i++) {
              fHits[fLastTF][i].clear();
              fSortedHits[i].clear();
              fExtraHits[i].clear();
            }
             fTimeframe[fLastTF]=-10;
             fNumToFHits[fLastTF] =0;
          }
          if (fSpyOpen) CloseSpy(fDetector,fRun,fSubrun);
          if (fRun !=run) {
            fEventNo=0;
          }
          if (fCounter) fCounter->WriteSummary();
          // Hack for Mike and Tricia here!
          if (fNewRun && (run!=fRun)) {
            // New run, so run script in background.
            char c[100];
            sprintf(c,"%d",fRun);
            string s = fNewRunScript +" "+string(c)+ " &";
            system(s.c_str());
          }
        
          fRun = run;
          fSubrun = subrun;
          fDetector = detector;
          fRunType = runtype;
          fFileOpen = OpenFile(fDetector,fRun,fSubrun);
          if (fSpyMode) fSpyOpen = OpenSpy(fDetector,fRun,fSubrun);
          if (fCounter) delete fCounter;
          if (fUseCounter) fCounter = new OltCounter(fRun,fSubrun,fCounterDir.c_str(),fSummaryDir);
        }
        }
      if (fRunType==1) return JobCResult::kFailed;

      const char  *streamname =0;
      if ( rawrec -> GetTempTags().Get("stream",streamname) )
              MSG("Olt",Msg::kVerbose) << "stream " << streamname << endl;
      TIter recit = rawrec->GetRawBlockIter();
      while (TObject *obj = recit.Next()) {
        RawDataBlock *rawdata = dynamic_cast<RawDataBlock *>(obj);
        if (rawdata) {
          MSG("Olt",Msg::kVerbose) <<rawdata->GetBlockId()<<endl;
        }
      }
      // Write records
      string rotoStrmName = 
        Form("%c%8.8d_%4.4d",Detector::AsString(detector)[0],run,subrun);
      string sname = streamname;
      if (sname == "DaqSnarl") {
        // Do triggering here
        ProcessTimeframe(rawrec,rotoStrmName + "." + streamname);
      }
      else {
        if (sname == "DaqMonitor") {
          // Here's a monitor block - construct one of Mike's 
          // decoder objects. Have two pointers for these, like [tf].
          fToFConverter[fCurrentTF] = new RawTofConverter(rawrec);
          //  fCounter->NumTDC(fTimeframe[fCurrentTF],
          //               fToFConverter[fCurrentTF]->GetNumberOfRawTOFBlocks());
          MSG("Olt",Msg::kDebug)<<"Got TOF TDC data for "<<fCurrentTF<<"  "<<fTimeframe[fCurrentTF]<<endl;
        }
        rotoStrmName = rotoStrmName + "." + streamname;
        if (!fOutputStreamManager) {
          MSG("Olt",Msg::kError) << "No output stream manager"<<endl;
          return JobCResult::kFailed;
        }
        PerOutputStream* stream = 0;
        stream = dynamic_cast<PerOutputStream*>
          (fOutputStreamManager->GetOpenedStream(rotoStrmName));
        if (!stream) {
          MSG("Olt",Msg::kError) << "Can't find stream "<<rotoStrmName<<endl;
          return JobCResult::kFailed;
        }
        stream->SetObject(rawrec);
        stream->Store();
      }
    }
  }
  }
  return JobCResult::kAOK;
}

bool OltNewModule::OpenFile(Detector::Detector_t det, Int_t run, Int_t subrun)
{
  // Open file for output. Name file *.tdaq.root for triggered data
  // Stolen from the Rotorooter...
  string fname = 
    Form("%c%8.8d_%4.4d",Detector::AsString(det)[0],run,subrun);
  
  string filename = fOutDir + "/" + fname + ".tdaq.root";
  bool ok = true;
  int fversion = 0;
  // 3 streams in daq file
  for (int i = Per::kDaqSnarl;i<=Per::kLightInjection;i++) {
    Per::EStreamType stype = (Per::EStreamType) i;
    string treeName = Per::AsString(stype);
    string rotoStrmName = fname + "." + treeName;
    int compressionLevel = 1; // ROOT Default
    PerOutputStream* astream =
      fOutputStreamManager->OpenStream(rotoStrmName,treeName,
                                       "RawRecord","","",Per::kRecSplit,
                                       64000,compressionLevel);
    if (astream) {
      astream->SetAutoSave(0,0); // Turn off autosave
      bool openok = 
        fOutputStreamManager->SetFile(rotoStrmName,filename,fAccessMode);
      MSG("Olt",Msg::kInfo) << "Opened stream "<<rotoStrmName
                            << " on file "<<filename<<endl;
      // handle potential case where file already exists
      // and the rotorooter is in kNew not kRecreate mode
      Per::EErrorCode ecode = astream->GetErrorCode();
      if (Per::kErrFileExists == ecode) {
        string basefilename = filename;
        string::size_type where = filename.rfind(".t");
        if (string::npos == where) where = filename.rfind(".root");
        if (string::npos == where) where = filename.length();
        bool keep_trying = true;
        // start adding version numbers
        do {
          ++fversion;
          filename = basefilename;  // without any attempt at versioning
          filename.insert(where,Form(".%d",fversion));
          openok = 
            fOutputStreamManager->SetFile(rotoStrmName,filename,fAccessMode);
          if (Per::kErrSuccess != ecode) {
          MSG("Olt",Msg::kInfo) << "Open versioned file saw Per error: "
                                <<Per::AsString(ecode)<<endl;
          }
          
          ecode = astream->GetErrorCode();
          keep_trying = (fversion<100) &&
            (Per::kErrFileExists == ecode);
        } while (keep_trying);
        // report if there was success
        if (Per::kErrSuccess == ecode) 
          MSG("Olt",Msg::kInfo) << "Open stream on file: "
                                <<filename<<endl;
        
      } // file exists error
      
      if (Per::kErrSuccess != ecode) {
        MSG("Olt",Msg::kInfo) << "Open stream saw Per error: "
                              <<Per::AsString(ecode)<<endl;
      }
     ok = ok & openok;     
    } 
    else {
      ok = false;
    }

  } 
  fCurrentFilename = filename;
  string rotoStrmName = 
    Form("%c%8.8d_%4.4d",Detector::AsString(fDetector)[0],fRun,fSubrun);
  WriteConfig(rotoStrmName + "." + "DaqMonitor");
  return ok;
}

  
bool OltNewModule::CloseFile(Detector::Detector_t det, Int_t run, Int_t subrun)
{
  // Close output file. Name file *.tdaq.root for triggered data
  // Stolen from the Rotorooter...
  string fname = 
    Form("%c%8.8d_%4.4d",Detector::AsString(det)[0],run,subrun);
  
   // 3 streams in daq file
  for (int i = Per::kDaqSnarl;i<=Per::kLightInjection;i++) {
    Per::EStreamType stype = (Per::EStreamType) i;
    string treeName = Per::AsString(stype);
    string rotoStrmName = fname + "." + treeName;
    fOutputStreamManager->Write(rotoStrmName);
    fOutputStreamManager->CloseStream(rotoStrmName);
    MSG("Olt",Msg::kInfo)<<"Closing stream "<<rotoStrmName<<endl;
   }

  //  string filename = fOutDir + "/" + fname;
  string link = fOutDir + "/LastFileTriggered";
  string mylink = fSymlinkDir + "/" + fname + ".tdaq.root";
  unlink(mylink.c_str());
  symlink(fCurrentFilename.c_str(),mylink.c_str());
  unlink(link.c_str());
  symlink(fCurrentFilename.c_str(),link.c_str());
  return true;
}

void OltNewModule::ProcessTimeframe(RawRecord *rawrec, string rotoStrmName)
{
  TIter iter = rawrec->GetRawBlockIter();
  while (RawDataBlock *rdb = dynamic_cast<RawDataBlock *>(iter.Next())) {
    if (rdb->InheritsFrom("RawSnarlHeaderBlock")) {
      RawSnarlHeaderBlock *rshb =dynamic_cast<RawSnarlHeaderBlock *>(rdb);
      fTimeframe[fCurrentTF] = rshb->GetTimeFrameNo();
      MSG("Olt",Msg::kVerbose) << "Processing Timeframe "<<fTimeframe[fCurrentTF]<<endl;
    }
    if (rdb->InheritsFrom("RawDigitDataBlock")) {
      int size = rdb->GetSize();
      const int *block = rdb->GetData();
      MSG("Olt",Msg::kVerbose)<<"Data block size: "<<size<<endl;
  
      int offset = 3;
      int thecrate = -1;
      while (offset< size-3) {
        // Pick up all the crates in the datablock
        ++thecrate;
        assert(thecrate<NCRATES);
        int crateid = block[offset++];
        int nentries = block[offset++];
        int t0sec = block[offset++];
        int t0nsec = block[offset++];
        int biggesttime=0; // biggest time for data that hasn;t strayed into
                           // the next tf
        fCrateId[fCurrentTF][thecrate] = crateid;
        fCrateSec[fCurrentTF][thecrate] = t0sec;
        fCrateNsec[fCurrentTF][thecrate] = t0nsec;
        if (fTimeframe[fCurrentTF]>0) {
          //assert(fCrateId[fCurrentTF][thecrate]==fCrateId[fLastTF][thecrate]);
        }
        if (crateid & 0x40) {
          // cout<<"Crate "<<thecrate<<" QIE\n";
          fElec[thecrate] = 2;
          // QIE
          for (int i=0;i<nentries;i++) {
            // We don't do anything with the QIE data here, just push it on
            // the vector...
            long long *qiedata = (long long *)(block + offset);
            // Hack to drop hits with times greater than 1s
            int thetime = ToVaTime((reinterpret_cast<QieHit *>(qiedata))->timeStamp);
            if (thetime > 650000000) {
              MSG("Olt",Msg::kWarning)<<"Dropping QIE hit with VA timestamp "
                                      << thetime<<endl;
            } else {
            fHits[fCurrentTF][thecrate].push_back(*qiedata);
            }
            offset +=2;
          }
        } else {
          //cout<<"Crate "<<thecrate<<" VA\n";
          fElec[thecrate] = 1;
          //VA
          for (int i=0;i<nentries;i++) {
            VaHit *hit = (VaHit *)(block + offset);
            if (thecrate==0 && hit->chad == (unsigned int)chad_ND_TIMING) {
              // Got the ND timing hit.
              MSG("Olt",Msg::kDebug)<<"Timeframe "<<fTimeframe[fCurrentTF]<<" timing hit: ";
              MSG("Olt",Msg::kDebug)<<"Timestamp "<<int(hit->timeStamp)<<" adc "<<int(hit->adcValue)<<endl;
              if (hit->adcValue>fNDFiducialADCCut) {
              fNDTimingHit[fCurrentTF] = *(reinterpret_cast<long long *>(hit));
              fHaveNDTimingHit = true;
              } else {
                MSG("Olt",Msg::kWarning)<<"Ignoring ND fiducial at time "<<int(hit->timeStamp)<<" with adc "<<int(hit->adcValue)<<endl;
              }
              if (hit->timeStamp>(1000/VATICK)) MSG("Olt",Msg::kWarning)<<
                  "Late ND fiducial at time "<<int(hit->timeStamp)<<
                  " with adc "<<int(hit->adcValue)<<endl;
            }
            if (thecrate==0 && hit->chad == (unsigned int)chad_TOF) {
              ++fNumToFHits[fCurrentTF];
              // if we've produced a -ve number, push the ToF hit to the 
              // previous TF.
              // if (hit->timeStamp<TOF_TARDIS) hit->timeStamp+=ONE_SECOND;
              if (hit->timeStamp<TOF_TARDIS) hit->timeStamp=TOF_TARDIS;
              hit->timeStamp-=TOF_TARDIS;
            }
            int time = hit->timeStamp;
            
            // Might need to put the ToF tardis in here...
            if (time >635000000 && biggesttime < 5000000) {
                                                  
              if (thecrate==0 && hit->chad == (unsigned int)chad_TOF) --fNumToFHits[fCurrentTF];
                      // data really belongs to previous tf
              MSG("Olt",Msg::kDebug)<<"Pushing hit with time "<<time
                                      <<"to previous tf"<<endl;
              if (fTimeframe[fCurrentTF] == 1+fTimeframe[fLastTF]) {
                //push the hit back
                fExtraHits[thecrate].push_back(*(reinterpret_cast<long long *>(hit)));        
                if (thecrate==0 && hit->chad == (unsigned int)chad_TOF) ++fNumToFHits[fLastTF];
              }
              else {
                if (fTimeframe[fCurrentTF]>0) {
                  MSG("Olt",Msg::kWarning)<<"Not pushing hit to previous tf: "
                                          <<fTimeframe[fCurrentTF]
                                          <<" does not follow "
                                          <<fTimeframe[fLastTF]<<endl;
                }
              }
            }
            else {
              biggesttime = time;
              fHits[fCurrentTF][thecrate].push_back(*(reinterpret_cast<long long *>(hit)));
            }
            
            offset +=2;
          }
        }
      }
      fCrates = thecrate + 1;
      fCrates = NCRATES;
    }
  }
  // Now Sort This tf, sort extras and insert into last tf.

  for (int i=0;i<fCrates;i++) {
    fSortedHits[i].resize(fHits[fLastTF][i].size() + fExtraHits[i].size());
    copy(fHits[fLastTF][i].begin(),fHits[fLastTF][i].end(),
         fSortedHits[i].begin());
    copy(fExtraHits[i].begin(),fExtraHits[i].end(),
         fSortedHits[i].begin()+fHits[fLastTF][i].size());
    if (fCrateId[fLastTF][i] & 0x40) {
      // QIE electronics if this bit is set
      sort(fSortedHits[i].begin(),fSortedHits[i].end(),qiesorter());
    } else {
      sort(fSortedHits[i].begin(),fSortedHits[i].end(),hitsorter());
    }
  }

  if ((fTimeframe[fLastTF]%60)==0) {
    MSG("Olt",Msg::kInfo)<<"Timeframe "
                         <<fTimeframe[fLastTF]<<endl;
  } else {
    MSG("Olt",Msg::kDebug)<<"Timeframe "
                          <<fTimeframe[fLastTF]<<endl;
    
  }
 // fLastTF is now guaranteed complete, so form events from it.
  // But ditch TF 0
    if (fTimeframe[fLastTF] >0) FormEvents(fLastTF,rotoStrmName);
  // OK - we've seen all the blocks in this record now, so swap the buffers.
if ((fTofIndex>0) || (fNumToFHits[fLastTF]>0)) 
  MSG("Olt",Msg::kInfo) << "TOF: " << fTofIndex << " TDCs, "
                        << fNumToFHits[fLastTF] << " hits\n";

  swap(fCurrentTF,fLastTF);
  fNumToFHits[fCurrentTF] = 0;
  if (fUseCounter && (fTimeframe[fLastTF]%10)==0)fCounter->Write();
  if (fSpyMode && (fTimeframe[fLastTF]%120)==0)
    {
      CloseSpy(fDetector,fRun,fSubrun);
      fSpyOpen = OpenSpy(fDetector,fRun,fSubrun);
    }
  // Dead chip business needs resetting!
  for (int crate=0; crate<fCrates; crate++) {
    for (int buf=0;buf<2;buf++) {
      map<int,int>::iterator it;
      for (it = fVmmFreeTime[buf][crate].begin();
           it !=fVmmFreeTime[buf][crate].end(); it++) {
        (*it).second = min((*it).second-int(1.0e9/VATICK),-2*DEADTIME); // Subtract a second.
      }
      for (it = fChipFreeTime[buf][crate].begin();
           it !=fChipFreeTime[buf][crate].end(); it++) {
        (*it).second = min((*it).second-int(1.0e9/VATICK),-2*DEADTIME); // Subtract a second.

      }
      for (it = fQieFreeTime[buf][crate].begin();
           it!= fQieFreeTime[buf][crate].end(); it++) {
        (*it).second = -2*QIEDEADTIME;
      }
    }
  }
 
  MSG("Olt",Msg::kVerbose)<<"Timeframe "<<fLastTF<<":"
                          <<fTimeframe[fLastTF]<<"  "
                          <<fCurrentTF<<":"
                          <<fTimeframe[fCurrentTF]<<endl;
  // and clear the maps ready for the new timeframe

  for (int i=0;i<fCrates;i++) {
    fHits[fCurrentTF][i].clear();
    fSortedHits[i].clear();
    fExtraHits[i].clear();
  }
 if (fUseCounter && fToFConverter[fCurrentTF]) fCounter->NumTDC(fTimeframe[fCurrentTF],
                   fToFConverter[fCurrentTF]->GetNumberOfRawTOFBlocks());
  delete fToFConverter[fCurrentTF];
  fToFConverter[fCurrentTF]=0;
  if (fUseCounter) fCounter->NumTOF(fTimeframe[fCurrentTF],fTofIndex);
  fTofIndex = 0;
}

void OltNewModule::FormEvents(int tf,string rotoStrmName)
{
  unsigned int start[NCRATES]={0};
  unsigned int end[NCRATES]={0};
  unsigned int hitit[NCRATES]={0};
  // indexes over the hitmap for a crate
 
  int teventstart;
  int teventend;
  //unused: int firstcrate;

  // Three iterators. start and end delimit events, hitit is the one 
  // that actually gets advanced over the hits.
  // Also meet hitplane the array. This gets a true if a plane is hit
  // so we can then use it in the trigger decision.

  bool hitplane[100]; // CalDet!!!
  memset(hitplane,0,sizeof(hitplane));

  // Let's tell the Counter how many hits each crate had:
  if (fUseCounter) {
    for (int crate=0; crate<fCrates;crate++) {
      fCounter->RawHits(fTimeframe[tf],crate,fSortedHits[crate].size());
    }
  }

  for (;;) {
    bool nomorehits = true;
    Trigbits trigbits;
    int n[NCRATES+1]={0};
    //unused: int lastchip=-1;
    //unused: Is not unused! Look down 8 lines, and 16 lines!
    int firstcrate;
    teventstart=1000000000L; // times are always less than this.
    
    for (int crate=0; crate<fCrates ; crate++) {
      bool nohitsleft=(hitit[crate] >= fSortedHits[crate].size());
      nomorehits &=nohitsleft;
      int thistime;
      if (fCrateId[tf][crate] & 0x40) {
        // QIE electronics if this bit is set 
        thistime = ToVaTime((reinterpret_cast<QieHit *>(&fSortedHits[crate][hitit[crate]]))->timeStamp);
      } else {
        thistime = (reinterpret_cast<VaHit *>(&fSortedHits[crate][hitit[crate]]))->timeStamp;
      }
      if (!nohitsleft && thistime < teventstart) {
        teventstart = thistime;
        firstcrate = crate;
      }
    }
    if (nomorehits) break;
    teventend = teventstart;
    MSG("Olt",Msg::kVerbose) << "Start at "<<teventstart<<" in crate "<<firstcrate<<" of "<<fCrates<<endl;
    // Suck up first crate's worth...
    n[firstcrate]+=SuckCrate(firstcrate,hitit[firstcrate],hitplane,
                             trigbits,teventend,tf);
    end[firstcrate] = hitit[firstcrate];

    // Now loop over all crates until no more added hits.
    for (;;) {
      int nAdded = 0;
      for (int crate=0;crate<fCrates ; crate++) {
        int num = SuckCrate(crate,hitit[crate],hitplane,
                            trigbits,teventend,tf);
        nAdded +=num;
        n[crate]+=num;
        end[crate] = hitit[crate];
      }
      if (nAdded == 0) break;
    }

    int sum[6][61]={{0},{0}}; // 1 = 2/3, 5 = 6/7
    int atplane[6]={0};

   for (int i=1;i<60;i++) {
      sum[0][i] = int(hitplane[i]) + int(hitplane[i+1]);
    }
    for (int j=1;j<6;j++) {
      for (int i=60;i>0;i--) {
        sum[j][i] = sum[j-1][i] + int(hitplane[i+j+1]);
        if (sum[j][i]>=j+1) atplane[j] = i;
      } 
    }

    int nplanes=0;
    int trigword = 0;
    
    for (int i=5;i>0;i--) {
      if (atplane[i]>0) {
        MSG("Olt",Msg::kDebug)<<"Trigger "<<i+1<<"/"<<i+2<<" at plane "
                                <<atplane[i]<<endl;
        nplanes = i+1;
        trigword = ((i+1)<<TRIG_NUM_SHIFT) | TRIG_PLANE_MASK;
        break;
      }
    }
    int ndead = -1;

    if (fUseCounter) fCounter->Trigger(trigword,atplane[nplanes-1]);
    //if (trigword) fCounter->DeadChips(fChipFreeTime[fDeadChipLastBuffer]);
    if (trigbits.isli) trigword |=TRIG_LI_MASK;
    if (trigbits.cer1) trigword |=TRIG_CER1_MASK;
    if (trigbits.cer2) trigword |=TRIG_CER2_MASK;
    if (trigbits.cer3) trigword |=TRIG_VARC0_MASK;
    if (trigbits.istof) trigword |=TRIG_TOF_MASK;
    if (trigbits.isv0) trigword |=TRIG_VARC0_MASK;
    //    if (trigbits.isv1) trigword |=TRIG_VARC1_MASK;
    if (trigbits.issgate) trigword |=TRIG_SGATE_MASK;
    if (trigword) ndead = CalculateDeadChips(teventstart,fDeadChipLastBuffer,nplanes);
    if ((fAllData
         ||((TRIG_PLANE_MASK&fTrigMask)&&(nplanes>fNumPlanes))
         ||(trigword&(fTrigMask&(~TRIG_PLANE_MASK))))
        &&(!(trigword&fExcludeMask))) WriteEvent(teventstart,trigword,tf,start,end,rotoStrmName);
        
    if (fUseCounter) fCounter->Event(fTimeframe[tf],teventstart,n[0],n[1],
                                     nplanes,int(trigbits.istof),
                                     int(trigbits.cer1),int(trigbits.cer2),
                                     int(trigbits.cer3),
                                     int(trigbits.isv0), 
                                     int(trigbits.isv1), ndead, 
                                     int(trigbits.isli));

    // end of event...

    for (int crate = 0; crate<fCrates; crate++) {
      start[crate] = end[crate];
    }
    memset(hitplane,0,sizeof(hitplane));
    swap(fDeadChipBuffer,fDeadChipLastBuffer);

    
  }
  // No more hits
}

void OltNewModule::WriteEvent(unsigned long teventstart, int trigword,int tf,
                           unsigned int *start, 
                           unsigned int *end,
                           string rotoStrmName)
{
  int bufpos = 0;
  //memset(fBuffer,0,200000*sizeof(long));
  //Snarl Header Block.
  mdBlockSnarlHeader_t *sh = reinterpret_cast<mdBlockSnarlHeader_t *>
    (fBuffer + bufpos);
  sh->gHdr.lenBlockWords = 11;
  sh->gHdr.checksum = 0;
  sh->gHdr.blockId = (kMdBlockSnarlHeader<<BLOCKID_BITPOS_IDENTIFIER) |
    (kMdBlockSourceCalDetector<<BLOCKID_BITPOS_DETECTOR) | (1);//minor 1
  sh->runNumber = fRun;
  sh->subRunAndType = (fSubrun<<16) & fRunType;
  sh->timeStamp.sec = fCrateSec[tf][0];
  sh->timeStamp.nsec = fCrateNsec[tf][0]+int(teventstart*VATICK);
  if (sh->timeStamp.nsec>1000000000L) {
    sh->timeStamp.nsec-=1000000000L;
    sh->timeStamp.sec+=1;
  }
  sh->timeFrameNumber = fTimeframe[tf];
  sh->snarlNumber = fEventNo;
  sh->triggerSource = trigword;
  sh->errorCode = 0;
  rdxsum_fill((long*)sh,0);  // fill in the checksum value
  bufpos +=sh->gHdr.lenBlockWords;

  //Crate Readout Block
  mdBlockGenericHeader_t *cratehead = 
    reinterpret_cast<mdBlockGenericHeader_t *>(fBuffer + bufpos);
  cratehead->checksum = 0;
  cratehead->blockId = (kMdBlockCrateReadout<<BLOCKID_BITPOS_IDENTIFIER) | 
    (kMdBlockSourceCalDetector<<BLOCKID_BITPOS_DETECTOR) | (1); // minor 1
  int nwords=0;
  unsigned long *nhits;
  bufpos+=3;

  // Special - write ND fiducial hit here.
 
  for (int crate = 0; crate<fCrates ; crate++) {
    if ((fHaveNDTimingHit&&crate==0)||(start[crate]!=end[crate])){
      nwords +=4;
      fBuffer[bufpos++] = fCrateId[tf][crate];
      nhits = fBuffer + bufpos;
      fBuffer[bufpos++] = 0;
      fBuffer[bufpos++] = fCrateSec[tf][crate]; // cratet0sec
      fBuffer[bufpos++] = fCrateNsec[tf][crate]; // cratet0nsec
      if (crate==0 && fHaveNDTimingHit) {
        long long *ptr = reinterpret_cast<long long *>(fBuffer + bufpos);
        *ptr = fNDTimingHit[tf];
        bufpos+=2;
        nwords+=2;
        (*nhits)+=1;
      }
      for (unsigned int it = start[crate];
           it!=end[crate];++it) {
        long long *ptr = reinterpret_cast<long long *>(fBuffer + bufpos);
        *ptr = fSortedHits[crate][it];
        bufpos+=2;
        nwords+=2;
        (*nhits)+=1;
      }
    }
  }
  cratehead->lenBlockWords = nwords + 3;
  rdxsum_fill((long*)cratehead,0);  // fill in the checksum value
 
  // Dead Chips
  memcpy(fBuffer+bufpos,fDeadBuf,fDeadBuf[0]*sizeof(long));
  bufpos +=fDeadBuf[0];

  // ToF Block
  if (trigword & TRIG_TOF_MASK) {
    memcpy(fBuffer+bufpos,fToFOutputArray,fToFOutputArray[0]*sizeof(long));
    bufpos +=fToFOutputArray[0];
    fToFOutputArray[0]=0; // Set size to 0 so we don't keep producing
    //the last buffer in the case of mismatched ToF hits.
  }

  int status;
  MomNavigator *mom = 
    RotoObjectifier::BufferInflate(reinterpret_cast<const char*>(fBuffer),
                                   bufpos*sizeof(long),status);
  WriteMom(mom,rotoStrmName,trigword);
  delete mom;
  ++fEventNo;
} 




int OltNewModule::ToChip(int chad)
{
  return (chad & 0x1fe0);
}

int OltNewModule::ToVmm(int chad)
{
return (chad & 0x1f00);
}

int OltNewModule::ToChad(int varc, int vmm, int adc, int chip, int channel)
{
  return channel + (chip<<5) + (adc<<7) + (vmm<<8) + (varc<<11);
}

int OltNewModule::CalculateDeadChips(int timestamp, int buf,int nplanes)
{
  int ndead = 0;
  fDeadBuf[0] = 3;
  fDeadBuf[1] = 0;
  fDeadBuf[2] = (0xf00<<BLOCKID_BITPOS_IDENTIFIER) | 
    (kMdBlockSourceCalDetector<<BLOCKID_BITPOS_DETECTOR);
  unsigned long *numptr;
  unsigned long *lptr = fDeadBuf + 3;
  for (int crate=0;crate<fCrates;crate++) {
    numptr = lptr;
    ++lptr;
    *numptr = 0;
    ++(*fDeadBuf);
    map<int,int>::iterator it;
    //cout<<crate<<"  "<<fElec[crate]<<endl;
    if (fElec[crate]==1) {
      // VA
      for (it = fChipFreeTime[buf][crate].begin();
           it != fChipFreeTime[buf][crate].end();
           it++) {
        if ((*it).second >timestamp) {
          // This chip is dead.
          if (fUseCounter) {
            fCounter->DeadTime((*it).second - timestamp);
            fCounter->DeadChip(crate, (*it).first);
            if (nplanes>3) fCounter->DeadChipTrig(crate, (*it).first);
          }
          ++ndead;
          ++(*numptr);
          *lptr++=(*it).first;
          ++(*fDeadBuf);
        // Form the buffer here.
        }
      }
    }
    else if (fElec[crate]==2) {
      for (it = fChipFreeTime[buf][crate].begin();
           it != fChipFreeTime[buf][crate].end();
           it++) {
        if ((*it).second >timestamp) {
          // This chip is dead.
          ++ndead;
          ++(*numptr);
          *lptr++=((*it).first&(1<<19));  // Set "Qie" bit if qie
          ++(*fDeadBuf);
        }
      }
    }
    else {
      //      MSG("Olt",Msg::kFatal) << "Don't know about electronics type "<<fElec[crate]<<endl;
    }
    //    MSG("Olt",Msg::kInfo)<<"There are "<<ndead<<" dead chips up to crate "
    //                   <<crate<<" of "<<fCrates<<endl;
  }
  rdxsum_fill((long*)fDeadBuf,0);  // fill in the checksum value
  return ndead;
}


int OltNewModule::SuckCrate(int crate, unsigned int &it, bool *hitplane, 
              OltNewModule::Trigbits &trigbits, int &teventend,int tf) 
{
  //cout<<hex<<"Crate "<<crate<<" id "<<fCrateId[fLastTF][crate]<<dec<<endl;
  MSG("Olt",Msg::kVerbose)<<"Will Suck Crate"<<crate<<" Id: "<<hex<<fCrateId[fLastTF][crate]<<dec<<endl;
  if (fCrateId[fLastTF][crate] & 0x40) {
      // QIE electronics if this bit is set
    return SuckQieCrate(crate,it,hitplane,trigbits,teventend,tf);
  } else {
    return SuckVaCrate(crate,it,hitplane,trigbits,teventend,tf);
  }
}


int OltNewModule::SuckVaCrate (int crate, unsigned int &it, bool *hitplane, 
                               OltNewModule::Trigbits &trigbits, 
                               int &teventend, int tf)
{
  //cout<<"Suck VA "<<crate<<endl;
  MSG("Olt",Msg::kVerbose)<<"In Suck VA: teventend is "<<teventend<<endl;
  int lastchip = -1;
  int n=0;
  for (;it<fSortedHits[crate].size();++it) {
    VaHit *hit = reinterpret_cast<VaHit *>(&fSortedHits[crate][it]);
    if (int(hit->timeStamp) < fGap + teventend) {
      ++n;
      teventend = max(teventend, (int)hit->timeStamp);
      int chad = hit->chad;
      MSG("Olt",Msg::kVerbose)<<"Suck VA Hit ts: "<<int(hit->timeStamp)<<" "<<hex<<chad<<dec<<" "<<int(hit->adcValue)<<endl; 
     hitplane[fPlane[crate][chad]] = true;
     if (crate==0) {
        int *tof;
        if (chad==chad_TOF) {
          trigbits.istof = true;
          if (fUseCounter) fCounter->Tof(teventend);
          MSG("Olt",Msg::kDebug)<<"Got a hit in [VMM6: VARC2] (TOF)\n";
          // We have a TOF hit - get next TDC from the correct Mike
          // object here and make an output block.
          // shove that block into fToFOutputArray.
          if (fToFConverter[tf]) {
                    MSG("Olt",Msg::kDebug)<<"TOF Hits: "<<fNumToFHits[tf]<<" TDCs: "<<fToFConverter[tf]->GetNumberOfRawTOFBlocks()<<endl;
            if (fToFConverter[tf]->GetNumberOfRawTOFBlocks()==fNumToFHits[tf])
              {
                tof =  fToFConverter[tf]->GetPackedRawTOFBlock
                  (fTofIndex,reinterpret_cast<long *>(hit));
                if (tof) {
                  memcpy(fToFOutputArray,tof,tof[0]*sizeof(long));
                  //        ++fTofIndex;        
                } 
                else {
                  MSG("Olt",Msg::kWarning)<<"ToF mismatch: tried to assign hit "
                                          <<fTofIndex<<" from "
                                          <<fToFConverter[fLastTF]->GetNumberOfRawTOFBlocks()
                                          <<" TDC readouts at "<<int(hit->timeStamp)<<endl;
                }
              }
            else {
              // Log the ToF Mismatch here
              fCounter->ToFMismatch(fTimeframe[tf], fNumToFHits[tf]);
            }
          }
          else {
            MSG("Olt",Msg::kWarning)<<"ToF mismatch: tried to assign hit "
                                    <<fTofIndex
                                    <<" but there was no TOF block present\n";
          }         
          ++fTofIndex;  
        }             
        else if (chad==chad_CER1) {
          trigbits.cer1 = true;
          if (fUseCounter) fCounter->Cerenkov(1,hit->adcValue,hit->timeStamp);
        }
        else if (chad== chad_CER2) {
          trigbits.cer2 = true;
          if (fUseCounter) fCounter->Cerenkov(2,hit->adcValue,hit->timeStamp);
        }
        else if (chad == chad_CER3) {
          trigbits.cer3 = true;
          if (fUseCounter) fCounter->Cerenkov(3,hit->adcValue,hit->timeStamp);
        }
        else if (chad==CHAD_VARC1){
          trigbits.isv1 = true;
          //      MSG("Olt",Msg::kInfo)<<"Got a hit in VMM6: VARC1\n";
        }
        else if (chad== CHAD_VARC0) {
          trigbits.isv0 = true;
          //      MSG("Olt",Msg::kInfo)<<"Got a hit in VMM6: VARC0\n";
        }
        else if (chad==chad_TRIGPMT) {
          trigbits.isli = true;
        }
     }
    
    
      int chip = ToChip(hit->chad);
      int vmm = ToVmm(hit->chad);
      
      if (chip!=lastchip) {
          lastchip = chip;
          int tstart = max(fVmmFreeTime[fDeadChipLastBuffer][crate][vmm],
                           (int)hit->timeStamp);
          tstart = max(fVmmFreeTime[fDeadChipBuffer][crate][vmm],
                           tstart);
          fChipFreeTime[fDeadChipBuffer][crate][chip] = tstart + DEADTIME;
          fVmmFreeTime[fDeadChipBuffer][crate][vmm] = tstart + DEADTIME;
      }

    }
    else {
      return n;
    }
  }
  return n;
}

int OltNewModule::ToVaTime(unsigned int qietime)
{
  return (int)(qietime * 16 * 58.0/77.0 + fQieOffset);
}

int OltNewModule::SuckQieCrate (int crate, unsigned int &it, bool *hitplane, 
                                OltNewModule::Trigbits&  trigbits , 
                                int &teventend, int /* tf */)
{
  //cout<<"Suck QIE "<<crate<<endl;
  MSG("Olt",Msg::kVerbose)<<"In Suck QIE: teventend is "<<teventend<<endl;
  //unused: int lastchip = -1;
  int n=0;
  for (;it<fSortedHits[crate].size();++it) {
    QieHit *hit = reinterpret_cast<QieHit *>(&fSortedHits[crate][it]);
    if (ToVaTime(hit->timeStamp) < fGap + teventend) {
      ++n;
      teventend = max(teventend, (int)(ToVaTime(hit->timeStamp)));
       MSG("Olt",Msg::kVerbose)<<"Suck QIE Hit at "<<ToVaTime(hit->timeStamp)<<" ts: "<<int(hit->timeStamp)<<" "<<int(hit->master)<<":"<<int(hit->minder)<<" "<<int(hit->adc)<<endl; 
       int chad = (hit->minder + (hit->master << 5) + (hit->geo << 8));
       hitplane[fQiePlane[crate][chad]] = true;
       MSG("Olt",Msg::kVerbose)<<"QIE hit in plane "<<fQiePlane[crate][chad]<<
         "  "<<crate<<"  "<<chad<<endl;

       int pmtmask = chad&0x1f80;
       fQieFreeTime[fDeadChipBuffer][crate][pmtmask] = ToVaTime(hit->timeStamp) + QIEDEADTIME;

       if (hit->type==4) trigbits.issgate = true;
    }
    else {
      return n;
    }
  }
  return n;
}

bool OltNewModule::OpenSpy(Detector::Detector_t det, Int_t run, Int_t subrun)
{
  string fname = 
    Form("%c%8.8d_%4.4d",Detector::AsString(det)[0],run,subrun);
  string number = Form("_%d",fSpyVersion);
  string filename = fOutDir + "/" + fname + number + ".spy.root";
  bool ok = true;  
  ++fSpyVersion;

// 3 streams in daq file
  for (int i = Per::kDaqSnarl;i<=Per::kLightInjection;i++) {
    Per::EStreamType stype = (Per::EStreamType) i;
    string treeName = Per::AsString(stype);
    string rotoStrmName = fname + "." + treeName;
    int compressionLevel = 1; // ROOT Default
    PerOutputStream* astream =
      fSpyStreamManager->OpenStream(rotoStrmName,treeName,
                                       "RawRecord","","",Per::kRecSplit,
                                       64000,compressionLevel);
    if (astream) {
      astream->SetAutoSave(0,0); // Turn off autosave
      bool openok = 
        fSpyStreamManager->SetFile(rotoStrmName,filename,Per::kRecreate);
      MSG("Olt",Msg::kInfo) << "Opened stream "<<rotoStrmName
                            << " on file "<<filename<<endl;
      // handle potential case where file already exists
      // and the rotorooter is in kNew not kRecreate mode
      Per::EErrorCode ecode = astream->GetErrorCode();
  
      
      if (Per::kErrSuccess != ecode) {
        MSG("Olt",Msg::kInfo) << "Open stream saw Per error: "
                              <<Per::AsString(ecode)<<endl;
      }
      ok = ok & openok;     
    } 
    else {
      ok = false;
    }

  } 
  return ok;
}




bool OltNewModule::CloseSpy(Detector::Detector_t det, Int_t run, Int_t subrun)
{
  // Close output file. Name file *.tdaq.root for triggered data
  // Stolen from the Rotorooter...
  string fname = 
    Form("%c%8.8d_%4.4d",Detector::AsString(det)[0],run,subrun);
  
   // 3 streams in daq file
  for (int i = Per::kDaqSnarl;i<=Per::kLightInjection;i++) {
    Per::EStreamType stype = (Per::EStreamType) i;
    string treeName = Per::AsString(stype);
    string rotoStrmName = fname + "." + treeName;
    fSpyStreamManager->Write(rotoStrmName);
    fSpyStreamManager->CloseStream(rotoStrmName);
   }
  return true;
}

void OltNewModule::WriteConfig(string rotoStrmName)
{

  VldTimeStamp now((const time_t)0,0); 
  VldContext vldc(fDetector,SimFlag::kData,now);
  RawDaqHeader *rawHead = new
    RawDaqHeader(vldc,fRun,fSubrun,fRunType,0);
  RawRecord *rawRec = new RawRecord(rawHead);
  RawDaqHeaderBlock *rawHeadBlk =
    new RawDaqHeaderBlock(vldc,fRun,fSubrun,fRunType,0);
  rawRec->AdoptRawBlock(rawHeadBlk);
  Registry &r = this->GetConfig();
  ostringstream text;
  r.PrintStream(text);
  char cvs[] = "$Id: OltNewModule.cxx,v 1.58 2006/12/03 02:15:30 gmieg Exp $\n";
  string blah(cvs);
  blah+=text.str();
  RawRunConfigBlock *rawRunConfigBlk =
     new RawRunConfigBlock(vldc,fRun,fSubrun,fRunType,blah.c_str());
  rawRec->AdoptRawBlock(rawRunConfigBlk);

  MomNavigator *mom = new MomNavigator;
  mom->AdoptFragment(rawRec);
  WriteMom(mom,rotoStrmName,0);
  delete mom;

}

void OltNewModule::WriteMom(MomNavigator *mom, string rotoStrmName, int trigword)
{
  // MSG("Olt",Msg::kDebug)<<"Sent "<<bufpos<<" words to the rooter"<<endl;
  TIter iter = mom->FragmentIter();
  while (TObject *obj = iter.Next()) {
    RawRecord *rawrec = dynamic_cast<RawRecord *>(obj);
    MSG("Olt",Msg::kDebug)<<"RawRec: "<<rawrec<<endl;
    TIter recit = rawrec->GetRawBlockIter();
    while (TObject *obj = recit.Next()) {
      RawDataBlock *rawdata = dynamic_cast<RawDataBlock *>(obj);
      if (rawdata) {
        MSG("Olt",Msg::kDebug) <<rawdata->GetBlockId()<<endl;
      }
    }
    if (rawrec) {
      if (!fOutputStreamManager) {
        MSG("Olt",Msg::kError) << "No output stream manager"<<endl;
        return;
      }
      PerOutputStream* stream = 0;
      stream = dynamic_cast<PerOutputStream*>
        (fOutputStreamManager->GetOpenedStream(rotoStrmName));
      if (!stream) {
        MSG("Olt",Msg::kError) << "Can't find stream "<<rotoStrmName<<endl;
        return;
      }
      stream->SetObject(rawrec);
      stream->Store();
      //Spy...
      if (fSpyMode) {
        if ((trigword & (TRIG_CER2_MASK | TRIG_CER1_MASK | TRIG_TOF_MASK | TRIG_VARC0_MASK))
            && (trigword & TRIG_PLANE_MASK)){
          if (!fSpyStreamManager) { 
            MSG("Olt",Msg::kError) << "No output stream manager"<<endl;
            return;
          }
          PerOutputStream* spystream = 0;
          spystream = dynamic_cast<PerOutputStream*>
            (fSpyStreamManager->GetOpenedStream(rotoStrmName));
          if (!spystream) {
            MSG("Olt",Msg::kError) << "Can't find spy stream "<<rotoStrmName<<endl;
            return;
          }
          spystream->SetObject(rawrec);
          spystream->Store();
        }
      }
    }
    else {
      MSG("Olt",Msg::kError) <<"Didn't get a rawrec back from BufferInflate()"
                             <<endl;
    }
  }
  

}

---