RotoObjectifier Class Reference

#include <RotoObjectifier.h>

List of all members.

Public Member Functions
	RotoObjectifier ()
virtual	~RotoObjectifier ()
Static Public Member Functions
static MomNavigator *	BufferInflate (const Char_t *buffer, Int_t nbytes, Int_t &status)
static void	SysLogRawBlockRegistry ()
static Int_t	BufferSquish (const RawRecord *rawrec, Char_t *buffer, Int_t maxbytes)
static void	FormattedIntDump (void *buffer, Int_t nwords, Bool_t extra_endl)
static UInt_t	GetDebugFlags ()
static void	SetDebugFlags (UInt_t dbgflgs)
static void	SetForceDetector (Detector::Detector_t detector=Detector::kUnknown)
static void	SetForceSimFlag (SimFlag::SimFlag_t simflag=SimFlag::kUnknown)
Static Private Member Functions
static MomNavigator *	BuildRecord (TObjArray *tobjarray, Int_t &status)
static RawDaqHeaderBlock *	BuildDaqHeaderBlock (const TObject *tobj)
static RawSnarlHeaderBlock *	BuildSnarlHeaderBlock (const TObject *tobj)
static Int_t	ExtractEncodedRawBlockId (Int_t *block)
static void	DebugDumpInflateBlock (Int_t *iptr, RawDataBlock *rawBlock)
static void	DebugDumpSquishBlock (Int_t *iptr, RawDataBlock *rawBlock)
Static Private Attributes
static UInt_t	fgDebugFlags = 0
static Detector::Detector_t	fgForceDetector = Detector::kUnknown
static SimFlag::SimFlag_t	fgForceSimFlag = SimFlag::kUnknown

---

Detailed Description

Definition at line 23 of file RotoObjectifier.h.

---

Constructor & Destructor Documentation

RotoObjectifier::RotoObjectifier

(

)

[inline]

Definition at line 49 of file RotoObjectifier.h.

{ }

virtual RotoObjectifier::~RotoObjectifier

(

)

[inline, virtual]

Definition at line 50 of file RotoObjectifier.h.

{ }

---

Member Function Documentation

MomNavigator * RotoObjectifier::BufferInflate	(	const Char_t *	buffer,
		Int_t	nbytes,
		Int_t &	status
	)			[static]

Definition at line 76 of file RotoObjectifier.cxx.

References RawBlockId::AsString(), RawBlockProxy::CreateRawDataBlock(), RawDataBlock::GetChecksum(), RawBlockId::GetMajor(), RawDataBlock::GetSize(), RawBlockRegistry::Instance(), RawBlockId::IsDCS(), kBadCheckSum, kPartialRecord, kUnknownId, logError(), logNotice(), RawBlockRegistry::LookUp(), and RawDataBlock::TestChecksum().

Referenced by RotoServer::ProcessBuffer(), and OltNewModule::WriteEvent().

{
//
//  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);
}

Int_t RotoObjectifier::BufferSquish	(	const RawRecord *	rawrec,
		Char_t *	buffer,
		Int_t	maxbytes
	)			[static]

Definition at line 282 of file RotoObjectifier.cxx.

References RawDataBlock::AppendToBuffer(), BuildDaqHeaderBlock(), BuildSnarlHeaderBlock(), DebugDumpSquishBlock(), fgDebugFlags, RawRecord::GetRawBlockIter(), RawDataBlock::GetSize(), Msg::kDebug, Msg::kWarning, and MSG.

Referenced by RotoClientModule::Put().

{
//
//  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);

}

RawDaqHeaderBlock * RotoObjectifier::BuildDaqHeaderBlock

(

const TObject *

tobj

)

[static, private]

Definition at line 750 of file RotoObjectifier.cxx.

References RawRecord::GetRawHeader(), RawDaqHeader::GetRun(), RawDaqHeader::GetRunType(), RawDaqHeader::GetSubRun(), RecMinosHdr::GetVldContext(), and run().

Referenced by BufferSquish().

{
//
//  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;
}

MomNavigator * RotoObjectifier::BuildRecord	(	TObjArray *	tobjarray,
		Int_t &	status
	)			[static, private]

Definition at line 536 of file RotoObjectifier.cxx.

References MomNavigator::AdoptFragment(), RawRecord::AdoptRawBlock(), RecJobHistory::CreateJobRecord(), RawDataBlock::GetBlockId(), RawBlockId::GetDetector(), RawSnarlHeaderBlock::GetErrorCode(), RecMinos::GetJobHistory(), RawSnarlHeaderBlock::GetNumRawDigits(), RawSnarlHeaderBlock::GetRemoteSpillType(), RawRunEndBlock::GetRun(), RawRunStartBlock::GetRun(), RawDaqHeaderBlock::GetRun(), RawSnarlHeaderBlock::GetRun(), RawRunEndBlock::GetRunType(), RawRunStartBlock::GetRunType(), RawDaqHeaderBlock::GetRunType(), RawSnarlHeaderBlock::GetRunType(), RawBlockId::GetSimFlag(), RawSnarlHeaderBlock::GetSnarl(), RawBeamMonHeaderBlock::GetSpillCountNum(), RawRunEndBlock::GetSubRun(), RawRunStartBlock::GetSubRun(), RawDaqHeaderBlock::GetSubRun(), RawSnarlHeaderBlock::GetSubRun(), RawDaqHeaderBlock::GetTimeFrameNum(), RawSnarlHeaderBlock::GetTimeFrameNum(), RawLITimingSummaryBlock::GetTimeStamp(), RawLIAdcSummaryBlock::GetTimeStamp(), RawRunEndBlock::GetTotalTimeFrames(), RawSnarlHeaderBlock::GetTriggerSource(), RawRunEndBlock::GetVldContext(), RawRunStartBlock::GetVldContext(), RawBeamMonHeaderBlock::GetVldContext(), RawDcsHeaderBlock::GetVldContext(), RawDaqHeaderBlock::GetVldContext(), RawSnarlHeaderBlock::GetVldContext(), RecJobHistory::kRaw, SimFlag::kUnknown, Detector::kUnknown, Msg::kWarning, logWarn(), MSG, and run().

