#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...

	~RPCUnpackingModule () override
	Destructor. More...

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

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

Static Public Member Functions
static void	fillDescriptions (edm::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

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(nullptr)
 {
   produces<RPCDigiCollection>();
   produces<RPCRawDataCounts>();
   if (doSynchro_) produces<RPCRawSynchro::ProdItem>();
   fedToken_=consumes<FEDRawDataCollection>(dataLabel_);
 
 }

RPCUnpackingModule::~RPCUnpackingModule ( )

override

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
	)

override

Definition at line 67 of file RPCUnpackingModule.cc.

References edm::ESWatcher< T >::check(), RPCEMap::convert(), 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(), and edm::ParameterSetDescription::add().

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

override

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

Definition at line 81 of file RPCUnpackingModule.cc.

References FEDHeader::bxID(), FEDHeader::check(), FEDTrailer::check(), rpcrawtodigi::EventRecords::complete(), FEDTrailer::crc(), FEDRawData::data(), debug, edm::MessageDrop::debugEnabled, TauDecayModes::dec, doSynchro_, event(), eventCounter_, FEDTrailer::evtStatus(), FEDRawDataCollection::FEDData(), l1t::stage2::layer2::fedId, fedToken_, FEDTrailer::fragmentLength(), edm::Event::getByToken(), RecoTauValidation_cfi::header, edm::MessageDrop::instance(), LogDebug, LogTrace, FEDHeader::lvl1ID(), FEDNumbering::MAXRPCFEDID, FEDNumbering::MINRPCFEDID, FEDHeader::moreHeaders(), FEDTrailer::moreTrailers(), eostools::move(), rpcrawtodigi::DataRecord::print(), edm::print(), edm::Event::put(), record, RPCRecordFormatter::recordUnpack(), FEDRawData::size(), FEDHeader::sourceID(), mps_update::status, harvestTrackValidationPlots::str, 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); 
 
 
   auto producedRPCDigis = std::make_unique<RPCDigiCollection>();
   auto producedRawDataCounts = std::make_unique<RPCRawDataCounts>();
   std::unique_ptr<RPCRawSynchro::ProdItem> producedRawSynchoCounts;
   if (doSynchro_) producedRawSynchoCounts = std::make_unique<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,nullptr);
     int triggerBX =0;
     unsigned 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.fragmentLength()!= nWords) {
         producedRawDataCounts->addReadoutError(fedId, ReadoutError(ReadoutError::InconsistentDataSize)); 
         if (debug) LogTrace("")<<" ** PROBLEM **, fedTrailer.fragmentLength()!= nWords, break";
         break;
       }
       moreTrailers = fedTrailer.moreTrailers();
       if (debug) {
         ostringstream str;
         str <<" trailer: "<<  *reinterpret_cast<const bitset<64>*> (trailer) << endl; 
         str <<"  trailer lenght:    "<<fedTrailer.fragmentLength()<<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(std::move(producedRPCDigis));  
   ev.put(std::move(producedRawDataCounts));
   if (doSynchro_) ev.put(std::move(producedRawSynchoCounts));
 
 }