RotoObjectifier.cxx

Go to the documentation of this file.

// $Id: RotoObjectifier.cxx,v 1.21 2007/11/10 16:46:09 schubert Exp $
//
// Static method(s) for turning flat buffer into RawRecord and back
//
// rhatcher@fnal.gov

#include "Rotorooter/RotoObjectifier.h"

#include "OnlineUtil/msgLogLib/msgLog.h"  

#include "MessageService/MsgService.h"

#include "TObjArray.h"
// for function: char* Form(const char *fmt, ...)
#include "TString.h"

#include "MinosObjectMap/MomNavigator.h"
#include "RawData/RawRecord.h"
#include "RawData/RawDaqHeader.h"
#include "RawData/RawDaqSnarlHeader.h"
#include "RawData/RawBeamMonHeader.h"

#include "RawData/RawBlockId.h"
#include "RawData/RawBlockRegistry.h"
#include "RawData/RawDataBlock.h"

#include "RawData/RawDaqHeaderBlock.h"
#include "RawData/RawSnarlHeaderBlock.h"
#include "RawData/RawDcsHeaderBlock.h"
#include "RawData/RawBeamMonHeaderBlock.h"

#include "RawData/RawLIAdcSummaryBlock.h"
#include "RawData/RawLITimingSummaryBlock.h"
#include "RawData/RawRunStartBlock.h"
#include "RawData/RawRunEndBlock.h"

const UInt_t dbg_InflateDumpBufferHeads    = 0x0001;
const UInt_t dbg_InflatePrintBlockType     = 0x0002;
const UInt_t dbg_InflatePrintWholeBlock    = 0x0004;

const UInt_t dbg_SquishDumpBufferHeads     = (0x0001 << 16);
const UInt_t dbg_SquishPrintBlockType      = (0x0002 << 16);
const UInt_t dbg_SquishPrintWholeBlock     = (0x0004 << 16);

const UInt_t headSize = 16;

UInt_t RotoObjectifier::fgDebugFlags = 0;
// | dbg_InflateDumpBufferHeads
// | dbg_InflatePrintBlockType 
// | dbg_SquishDumpBufferHeads
// | dbg_SquishPrintBlockType 
//;

// By default no attempt is made to override the detector/simflag
// tagging of blocks as they come in from the DAQ/DCS/BEAMMON
Detector::Detector_t 
  RotoObjectifier::fgForceDetector = Detector::kUnknown;
SimFlag::SimFlag_t
  RotoObjectifier::fgForceSimFlag = SimFlag::kUnknown;

enum RotoObjectifierFailureFlag {
   kSuccess         = 0x00000000,
   kUnknownId       = 0x00000001,
   kBadCheckSum     = 0x00000002,
   kPartialRecord   = 0x00000004,
   kUknownRecType   = 0x00000008
};


ClassImp(RotoObjectifier)
CVSID("$Id: RotoObjectifier.cxx,v 1.21 2007/11/10 16:46:09 schubert Exp $");

