#include <EventFilter/GctRawToDigi/src/GctRawToDigi.cc>

Inheritance diagram for GctRawToDigi:

Public Member Functions
	GctRawToDigi (const edm::ParameterSet &)

	~GctRawToDigi () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Member Functions
void	addError (const unsigned code)

bool	autoDetectRequiredFormatTranslator (const unsigned char *data)
	Looks at the firmware version header in the S-Link packet and instantiates relevant format translator. More...

void	checkHeaders ()
	check block headers for consistency More...

void	doVerboseOutput (const GctBlockHeaderCollection &bHdrs, const GctUnpackCollections *const colls) const
	Prints out a list of blocks and the various numbers of trigger objects that have been unpacked from them. More...

virtual void	endJob ()
	method called at job end - use to print summary report More...

void	produce (edm::Event &, const edm::EventSetup &) override

void	unpack (const FEDRawData &d, edm::Event &e, GctUnpackCollections *const colls)
	Unpacks the raw data. More...

Private Attributes
GctBlockHeaderCollection	blockHeaders_

const bool	checkHeaders_
	If true, check block headers for synchronisation. More...

std::vector< unsigned >	errorCounters_
	Counts number of errors for each code (index) More...

L1TriggerErrorCollection *	errors_
	pointer to error collection More...

int	fedId_
	GCT FED ID. More...

GctFormatTranslateBase *	formatTranslator_
	pointer to the block-to-digi converter More...

const unsigned	formatVersion_
	Defines unpacker verison to be used (e.g.: "Auto-detect", "MCLegacy", "V35", etc). More...

const bool	hltMode_
	If true, only outputs the GCT data sent to the GT (number of BXs defined by numberOfGctSamplesToUnpack_) More...

edm::InputTag	inputLabel_
	FED collection label. More...

const unsigned	numberOfGctSamplesToUnpack_
	Number of BXs of GCT data to unpack (assuming they are in the raw data) More...

const unsigned	numberOfRctSamplesToUnpack_
	Number of BXs of RCT data to unpack (assuming they are in the raw data) More...

unsigned	unpackFailures_
	To count the total number of GCT unpack failures. More...

const bool	unpackSharedRegions_
	Commissioning option: if true, where applicable the shared RCT calo regions will also be unpacked. More...

const bool	verbose_
	If true, then debug print out for each event. More...

Static Private Attributes
static const unsigned	MAX_BLOCKS = 256
	The maximum number of blocks we will try to unpack before thinking something is wrong. More...

static const unsigned	MAX_ERR_CODE = 6

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

Description: Produce GCT digis from raw data

Implementation: <Notes on="" implementation>="">

Definition at line 43 of file GctRawToDigi.h.

Constructor & Destructor Documentation

◆ GctRawToDigi()

GctRawToDigi::GctRawToDigi ( const edm::ParameterSet & iConfig )

explicit

Register Products

