#include <RPCUnpackingModule.h>

Inheritance diagram for RPCUnpackingModule:

Public Member Functions
void	beginRun (const edm::Run &run, const edm::EventSetup &es) override

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

	RPCUnpackingModule (const edm::ParameterSet &pset)
	Constructor. More...

virtual	~RPCUnpackingModule ()
	Destructor. More...

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 (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &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 Attributes
edm::InputTag	dataLabel_

bool	doSynchro_

unsigned long	eventCounter_

edm::EDGetTokenT < FEDRawDataCollection >	fedToken_

const RPCReadOutMapping *	theCabling

RPCReadOutMappingWithFastSearch	theReadoutMappingSearch

edm::ESWatcher< RPCEMapRcd >	theRecordWatcher

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

unpacking RPC raw data

Definition at line 20 of file RPCUnpackingModule.h.

Constructor & Destructor Documentation

RPCUnpackingModule::RPCUnpackingModule ( const edm::ParameterSet & pset )

Constructor.

Definition at line 41 of file RPCUnpackingModule.cc.

References dataLabel_, doSynchro_, and fedToken_.

   : dataLabel_(pset.getParameter<edm::InputTag>("InputLabel")),
     doSynchro_(pset.getParameter<bool>("doSynchro")),
     eventCounter_(0),
     theCabling(0)
 {
   produces<RPCDigiCollection>();
   produces<RPCRawDataCounts>();
   if (doSynchro_) produces<RPCRawSynchro::ProdItem>();
   fedToken_=consumes<FEDRawDataCollection>(dataLabel_);
 
 }

RPCUnpackingModule::~RPCUnpackingModule ( )

virtual

Destructor.

Definition at line 54 of file RPCUnpackingModule.cc.

References theCabling.

 { 
   delete theCabling;
 }

Member Function Documentation

void RPCUnpackingModule::beginRun	(	const edm::Run &	run,
		const edm::EventSetup &	es
	)

overridevirtual

Reimplemented from edm::stream::EDProducerBase.

Definition at line 67 of file RPCUnpackingModule.cc.

References edm::ESWatcher< T >::check(), edm::EventSetup::get(), RPCReadOutMappingWithFastSearch::init(), LogTrace, theCabling, theReadoutMappingSearch, theRecordWatcher, and RPCReadOutMapping::version().

 {
   if (theRecordWatcher.check(es)) {  
     LogTrace("") << "record has CHANGED!!, (re)initialise readout map!";
     delete theCabling; 
     ESTransientHandle<RPCEMap> readoutMapping;
     es.get<RPCEMapRcd>().get(readoutMapping);
     theCabling = readoutMapping->convert();
     theReadoutMappingSearch.init(theCabling);
      LogTrace("") <<" READOUT MAP VERSION: " << theCabling->version() << endl;
   }
 }

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

static

Definition at line 59 of file RPCUnpackingModule.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), and HLT_FULL_cff::InputTag.

                                                                                     {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("InputLabel",edm::InputTag("rawDataCollector"));
   desc.add<bool>("doSynchro",true);
   descriptions.add("rpcUnpackingModule",desc);
 }

void RPCUnpackingModule::produce	(	edm::Event &	ev,
		const edm::EventSetup &	es
	)

overridevirtual

Retrieves a RPCDigiCollection from the Event, creates a FEDRawDataCollection (EDProduct) using the DigiToRaw converter, and attaches it to the Event.

Implements edm::stream::EDProducerBase.

Definition at line 81 of file RPCUnpackingModule.cc.

