RotoObjectifier Class Reference

#include <RotoObjectifier.h>

List of all members.

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

---

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(), 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(), RawRecord::GetRawBlockIter(), RawDataBlock::GetSize(), 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(), 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 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_InflatePrintBlockType, 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, and fgForceSimFlag. { // // 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"); }

UInt_t RotoObjectifier::GetDebugFlags (   )  [inline, static]

Definition at line 38 of file RotoObjectifier.h. { return fgDebugFlags; }

void RotoObjectifier::SetDebugFlags (  UInt_t  dbgflgs  )  [inline, static]

Definition at line 39 of file RotoObjectifier.h. Referenced by RotoClientModule::HandleCommand(). { fgDebugFlags = dbgflgs; }

void RotoObjectifier::SetForceDetector (  Detector::Detector_t  detector = Detector::kUnknown  )  [inline, static]

Definition at line 44 of file RotoObjectifier.h. Referenced by main(). { fgForceDetector = detector; }

void RotoObjectifier::SetForceSimFlag (  SimFlag::SimFlag_t  simflag = SimFlag::kUnknown  )  [inline, static]

Definition at line 46 of file RotoObjectifier.h. Referenced by main(). { fgForceSimFlag = simflag; }

void RotoObjectifier::SysLogRawBlockRegistry (   )  [static]

Definition at line 209 of file RotoObjectifier.cxx. References RawBlockProxy::GetMajorId(), RawBlockProxy::GetName(), RawBlockRegistry::GetProxyList(), RawBlockRegistry::Instance(), RawBlockProxy::IsDCS(), 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 49 of file RotoObjectifier.cxx. Referenced by DebugDumpInflateBlock(), and DebugDumpSquishBlock().

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

Definition at line 59 of file RotoObjectifier.cxx. Referenced by ExtractEncodedRawBlockId().

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

Definition at line 61 of file RotoObjectifier.cxx. Referenced by ExtractEncodedRawBlockId().

---

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

• RotoObjectifier.h
• RotoObjectifier.cxx

---