Definition at line 34 of file GctRawToDigi.cc.

     : inputLabel_(iConfig.getParameter<edm::InputTag>("inputLabel")),
       fedId_(iConfig.getUntrackedParameter<int>("gctFedId", FEDNumbering::MINTriggerGCTFEDID)),
       hltMode_(iConfig.getParameter<bool>("hltMode")),
       numberOfGctSamplesToUnpack_(iConfig.getParameter<unsigned>("numberOfGctSamplesToUnpack")),
       numberOfRctSamplesToUnpack_(iConfig.getParameter<unsigned>("numberOfRctSamplesToUnpack")),
       unpackSharedRegions_(iConfig.getParameter<bool>("unpackSharedRegions")),
       formatVersion_(iConfig.getParameter<unsigned>("unpackerVersion")),
       checkHeaders_(iConfig.getUntrackedParameter<bool>("checkHeaders", false)),
       verbose_(iConfig.getUntrackedParameter<bool>("verbose", false)),
       formatTranslator_(nullptr),
       errors_(nullptr),
       errorCounters_(MAX_ERR_CODE + 1),  // initialise with the maximum error codes!
       unpackFailures_(0) {
   LogDebug("GCT") << "GctRawToDigi will unpack FED Id " << fedId_;
  
   // If the GctFormatTranslate version has been forced from config file, instantiate the relevant one.
   /***  THIS OBVIOUSLY STINKS - NEED TO REPLACE WITH SOMETHING BETTER THAN MASSIVE IF-ELSE SOON ***/
   /***  WHEN THIS MESS IS REMOVED REMEMBER THAT THE V38 FORMAT TRANSLATE HAS A DIFERENT CTOR TO THE OTHERS ***/
   if (formatVersion_ == 0) {
     edm::LogInfo("GCT")
         << "The required GCT Format Translator will be automatically determined from the first S-Link packet header.";
   } else if (formatVersion_ == 1) {
     edm::LogInfo("GCT") << "You have selected to use GctFormatTranslateMCLegacy";
     formatTranslator_ = new GctFormatTranslateMCLegacy(hltMode_, unpackSharedRegions_);
   } else if (formatVersion_ == 2) {
     edm::LogInfo("GCT") << "You have selected to use GctFormatTranslateV35";
     formatTranslator_ = new GctFormatTranslateV35(hltMode_, unpackSharedRegions_);
   } else if (formatVersion_ == 3) {
     edm::LogInfo("GCT") << "You have selected to use GctFormatTranslateV38";
     formatTranslator_ = new GctFormatTranslateV38(
         hltMode_, unpackSharedRegions_, numberOfGctSamplesToUnpack_, numberOfRctSamplesToUnpack_);
   } else {
     edm::LogWarning("GCT")
         << "You have requested a version of GctFormatTranslate that does not exist! Will attempt to auto-detect "
            "the required GCT Format Translator from the first S-Link packet header instead.";
   }
  
   if (hltMode_) {
     edm::LogInfo("GCT") << "HLT unpack mode selected: HLT unpack optimisations will be used.";
   }
   if (unpackSharedRegions_) {
     edm::LogInfo("GCT") << "You have selected to unpack shared RCT calo regions - be warned: "
                            "this is for commissioning purposes only!";
   }
  
   // GCT input collections
   produces<L1GctFibreCollection>();
   produces<L1CaloEmCollection>();
   produces<L1CaloRegionCollection>();
  
   // GCT internal collections
   produces<L1GctInternEmCandCollection>();
   produces<L1GctInternJetDataCollection>();
   produces<L1GctInternEtSumCollection>();
   produces<L1GctInternHFDataCollection>();
   produces<L1GctInternHtMissCollection>();
  
   // GCT output collections
   produces<L1GctEmCandCollection>("isoEm");
   produces<L1GctEmCandCollection>("nonIsoEm");
   produces<L1GctJetCandCollection>("cenJets");
   produces<L1GctJetCandCollection>("forJets");
   produces<L1GctJetCandCollection>("tauJets");
   produces<L1GctHFBitCountsCollection>();
   produces<L1GctHFRingEtSumsCollection>();
   produces<L1GctEtTotalCollection>();
   produces<L1GctEtHadCollection>();
   produces<L1GctEtMissCollection>();
   produces<L1GctHtMissCollection>();
   produces<L1GctJetCountsCollection>();  // Deprecated (empty collection still needed by GT)
  
   // Error collection
   produces<L1TriggerErrorCollection>();
   consumes<FEDRawDataCollection>(inputLabel_);
 }

References fedId_, formatTranslator_, formatVersion_, hltMode_, inputLabel_, LogDebug, numberOfGctSamplesToUnpack_, numberOfRctSamplesToUnpack_, and unpackSharedRegions_.

◆ ~GctRawToDigi()

GctRawToDigi::~GctRawToDigi ( )

override

Definition at line 112 of file GctRawToDigi.cc.

                             {
   // do anything here that needs to be done at destruction time
   // (e.g. close files, deallocate resources etc.)
   delete formatTranslator_;
 }

References formatTranslator_.

Member Function Documentation

◆ addError()

void GctRawToDigi::addError ( const unsigned code )

private

