Inheritance diagram for L1TStage1Layer2Producer:

Public Member Functions
	L1TStage1Layer2Producer (const ParameterSet &)

	~L1TStage1Layer2Producer () override

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

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

	~ProducerBase () noexcept(false) override

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

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

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

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

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

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Private Member Functions
void	beginJob () override

void	beginRun (Run const &iR, EventSetup const &iE) override

void	endJob () override

void	endRun (Run const &iR, EventSetup const &iE) override

void	produce (Event &, EventSetup const &) override

Private Attributes
EDGetToken	candsToken

std::string	m_conditionsLabel

CaloConfigHelper	m_config

unsigned long long	m_configCacheId

Stage1Layer2FirmwareFactory	m_factory

std::shared_ptr< Stage1Layer2MainProcessor >	m_fw

CaloParamsHelper *	m_params

unsigned long long	m_paramsCacheId

EDGetToken	regionToken

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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 70 of file L1TStage1Layer2Producer.cc.

Constructor & Destructor Documentation

L1TStage1Layer2Producer::L1TStage1Layer2Producer ( const ParameterSet & iConfig )

explicit

Definition at line 106 of file L1TStage1Layer2Producer.cc.

References edm::ParameterSet::getParameter(), and AlCaHLTBitMon_QueryRunRegistry::string.

   {
     // register what you produce
     produces<BXVector<EGamma>>();
     produces<BXVector<Tau>>("rlxTaus");
     produces<BXVector<Tau>>("isoTaus");
     produces<BXVector<Jet>>();
     produces<BXVector<Jet>>("preGtJets");
     produces<BXVector<EtSum>>();
     produces<BXVector<CaloSpare>>("HFRingSums");
     produces<BXVector<CaloSpare>>("HFBitCounts");
 
     // register what you consume and keep token for later access:
     regionToken = consumes<BXVector<CaloRegion>>(iConfig.getParameter<InputTag>("CaloRegions"));
     candsToken = consumes<BXVector<CaloEmCand>>(iConfig.getParameter<InputTag>("CaloEmCands"));
     //int ifwv=iConfig.getParameter<unsigned>("FirmwareVersion");  // LenA  make configurable for now
 
     m_conditionsLabel = iConfig.getParameter<std::string>("conditionsLabel");
 
     m_params = new CaloParamsHelper;
 
     // set cache id to zero, will be set at first beginRun:
     m_paramsCacheId = 0;
     m_configCacheId = 0;
   }

L1TStage1Layer2Producer::~L1TStage1Layer2Producer ( )

override

Definition at line 133 of file L1TStage1Layer2Producer.cc.

134 {

135 }

Member Function Documentation

void L1TStage1Layer2Producer::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 255 of file L1TStage1Layer2Producer.cc.

256 {

257 }

void L1TStage1Layer2Producer::beginRun	(	Run const &	iR,
		EventSetup const &	iE
	)

overrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 266 of file L1TStage1Layer2Producer.cc.