References FEDHeader::bxID(), FEDTrailer::check(), FEDHeader::check(), rpcrawtodigi::EventRecords::complete(), FEDTrailer::crc(), FEDRawData::data(), debug, edm::MessageDrop::debugEnabled, TauDecayModes::dec, doSynchro_, event(), eventCounter_, FEDTrailer::evtStatus(), stage2MP7BufferRaw_cfi::fedId, fedToken_, edm::Event::getByToken(), edm::MessageDrop::instance(), FEDTrailer::lenght(), LogDebug, LogTrace, FEDHeader::lvl1ID(), FEDNumbering::MAXRPCFEDID, FEDNumbering::MINRPCFEDID, FEDHeader::moreHeaders(), FEDTrailer::moreTrailers(), reco::print(), rpcrawtodigi::DataRecord::print(), edm::Event::put(), record, RPCRecordFormatter::recordUnpack(), FEDRawData::size(), FEDHeader::sourceID(), ntuplemaker::status, theCabling, theReadoutMappingSearch, FEDHeader::triggerType(), FEDTrailer::ttsBits(), rpcrawtodigi::DataRecord::type(), and FEDHeader::version().

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

 {
   bool debug = edm::MessageDrop::instance()->debugEnabled;
   eventCounter_++; 
   if (debug) LogDebug ("RPCUnpacker::produce") <<"Beginning To Unpack Event: "<<eventCounter_;
  
   Handle<FEDRawDataCollection> allFEDRawData; 
   ev.getByToken(fedToken_,allFEDRawData); 
 
 
   std::auto_ptr<RPCDigiCollection> producedRPCDigis(new RPCDigiCollection);
   std::auto_ptr<RPCRawDataCounts> producedRawDataCounts(new RPCRawDataCounts);
   std::auto_ptr<RPCRawSynchro::ProdItem> producedRawSynchoCounts;
   if (doSynchro_) producedRawSynchoCounts.reset(new RPCRawSynchro::ProdItem);
 
   int status = 0;
   for (int fedId= FEDNumbering::MINRPCFEDID; fedId<=FEDNumbering::MAXRPCFEDID; ++fedId){  
 
     const FEDRawData & rawData = allFEDRawData->FEDData(fedId);
     RPCRecordFormatter interpreter = 
         theCabling ? RPCRecordFormatter(fedId,&theReadoutMappingSearch) : RPCRecordFormatter(fedId,0);
     int triggerBX =0;
     int nWords = rawData.size()/sizeof(Word64);
     if (nWords==0) continue;
 
     //
     // check headers
     //
     const Word64* header = reinterpret_cast<const Word64* >(rawData.data()); header--;
     bool moreHeaders = true;
     while (moreHeaders) {
       header++;
       FEDHeader fedHeader( reinterpret_cast<const unsigned char*>(header));
       if (!fedHeader.check()) {
         producedRawDataCounts->addReadoutError(fedId, ReadoutError(ReadoutError::HeaderCheckFail)); 
         if (debug) LogTrace("") <<" ** PROBLEM **, header.check() failed, break"; 
         break; 
       }
       if ( fedHeader.sourceID() != fedId) {
         producedRawDataCounts->addReadoutError(fedId, ReadoutError(ReadoutError::InconsitentFedId)); 
         if (debug) LogTrace ("") <<" ** PROBLEM **, fedHeader.sourceID() != fedId"
             << "fedId = " << fedId<<" sourceID="<<fedHeader.sourceID(); 
       }
       triggerBX = fedHeader.bxID();
       moreHeaders = fedHeader.moreHeaders();
       if (debug) {
         stringstream str;
         str <<"  header: "<< *reinterpret_cast<const bitset<64>*> (header) << endl;
         str <<"  header triggerType: " << fedHeader.triggerType()<<endl;
         str <<"  header lvl1ID:      " << fedHeader.lvl1ID() << endl;
         str <<"  header bxID:        " << fedHeader.bxID() << endl;
         str <<"  header sourceID:    " << fedHeader.sourceID() << endl;
         str <<"  header version:     " << fedHeader.version() << endl;
         LogTrace("") << str.str();
       }
     }
 
     //
     // check trailers
     //
     const Word64* trailer=reinterpret_cast<const Word64* >(rawData.data())+(nWords-1); trailer++;
     bool moreTrailers = true;
     while (moreTrailers) {
       trailer--;
       FEDTrailer fedTrailer(reinterpret_cast<const unsigned char*>(trailer));
       if ( !fedTrailer.check()) {
         producedRawDataCounts->addReadoutError(fedId, ReadoutError(ReadoutError::TrailerCheckFail));
         if (debug) LogTrace("") <<" ** PROBLEM **, trailer.check() failed, break";
         break;
       }
       if ( fedTrailer.lenght()!= nWords) {
         producedRawDataCounts->addReadoutError(fedId, ReadoutError(ReadoutError::InconsistentDataSize)); 
         if (debug) LogTrace("")<<" ** PROBLEM **, fedTrailer.lenght()!= nWords, break";
         break;
       }
       moreTrailers = fedTrailer.moreTrailers();
       if (debug) {
         ostringstream str;
         str <<" trailer: "<<  *reinterpret_cast<const bitset<64>*> (trailer) << endl; 
         str <<"  trailer lenght:    "<<fedTrailer.lenght()<<endl;
         str <<"  trailer crc:       "<<fedTrailer.crc()<<endl;
         str <<"  trailer evtStatus: "<<fedTrailer.evtStatus()<<endl;
         str <<"  trailer ttsBits:   "<<fedTrailer.ttsBits()<<endl;
         LogTrace("") << str.str();
       }
     }
 
     //
     // data records
     //
     if (debug) {
       ostringstream str;
       for (const Word64* word = header+1; word != trailer; word++) {
         str<<"    data: "<<*reinterpret_cast<const bitset<64>*>(word) << endl; 
       }
       LogTrace("") << str.str();
     }
 //    if (triggerBX != 51) continue;
 //    if (triggerBX != 2316) continue;
     EventRecords event(triggerBX);
     for (const Word64* word = header+1; word != trailer; word++) {
       for( int iRecord=1; iRecord<=4; iRecord++){
         const DataRecord::Data* pRecord = reinterpret_cast<const DataRecord::Data* >(word+1)-iRecord;
         DataRecord record(*pRecord);
         event.add(record);
         if (debug) {
           std::ostringstream str;
           str <<"record: "<<record.print()<<" hex: "<<hex<<*pRecord<<dec;
           str <<" type:"<<record.type()<<DataRecord::print(record);
           if (event.complete()) {
             str<< " --> dccId: "<<fedId
                << " rmb: " <<event.recordSLD().rmb()
                << " lnk: "<<event.recordSLD().tbLinkInputNumber()
                << " lb: "<<event.recordCD().lbInLink()
                << " part: "<<event.recordCD().partitionNumber()
                << " data: "<<event.recordCD().partitionData()
                << " eod: "<<event.recordCD().eod();
           }
           LogTrace("") << str.str();
         }
         producedRawDataCounts->addDccRecord(fedId, record);
         int statusTMP = 0;
         if (event.complete() ) statusTMP= 
             interpreter.recordUnpack( event, 
             producedRPCDigis.get(), producedRawDataCounts.get(), producedRawSynchoCounts.get()); 
         if (statusTMP != 0) status = statusTMP;
       }
     }
   }
   if (status && debug) LogTrace("")<<" RPCUnpackingModule - There was unpacking PROBLEM in this event"<<endl;
   if (debug) LogTrace("") << DebugDigisPrintout()(producedRPCDigis.get()) << endl;
   ev.put(producedRPCDigis);  
   ev.put(producedRawDataCounts);
   if (doSynchro_) ev.put(producedRawSynchoCounts);
 
 }