Definition at line 291 of file GctRawToDigi.cc.

                                                {
   // check this isn't going to break error handling
   if (code > MAX_ERR_CODE) {
     LogDebug("GCT") << "Unknown error code : " << code;
     return;
   }
  
   // print message on first instance of this error and if verbose flag set to true
   if (errorCounters_.at(code) == 0 && verbose_) {
     std::ostringstream os;
     switch (code) {
       case 0:
         os << "Reserved error code - not in use";
         break;
       case 1:
         os << "FED record empty or too short";
         break;
       case 2:
         os << "Unknown raw data version";
         break;
       case 3:
         os << "Detected unknown firmware version";
         break;
       case 4:
         os << "Detected unknown data block";
         break;
       case 5:
         os << "Block headers out of sync";
         break;
       case 6:
         os << "Too many blocks";
         break;
       default:
         os << "Unknown error code";
     }
     edm::LogError("GCT") << "Unpacking error " << code << " : " << os.str();
   }
  
   // increment error counter
   ++(errorCounters_.at(code));
  
   // store error in event if possible
   if (errors_ != nullptr) {
     errors_->push_back(L1TriggerError(fedId_, code));
   } else
     LogDebug("GCT") << "Detected error (code=" << code << ") but no error collection available!";
 }

References errorCounters_, errors_, fedId_, LogDebug, MAX_ERR_CODE, and verbose_.

Referenced by autoDetectRequiredFormatTranslator(), produce(), and unpack().

◆ autoDetectRequiredFormatTranslator()

bool GctRawToDigi::autoDetectRequiredFormatTranslator ( const unsigned char * data )

private

Looks at the firmware version header in the S-Link packet and instantiates relevant format translator.

Returns false if it fails to instantiate a Format Translator

Definition at line 238 of file GctRawToDigi.cc.

                                                                             {
   LogDebug("GCT") << "About to auto-detect the required format translator from the firmware version header.";
  
   const uint32_t* p32 = reinterpret_cast<const uint32_t*>(d);
   unsigned firmwareHeader = p32[2];
  
   /***  THIS OBVIOUSLY STINKS - NEED TO REPLACE WITH SOMETHING BETTER THAN MASSIVE IF-ELSE SOON ***/
   /***  WHEN THIS MESS IS REMOVED REMEMBER THAT THE V38 FORMAT TRANSLATE HAS A DIFERENT CTOR TO THE OTHERS ***/
  
   if (firmwareHeader >= 25 && firmwareHeader <= 35) {
     edm::LogInfo("GCT") << "Firmware Version V" << firmwareHeader << " detected: GctFormatTranslateV" << firmwareHeader
                         << " will be used to unpack.";
     formatTranslator_ = new GctFormatTranslateV35(hltMode_, unpackSharedRegions_);
     return true;
   } else if (firmwareHeader == 38) {
     edm::LogInfo("GCT") << "Firmware Version V" << firmwareHeader << " detected: GctFormatTranslateV" << firmwareHeader
                         << " will be used to unpack.";
     formatTranslator_ = new GctFormatTranslateV38(
         hltMode_, unpackSharedRegions_, numberOfGctSamplesToUnpack_, numberOfRctSamplesToUnpack_);
     return true;
   } else if (firmwareHeader == 0x00000000) {
     edm::LogInfo("GCT") << "Legacy Monte-Carlo data detected: GctFormatTranslateMCLegacy will be used to unpack.";
     formatTranslator_ = new GctFormatTranslateMCLegacy(hltMode_, unpackSharedRegions_);
     return true;
   }
   // these lines comments otherwise error is not reported!!!
   //  else if(firmwareHeader == 0xdeadffff) { /* Driver detected unknown firmware version. L1TriggerError code? */ }
   //  else if( firmwareHeader == 0xaaaaaaaa) { /* Before driver firmware version checks implemented. L1TriggerError code?  */ }
   else { /* Totally unknown firmware header */
  
     LogDebug("GCT") << "Failed to determine unpacker to use from the firmware version header! "
                        "(firmware header = 0x"
                     << hex << firmwareHeader << dec << ")";
     addError(2);
     return false;
   }
 }

References addError(), ztail::d, TauDecayModes::dec, formatTranslator_, hltMode_, LogDebug, numberOfGctSamplesToUnpack_, numberOfRctSamplesToUnpack_, and unpackSharedRegions_.

Referenced by produce().

◆ checkHeaders()

void GctRawToDigi::checkHeaders ( )

private

check block headers for consistency

