Inheritance diagram for omtf::OmtfPacker:

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

	OmtfPacker (const edm::ParameterSet &pset)

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

	~OmtfPacker () 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

CscPacker	theCscPacker

edm::EDGetTokenT< CSCCorrelatedLCTDigiCollection >	theCscToken

DtPacker	theDtPacker

edm::EDGetTokenT< L1MuDTChambPhContainer >	theDtPhToken

edm::EDGetTokenT< L1MuDTChambThContainer >	theDtThToken

unsigned long	theEventCounter

std::string	theOutputTag

edm::ESGetToken< RPCEMap, RPCEMapRcd >	theRPCEMapToken

RpcPacker	theRpcPacker

edm::EDGetTokenT< RPCDigiCollection >	theRpcToken

bool	theSkipCsc

bool	theSkipDt

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 50 of file OmtfPacker.cc.

Constructor & Destructor Documentation

◆ OmtfPacker()

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

Definition at line 83 of file OmtfPacker.cc.

References edm::ParameterSet::getParameter(), muonDTDigis_cfi::pset, AlCaHLTBitMon_QueryRunRegistry::string, theAmcMappingToken, theConfig, theCscToken, theDtPhToken, theDtThToken, theOutputTag, theRPCEMapToken, theRpcToken, theSkipCsc, theSkipDt, and theSkipRpc.

                                                     : theConfig(pset), theEventCounter(0) {
     theOutputTag = pset.getParameter<std::string>("outputTag");
 
     produces<FEDRawDataCollection>(theOutputTag);
 
     theRpcToken = consumes<RPCDigiCollection>(pset.getParameter<edm::InputTag>("rpcInputLabel"));
     theCscToken = consumes<CSCCorrelatedLCTDigiCollection>(pset.getParameter<edm::InputTag>("cscInputLabel"));
     theDtPhToken = consumes<L1MuDTChambPhContainer>(pset.getParameter<edm::InputTag>("dtPhInputLabel"));
     theDtThToken = consumes<L1MuDTChambThContainer>(pset.getParameter<edm::InputTag>("dtThInputLabel"));
 
     theSkipDt = pset.getParameter<bool>("skipDt");
     theSkipRpc = pset.getParameter<bool>("skipRpc");
     theSkipCsc = pset.getParameter<bool>("skipCsc");
 
     if (!theSkipRpc) {
       theRPCEMapToken = esConsumes<edm::Transition::BeginRun>();
       if (not theConfig.getParameter<bool>("useRpcConnectionFile")) {
         theAmcMappingToken = esConsumes<edm::Transition::BeginRun>();
       }
     }
   }

◆ ~OmtfPacker()

omtf::OmtfPacker::~OmtfPacker ( )

inlineoverride

Definition at line 54 of file OmtfPacker.cc.

54 {}

Member Function Documentation

◆ beginRun()

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

override

Definition at line 120 of file OmtfPacker.cc.

References edm::FileInPath::fullPath(), edm::EventSetup::getData(), edm::ParameterSet::getParameter(), edm::EventSetup::getTransientHandle(), omtf::CscPacker::init(), omtf::RpcPacker::init(), AlCaHLTBitMon_QueryRunRegistry::string, theAmcMappingToken, theConfig, theCscPacker, theRPCEMapToken, theRpcPacker, theSkipCsc, and theSkipRpc.

                                                                       {
     //
     // initialise RPC packer
     //
     if (!theSkipRpc) {
       edm::ESTransientHandle<RPCEMap> readoutMapping = es.getTransientHandle(theRPCEMapToken);
       if (theConfig.getParameter<bool>("useRpcConnectionFile")) {
         theRpcPacker.init(*readoutMapping,
                           edm::FileInPath(theConfig.getParameter<std::string>("rpcConnectionFile")).fullPath());
       } else {
         auto const& amcMapping = es.getData(theAmcMappingToken);
         theRpcPacker.init(*readoutMapping, amcMapping);
       }
     }
 
     //
     // init CSC Link map
     //
     if (!theSkipCsc)
       theCscPacker.init();
   }

◆ fillDescriptions()

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

static

Definition at line 105 of file OmtfPacker.cc.

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

                                                                               {
     edm::ParameterSetDescription desc;
     desc.add<edm::InputTag>("rpcInputLabel", edm::InputTag(""));
     desc.add<edm::InputTag>("cscInputLabel", edm::InputTag(""));
     desc.add<edm::InputTag>("dtPhInputLabel", edm::InputTag(""));
     desc.add<edm::InputTag>("dtThInputLabel", edm::InputTag(""));
     desc.add<bool>("skipRpc", false);
     desc.add<bool>("skipCsc", false);
     desc.add<bool>("skipDt", false);
     desc.add<bool>("useRpcConnectionFile", false);
     desc.add<std::string>("rpcConnectionFile", "");
     desc.add<std::string>("outputTag", "");
     descriptions.add("omtfPacker", desc);
   }

◆ produce()

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

override

Definition at line 142 of file OmtfPacker.cc.