{
//
//  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;

}

RawSnarlHeaderBlock * RotoObjectifier::BuildSnarlHeaderBlock

(

const TObject *

tobj

)

[static, private]

Definition at line 789 of file RotoObjectifier.cxx.

References err(), RawDaqSnarlHeader::GetErrorCode(), RawDaqSnarlHeader::GetNumRawDigits(), RawRecord::GetRawHeader(), RawDaqHeader::GetRun(), RawDaqHeader::GetRunType(), RawDaqSnarlHeader::GetSnarl(), RawDaqHeader::GetSubRun(), RawDaqHeader::GetTimeFrameNum(), RawDaqSnarlHeader::GetTrigSrc(), RecMinosHdr::GetVldContext(), and run().

Referenced by BufferSquish().

{
//
//  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;
}

void RotoObjectifier::DebugDumpInflateBlock	(	Int_t *	iptr,
		RawDataBlock *	rawBlock
	)			[static, private]

Definition at line 481 of file RotoObjectifier.cxx.

References dbg_InflateDumpBufferHeads, dbg_InflatePrintBlockType, dbg_InflatePrintWholeBlock, fgDebugFlags, FormattedIntDump(), RawDataBlock::GetSize(), headSize, and RawDataBlock::Print().

{
//
//  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
	)			[static, private]

Definition at line 509 of file RotoObjectifier.cxx.

References dbg_SquishDumpBufferHeads, dbg_SquishPrintBlockType, dbg_SquishPrintWholeBlock, fgDebugFlags, FormattedIntDump(), RawDataBlock::GetSize(), headSize, and RawDataBlock::Print().

Referenced by BufferSquish().

{
//
//  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();

}

Int_t RotoObjectifier::ExtractEncodedRawBlockId

(

Int_t *

block

)

[static, private]

Definition at line 239 of file RotoObjectifier.cxx.

References SimFlag::Compact(), fgForceDetector, fgForceSimFlag, SimFlag::kUnknown, Detector::kUnknown, maskRawBlkIdCSimFlag, maskRawBlkIdDetector, shiftRawBlkIdCSimFlag, and shiftRawBlkIdDetector.

{
//
//  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; 
}

void RotoObjectifier::FormattedIntDump	(	void *	buffer,
		Int_t	nwords,
		Bool_t	extra_endl
	)			[static]

Definition at line 392 of file RotoObjectifier.cxx.

Referenced by DebugDumpInflateBlock(), and DebugDumpSquishBlock().

{
//
//  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");
}

static UInt_t RotoObjectifier::GetDebugFlags

(

)

[inline, static]

Definition at line 38 of file RotoObjectifier.h.

References fgDebugFlags.

{ return fgDebugFlags; }

static void RotoObjectifier::SetDebugFlags

(

UInt_t

dbgflgs

)

[inline, static]

Definition at line 39 of file RotoObjectifier.h.

References fgDebugFlags.

Referenced by RotoClientModule::HandleCommand().

{ fgDebugFlags = dbgflgs; }

static void RotoObjectifier::SetForceDetector

(

Detector::Detector_t

detector = Detector::kUnknown

)

[inline, static]

Definition at line 44 of file RotoObjectifier.h.

References fgForceDetector.

Referenced by main().

      { fgForceDetector = detector; }

static void RotoObjectifier::SetForceSimFlag

(

SimFlag::SimFlag_t

simflag = SimFlag::kUnknown

)

[inline, static]

Definition at line 46 of file RotoObjectifier.h.

References fgForceSimFlag.

Referenced by main().

      { fgForceSimFlag = simflag; }

void RotoObjectifier::SysLogRawBlockRegistry

(

)

[static]

Definition at line 209 of file RotoObjectifier.cxx.

References RawBlockRegistry::GetProxyList(), RawBlockRegistry::Instance(), and logInfo().

Referenced by RotoServer::Init().

{
//
//  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);

   }
}

---

Member Data Documentation

UInt_t RotoObjectifier::fgDebugFlags = 0 [static, private]

Definition at line 62 of file RotoObjectifier.h.

Referenced by BufferSquish(), DebugDumpInflateBlock(), DebugDumpSquishBlock(), GetDebugFlags(), and SetDebugFlags().

Detector::Detector_t RotoObjectifier::fgForceDetector = Detector::kUnknown [static, private]

Definition at line 64 of file RotoObjectifier.h.

Referenced by ExtractEncodedRawBlockId(), and SetForceDetector().

SimFlag::SimFlag_t RotoObjectifier::fgForceSimFlag = SimFlag::kUnknown [static, private]

Definition at line 65 of file RotoObjectifier.h.

Referenced by ExtractEncodedRawBlockId(), and SetForceSimFlag().

---

The documentation for this class was generated from the following files:

• RotoObjectifier.h
• RotoObjectifier.cxx

---