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

Inheritance diagram for GctRawToDigi:

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

	~GctRawToDigi ()

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

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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

Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (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...

virtual 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

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Description: Produce GCT digis from raw data

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

Definition at line 44 of file GctRawToDigi.h.

Constructor & Destructor Documentation

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

explicit

Register Products

Definition at line 36 of file GctRawToDigi.cc.

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

                                                          :
   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_(0),
   errors_(0),
   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_);
 }

GctRawToDigi::~GctRawToDigi ( )

Definition at line 115 of file GctRawToDigi.cc.

References formatTranslator_.

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

Member Function Documentation

void GctRawToDigi::addError ( const unsigned code )

private

Definition at line 310 of file GctRawToDigi.cc.

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

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

                                                {
 
   // 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_ != 0) {
     errors_->push_back(L1TriggerError(fedId_, code));
   }
   else LogDebug("GCT") << "Detected error (code=" << code << ") but no error collection available!";
 
 }

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 247 of file GctRawToDigi.cc.

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

Referenced by produce().

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

void GctRawToDigi::checkHeaders ( )

private

check block headers for consistency

Definition at line 289 of file GctRawToDigi.cc.

Referenced by produce().

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

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 296 of file GctRawToDigi.cc.

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

Referenced by produce().

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

void GctRawToDigi::endJob ( void )

privatevirtual

method called at job end - use to print summary report

Definition at line 346 of file GctRawToDigi.cc.

References errorCounters_, i, MAX_ERR_CODE, pileupDistInMC::total, and verbose_.

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

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

static

Definition at line 122 of file GctRawToDigi.cc.

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

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

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

overrideprivatevirtual

Implements edm::stream::EDProducerBase.

Definition at line 149 of file GctRawToDigi.cc.

References addError(), autoDetectRequiredFormatTranslator(), blockHeaders_, checkHeaders(), checkHeaders_, FEDRawData::data(), TauDecayModes::dec, doVerboseOutput(), errors_, fedId_, HcalMonitorModule_cfi::feds, formatTranslator_, edm::Event::get(), edm::Event::getByLabel(), inputLabel_, LogDebug, FEDRawData::size(), unpack(), and verbose_.

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), and HTMLExport.HTMLExportStatic::export().

 {
   using namespace edm;
 
   // Instantiate all the collections the unpacker needs; puts them in event when this object goes out of scope.
   std::auto_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()); }
     
   }
 
 }

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 200 of file GctRawToDigi.cc.

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

Referenced by produce().

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

Member Data Documentation

GctBlockHeaderCollection GctRawToDigi::blockHeaders_

private

Definition at line 99 of file GctRawToDigi.h.

Referenced by produce(), and unpack().

const bool GctRawToDigi::checkHeaders_

private

If true, check block headers for synchronisation.

Definition at line 92 of file GctRawToDigi.h.

Referenced by produce(), and unpack().

std::vector<unsigned> GctRawToDigi::errorCounters_

private

Counts number of errors for each code (index)

Definition at line 104 of file GctRawToDigi.h.

Referenced by addError(), and endJob().

L1TriggerErrorCollection* GctRawToDigi::errors_

private

pointer to error collection

Definition at line 103 of file GctRawToDigi.h.

Referenced by addError(), and produce().

int GctRawToDigi::fedId_

private

GCT FED ID.

Definition at line 85 of file GctRawToDigi.h.

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

GctFormatTranslateBase* GctRawToDigi::formatTranslator_

private

pointer to the block-to-digi converter

Definition at line 96 of file GctRawToDigi.h.

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

const unsigned GctRawToDigi::formatVersion_

private

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

Definition at line 91 of file GctRawToDigi.h.

Referenced by GctRawToDigi().

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 87 of file GctRawToDigi.h.

Referenced by autoDetectRequiredFormatTranslator(), and GctRawToDigi().

edm::InputTag GctRawToDigi::inputLabel_

private

FED collection label.

Definition at line 84 of file GctRawToDigi.h.

Referenced by GctRawToDigi(), and produce().

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 81 of file GctRawToDigi.h.

Referenced by unpack().

const unsigned GctRawToDigi::MAX_ERR_CODE = 6

staticprivate

Definition at line 102 of file GctRawToDigi.h.

Referenced by addError(), and endJob().

const unsigned GctRawToDigi::numberOfGctSamplesToUnpack_

private

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

Definition at line 88 of file GctRawToDigi.h.

Referenced by autoDetectRequiredFormatTranslator(), and GctRawToDigi().

const unsigned GctRawToDigi::numberOfRctSamplesToUnpack_

private

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

Definition at line 89 of file GctRawToDigi.h.

Referenced by autoDetectRequiredFormatTranslator(), and GctRawToDigi().

unsigned GctRawToDigi::unpackFailures_

private

To count the total number of GCT unpack failures.

Definition at line 105 of file GctRawToDigi.h.

const bool GctRawToDigi::unpackSharedRegions_

private

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

Definition at line 90 of file GctRawToDigi.h.

Referenced by autoDetectRequiredFormatTranslator(), and GctRawToDigi().

const bool GctRawToDigi::verbose_

private

If true, then debug print out for each event.

Definition at line 93 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

Member Function Documentation

Member Data Documentation