//_____________________________________________________________________________
MomNavigator* RotoObjectifier::BufferInflate(const Char_t* buffer, 
                                             Int_t nbytes,
                                             Int_t& status)
{
//
//  Purpose:  Turn flat buffer into objects held by a MOM
//
//  Argument: buffer   ptr to buffer
//            nbytes   number of bytes used in buffer
//            status   (return value) 0 = success
//                     1 = had unknown block id
//                     2 = had bad checksum in a block
//                     4 = had to skip to end-of-buffer
//                     8 = unknown record type
//                         none of: 
//                            RawDaqHeaderBlock
//                            RawSnarlHeaderBlock
//
//  Return:   MomNavigator holding RawRecord (gives up ownership)
//
//  Contact:  R. Hatcher
//
   static int nrec = 0;
   nrec++;

   //if (fgDebugFlags) MSG("Roto", Msg::kInfo) 
   //   << "RotoObjectifier::BufferInflate " << nbytes << " bytes (" 
   //   << nbytes/4 << " words)" << endl;

   TObjArray tmpArray;
   RawBlockRegistry& rbr = RawBlockRegistry::Instance();
   RawBlockProxy* rbp_generic = rbr.LookUp(0,0);

   Int_t *iptr_begin = (Int_t*) buffer;
   Int_t *iptr_end   = (Int_t*)(buffer+nbytes); 

   Int_t *iptr = iptr_begin;
   status = 0;

   Int_t nblk = -1;
   Int_t last_id = 0;
   Int_t last_nwords = 0;

   while ( iptr < iptr_end ) {
      nblk++;

      //
      // Build next individual RawBlock out of the buffer
      //

      if ( iptr_end-iptr < 3 ) {
         // real blocks are at least three words long:
         //     (size,checksum,blockid)
         logError("REC %d BLK %d, size %d, too few words (%d) at BUF end",
                  nrec,nblk,nbytes,iptr_end-iptr);
         status |= kPartialRecord;
         break;
      }

      int nwords = iptr[0];
      if (nwords < 3) {
         // real blocks are at least three words long
         logError("REC %d BLK %d, blocksize %d (0x%8.8x) too short",
                  nrec,nblk,nwords,nwords);
         logError("  at BUF index 0x%x of 0x%x",
                  iptr-iptr_begin,iptr_end-iptr_begin);

         if (nblk > 0)
            logError("  previous BLK id 0x%8.8x, size 0x%x",
                     last_id,last_nwords);

         if (iptr_end-iptr > 3 ) {
            Int_t encoded_id = ExtractEncodedRawBlockId(iptr);
            logError("  current BLK id 0x%8.8x",encoded_id);
         }
         // FormattedIntDump(iptr_begin,iptr_end-iptr_begin,true);

         // there isn't any way to recover from this as we don't
         // know where the next block might begin
         status |= kPartialRecord;
         break;
      }
   
      Int_t encoded_id = ExtractEncodedRawBlockId(iptr);
      RawBlockId rbid(encoded_id);

      RawBlockProxy* rbp = rbr.LookUp(rbid.IsDCS(),rbid.GetMajor());
      if (!rbp) {
         // couldn't find an appropriate block id
         logNotice("REC %d, BUF index %d, no PROXY for RawBlockId 0x%8.8x",
                   nrec,iptr-iptr_begin,encoded_id);
         // use generic block as a fall back
         rbp = rbp_generic;
         status |= kUnknownId;
      }

      RawDataBlock *rawBlock = rbp->CreateRawDataBlock(iptr);

      if (rawBlock->TestChecksum()) {
         status |= kBadCheckSum;
         static int nmsg = 5;
         if (nmsg>0) {
            nmsg--;
            if (rawBlock->GetChecksum() == 0) 
              logNotice("REC %d, unset checksum on %s",nrec,rbid.AsString());
            else 
              logNotice("REC %d, checksum err on %s",nrec,rbid.AsString());
            if (nmsg==0)
               logNotice("...last checksum error message");
         }
      }

      // add the block to our temporary container
      tmpArray.Add(rawBlock);

      // advance the buffer pointer, size includes the word count
      iptr += rawBlock->GetSize();
      
      last_id = encoded_id;
      last_nwords = nwords;

      // if (fgDebugFlags) 
      //    DebugDumpInflateBlock(iptr_bsize,rawBlock);         
         
   }

   // All possible blocks have been unpacked
   // now attempt to make a record of some type

   return BuildRecord(&tmpArray,status);
}

//_____________________________________________________________________________
void RotoObjectifier::SysLogRawBlockRegistry()
{
//
//  Purpose:  Send the list of RawBlockProxies in the RawBlockRegistry
//            to msgLog service 
//  
//  Argument: none
//
//  Return:   none
//
//  Contact:  R. Hatcher
//
   RawBlockRegistry& rbr = RawBlockRegistry::Instance();

   logInfo("RawBlockProxies in the RawBlockRegistry:");
   list<RawBlockProxy*> proxyTable = rbr.GetProxyList();
   list<RawBlockProxy*>::iterator itrProxyTable;
   for (itrProxyTable  = proxyTable.begin();
        itrProxyTable != proxyTable.end();
        ++itrProxyTable) {
      const RawBlockProxy& proxy = (*(*itrProxyTable));
      const char* dataSrc = ((proxy.IsDCS()) ? "DCS" : "DAQ");
      int majorid = proxy.GetMajorId();
      const char* proxyName = proxy.GetName();
      logInfo("  %s  0x%4.4x  %s",dataSrc,majorid,proxyName);

   }
}