References evf::compute_crc(), omtf::DataWord64::csc, FEDRawData::data(), omtf::DataWord64::dt, makeMEIFBenchmarkPlots::ev, l1tstage2_dqm_sourceclient-live_cfg::fedId, L1TStage2BMTF_cff::fedIds, EcalFEDMonitor_cfi::FEDRawDataCollection, RecoTauValidation_cfi::header, LogDebug, LogTrace, eostools::move(), omtf::DataWord64::omtf, omtf::DtPacker::pack(), omtf::CscPacker::pack(), omtf::RpcPacker::pack(), jetsAK4_Puppi_cff::payload, edm::Handle< T >::product(), FEDRawData::resize(), omtf::DataWord64::rpc, FEDTrailer::set(), findQualityFiles::size, theCscPacker, theCscToken, theDtPacker, theDtPhToken, theDtThToken, theEventCounter, theOutputTag, theRpcPacker, theRpcToken, theSkipCsc, theSkipDt, theSkipRpc, and omtf::DataWord64::type().

                                                                 {
     LogDebug("OmtfPacker::produce") << "Beginning To Pack Event: " << ++theEventCounter;
 
     //
     // prepare FedAmcRawsMap structure to collect Word64 raws from digi packers
     //
     FedAmcRawsMap raws;
     std::list<unsigned int> amcIds = {1, 3, 5, 7, 9, 11};
     std::list<unsigned int> fedIds = {1380, 1381};
     for (auto& fedId : fedIds) {
       for (auto& amcId : amcIds) {
         raws[std::make_pair(fedId, amcId)];
       }
     }
 
     //
     // DT raws
     //
     if (!theSkipDt) {
       edm::Handle<L1MuDTChambPhContainer> digiCollectionDTPh;
       ev.getByToken(theDtPhToken, digiCollectionDTPh);
       edm::Handle<L1MuDTChambThContainer> digiCollectionDTTh;
       ev.getByToken(theDtThToken, digiCollectionDTTh);
       theDtPacker.pack(digiCollectionDTPh.product(), digiCollectionDTTh.product(), raws);
     }
 
     //
     // csc raws
     //
     if (!theSkipCsc) {
       edm::Handle<CSCCorrelatedLCTDigiCollection> digiCollectionCSC;
       ev.getByToken(theCscToken, digiCollectionCSC);
       theCscPacker.pack(digiCollectionCSC.product(), raws);
     }
 
     //
     // rpc raws
     //
     if (!theSkipRpc) {
       edm::Handle<RPCDigiCollection> digiCollectionRPC;
       ev.getByToken(theRpcToken, digiCollectionRPC);
       theRpcPacker.pack(digiCollectionRPC.product(), raws);
     }
 
     auto bxId = ev.bunchCrossing();
     auto evtId = ev.id().event();
     auto orbit = ev.eventAuxiliary().orbitNumber();
     std::unique_ptr<FEDRawDataCollection> raw_coll(new FEDRawDataCollection());
     for (auto& fedId : fedIds) {
       //
       // assign formatted raws to feds
       //
       amc13::Packet amc13;
       for (const auto& it : raws) {
         if (fedId != it.first.first)
           continue;
         const std::vector<Word64>& amcData = it.second;
         unsigned int amcId = it.first.second;
         for (const auto& raw : amcData) {
           std::ostringstream dataStr;
           if (DataWord64::csc == DataWord64::type(raw))
             dataStr << CscDataWord64(raw);
           if (DataWord64::dt == DataWord64::type(raw))
             dataStr << DtDataWord64(raw);
           if (DataWord64::rpc == DataWord64::type(raw))
             dataStr << RpcDataWord64(raw);
           if (DataWord64::omtf == DataWord64::type(raw))
             dataStr << MuonDataWord64(raw);
           LogTrace("") << " fed: " << fedId << " amcId: " << amcId << " RAW DATA: " << dataStr.str() << std::endl;
         }
         amc13.add(amcId, 43981, evtId, orbit, bxId, amcData);
       }
 
       FEDRawData& fed_data = raw_coll->FEDData(fedId);
 
       const unsigned int slinkHeaderSize = 8;
       const unsigned int slinkTrailerSize = 8;
       unsigned int size = (amc13.size()) * sizeof(Word64) + slinkHeaderSize + slinkTrailerSize;
       fed_data.resize(size);
       unsigned char* payload = fed_data.data();
       unsigned char* payload_start = payload;
 
       FEDHeader header(payload);
       const unsigned int evtType = 1;
       header.set(payload, evtType, evtId, bxId, fedId);
 
       amc13.write(ev, payload, slinkHeaderSize, size - slinkHeaderSize - slinkTrailerSize);
 
       payload += slinkHeaderSize;
       payload += amc13.size() * 8;
 
       FEDTrailer trailer(payload);
       trailer.set(payload, size / 8, evf::compute_crc(payload_start, size), 0, 0);
     }
     ev.put(std::move(raw_coll), theOutputTag);
   }