#include <CandidateTriggerObjectProducer.h>

Inheritance diagram for CandidateTriggerObjectProducer:

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

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

std::vector< bool > const &	recordProvenanceList () 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)

TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...

	~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 &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

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 &	operator= (EDConsumerBase &&)=default

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

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)

Private Member Functions
void	beginJob () override

void	beginRun (const edm::Run &iRun, edm::EventSetup const &iSetup) override

void	endJob () override

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

Private Attributes
HLTPrescaleProvider	hltPrescaleProvider_

edm::Handle< trigger::TriggerEvent >	triggerEventHandle_

edm::InputTag	triggerEventTag_

edm::EDGetTokenT< trigger::TriggerEvent >	triggerEventToken_

std::string	triggerName_

edm::Handle< edm::TriggerResults >	triggerResultsHandle_
	additional class data memebers More...

edm::InputTag	triggerResultsTag_
	module config parameters More...

edm::EDGetTokenT< edm::TriggerResults >	triggerResultsToken_

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

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

Protected Member Functions inherited from edm::ProducerBase
template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()
	declare what type of product will make and with which optional label More...

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()

BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (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)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

Detailed Description

This class creates a list of candidates based on the last accepted filter

Author: Paolo Meridiani

Definition at line 23 of file CandidateTriggerObjectProducer.h.

Constructor & Destructor Documentation

◆ CandidateTriggerObjectProducer()

CandidateTriggerObjectProducer::CandidateTriggerObjectProducer ( const edm::ParameterSet & ps )

explicit

Definition at line 19 of file CandidateTriggerObjectProducer.cc.

     : triggerResultsToken_(consumes<edm::TriggerResults>(ps.getParameter<edm::InputTag>("triggerResults"))),
       triggerEventTag_(ps.getParameter<edm::InputTag>("triggerEvent")),
       triggerEventToken_(consumes<trigger::TriggerEvent>(triggerEventTag_)),
       triggerName_(ps.getParameter<std::string>("triggerName")),
       hltPrescaleProvider_(ps, consumesCollector(), *this) {
   //   cout << "Trigger Object Producer:" << endl
   //        << "   TriggerResultsTag = " << triggerResultsTag_.encode() << endl
   //        << "   TriggerEventTag = " << triggerEventTag_.encode() << endl;
  
   produces<reco::CandidateCollection>();
 }

◆ ~CandidateTriggerObjectProducer()

CandidateTriggerObjectProducer::~CandidateTriggerObjectProducer ( )

override

Definition at line 32 of file CandidateTriggerObjectProducer.cc.

32 {}

Member Function Documentation

◆ beginJob()

void CandidateTriggerObjectProducer::beginJob ( void )

inlineoverrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 30 of file CandidateTriggerObjectProducer.h.

30 {};

◆ beginRun()

void CandidateTriggerObjectProducer::beginRun	(	const edm::Run &	iRun,
		edm::EventSetup const &	iSetup
	)

overrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 37 of file CandidateTriggerObjectProducer.cc.

                                                                                              {
   using namespace edm;
  
   bool changed(false);
   if (!hltPrescaleProvider_.init(iRun, iSetup, triggerEventTag_.process(), changed)) {
     edm::LogError("CandidateTriggerObjectProducer") << "Error! Can't initialize HLTConfigProvider";
     throw cms::Exception("HLTConfigProvider::init() returned non 0");
   }
  
   return;
 }

References Exception, hltPrescaleProvider_, HLTPrescaleProvider::init(), edm::InputTag::process(), and triggerEventTag_.

◆ endJob()

void CandidateTriggerObjectProducer::endJob ( void )

inlineoverrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 32 of file CandidateTriggerObjectProducer.h.

32 {};

Referenced by o2olib.O2ORunMgr::executeJob().

◆ produce()

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

overrideprivatevirtual

Implements edm::EDProducer.