//_____________________________________________________________________________
Int_t RotoObjectifier::ExtractEncodedRawBlockId(Int_t* block)
{
//
//  Purpose:  Extract the encoded RawBlockId for this block from the buffer
//  
//            *POSSIBLY* modifying the Detector and/or the SimFlag
//            values in the underlying block itself (as well as returned
//            value).  This hack might be necessitated by incorrect settings
//            in the DAQ/DCS system when forming the blocks.
//
//  Argument: block      pointer to first word of block
//
//  Return:   the extracted (and possibly modified) id
//
//  Contact:  R. Hatcher
//

//    MSB                          LSB
//     3         2         1         0
//    10987654321098765432109876543210
//    --xxCFNSMMMMMMMMMMMMMMMMmmmmmmmm
//
//         xx: compactSimFlag: {00=data, 01=fakedaqdata, 10=MC, 11=Reroot}
//        CFN: Detector & 0x07 (CalDet,Far,Near bits)
//          S: Source (0=DAQ, 1=DCS)
//   MMMMMMMM: major block id
//   mmmmmmmm: minor block id

   Int_t* encodedId = block + 2; // block id after # words & checksum

   if (Detector::kUnknown != fgForceDetector) {
      *encodedId &= ~maskRawBlkIdDetector; // remove existing value
      *encodedId |= ((fgForceDetector & 0x07) << shiftRawBlkIdDetector);
   }
   if (SimFlag::kUnknown != fgForceSimFlag) {
      *encodedId &= ~maskRawBlkIdCSimFlag; // remove existing value
      *encodedId |= ((SimFlag::Compact(fgForceSimFlag) & 0x03) 
                                          << shiftRawBlkIdCSimFlag);
   }

   return *encodedId; 
}
//_____________________________________________________________________________
Int_t RotoObjectifier::BufferSquish(const RawRecord* rawrec,
                                    Char_t* buffer, Int_t maxbytes)
{
//
//  Purpose:  Flatten RawRecord 
//
//  Argument: rawrec     ptr to RawRecord
//            buffer     buffer array to fill
//            maxbytes   maximum space (bytes) in buffer
//
//  Return:   number of bytes used
//
//  Contact:  R. Hatcher
//

   MSG("Roto", Msg::kDebug) << "RotoObjectifier::BufferSquish" << endl;

   if (rawrec == 0) {
      MSG("Root", Msg::kWarning) << "No RawRecord in MOM." << endl;
      return 0;
   }

   Int_t* iptr_begin = (Int_t*) buffer;
   Int_t* iptr_end   = (Int_t*)(buffer+maxbytes);
   Bool_t partial   = false;

   Int_t* iptr = iptr_begin;

   TObject *tobj;

   // look for a RawSnarlHeaderBlock, RawDaqHeaderBlock, or ...
   RawSnarlHeaderBlock* snarlHdrBlk = 0;
   RawDaqHeaderBlock*   daqHdrBlk   = 0;
   TIter rbi = rawrec->GetRawBlockIter();
   while ((tobj = rbi())) {
      if ((snarlHdrBlk = dynamic_cast<RawSnarlHeaderBlock*>(tobj))) break;
      if ((daqHdrBlk   = dynamic_cast<RawDaqHeaderBlock*>(tobj)  )) break;
   }
   // push Record header information into buffer as a block if such
   // a block doesn't already exist
   if ( ! snarlHdrBlk && ! daqHdrBlk ) {

      // perhaps we can build a block out of an existing
      // RawDaqSnarlHeader
      snarlHdrBlk = BuildSnarlHeaderBlock(rawrec);

      if (snarlHdrBlk) {
         iptr = snarlHdrBlk->AppendToBuffer(iptr);
         if (fgDebugFlags) {
            Int_t* iptr_bsize = iptr; // pointer to where block size lives 
            DebugDumpSquishBlock(iptr_bsize,snarlHdrBlk);
         }
         delete snarlHdrBlk;  // clean up!
      }
      else {

         // perhaps we can build a block out of an existing
         // RawDaqHeader
         daqHdrBlk = BuildDaqHeaderBlock(rawrec);

         if (daqHdrBlk) {
            iptr = daqHdrBlk->AppendToBuffer(iptr);
            if (fgDebugFlags) {
               Int_t* iptr_bsize = iptr; // pointer to where block size lives 
               DebugDumpSquishBlock(iptr_bsize,daqHdrBlk);
            }
            delete daqHdrBlk;  // clean up!
         }
      }
   }

   // Iterate over RawRecord's RawDataBlockList 
   // process all RawDataBlocks.
   TIter rawBlockIter = rawrec->GetRawBlockIter();
   RawDataBlock *rawBlock;
   while ((tobj = rawBlockIter())) {
      if ((rawBlock = dynamic_cast<RawDataBlock*>(tobj))) {

         int size = rawBlock->GetSize();

         if (iptr+size < iptr_end) {

            Int_t* iptr_bsize = iptr; // pointer to where block size lives

            iptr = rawBlock->AppendToBuffer(iptr);

            if (fgDebugFlags) DebugDumpSquishBlock(iptr_bsize,rawBlock);
            
         } else {
            
            if ( ! partial ) {
               partial = true;
               MSG("Roto", Msg::kWarning) 
                  << "RotoObjectifier::BufferSquish adding " << size
                  << " words would exceed buffer - "
                  << " current index " << iptr-iptr_begin << endl;
               // don't break out of loop, perhaps there's a smaller block
               // that will fit ... the record is still partial
               // but at least we'll have a bit more
            }
         }
      }
   }

   // return the number of bytes used
   return (iptr-iptr_begin)*sizeof(Int_t)/sizeof(Char_t);

}