References edm::EventSetup::get(), triggerObjects_cff::id, wplusjetsAnalysis_cfi::jetScale, LogDebug, and edm::ESHandle< T >::product().

                                                                        {
   unsigned long long id = 0;
 
   id = iE.get<L1TCaloParamsRcd>().cacheIdentifier();
   if (id != m_paramsCacheId) {
 
     m_paramsCacheId = id;
 
     edm::ESHandle<CaloParams> paramsHandle;
 
     iE.get<L1TCaloParamsRcd>().get(m_conditionsLabel, paramsHandle);
 
     // replace our local copy of the parameters with a new one using placement new
     m_params->~CaloParamsHelper();
     m_params = new (m_params) CaloParamsHelper(*paramsHandle.product());
 
     LogDebug("L1TDebug") << *m_params << std::endl;
 
     if (! m_params){
       edm::LogError("l1t|caloStage1") << "Could not retrieve params from Event Setup" << std::endl;
     }
 
   }
 
   id = iE.get<L1TCaloConfigRcd>().cacheIdentifier();
   if (id != m_configCacheId) {
     m_configCacheId = id;
 
     edm::ESHandle<CaloConfig> configHandle;
 
     iE.get<L1TCaloConfigRcd>().get(m_conditionsLabel, configHandle);
 
 
     if (! configHandle.product()){
       edm::LogError("l1t|caloStage1") << "Could not retrieve config from Event Setup" << std::endl;
     } else {
       //update our DB payload in CaloConfigHelper:
       m_config.UpdatePayload(configHandle.product());
       //cout << "DEBUG:  L1T Calo Config reports the Layer2 firmware version is " << m_config.fwv() << "\n";
     }      
   }
 
 
 
 
 
 
   LogDebug("l1t|stage 1 jets") << "L1TStage1Layer2Producer::beginRun function called...\n";
 
   //get the proper scales for conversion to physical et AND gt scales
   edm::ESHandle< L1CaloEtScale > emScale ;
   iE.get< L1EmEtScaleRcd >().get( m_conditionsLabel, emScale ) ;
   m_params->setEmScale(*emScale);
 
   edm::ESHandle< L1CaloEtScale > jetScale ;
   iE.get< L1JetEtScaleRcd >().get( m_conditionsLabel, jetScale ) ;
   m_params->setJetScale(*jetScale);
 
   edm::ESHandle< L1CaloEtScale > HtMissScale;
   iE.get< L1HtMissScaleRcd >().get( m_conditionsLabel, HtMissScale ) ;
   m_params->setHtMissScale(*HtMissScale);
 
   //not sure if I need this one
   edm::ESHandle< L1CaloEtScale > HfRingScale;
   iE.get< L1HfRingEtScaleRcd >().get( m_conditionsLabel, HfRingScale );
   m_params->setHfRingScale(*HfRingScale);
 
 
   //unsigned long long id = iE.get<CaloParamsRcd>().cacheIdentifier();
 
   //if (id != m_paramsCacheId)
   { // Need to update:
     //m_paramsCacheId = id;
 
     //ESHandle<CaloParams> parameters;
     //iE.get<CaloParamsRcd>().get(parameters);
 
     // LenA move the setting of the firmware version to the L1TStage1Layer2Producer constructor
 
     //m_params = std::shared_ptr<const CaloParams>(parameters.product());
     //m_fwv = std::shared_ptr<const FirmwareVersion>(new FirmwareVersion());
     //printf("Begin.\n");
     //m_fwv = std::make_shared<FirmwareVersion>(); //not const during testing
     //printf("Success m_fwv.\n");
     //m_fwv->setFirmwareVersion(1); //hardcode for now, 1=HI, 2=PP
     //printf("Success m_fwv version set.\n");
 
     // if (! m_params){
     //   LogError("l1t|stage 1 jets") << "L1TStage1Layer2Producer: could not retreive DB params from Event Setup\n";
     // }
 
     // Set the current algorithm version based on DB pars from database:
     //m_fw = m_factory.create(*m_fwv /*,*m_params*/);
     //printf("Success create.\n");
 
     //if (! m_fw) {
     //  // we complain here once per run
     //  LogError("l1t|stage 1 jets") << "L1TStage1Layer2Producer: firmware could not be configured.\n";
     //}
   }
 
 
 
     int ifwv=m_config.fwv();
     //cout << "DEBUG:  ifwv is " << ifwv << "\n";
     //m_fwv = std::make_shared<FirmwareVersion>(); //not const during testing
     if (ifwv == 1){
       LogDebug("l1t|stage1firmware") << "L1TStage1Layer2Producer -- Running HI implementation\n";
       //std::cout << "L1TStage1Layer2Producer -- Running HI implementation\n";
     }else if (ifwv == 2){
       LogDebug("l1t|stage1firmware") << "L1TStage1Layer2Producer -- Running pp implementation\n";
       //std::cout << "L1TStage1Layer2Producer -- Running pp implementation\n";
     } else if (ifwv == 3){
       LogDebug("l1t|stage1firmware") << "L1TStage1Layer2Producer -- Running SimpleHW implementation\n";
       //std::cout << "L1TStage1Layer2Producer -- Running SimpleHW implementation -- for testing only\n";
     }else{
       LogError("l1t|stage1firmware") << "L1TStage1Layer2Producer -- Unknown implementation.\n";
       //std::cout << "L1TStage1Layer2Producer -- Unknown implementation.\n";
     }
     //m_fwv->setFirmwareVersion(ifwv); // =1 HI, =2 PP
     // m_fw = m_factory.create(*m_fwv /*,*m_params*/);
     //m_fwv = ifwv;
     m_fw = m_factory.create(ifwv ,m_params);
     //printf("Success create.\n");
     if (! m_fw) {
       // we complain here once per job
       LogError("l1t|stage1firmware") << "L1TStage1Layer2Producer: firmware could not be configured.\n";
     }
 
 
 
 
 }

