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

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

	~EDProducerBase () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

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::ParameterSet	theConfig

CscPacker	theCscPacker

edm::EDGetTokenT< CSCCorrelatedLCTDigiCollection >	theCscToken

DtPacker	theDtPacker

edm::EDGetTokenT< L1MuDTChambPhContainer >	theDtPhToken

edm::EDGetTokenT< L1MuDTChambThContainer >	theDtThToken

unsigned long	theEventCounter

std::string	theOutputTag

RpcPacker	theRpcPacker

edm::EDGetTokenT< RPCDigiCollection >	theRpcToken

bool	theSkipCsc

bool	theSkipDt

bool	theSkipRpc

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
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

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

Definition at line 46 of file OmtfPacker.cc.

Constructor & Destructor Documentation

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

Definition at line 79 of file OmtfPacker.cc.

References edm::ParameterSet::getParameter(), AlCaHLTBitMon_QueryRunRegistry::string, theCscToken, theDtPhToken, theDtThToken, theOutputTag, 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");
 
 }

omtf::OmtfPacker::~OmtfPacker ( )

inlineoverride

Definition at line 51 of file OmtfPacker.cc.

References beginRun(), ev, fillDescriptions(), produce(), and findQualityFiles::run.

51 {}

Member Function Documentation

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

override

Definition at line 111 of file OmtfPacker.cc.

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

Referenced by ~OmtfPacker().

                                                                     {
 
   //
   // initialise RPC packer
   //
   if (!theSkipRpc) {
   if (theConfig.getParameter<bool>("useRpcConnectionFile")) {
     theRpcPacker.init(es, edm::FileInPath(theConfig.getParameter<std::string>("rpcConnectionFile")).fullPath());
   } else {
     theRpcPacker.init(es); 
   } 
   }
 
   //
   // init CSC Link map
   //
   if (!theSkipCsc) theCscPacker.init();
 }

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

static

Definition at line 96 of file OmtfPacker.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by ~OmtfPacker().

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

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

override

Definition at line 131 of file OmtfPacker.cc.

References amc13::Packet::add(), edm::EventBase::bunchCrossing(), evf::compute_crc(), omtf::DataWord64::csc, FEDRawData::data(), DEFINE_FWK_MODULE, omtf::DataWord64::dt, edm::EventID::event(), edm::Event::eventAuxiliary(), l1t::stage2::layer2::fedId, edm::Event::getByToken(), RecoTauValidation_cfi::header, edm::EventBase::id(), LogDebug, LogTrace, eostools::move(), omtf::DataWord64::omtf, edm::EventAuxiliary::orbitNumber(), omtf::DtPacker::pack(), omtf::CscPacker::pack(), omtf::RpcPacker::pack(), jets_cff::payload, edm::Handle< T >::product(), edm::Event::put(), FEDRawData::resize(), omtf::DataWord64::rpc, FEDTrailer::set(), FEDHeader::set(), amc13::Packet::size(), findQualityFiles::size, theCscPacker, theCscToken, theDtPacker, theDtPhToken, theDtThToken, theEventCounter, theOutputTag, theRpcPacker, theRpcToken, theSkipCsc, theSkipDt, theSkipRpc, omtf::DataWord64::type(), and amc13::Packet::write().

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

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