//_____________________________________________________________________________
void RotoObjectifier::FormattedIntDump(void* buffer, Int_t nwords,
                                       Bool_t extra_endl) 
{
//
//  Purpose:  A formatted hex dump of a block of data under the
//            assumption that it is a block of Int_t's
//
//  Argument: buffer     ptr to start of memory
//            nwords     number of words
//            extra_endl if true follow dump with empty line
//
//  Return:   (none)
//
//  Contact:  R. Hatcher
//

#ifdef OLDCODE
   Int_t *iptr = (Int_t*)buffer;
   int nperline = 4;
   int online   = 0;
   for (int i=0; i<nwords; i++) {
      printf(" 0x%8.8x",*iptr++);
      online++;
      if (online == nperline) { printf("\n"); online=0; }
   }
   if (online != 0) printf("\n");
#else
   Int_t* start = (Int_t*)buffer;

   // format into columns, suppress duplicate lines unless 
   // it is the last line
   // -- this could probably be done in a cleaner fashion
   Int_t  ncol        = 4;
   Int_t  ncol_last   = (nwords+ncol-1)%ncol + 1;
   Bool_t lastmatch   = false;
   Bool_t lastline    = false;
   Int_t *next_word   = start;
   Int_t  nfull_lines = nwords/ncol;
   if (ncol_last == ncol) nfull_lines--; // if exact, pretend last is partial
   Int_t *start_last  = start + ncol*nfull_lines;
   Int_t  nbytes = 0;
   
   while (next_word < start+nwords) {
      // adjust down the number of columns if this is the last line
      if (next_word == start_last) {
         lastline = true;
         ncol = ncol_last;
      }
      
      Int_t *prev = next_word - ncol;
      if (prev >= start && !lastline ) { 
         // check for match of previous line
         Bool_t linematch = true;
         Int_t *chek = next_word;
         for (int i=0; i<ncol; i++)
            linematch = ( *prev++ == *chek++ ) ? linematch : false;
         if (linematch) {
            next_word += ncol;
            nbytes += sizeof(Int_t)*ncol;
            if (!lastmatch) {
               // was a match, but previous line wasn't also "*"
               // and it isn't the very last line
                  printf("  *\n");
            }
            lastmatch = true;
            continue;
         } 
         else lastmatch = false;
         
      }
      // print offset info
      //rwh: we want "index" no byte offset// printf("  0x%6.6x:",nbytes);
      printf("  0x%6.6x:",nbytes/4);
      // print elements of line (advance pointer and count)
      for (int i=0; i<ncol; i++) {
         printf(" %8.8x",*next_word);
         next_word++;
         nbytes += sizeof(Int_t);
      }
      // end the line
      printf("\n");
   }
   
#endif

   if (extra_endl) printf("\n");
}