void L1TStage1Layer2Producer::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 261 of file L1TStage1Layer2Producer.cc.

261 {

262 }

void L1TStage1Layer2Producer::endRun	(	Run const &	iR,
		EventSetup const &	iE
	)

overrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 401 of file L1TStage1Layer2Producer.cc.

                                                                        {
 
 }

void L1TStage1Layer2Producer::fillDescriptions ( ConfigurationDescriptions & descriptions )

static

Definition at line 408 of file L1TStage1Layer2Producer.cc.

References edm::ConfigurationDescriptions::addDefault(), DEFINE_FWK_MODULE, and edm::ParameterSetDescription::setUnknown().

                                                                                  {
   //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
   ParameterSetDescription desc;
   desc.setUnknown();
   descriptions.addDefault(desc);
 }

void L1TStage1Layer2Producer::produce	(	Event &	,
		EventSetup const &
	)

overrideprivatevirtual

Implements edm::EDProducer.

Definition at line 145 of file L1TStage1Layer2Producer.cc.

References edm::Event::getByToken(), mps_fire::i, metsig::jet, fwrapper::jets, LogDebug, eostools::move(), edm::Event::put(), l1t::CaloSpare::setType(), metsig::tau, and nano_cff::taus.

 {
 
   LogDebug("l1t|stage 1 jets") << "L1TStage1Layer2Producer::produce function called...\n";
 
   //return;
 
   //inputs
   Handle<BXVector<CaloRegion>> caloRegions;
   iEvent.getByToken(regionToken,caloRegions);
 
   Handle<BXVector<CaloEmCand>> caloEmCands;
   iEvent.getByToken(candsToken, caloEmCands);
 
   int bxFirst = caloRegions->getFirstBX();
   int bxLast = caloRegions->getLastBX();
 
   //outputs
   std::unique_ptr<EGammaBxCollection> egammas (new EGammaBxCollection);
   std::unique_ptr<TauBxCollection> taus (new TauBxCollection);
   std::unique_ptr<TauBxCollection> isoTaus (new TauBxCollection);
   std::unique_ptr<JetBxCollection> jets (new JetBxCollection);
   std::unique_ptr<JetBxCollection> preGtJets (new JetBxCollection);
   std::unique_ptr<EtSumBxCollection> etsums (new EtSumBxCollection);
   std::unique_ptr<CaloSpareBxCollection> hfSums (new CaloSpareBxCollection);
   std::unique_ptr<CaloSpareBxCollection> hfCounts (new CaloSpareBxCollection);
 
   egammas->setBXRange(bxFirst, bxLast);
   taus->setBXRange(bxFirst, bxLast);
   isoTaus->setBXRange(bxFirst, bxLast);
   jets->setBXRange(bxFirst, bxLast);
   preGtJets->setBXRange(bxFirst, bxLast);
   etsums->setBXRange(bxFirst, bxLast);
   hfSums->setBXRange(bxFirst, bxLast);
   hfCounts->setBXRange(bxFirst, bxLast);
 
   //producer is responsible for splitting the BXVector into pieces for
   //the firmware to handle
   for(int i = bxFirst; i <= bxLast; ++i)
   {
     //make local inputs
     std::vector<CaloRegion> *localRegions = new std::vector<CaloRegion>();
     std::vector<CaloEmCand> *localEmCands = new std::vector<CaloEmCand>();
 
     //make local outputs
     std::vector<EGamma> *localEGammas = new std::vector<EGamma>();
     std::vector<Tau> *localTaus = new std::vector<Tau>();
     std::vector<Tau> *localIsoTaus = new std::vector<Tau>();
     std::vector<Jet> *localJets = new std::vector<Jet>();
     std::vector<Jet> *localPreGtJets = new std::vector<Jet>();
     std::vector<EtSum> *localEtSums = new std::vector<EtSum>();
     CaloSpare *localHfSums = new CaloSpare();
     localHfSums->setType(CaloSpare::HFRingSum);
     CaloSpare *localHfCounts = new CaloSpare();
     localHfCounts->setType(CaloSpare::HFBitCount);
 
     // copy over the inputs -> there must be a better way to do this
     for(std::vector<CaloRegion>::const_iterator region = caloRegions->begin(i);
     region != caloRegions->end(i); ++region)
       localRegions->push_back(*region);
     for(std::vector<CaloEmCand>::const_iterator emcand = caloEmCands->begin(i);
     emcand != caloEmCands->end(i); ++emcand)
       localEmCands->push_back(*emcand);
 
     //run the firmware on one event
     m_fw->processEvent(*localEmCands, *localRegions,
                localEGammas, localTaus, localIsoTaus, localJets, localPreGtJets, localEtSums,
                localHfSums, localHfCounts);
 
     // copy the output into the BXVector -> there must be a better way
     for(std::vector<EGamma>::const_iterator eg = localEGammas->begin(); eg != localEGammas->end(); ++eg)
       egammas->push_back(i, *eg);
     for(std::vector<Tau>::const_iterator tau = localTaus->begin(); tau != localTaus->end(); ++tau)
       taus->push_back(i, *tau);
     for(std::vector<Tau>::const_iterator isotau = localIsoTaus->begin(); isotau != localIsoTaus->end(); ++isotau)
       isoTaus->push_back(i, *isotau);
     for(std::vector<Jet>::const_iterator jet = localJets->begin(); jet != localJets->end(); ++jet)
       jets->push_back(i, *jet);
     for(std::vector<Jet>::const_iterator jet = localPreGtJets->begin(); jet != localPreGtJets->end(); ++jet)
       preGtJets->push_back(i, *jet);
     for(std::vector<EtSum>::const_iterator etsum = localEtSums->begin(); etsum != localEtSums->end(); ++etsum)
       etsums->push_back(i, *etsum);
     hfSums->push_back(i, *localHfSums);
     hfCounts->push_back(i, *localHfCounts);
 
     delete localRegions;
     delete localEmCands;
     delete localEGammas;
     delete localTaus;
     delete localIsoTaus;
     delete localJets;
     delete localPreGtJets;
     delete localEtSums;
     delete localHfSums;
     delete localHfCounts;
   }
 
 
   iEvent.put(std::move(egammas));
   iEvent.put(std::move(taus),"rlxTaus");
   iEvent.put(std::move(isoTaus),"isoTaus");
   iEvent.put(std::move(jets));
   iEvent.put(std::move(preGtJets),"preGtJets");
   iEvent.put(std::move(etsums));
   iEvent.put(std::move(hfSums),"HFRingSums");
   iEvent.put(std::move(hfCounts),"HFBitCounts");
 }