Definition at line 276 of file GctRawToDigi.cc.

                                 {
   // TODO : loop over block headers found this event and check for consistency
 }

Referenced by produce().

◆ doVerboseOutput()

void GctRawToDigi::doVerboseOutput	(	const GctBlockHeaderCollection &	bHdrs,
		const GctUnpackCollections *const	colls
	)		const

private

Prints out a list of blocks and the various numbers of trigger objects that have been unpacked from them.

Definition at line 280 of file GctRawToDigi.cc.

                                                                                   {
   std::ostringstream os;
   os << "Found " << bHdrs.size() << " GCT block headers" << endl;
   for (unsigned i = 0, size = bHdrs.size(); i < size; ++i) {
     os << "GCT Raw Data Block : " << formatTranslator_->getBlockDescription(bHdrs[i]) << " : " << bHdrs[i] << endl;
   }
   os << *colls << endl;
   edm::LogVerbatim("GCT") << os.str();
 }

References formatTranslator_, GctFormatTranslateBase::getBlockDescription(), mps_fire::i, and findQualityFiles::size.

Referenced by produce().

◆ endJob()

void GctRawToDigi::endJob ( void )

privatevirtual

method called at job end - use to print summary report

Definition at line 340 of file GctRawToDigi.cc.

                           {
   unsigned total = 0;
   std::ostringstream os;
  
   for (unsigned i = 0; i <= MAX_ERR_CODE; ++i) {
     total += errorCounters_.at(i);
     os << "Error " << i << " (" << errorCounters_.at(i) << ")";
     if (i < MAX_ERR_CODE) {
       os << ", ";
     }
   }
  
   if (total > 0 && verbose_) {
     edm::LogError("GCT") << "Encountered " << total << " unpacking errors: " << os.str();
   }
 }

References errorCounters_, mps_fire::i, MAX_ERR_CODE, dqmMemoryStats::total, and verbose_.

◆ fillDescriptions()

void GctRawToDigi::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 118 of file GctRawToDigi.cc.

                                                                               {
   edm::ParameterSetDescription desc;
   desc.add<bool>("unpackSharedRegions", false);
   desc.add<unsigned int>("numberOfGctSamplesToUnpack", 1);
   desc.add<unsigned int>("numberOfRctSamplesToUnpack", 1);
   desc.add<bool>("hltMode", false);
   desc.add<edm::InputTag>("inputLabel", edm::InputTag("rawDataCollector"));
   static const char* const kComment =
       " \n"
       "   value   |                        Unpacker/RAW Format Version \n"
       "-----------|---------------------------------------------------------------------------- \n"
       "     0     |   Auto-detects RAW Format in use - the recommended option \n"
       "     1     |   Force usage of the Monte-Carlo Legacy unpacker (unpacks DigiToRaw events) \n"
       "     2     |   Force usage of the RAW Format V35 unpacker \n"
       "     3     |   Force usage of the RAW Format V38 unpacker \n";
   desc.add<unsigned int>("unpackerVersion", 0)->setComment(kComment);
   desc.addUntracked<int>("gctFedId", 745);
   desc.addUntracked<bool>("checkHeaders", false), desc.addUntracked<bool>("verbose", false);
   descriptions.add("gctRawToDigi", desc);
 }

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), HLT_2018_cff::InputTag, and kComment.

◆ produce()

void GctRawToDigi::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 144 of file GctRawToDigi.cc.

                                                                         {
   using namespace edm;
  
   // Instantiate all the collections the unpacker needs; puts them in event when this object goes out of scope.
   std::unique_ptr<GctUnpackCollections> colls(new GctUnpackCollections(iEvent));
   errors_ = colls->errors();
  
   // get raw data collection
   edm::Handle<FEDRawDataCollection> feds;
   iEvent.getByLabel(inputLabel_, feds);
  
   // if raw data collection is present, do the unpacking
   if (feds.isValid()) {
     const FEDRawData& gctRcd = feds->FEDData(fedId_);
  
     LogDebug("GCT") << "Upacking FEDRawData of size " << std::dec << gctRcd.size();
  
     // check for empty events
     if (gctRcd.size() < 16) {
       LogDebug("GCT") << "Cannot unpack: empty/invalid GCT raw data (size = " << gctRcd.size()
                       << "). Returning empty collections!";
       addError(1);
       return;
     }
  
     // If no format translator yet set, need to auto-detect from header.
     // If auto format detection fails, we have no concrete format
     // translator instantiated... set error and bail
     if (!formatTranslator_) {
       if (!autoDetectRequiredFormatTranslator(gctRcd.data()))
         return;
     }
  
     // reset collection of block headers
     blockHeaders_.clear();
  
     // do the unpacking
     unpack(gctRcd, iEvent, colls.get());
  
     // check headers, if enabled
     if (checkHeaders_)
       checkHeaders();
  
     // dump summary in verbose mode
     if (verbose_) {
       doVerboseOutput(blockHeaders_, colls.get());
     }
   }
 }

References addError(), autoDetectRequiredFormatTranslator(), blockHeaders_, checkHeaders(), checkHeaders_, FEDRawData::data(), TauDecayModes::dec, doVerboseOutput(), errors_, fedId_, l1tstage2emulator_dqm_sourceclient-live_cfg::feds, formatTranslator_, iEvent, inputLabel_, LogDebug, FEDRawData::size(), unpack(), and verbose_.

◆ unpack()

void GctRawToDigi::unpack	(	const FEDRawData &	d,
		edm::Event &	e,
		GctUnpackCollections *const	colls
	)

private

Unpacks the raw data.

Parameters

invalidDataFlag - if true, then won't attempt unpack but just output empty collecions.

Definition at line 194 of file GctRawToDigi.cc.

                                                                                              {
   // We should now have a valid formatTranslator pointer
   formatTranslator_->setUnpackCollections(colls);
  
   const unsigned char* data = d.data();  // The 8-bit wide raw-data array.
  
   // Data offset - starts at 16 as there is a 64-bit S-Link header followed
   // by a 64-bit software-controlled header (for pipeline format version
   // info that is not yet used).
   unsigned dPtr = 16;
  
   const unsigned dEnd = d.size() - 8;  // End of payload is at (packet size - final slink header)
  
   // read blocks
   for (unsigned nb = 0; dPtr < dEnd; ++nb) {
     if (nb >= MAX_BLOCKS) {
       LogDebug("GCT") << "Reached block limit - bailing out from this event!";
       addError(6);
       break;
     }
  
     // read block header
     GctBlockHeader blockHeader = formatTranslator_->generateBlockHeader(&data[dPtr]);
  
     // unpack the block; dPtr+4 is to get to the block data.
     if (!formatTranslator_->convertBlock(&data[dPtr + 4],
                                          blockHeader))  // Record if we had an unpack problem then skip rest of event.
     {
       LogDebug("GCT") << "Encountered block unpack error - bailing out from this event!";
       addError(4);
       break;
     }
  
     // advance pointer
     dPtr += 4 * (blockHeader.blockLength() * blockHeader.nSamples() +
                  1);  // *4 because blockLen is in 32-bit words, +1 for header
  
     // if verbose or checking block headers, store the header
     if (verbose_ || checkHeaders_)
       blockHeaders_.push_back(blockHeader);
   }
 }

References addError(), blockHeaders_, GctBlockHeader::blockLength(), checkHeaders_, GctFormatTranslateBase::convertBlock(), ztail::d, data, formatTranslator_, GctFormatTranslateBase::generateBlockHeader(), LogDebug, MAX_BLOCKS, GctBlockHeader::nSamples(), GctFormatTranslateBase::setUnpackCollections(), and verbose_.

Referenced by produce().

Member Data Documentation

◆ blockHeaders_

GctBlockHeaderCollection GctRawToDigi::blockHeaders_

private

Definition at line 97 of file GctRawToDigi.h.

Referenced by produce(), and unpack().

◆ checkHeaders_

const bool GctRawToDigi::checkHeaders_

private

If true, check block headers for synchronisation.

Definition at line 90 of file GctRawToDigi.h.

Referenced by produce(), and unpack().

◆ errorCounters_

std::vector<unsigned> GctRawToDigi::errorCounters_

private

Counts number of errors for each code (index)

Definition at line 102 of file GctRawToDigi.h.

Referenced by addError(), and endJob().

◆ errors_

L1TriggerErrorCollection* GctRawToDigi::errors_