//_____________________________________________________________________________
void RotoObjectifier::DebugDumpInflateBlock(Int_t* iptr, RawDataBlock* rawBlock)
{
//
//  Purpose:  Common place for generating some debugging dumps
//            to be called during inflation process
//
//  Argument: iptr       ptr to start of memory that might be dumped
//            rawBlock   ptr to a RawDataBlock of interest
//
//  Return:   (none)
//
//  Contact:  R. Hatcher
//

   if (fgDebugFlags & dbg_InflatePrintBlockType && rawBlock)
      cout << " Built " << rawBlock->GetName()
           << " size " << rawBlock->GetSize()
           << endl;

   if (fgDebugFlags & dbg_InflateDumpBufferHeads)
      FormattedIntDump(iptr,headSize,true);
         
   if (fgDebugFlags & dbg_InflatePrintWholeBlock) 
      rawBlock->Print();

}

//_____________________________________________________________________________
void RotoObjectifier::DebugDumpSquishBlock(Int_t* iptr, RawDataBlock* rawBlock)
{
//
//  Purpose:  Common place for generating some debugging dumps
//            to be called during squishing process
//
//  Argument: iptr       ptr to start of memory that might be dumped
//            rawBlock   ptr to a RawDataBlock of interest
//
//  Return:   (none)
//
//  Contact:  R. Hatcher
//

   if (fgDebugFlags & dbg_SquishPrintBlockType && rawBlock)
      cout << " Squish " << rawBlock->GetName()
           << " size " << rawBlock->GetSize() << endl;

   if (fgDebugFlags & dbg_SquishDumpBufferHeads && iptr)
      FormattedIntDump(iptr,headSize,true);
   
   if (fgDebugFlags & dbg_SquishPrintWholeBlock && rawBlock) 
      rawBlock->Print();

}

//_____________________________________________________________________________
MomNavigator* RotoObjectifier::BuildRecord(TObjArray* tobjarray,
                                           Int_t& /* status */ )
{
//
//  Purpose:  Generate the Record from the RawDataBlocks
//
//  Argument: tobjarray  array of RawDataBlocks
//
//  Return:   new MomNavigator (give up ownership)
//            status   (return value) 0 = success
//                     8 = unknown record type
//                         (none of RawSnarlHeaderBlock, ...)
//
//  Contact:  R. Hatcher
//

   MomNavigator* mom = 0;

   TObject *tobj = 0;
   RawSnarlHeaderBlock     *snarlHdrBlk = 0;
   RawDaqHeaderBlock       *daqHdrBlk   = 0;
   RawDcsHeaderBlock       *dcsHdrBlk   = 0;
   RawBeamMonHeaderBlock   *beamHdrBlk  = 0;
   RawLIAdcSummaryBlock    *liAdcBlk    = 0;
   RawLITimingSummaryBlock *liTimingBlk = 0;
   RawRunStartBlock        *startBlk    = 0;
   RawRunEndBlock          *endBlk      = 0;

   // look for special blocks
   TIter iter_quick(tobjarray);
   while ((tobj = iter_quick())) {
      if (!snarlHdrBlk)
         snarlHdrBlk = dynamic_cast<RawSnarlHeaderBlock*>(tobj);
      if (!daqHdrBlk)
         daqHdrBlk = dynamic_cast<RawDaqHeaderBlock*>(tobj);
      if (!dcsHdrBlk)
         dcsHdrBlk = dynamic_cast<RawDcsHeaderBlock*>(tobj);
      if (!beamHdrBlk)
         beamHdrBlk = dynamic_cast<RawBeamMonHeaderBlock*>(tobj);

      // these are a kludge ...
      // we *should* be getting some other "header" block
      if (!liAdcBlk)
         liAdcBlk = dynamic_cast<RawLIAdcSummaryBlock*>(tobj);
      if (!liTimingBlk)
         liTimingBlk = dynamic_cast<RawLITimingSummaryBlock*>(tobj);
      if (!startBlk)
         startBlk = dynamic_cast<RawRunStartBlock*>(tobj);
      if (!endBlk)
         endBlk = dynamic_cast<RawRunEndBlock*>(tobj);
   }

   RawHeader* rawhead = 0;

   if (snarlHdrBlk) {
      // 
      // if there was a snarl block, then build a RawDaqSnarlHeader ... 
      //
      VldContext vldc = snarlHdrBlk->GetVldContext();
      Int_t   run     = snarlHdrBlk->GetRun();
      Short_t subrun  = snarlHdrBlk->GetSubRun();
      Short_t runtype = snarlHdrBlk->GetRunType();
      Int_t   tf      = snarlHdrBlk->GetTimeFrameNum();
      Int_t   snarl   = snarlHdrBlk->GetSnarl();
      Int_t   trigsrc = snarlHdrBlk->GetTriggerSource();
      Int_t   errcode = snarlHdrBlk->GetErrorCode();
      Int_t   nrdigit = snarlHdrBlk->GetNumRawDigits();
      Int_t   spilltype = snarlHdrBlk->GetRemoteSpillType();

      rawhead = new RawDaqSnarlHeader(vldc,run,subrun,runtype,tf,
                                      snarl,trigsrc,errcode,nrdigit,spilltype);
   }
   else
   if (daqHdrBlk) {
      // 
      // if there was a snarl block, then build a RawDaqHeader ... 
      //
      VldContext vldc = daqHdrBlk->GetVldContext();
      Int_t   run     = daqHdrBlk->GetRun();
      Short_t subrun  = daqHdrBlk->GetSubRun();
      Short_t runtype = daqHdrBlk->GetRunType();
      Int_t   tf      = daqHdrBlk->GetTimeFrameNum();

      rawhead = new RawDaqHeader(vldc,run,subrun,runtype,tf);
   }
   else
   if (dcsHdrBlk) {
      // 
      // if there was a dcs header block, then build a plain ol' RawHeader ... 
      //
      VldContext vldc = dcsHdrBlk->GetVldContext();

      rawhead = new RawHeader(vldc);
   }
   else
   if (beamHdrBlk) {
      // 
      // if there was a beam monitor header block
      //
      VldContext vldc = beamHdrBlk->GetVldContext();
      UInt_t spillcnt = beamHdrBlk->GetSpillCountNum();

      rawhead = new RawBeamMonHeader(vldc,spillcnt);
   }
   else
   if (startBlk) {
      // 
      // if there was a RunStart block, build a RawDaqHeader ... 
      //

      logWarn("BuildRecord missing HeaderBlock, use RunStart");

      VldContext vldc = startBlk->GetVldContext();
      Int_t   run     = startBlk->GetRun();
      Short_t subrun  = startBlk->GetSubRun();
      Short_t runtype = startBlk->GetRunType();
      Int_t   tf      = 0; // bogus value

      rawhead = new RawDaqHeader(vldc,run,subrun,runtype,tf);
   }
   else
   if (endBlk) {
      // 
      // if there was a RunEnd block, build a RawDaqHeader ... 
      //

      logWarn("BuildRecord missing HeaderBlock, use RunEnd");

      VldContext vldc = endBlk->GetVldContext();
      Int_t   run     = endBlk->GetRun();
      Short_t subrun  = endBlk->GetSubRun();
      Short_t runtype = endBlk->GetRunType();
      Int_t   tf      = endBlk->GetTotalTimeFrames(); // bogus value

      rawhead = new RawDaqHeader(vldc,run,subrun,runtype,tf);
   }
   else
   if (liAdcBlk || liTimingBlk) {
      // 
      // if there was a LI block, then build a RawDaqHeader ... 
      //

      logWarn("BuildRecord missing HeaderBlock, attempt to use LI");

      Int_t   run     = -1;   // undetermined from LI block
      Short_t subrun  = -1;
      Short_t runtype = -1;
      Int_t   tf      = -1;   // bogus time frame #
      VldContext vldc;
      if (liAdcBlk) {
         RawBlockId rbid = liAdcBlk->GetBlockId();
         vldc = VldContext(rbid.GetDetector(),rbid.GetSimFlag(),
                           liAdcBlk->GetTimeStamp());
      }
      else if (liTimingBlk) {
         RawBlockId rbid = liTimingBlk->GetBlockId();
         vldc = VldContext(rbid.GetDetector(),rbid.GetSimFlag(),
                           liTimingBlk->GetTimeStamp());
      }
      rawhead = new RawDaqHeader(vldc,run,subrun,runtype,tf);

   }

   if (!rawhead) {
      // 
      // there was nothing to use to build a RawHeader ... 
      // ... fake something up as a final resort
      //
      Int_t   run     = -1;
      Short_t subrun  = -1;
      Short_t runtype = -1;
      Int_t   tf      = -1;
      VldTimeStamp ts; // use a timestamp of "now"
      VldContext vldc = VldContext(Detector::kUnknown,
                                   SimFlag::kUnknown,ts);

      rawhead = new RawDaqHeader(vldc,run,subrun,runtype,tf);

   }

   // produce a RawRecord, have it adopt the header
   
   RawRecord *rawRec = new RawRecord(rawhead);
   RecJobHistory& jobhist 
                     = const_cast<RecJobHistory&>(rawRec->GetJobHistory());
   jobhist.CreateJobRecord(RecJobHistory::kRaw);
  
   // give the blocks to the RawRecord
   TIter iter(tobjarray);
   while ((tobj = iter())) {
      RawDataBlock* rawBlock =
         dynamic_cast<RawDataBlock*>(tobj);
      if (rawBlock) {
         rawRec->AdoptRawBlock(rawBlock);
         tobjarray->Remove(tobj);
      } else {
         MSG("Roto", Msg::kWarning) 
            << "Saw something other than RawDataBlock" << endl;
      }
   }
   
   // create a MOM and give the RawRecord to MOM to hold as a "fragment"
   mom = new MomNavigator;
   mom->AdoptFragment(rawRec);

   // make sure tobjarray no longer holds anything
   // all RawDataBlocks should have been removed by above loop
   // so "Delete" is okay.
   tobjarray->Delete();

   return mom;

}
//_____________________________________________________________________________
RawDaqHeaderBlock* RotoObjectifier::BuildDaqHeaderBlock(const TObject* tobj)
{
//
//  Purpose:  Generate a RawDaqHeaderBlock from information
//            found in TObject (hopefully a RawRecord or such)
//
//  Argument: tobj   (a RawRecord perhaps?)
//
//  Return:   new RawDaqHeaderBlock (give up ownership)
//
//  Contact:  R. Hatcher
//
   RawDaqHeaderBlock *daqHdrBlk = 0;

   // Perhaps we were passed a RawRecord
   // then the info we want should be in the RawDaqHeader

   const RawRecord *rr = dynamic_cast<const RawRecord *>(tobj);

   if (rr) {
      const RawDaqHeader* daqHdr = 
         dynamic_cast<const RawDaqHeader*>(rr->GetRawHeader());

      if (daqHdr) {
         VldContext vldc   = daqHdr->GetVldContext();
         Int_t   run       = daqHdr->GetRun();
         Short_t subrun    = daqHdr->GetSubRun();
         Short_t runtype   = daqHdr->GetRunType();
         Int_t   timeframe = -1;
         
         daqHdrBlk =
            new RawDaqHeaderBlock(vldc,run,subrun,runtype,timeframe);

      }
   }
      
   return daqHdrBlk;
}
//_____________________________________________________________________________
RawSnarlHeaderBlock* RotoObjectifier::BuildSnarlHeaderBlock(const TObject* tobj)
{
//
//  Purpose:  Generate a RawSnarlHeaderBlock from information
//            found in TObject (hopefully a RawRecord or such)
//
//  Argument: tobj   (a RawRecord perhaps?)
//
//  Return:   new RawSnarlHeaderBlock (give up ownership)
//
//  Contact:  R. Hatcher
//
   RawSnarlHeaderBlock *snarlHdrBlk = 0;

   // Perhaps we were passed a RawRecord
   // then the info we want should be in the RawDaqSnarlHeader

   const RawRecord *rr = dynamic_cast<const RawRecord *>(tobj);

   if (rr) {
      const RawDaqSnarlHeader* snarlHdr = 
         dynamic_cast<const RawDaqSnarlHeader*>(rr->GetRawHeader());

      if (snarlHdr) {
         VldContext vldc   = snarlHdr->GetVldContext();
         Int_t   run       = snarlHdr->GetRun();
         Short_t subrun    = snarlHdr->GetSubRun();
         Short_t runtype   = snarlHdr->GetRunType();
         Int_t   timeframe = snarlHdr->GetTimeFrameNum();
         Int_t   snarl     = snarlHdr->GetSnarl();         
         Int_t   trigsrc   = snarlHdr->GetTrigSrc();
         Int_t   err       = snarlHdr->GetErrorCode();
         Int_t   nrawdigit = snarlHdr->GetNumRawDigits();
         
         snarlHdrBlk =
            new RawSnarlHeaderBlock(vldc,run,subrun,runtype,timeframe,
                                    snarl,trigsrc,err,nrawdigit);

      }
   }
      
   return snarlHdrBlk;
}
//_____________________________________________________________________________

---