Member Data Documentation

EDGetToken L1TStage1Layer2Producer::candsToken

private

Definition at line 99 of file L1TStage1Layer2Producer.cc.

std::string L1TStage1Layer2Producer::m_conditionsLabel

private

Definition at line 95 of file L1TStage1Layer2Producer.cc.

CaloConfigHelper L1TStage1Layer2Producer::m_config

private

Definition at line 88 of file L1TStage1Layer2Producer.cc.

unsigned long long L1TStage1Layer2Producer::m_configCacheId

private

Definition at line 86 of file L1TStage1Layer2Producer.cc.

Stage1Layer2FirmwareFactory L1TStage1Layer2Producer::m_factory

private

Definition at line 93 of file L1TStage1Layer2Producer.cc.

std::shared_ptr<Stage1Layer2MainProcessor> L1TStage1Layer2Producer::m_fw

private

Definition at line 91 of file L1TStage1Layer2Producer.cc.

CaloParamsHelper* L1TStage1Layer2Producer::m_params

private

Definition at line 87 of file L1TStage1Layer2Producer.cc.

unsigned long long L1TStage1Layer2Producer::m_paramsCacheId

private

Definition at line 85 of file L1TStage1Layer2Producer.cc.

EDGetToken L1TStage1Layer2Producer::regionToken

private

Definition at line 98 of file L1TStage1Layer2Producer.cc.

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation