Inheritance diagram for HcalDigiToRawuHTR:

Public Member Functions
	HcalDigiToRawuHTR (const edm::ParameterSet &)

	~HcalDigiToRawuHTR ()

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

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

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

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

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, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

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

	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 Member Functions
void	getData (const edm::Event &, const edm::EventSetup &)

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

Private Attributes
int	_verbosity

std::string	electronicsMapLabel_

edm::Handle< HBHEDigiCollection >	hbheDigiCollection

edm::InputTag	hbheqie8Tag_

edm::Handle< HFDigiCollection >	hfDigiCollection

edm::InputTag	hfqie8Tag_

bool	premix_

edm::Handle< QIE10DigiCollection >	qie10DigiCollection

edm::InputTag	qie10Tag_

edm::Handle< QIE11DigiCollection >	qie11DigiCollection

edm::InputTag	qie11Tag_

edm::EDGetTokenT< HBHEDigiCollection >	tok_HBHEDigiCollection_

edm::EDGetTokenT< HFDigiCollection >	tok_HFDigiCollection_

edm::EDGetTokenT< HcalDataFrameContainer< QIE10DataFrame > >	tok_QIE10DigiCollection_

edm::EDGetTokenT< HcalDataFrameContainer< QIE11DataFrame > >	tok_QIE11DigiCollection_

edm::EDGetTokenT< HcalTrigPrimDigiCollection >	tok_TPDigiCollection_

edm::Handle< HcalTrigPrimDigiCollection >	tpDigiCollection

edm::InputTag	trigTag_

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
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 41 of file HcalDigiToRawuHTR.cc.

Constructor & Destructor Documentation

HcalDigiToRawuHTR::HcalDigiToRawuHTR ( const edm::ParameterSet & iConfig )

explicit

Definition at line 70 of file HcalDigiToRawuHTR.cc.

References hbheqie8Tag_, hfqie8Tag_, qie10Tag_, qie11Tag_, tok_HBHEDigiCollection_, tok_HFDigiCollection_, tok_QIE10DigiCollection_, tok_QIE11DigiCollection_, tok_TPDigiCollection_, and trigTag_.

                                                                    :
   _verbosity(iConfig.getUntrackedParameter<int>("Verbosity", 0)),
   electronicsMapLabel_(iConfig.getParameter<std::string>("ElectronicsMap")),
   qie10Tag_(iConfig.getParameter<edm::InputTag>("QIE10")),
   qie11Tag_(iConfig.getParameter<edm::InputTag>("QIE11")),
   hbheqie8Tag_(iConfig.getParameter<edm::InputTag>("HBHEqie8")),
   hfqie8Tag_(iConfig.getParameter<edm::InputTag>("HFqie8")),
   trigTag_(iConfig.getParameter<edm::InputTag>("TP")),
   premix_(iConfig.getParameter<bool>("premix"))
 {
   produces<FEDRawDataCollection>("");
   tok_QIE10DigiCollection_ = consumes<HcalDataFrameContainer<QIE10DataFrame> >(qie10Tag_);
   tok_QIE11DigiCollection_ = consumes<HcalDataFrameContainer<QIE11DataFrame> >(qie11Tag_);
   tok_HBHEDigiCollection_ = consumes<HBHEDigiCollection >(hbheqie8Tag_);
   tok_HFDigiCollection_ = consumes<HFDigiCollection>(hfqie8Tag_);
   tok_TPDigiCollection_ = consumes<HcalTrigPrimDigiCollection>(trigTag_);
 }

HcalDigiToRawuHTR::~HcalDigiToRawuHTR ( )

Definition at line 88 of file HcalDigiToRawuHTR.cc.

88 {}

Member Function Documentation

void HcalDigiToRawuHTR::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 274 of file HcalDigiToRawuHTR.cc.

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

                                                                                   {
   //The following says we do not know what parameters are allowed so do no validation
   // Please change this to state exactly what you do use, even if it is no parameters
   edm::ParameterSetDescription desc;
   desc.addUntracked<int>("Verbosity", 0);
   desc.add<std::string>("ElectronicsMap", "");
   desc.add<edm::InputTag>("QIE10", edm::InputTag("simHcalDigis", "HFQIE10DigiCollection"));
   desc.add<edm::InputTag>("QIE11", edm::InputTag("simHcalDigis", "HBHEQIE11DigiCollection"));
   desc.add<edm::InputTag>("HBHEqie8", edm::InputTag("simHcalDigis"));
   desc.add<edm::InputTag>("HFqie8", edm::InputTag("simHcalDigis"));
   desc.add<edm::InputTag>("TP", edm::InputTag("simHcalTriggerPrimitiveDigis"));
   desc.add<bool>("premix", false);
   descriptions.add("hcalDigiToRawuHTR",desc);
   descriptions.addDefault(desc);
 }

void HcalDigiToRawuHTR::getData	(	const edm::Event &	,
		const edm::EventSetup &
	)

private

void HcalDigiToRawuHTR::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivatevirtual

Definition at line 90 of file HcalDigiToRawuHTR.cc.

References _verbosity, UHTRpacker::addChannel(), edm::SortedCollection< T, SORT >::begin(), edm::EventBase::bunchCrossing(), evf::compute_crc(), QIE11DataFrame::detid(), QIE10DataFrame::detid(), runTauDisplay::eid, electronicsMapLabel_, edm::SortedCollection< T, SORT >::end(), edm::EventID::event(), UHTRpacker::exist(), l1t::stage2::layer2::fedId, UHTRpacker::finalizeHeadTail(), edm::EventSetup::get(), edm::Event::getByToken(), hbheDigiCollection, hfDigiCollection, edm::EventBase::id(), HcalElectronicsMap::lookup(), HcalElectronicsMap::lookupTrigger(), genParticles_cff::map, FEDNumbering::MINHCALuTCAFEDID, eostools::move(), UHTRpacker::newUHTR(), edm::EventBase::orbitNumber(), premix_, hcalTTPDigis_cfi::presamples, QIE11DataFrame::presamples(), QIE10DataFrame::presamples(), edm::ESHandle< T >::product(), edm::Event::put(), qie10DigiCollection, qie11DigiCollection, FEDTrailer::set(), FEDHeader::set(), edm::DataFrameContainer::size(), tok_HBHEDigiCollection_, tok_HFDigiCollection_, tok_QIE10DigiCollection_, tok_QIE11DigiCollection_, tok_TPDigiCollection_, tpDigiCollection, and UHTRpacker::uhtrs.

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

                                                                             {
 
   using namespace edm;
 
   edm::ESHandle<HcalElectronicsMap> item;
   iSetup.get<HcalElectronicsMapRcd>().get(electronicsMapLabel_,item);
   const HcalElectronicsMap* readoutMap = item.product();
 
   //collection to be inserted into event
   std::unique_ptr<FEDRawDataCollection> fed_buffers(new FEDRawDataCollection());
   
   //
   //  Extracting All the Collections containing useful Info
   iEvent.getByToken(tok_QIE10DigiCollection_,qie10DigiCollection);
   iEvent.getByToken(tok_QIE11DigiCollection_,qie11DigiCollection);
   iEvent.getByToken(tok_HBHEDigiCollection_,hbheDigiCollection);
   iEvent.getByToken(tok_HFDigiCollection_,hfDigiCollection);
   iEvent.getByToken(tok_TPDigiCollection_,tpDigiCollection);
 
   // first argument is the fedid (minFEDID+crateId)
   map<int,unique_ptr<HCalFED> > fedMap;
 
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - 
   // QIE10 precision data
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - 
   UHTRpacker uhtrs;
   // loop over each digi and allocate memory for each
   if( qie10DigiCollection.isValid() ){
     const QIE10DigiCollection& qie10dc=*(qie10DigiCollection);
     for (unsigned int j=0; j < qie10dc.size(); j++){
       QIE10DataFrame qiedf = static_cast<QIE10DataFrame>(qie10dc[j]);
       DetId detid = qiedf.detid();
       HcalElectronicsId eid(readoutMap->lookup(detid));
       int crateId = eid.crateId();
       int slotId = eid.slot();
       int uhtrIndex = ((slotId&0xF)<<8) | (crateId&0xFF);
       int presamples = qiedf.presamples();
 
       /* Defining a custom index that will encode only
      the information about the crate and slot of a 
      given channel:   crate: bits 0-7
      slot:  bits 8-12 */
 
       if( ! uhtrs.exist( uhtrIndex ) ){
     uhtrs.newUHTR( uhtrIndex , presamples );
       }
       uhtrs.addChannel(uhtrIndex,qiedf,readoutMap,_verbosity);
     }
   }
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - 
   // QIE11 precision data
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - 
   //UHTRpacker uhtrs;
   // loop over each digi and allocate memory for each
   if( qie11DigiCollection.isValid() ){
     const QIE11DigiCollection& qie11dc=*(qie11DigiCollection);
     for (unsigned int j=0; j < qie11dc.size(); j++){
       QIE11DataFrame qiedf = static_cast<QIE11DataFrame>(qie11dc[j]);
       DetId detid = qiedf.detid();
       HcalElectronicsId eid(readoutMap->lookup(detid));
       int crateId = eid.crateId();
       int slotId = eid.slot();
       int uhtrIndex = ((slotId&0xF)<<8) | (crateId&0xFF);
       int presamples = qiedf.presamples();
 
       if( ! uhtrs.exist(uhtrIndex) ){
     uhtrs.newUHTR( uhtrIndex , presamples );
       }
       uhtrs.addChannel(uhtrIndex,qiedf,readoutMap,_verbosity);
     }
   }
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - 
   // HF (QIE8) precision data
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - 
   // loop over each digi and allocate memory for each
   if(hfDigiCollection.isValid()){
     const HFDigiCollection& qie8hfdc=*(hfDigiCollection);
     for(HFDigiCollection::const_iterator qiedf=qie8hfdc.begin();qiedf!=qie8hfdc.end();qiedf++){
       DetId detid = qiedf->id();
 
       HcalElectronicsId eid(readoutMap->lookup(detid));
       int crateId = eid.crateId();
       int slotId = eid.slot();
       int uhtrIndex = (crateId&0xFF) | ((slotId&0xF)<<8) ; 
       int presamples = qiedf->presamples();
 
       if( ! uhtrs.exist(uhtrIndex) ){
     uhtrs.newUHTR( uhtrIndex , presamples );
       }
       uhtrs.addChannel(uhtrIndex,qiedf,readoutMap,premix_,_verbosity);
     }
   }
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - 
   // HBHE (QIE8) precision data
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - 
   // loop over each digi and allocate memory for each
   if(hbheDigiCollection.isValid()){
     const HBHEDigiCollection& qie8hbhedc=*(hbheDigiCollection);
     for(HBHEDigiCollection::const_iterator qiedf=qie8hbhedc.begin();qiedf!=qie8hbhedc.end();qiedf++){
       DetId detid = qiedf->id();
 
       HcalElectronicsId eid(readoutMap->lookup(detid));
       int crateId = eid.crateId();
       int slotId = eid.slot();
       int uhtrIndex = (crateId&0xFF) | ((slotId&0xF)<<8) ; 
       int presamples = qiedf->presamples();
 
       if( ! uhtrs.exist(uhtrIndex) ){
     uhtrs.newUHTR( uhtrIndex , presamples );
       }
       uhtrs.addChannel(uhtrIndex,qiedf,readoutMap,premix_,_verbosity);
     }
   }
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - 
   // TP data
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - 
   // loop over each digi and allocate memory for each
   if(tpDigiCollection.isValid()){
     const HcalTrigPrimDigiCollection& qietpdc=*(tpDigiCollection);
     for(HcalTrigPrimDigiCollection::const_iterator qiedf=qietpdc.begin();qiedf!=qietpdc.end();qiedf++){
       DetId detid = qiedf->id();
       HcalElectronicsId eid(readoutMap->lookupTrigger(detid));
     
       int crateId = eid.crateId();
       int slotId = eid.slot();
       int uhtrIndex = (crateId&0xFF) | ((slotId&0xF)<<8);
       int ilink = eid.fiberIndex();
       int itower = eid.fiberChanId();
       int channelid = (itower&0xF) | ((ilink&0xF)<<4);
       int presamples = qiedf->presamples();
 
       if( ! uhtrs.exist(uhtrIndex) ){
     uhtrs.newUHTR( uhtrIndex , presamples );
       }
       uhtrs.addChannel(uhtrIndex,qiedf,channelid,_verbosity);
     }
   }
   // -----------------------------------------------------
   // -----------------------------------------------------
   // loop over each uHTR and format data
   // -----------------------------------------------------
   // -----------------------------------------------------
   // loop over each uHTR and format data
   int idxuhtr =-1;
   for( UHTRpacker::UHTRMap::iterator uhtr = uhtrs.uhtrs.begin() ; uhtr != uhtrs.uhtrs.end() ; ++uhtr){
 
     idxuhtr ++;
    
     uint64_t crateId = (uhtr->first)&0xFF;
     uint64_t slotId =  (uhtr->first&0xF00)>>8;
 
     uhtrs.finalizeHeadTail(&(uhtr->second),_verbosity);
     int fedId = FEDNumbering::MINHCALuTCAFEDID + crateId;
     if( fedMap.find(fedId) == fedMap.end() ){
       /* QUESTION: where should the orbit number come from? */
       fedMap[fedId] = std::unique_ptr<HCalFED>(new HCalFED(fedId,iEvent.id().event(),iEvent.orbitNumber(),iEvent.bunchCrossing()));
     }
     fedMap[fedId]->addUHTR(uhtr->second,crateId,slotId);
   }// end loop over uhtr containers
 
   /* ------------------------------------------------------
      ------------------------------------------------------
            putting together the FEDRawDataCollection
      ------------------------------------------------------
      ------------------------------------------------------ */
   for( map<int,unique_ptr<HCalFED> >::iterator fed = fedMap.begin() ; fed != fedMap.end() ; ++fed ){
 
     int fedId = fed->first;
 
     auto & rawData = fed_buffers->FEDData(fedId);
     fed->second->formatFEDdata(rawData);
 
     FEDHeader hcalFEDHeader(rawData.data());
     hcalFEDHeader.set(rawData.data(), 1, iEvent.id().event(), iEvent.bunchCrossing(), fedId);
     FEDTrailer hcalFEDTrailer(rawData.data()+(rawData.size()-8));
     hcalFEDTrailer.set(rawData.data()+(rawData.size()-8), rawData.size()/8, evf::compute_crc(rawData.data(),rawData.size()), 0, 0);
 
   }// end loop over FEDs with data
 
   iEvent.put(std::move(fed_buffers));
   
 }