Definition at line 50 of file CandidateTriggerObjectProducer.cc.

                                                                                           {
   using namespace edm;
   using namespace reco;
   using namespace trigger;
  
   std::unique_ptr<reco::CandidateCollection> coll(new reco::CandidateCollection);
  
   // get event products
   iEvent.getByToken(triggerResultsToken_, triggerResultsHandle_);
   if (!triggerResultsHandle_.isValid()) {
     edm::LogError("CandidateTriggerObjectProducer")
         << "CandidateTriggerObjectProducer::analyze: Error in getting TriggerResults product from Event!";
     return;
   }
   iEvent.getByToken(triggerEventToken_, triggerEventHandle_);
   if (!triggerEventHandle_.isValid()) {
     edm::LogError("CandidateTriggerObjectProducer")
         << "CandidateTriggerObjectProducer::analyze: Error in getting TriggerEvent product from Event!";
     return;
   }
  
   HLTConfigProvider const& hltConfig = hltPrescaleProvider_.hltConfigProvider();
  
   // sanity check
   //   std::cout << hltConfig.size() << std::endl;
   //   std::cout << triggerResultsHandle_->size() << std::endl;
   assert(triggerResultsHandle_->size() == hltConfig.size());
  
   const unsigned int n(hltConfig.size());
   std::vector<std::string> activeHLTPathsInThisEvent = hltConfig.triggerNames();
   std::map<std::string, bool> triggerInMenu;
   std::map<std::string, bool> triggerUnprescaled;
  
   for (std::vector<std::string>::const_iterator iHLT = activeHLTPathsInThisEvent.begin();
        iHLT != activeHLTPathsInThisEvent.end();
        ++iHLT) {
     //matching with regexp filter name. More than 1 matching filter is allowed
     if (TString(*iHLT).Contains(TRegexp(TString(triggerName_)))) {
       triggerInMenu[*iHLT] = true;
       const std::pair<int, int> prescales(hltPrescaleProvider_.prescaleValues(iEvent, iSetup, *iHLT));
       if (prescales.first * prescales.second == 1)
         triggerUnprescaled[*iHLT] = true;
     }
   }
  
   for (std::map<std::string, bool>::const_iterator iMyHLT = triggerInMenu.begin(); iMyHLT != triggerInMenu.end();
        ++iMyHLT) {
     //using only unprescaled triggers
     if (!(iMyHLT->second && triggerUnprescaled[iMyHLT->first]))
       continue;
     const unsigned int triggerIndex(hltConfig.triggerIndex(iMyHLT->first));
  
     assert(triggerIndex == iEvent.triggerNames(*triggerResultsHandle_).triggerIndex(iMyHLT->first));
  
     // abort on invalid trigger name
     if (triggerIndex >= n) {
       edm::LogError("CandidateTriggerObjectProducer")
           << "CandidateTriggerObjectProducer::analyzeTrigger: path " << triggerName_ << " - not found!";
       return;
     }
  
     // modules on this trigger path
     //      const unsigned int m(hltConfig.size(triggerIndex));
     const std::vector<std::string>& moduleLabels(hltConfig.saveTagsModules(triggerIndex));
  
     // Results from TriggerResults product
     if (!(triggerResultsHandle_->wasrun(triggerIndex)) || !(triggerResultsHandle_->accept(triggerIndex)) ||
         (triggerResultsHandle_->error(triggerIndex))) {
       continue;
     }
  
     //       const unsigned int moduleIndex(triggerResultsHandle_->index(triggerIndex));
  
     //       assert (moduleIndex<m);
  
     // Results from TriggerEvent product - Looking only on last filter since trigger is accepted
     for (unsigned int imodule = 0; imodule < moduleLabels.size(); ++imodule) {
       const std::string& moduleLabel(moduleLabels[imodule]);
       const std::string moduleType(hltConfig.moduleType(moduleLabel));
       //Avoiding L1 seeds
       if (moduleType.find("Level1GTSeed") != std::string::npos)
         continue;
       // check whether the module is packed up in TriggerEvent product
       const unsigned int filterIndex(
           triggerEventHandle_->filterIndex(InputTag(moduleLabel, "", triggerEventTag_.process())));
       if (filterIndex < triggerEventHandle_->sizeFilters()) {
         //      std::cout << " 'L3' filter in slot " << imodule
         //                << " - label/type " << moduleLabel << "/" << moduleType << std::endl;
         const Vids& VIDS(triggerEventHandle_->filterIds(filterIndex));
         const Keys& KEYS(triggerEventHandle_->filterKeys(filterIndex));
         const size_type nI(VIDS.size());
         const size_type nK(KEYS.size());
         assert(nI == nK);
         const size_type n(std::max(nI, nK));
         //      std::cout << "   " << n  << " accepted 'L3' objects found: " << std::endl;
         const TriggerObjectCollection& TOC(triggerEventHandle_->getObjects());
         for (size_type i = 0; i != n; ++i) {
           const TriggerObject& TO(TOC[KEYS[i]]);
           coll->push_back(reco::LeafCandidate(0, TO.particle().p4(), reco::Particle::Point(0., 0., 0.), TO.id()));
           //          std::cout << "   " << i << " " << VIDS[i] << "/" << KEYS[i] << ": "
           //                      << TO.id() << " " << TO.pt() << " " << TO.eta() << " " << TO.phi() << " " << TO.mass()
           //                      << std::endl;
         }
       }
     }
   }
  
   iEvent.put(std::move(coll));
   return;
 }