Inheritance diagram for omtf::OmtfUnpacker:

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

	OmtfUnpacker (const edm::ParameterSet &pset)

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

	~OmtfUnpacker () override

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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

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

Private Attributes
edm::ESGetToken< RPCAMCLinkMap, RPCOMTFLinkMapRcd >	theAmcMappingToken

edm::ParameterSet	theConfig

CscUnpacker	theCscUnpacker

DtUnpacker	theDtUnpacker

unsigned long	theEventCounter

edm::EDGetTokenT < FEDRawDataCollection >	theFedDataToken

MuonUnpacker	theMuonUnpacker

std::string	theOutputTag

edm::ESGetToken< RPCEMap, RPCEMapRcd >	theRPCEMapToken

RpcUnpacker	theRpcUnpacker

bool	theSkipCsc

bool	theSkipDt

bool	theSkipMuon

bool	theSkipRpc

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

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 52 of file OmtfUnpacker.cc.

Constructor & Destructor Documentation

omtf::OmtfUnpacker::OmtfUnpacker ( const edm::ParameterSet & pset )

Definition at line 83 of file OmtfUnpacker.cc.

References edm::ParameterSet::getParameter(), AlCaHLTBitMon_QueryRunRegistry::string, theAmcMappingToken, theConfig, theFedDataToken, theOutputTag, theRPCEMapToken, theSkipCsc, theSkipDt, theSkipMuon, and theSkipRpc.

                                                         : theConfig(pset) {
     theOutputTag = pset.getParameter<std::string>("outputTag");
 
     produces<RPCDigiCollection>(theOutputTag);
     produces<CSCCorrelatedLCTDigiCollection>(theOutputTag);
     produces<l1t::RegionalMuonCandBxCollection>(theOutputTag);
     produces<L1MuDTChambPhContainer>(theOutputTag);
     produces<L1MuDTChambThContainer>(theOutputTag);
 
     theSkipDt = pset.getParameter<bool>("skipDt");
     theSkipRpc = pset.getParameter<bool>("skipRpc");
     theSkipCsc = pset.getParameter<bool>("skipCsc");
     theSkipMuon = pset.getParameter<bool>("skipMuon");
 
     theFedDataToken = consumes<FEDRawDataCollection>(pset.getParameter<edm::InputTag>("inputLabel"));
 
     if (!theSkipRpc) {
       theRPCEMapToken = esConsumes<edm::Transition::BeginRun>();
       if (not theConfig.getParameter<bool>("useRpcConnectionFile")) {
         theAmcMappingToken = esConsumes<edm::Transition::BeginRun>();
       }
     }
   }

omtf::OmtfUnpacker::~OmtfUnpacker ( )

inlineoverride

Definition at line 56 of file OmtfUnpacker.cc.

56 {}

Member Function Documentation

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

override

Definition at line 120 of file OmtfUnpacker.cc.

References edm::FileInPath::fullPath(), edm::EventSetup::getData(), edm::ParameterSet::getParameter(), edm::EventSetup::getTransientHandle(), omtf::CscUnpacker::init(), omtf::RpcUnpacker::init(), AlCaHLTBitMon_QueryRunRegistry::string, theAmcMappingToken, theConfig, theCscUnpacker, theRPCEMapToken, theRpcUnpacker, theSkipCsc, and theSkipRpc.

                                                                         {
     //
     // rpc unpacker
     //
     if (!theSkipRpc) {
       edm::ESTransientHandle<RPCEMap> readoutMapping = es.getTransientHandle(theRPCEMapToken);
       if (theConfig.getParameter<bool>("useRpcConnectionFile")) {
         theRpcUnpacker.init(*readoutMapping,
                             edm::FileInPath(theConfig.getParameter<std::string>("rpcConnectionFile")).fullPath());
       } else {
         auto const& amcMapping = es.getData(theAmcMappingToken);
         theRpcUnpacker.init(*readoutMapping, amcMapping);
       }
     }
 
     //
     // csc unpacker
     //
     if (!theSkipCsc)
       theCscUnpacker.init();
   }