private

pointer to error collection

Definition at line 101 of file GctRawToDigi.h.

Referenced by addError(), and produce().

◆ fedId_

int GctRawToDigi::fedId_

private

GCT FED ID.

Definition at line 79 of file GctRawToDigi.h.

Referenced by addError(), GctRawToDigi(), and produce().

◆ formatTranslator_

GctFormatTranslateBase* GctRawToDigi::formatTranslator_

private

pointer to the block-to-digi converter

Definition at line 94 of file GctRawToDigi.h.

Referenced by autoDetectRequiredFormatTranslator(), doVerboseOutput(), GctRawToDigi(), produce(), unpack(), and ~GctRawToDigi().

◆ formatVersion_

const unsigned GctRawToDigi::formatVersion_

private

Defines unpacker verison to be used (e.g.: "Auto-detect", "MCLegacy", "V35", etc).

Definition at line 89 of file GctRawToDigi.h.

Referenced by GctRawToDigi().

◆ hltMode_

const bool GctRawToDigi::hltMode_

private

If true, only outputs the GCT data sent to the GT (number of BXs defined by numberOfGctSamplesToUnpack_)

Definition at line 82 of file GctRawToDigi.h.

Referenced by autoDetectRequiredFormatTranslator(), and GctRawToDigi().

◆ inputLabel_

edm::InputTag GctRawToDigi::inputLabel_

private

FED collection label.

Definition at line 78 of file GctRawToDigi.h.

Referenced by GctRawToDigi(), and produce().

◆ MAX_BLOCKS

const unsigned GctRawToDigi::MAX_BLOCKS = 256

staticprivate

The maximum number of blocks we will try to unpack before thinking something is wrong.

Definition at line 75 of file GctRawToDigi.h.

Referenced by unpack().

◆ MAX_ERR_CODE

const unsigned GctRawToDigi::MAX_ERR_CODE = 6

staticprivate

Definition at line 100 of file GctRawToDigi.h.

Referenced by addError(), and endJob().

◆ numberOfGctSamplesToUnpack_

const unsigned GctRawToDigi::numberOfGctSamplesToUnpack_

private

Number of BXs of GCT data to unpack (assuming they are in the raw data)

Definition at line 84 of file GctRawToDigi.h.

Referenced by autoDetectRequiredFormatTranslator(), and GctRawToDigi().

◆ numberOfRctSamplesToUnpack_

const unsigned GctRawToDigi::numberOfRctSamplesToUnpack_

private

Number of BXs of RCT data to unpack (assuming they are in the raw data)

Definition at line 86 of file GctRawToDigi.h.

Referenced by autoDetectRequiredFormatTranslator(), and GctRawToDigi().

◆ unpackFailures_

unsigned GctRawToDigi::unpackFailures_

private

To count the total number of GCT unpack failures.

Definition at line 103 of file GctRawToDigi.h.

◆ unpackSharedRegions_

const bool GctRawToDigi::unpackSharedRegions_

private

Commissioning option: if true, where applicable the shared RCT calo regions will also be unpacked.

Definition at line 88 of file GctRawToDigi.h.

Referenced by autoDetectRequiredFormatTranslator(), and GctRawToDigi().

◆ verbose_

const bool GctRawToDigi::verbose_

private

If true, then debug print out for each event.

Definition at line 91 of file GctRawToDigi.h.

Referenced by addError(), endJob(), produce(), and unpack().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ GctRawToDigi()

◆ ~GctRawToDigi()

Member Function Documentation

◆ addError()

◆ autoDetectRequiredFormatTranslator()

◆ checkHeaders()

◆ doVerboseOutput()

◆ endJob()

◆ fillDescriptions()

◆ produce()

◆ unpack()

Member Data Documentation

◆ blockHeaders_

◆ checkHeaders_

◆ errorCounters_

◆ errors_

◆ fedId_

◆ formatTranslator_

◆ formatVersion_

◆ hltMode_

◆ inputLabel_

◆ MAX_BLOCKS

◆ MAX_ERR_CODE

◆ numberOfGctSamplesToUnpack_

◆ numberOfRctSamplesToUnpack_

◆ unpackFailures_

◆ unpackSharedRegions_

◆ verbose_