#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	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 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 22 of file RPCUnpackingModule.h.

Constructor & Destructor Documentation

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

Constructor.

Definition at line 40 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 52 of file RPCUnpackingModule.cc.

References theCabling.

52 { delete theCabling; }

RPCUnpackingModule::theCabling

const RPCReadOutMapping * theCabling

Definition: RPCUnpackingModule.h:45

Member Function Documentation

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

override

Definition at line 61 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 54 of file RPCUnpackingModule.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), and HLT_2018_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
	)

override

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

Definition at line 73 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(), l1tstage2_dqm_sourceclient-live_cfg::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(), l1tstage2_dqm_sourceclient-live_cfg::rawData, record, RPCRecordFormatter::recordUnpack(), FEDRawData::size(), FEDHeader::sourceID(), mps_update::status, 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));
 }