void omtf::OmtfUnpacker::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 107 of file OmtfUnpacker.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                 {
     edm::ParameterSetDescription desc;
     desc.add<edm::InputTag>("inputLabel", edm::InputTag("rawDataCollector"));
     desc.add<bool>("skipRpc", false);
     desc.add<bool>("skipCsc", false);
     desc.add<bool>("skipDt", false);
     desc.add<bool>("skipMuon", false);
     desc.add<bool>("useRpcConnectionFile", false);
     desc.add<std::string>("rpcConnectionFile", "");
     desc.add<std::string>("outputTag", "");
     descriptions.add("omtfUnpacker", desc);
   }

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

override

Definition at line 142 of file OmtfUnpacker.cc.

References amc, FEDHeader::bxID(), amc13::Header::check(), FEDHeader::check(), FEDTrailer::check(), FEDTrailer::crc(), omtf::DataWord64::csc, FEDRawData::data(), debug, edm::MessageDrop::debugEnabled, omtf::DataWord64::dt, FEDTrailer::evtStatus(), l1tstage2_dqm_sourceclient-live_cfg::fedId, FEDTrailer::fragmentLength(), amc::BlockHeader::getAMCNumber(), amc::Header::getAMCNumber(), amc13::Trailer::getBlock(), amc::BlockHeader::getBoardID(), amc13::Trailer::getBX(), amc13::Trailer::getCRC(), amc13::Header::getFormatVersion(), amc13::Trailer::getLV1ID(), amc13::Header::getNumberOfAMCs(), amc13::Header::getOrbitNumber(), amc::BlockHeader::getSize(), edm::MessageDrop::instance(), LogDebug, LogTrace, FEDHeader::lvl1ID(), FEDHeader::moreHeaders(), FEDTrailer::moreTrailers(), eostools::move(), omtf::DataWord64::omtf, amc13::Packet::parse(), amc13::Packet::payload(), amc::BlockHeader::raw(), amc::Header::raw(), omtf::DataWord64::rpc, FEDRawData::size(), FEDHeader::sourceID(), str, theCscUnpacker, theDtUnpacker, theEventCounter, theFedDataToken, theMuonUnpacker, theOutputTag, theRpcUnpacker, theSkipCsc, theSkipDt, theSkipMuon, theSkipRpc, FEDHeader::triggerType(), FEDTrailer::ttsBits(), omtf::DataWord64::type(), omtf::DtUnpacker::unpack(), omtf::MuonUnpacker::unpack(), omtf::CscUnpacker::unpack(), omtf::RpcUnpacker::unpack(), and FEDHeader::version().

                                                                         {
     bool debug = edm::MessageDrop::instance()->debugEnabled;
     theEventCounter++;
     if (debug)
       LogDebug("OmtfUnpacker::produce") << "Beginning To Unpack Event: " << theEventCounter;
 
     edm::Handle<FEDRawDataCollection> allFEDRawData;
     event.getByToken(theFedDataToken, allFEDRawData);
 
     auto producedRPCDigis = std::make_unique<RPCDigiCollection>();
     auto producedCscLctDigis = std::make_unique<CSCCorrelatedLCTDigiCollection>();
     auto producedMuonDigis = std::make_unique<l1t::RegionalMuonCandBxCollection>();
     producedMuonDigis->setBXRange(-3, 4);
     auto producedDTPhDigis = std::make_unique<L1MuDTChambPhContainer>();
     auto producedDTThDigis = std::make_unique<L1MuDTChambThContainer>();
     std::vector<L1MuDTChambPhDigi> phi_Container;
     std::vector<L1MuDTChambThDigi> the_Container;
 
     for (int fedId = 1380; fedId <= 1381; ++fedId) {
       const FEDRawData& rawData = allFEDRawData->FEDData(fedId);
       unsigned int nWords = rawData.size() / sizeof(Word64);
       LogTrace("") << "FED : " << fedId << " words: " << nWords;
       if (nWords == 0)
         continue;
 
       //
       // FED header
       //
       const Word64* header = reinterpret_cast<const Word64*>(rawData.data());
       FEDHeader fedHeader(reinterpret_cast<const unsigned char*>(header));
       if (!fedHeader.check()) {
         LogTrace("") << " ** PROBLEM **, header.check() failed, break";
         break;
       }
       if (fedHeader.sourceID() != fedId) {
         LogTrace("") << " ** PROBLEM **, fedHeader.sourceID() != fedId"
                      << "fedId = " << fedId << " sourceID=" << fedHeader.sourceID();
       }
       int triggerBX = fedHeader.bxID();
       if (debug) {
         std::ostringstream str;
         str << "  header: " << *reinterpret_cast<const std::bitset<64>*>(header) << std::endl;
         str << "  header triggerType: " << fedHeader.triggerType() << std::endl;
         str << "  header lvl1ID:      " << fedHeader.lvl1ID() << std::endl;
         str << "  header bxID:        " << fedHeader.bxID() << std::endl;
         str << "  header sourceID:    " << fedHeader.sourceID() << std::endl;
         str << "  header version:     " << fedHeader.version() << std::endl;
         str << "  header more :     " << fedHeader.moreHeaders() << std::endl;
         str << " triggerBx " << triggerBX << std::endl;
         LogTrace("") << str.str();
       }
 
       //
       // FED trailer
       //
       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()) {
           if (debug)
             LogTrace("") << " ** PROBLEM **, trailer.check() failed, break";
           break;
         }
         if (fedTrailer.fragmentLength() != nWords) {
           if (debug)
             LogTrace("") << " ** PROBLEM **, fedTrailer.fragmentLength()!= nWords, break";
           break;
         }
         moreTrailers = fedTrailer.moreTrailers();
         if (debug) {
           std::ostringstream str;
           str << " trailer: " << *reinterpret_cast<const std::bitset<64>*>(trailer) << std::endl;
           str << "  trailer lenght:    " << fedTrailer.fragmentLength() << std::endl;
           str << "  trailer crc:       " << fedTrailer.crc() << std::endl;
           str << "  trailer evtStatus: " << fedTrailer.evtStatus() << std::endl;
           str << "  trailer ttsBits:   " << fedTrailer.ttsBits() << std::endl;
           LogTrace("") << str.str();
         }
       }
 
       //
       // dump all FED data for debug
       //
       if (debug) {
         std::ostringstream str;
         for (const Word64* word = header + 1; word != trailer; word++) {
           str << "    data: " << *reinterpret_cast<const std::bitset<64>*>(word) << std::endl;
         }
         LogTrace("") << str.str();
       }
 
       //
       // AMC13 header
       //
       const Word64* headerAmc13raw = header + 1;
       amc13::Header headerAmc13(headerAmc13raw);
       if (debug) {
         std::ostringstream str;
         str << " headerAMC13:  " << *reinterpret_cast<const std::bitset<64>*>(headerAmc13raw) << std::endl;
         str << " amc13 check:  " << headerAmc13.check() << std::endl;
         str << " amc13 format: " << headerAmc13.getFormatVersion() << std::endl;
         str << " amc13 nAMCs:  " << headerAmc13.getNumberOfAMCs() << std::endl;
         str << " amc13 orbit:  " << headerAmc13.getOrbitNumber() << std::endl;
         LogTrace("") << str.str();
       }
       //unsigned int nAMCs = headerAmc13.getNumberOfAMCs();
       //for (unsigned int iAMC = 0; iAMC <nAMCs; iAMC++) {
       // const Word64* raw = header+1 +(iAMC+1);
       //}
 
       //
       // AMC13 trailer
       //
       const Word64* trailerAmc13raw = trailer - 1;
       amc13::Trailer trailerAmc13(trailerAmc13raw);
       if (debug) {
         std::ostringstream str;
         str << " trailerAMC13:  " << *reinterpret_cast<const std::bitset<64>*>(trailerAmc13raw) << std::endl;
         str << " crc:  " << trailerAmc13.getCRC() << std::endl;
         str << " block: " << trailerAmc13.getBlock() << std::endl;
         str << " LV1ID:  " << trailerAmc13.getLV1ID() << std::endl;
         str << " BX:  " << trailerAmc13.getBX() << std::endl;
         LogTrace("") << str.str();
       }
 
       //
       // get AMC13 payload (-> AMC's data)
       //
       amc13::Packet packetAmc13;
       if (!packetAmc13.parse(header, header + 1, nWords - 2, fedHeader.lvl1ID(), fedHeader.bxID(), true, false)) {
         edm::LogError("OMTF") << "Could not extract AMC13 Packet.";
         return;
       }
       //LogTrace("") <<"AMC13 Packet: "<< packetAmc13.blocks() << " size "<<packetAmc13.size() << std::endl;
 
       //
       // loop over AMC's
       //
       unsigned int blockNum = 0;
       for (auto amc : packetAmc13.payload()) {
         amc::BlockHeader bh = amc.blockHeader();
         if (debug) {
           std::ostringstream str;
           str << " ----------- #" << blockNum++ << std::endl;
           str << " blockheader:  " << std::bitset<64>(bh.raw()) << std::endl;
           str << " boardID:  " << bh.getBoardID() << std::endl;
           str << " amcNumber:  " << bh.getAMCNumber() << std::endl;
           str << " size:  " << bh.getSize();  // << std::endl;
           LogTrace("") << str.str();
         }
 
         //
         // AMC header
         //
         amc::Header headerAmc = amc.header();
         if (debug) {
           std::ostringstream str;
           str << " AMC header[0]:  " << std::bitset<64>(headerAmc.raw()[0]) << std::endl;
           str << " AMC header[1]:  " << std::bitset<64>(headerAmc.raw()[1]) << std::endl;
           str << " AMC number:     " << headerAmc.getAMCNumber();  // << std::endl;
           LogTrace("") << str.str();
         }
 
         //
         // AMC trailer
         //
         //amc::Trailer trailerAmc = amc.trailer();              //this is the expected way but does not work
         amc::Trailer trailerAmc(amc.data().get() + amc.size() -
                                 1);  //FIXME: the above is prefered but this works (CMSSW900)
         if (debug) {
           std::ostringstream str;
           str << " AMC trailer:  " << std::bitset<64>(trailerAmc.raw()) << std::endl;
           str << " getLV1ID:     " << trailerAmc.getLV1ID() << std::endl;
           str << " size:         " << trailerAmc.getSize() << std::endl;
           LogTrace("") << str.str();
         }
 
         //
         // AMC payload
         //
         const auto& payload64 = amc.data();
         const Word64* word = payload64.get();
         for (unsigned int iWord = 1; iWord <= amc.size(); iWord++, word++) {
           if (iWord <= 2)
             continue;  // two header words for each AMC
           if (iWord == amc.size())
             continue;  // trailer for each AMC
 
           LogTrace("") << " payload: " << *reinterpret_cast<const std::bitset<64>*>(word);
           DataWord64::Type recordType = DataWord64::type(*word);
 
           unsigned int fedId = fedHeader.sourceID();
           unsigned int amcId = bh.getAMCNumber() / 2 + 1;  // in OMTF convertsion 1-6
           //
           // RPC data
           //
           if (DataWord64::rpc == recordType && !theSkipRpc) {
             theRpcUnpacker.unpack(triggerBX, fedId, amcId, RpcDataWord64(*word), producedRPCDigis.get());
           }
 
           //
           // CSC data
           //
           if (DataWord64::csc == recordType && !theSkipCsc) {
             theCscUnpacker.unpack(fedId, amcId, CscDataWord64(*word), producedCscLctDigis.get());
           }
 
           //
           // DT data
           //
           if (DataWord64::dt == recordType && !theSkipDt) {
             theDtUnpacker.unpack(fedId, amcId, DtDataWord64(*word), phi_Container, the_Container);
           }
 
           //
           // OMTF (muon) data
           //
           if (DataWord64::omtf == recordType && !theSkipMuon) {
             theMuonUnpacker.unpack(fedId, amcId, MuonDataWord64(*word), producedMuonDigis.get());
           }
         }
       }
     }
     event.put(std::move(producedRPCDigis), theOutputTag);
     event.put(std::move(producedCscLctDigis), theOutputTag);
     event.put(std::move(producedMuonDigis), theOutputTag);
     producedDTPhDigis->setContainer(phi_Container);
     event.put(std::move(producedDTPhDigis), theOutputTag);
     producedDTThDigis->setContainer(the_Container);
     event.put(std::move(producedDTThDigis), theOutputTag);
   }