#include <TriggerMatchProducer.h>

Inheritance diagram for TriggerMatchProducer< object >:

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

	~TriggerMatchProducer () override

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

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

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

Private Attributes
edm::InputTag	_inputProducer

edm::EDGetTokenT< edm::View< object > >	_inputProducerToken

bool	changed_

double	delRMatchingCut_

std::string	filterName_

HLTPrescaleProvider	hltPrescaleProvider_

std::string	hltTag_

bool	storeRefCollection_

edm::InputTag	triggerEventTag_

edm::EDGetTokenT< trigger::TriggerEvent >	triggerEventToken_

edm::InputTag	triggerResultsTag_

edm::EDGetTokenT< edm::TriggerResults >	triggerResultsToken_

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

Detailed Description

template<class object>
class TriggerMatchProducer< object >

Definition at line 30 of file TriggerMatchProducer.h.

Constructor & Destructor Documentation

◆ TriggerMatchProducer()

template<class object >

TriggerMatchProducer< object >::TriggerMatchProducer ( const edm::ParameterSet & iConfig )

explicit

Definition at line 58 of file TriggerMatchProducer.h.

     : hltPrescaleProvider_(iConfig, consumesCollector(), *this) {
   _inputProducer = iConfig.template getParameter<edm::InputTag>("InputProducer");
   _inputProducerToken = consumes<edm::View<object> >(_inputProducer);
  
   // **************** Trigger ******************* //
   const edm::InputTag dTriggerEventTag("hltTriggerSummaryAOD", "", "HLT");
   triggerEventTag_ = iConfig.getUntrackedParameter<edm::InputTag>("triggerEventTag", dTriggerEventTag);
   triggerEventToken_ = consumes<trigger::TriggerEvent>(triggerEventTag_);
  
   const edm::InputTag dTriggerResults("TriggerResults", "", "HLT");
   // By default, trigger results are labeled "TriggerResults" with process name "HLT" in the event.
   triggerResultsTag_ = iConfig.getUntrackedParameter<edm::InputTag>("triggerResultsTag", dTriggerResults);
   triggerResultsToken_ = consumes<edm::TriggerResults>(triggerResultsTag_);
  
   //  const edm::InputTag dHLTTag("HLT_Ele15_LW_L1R", "","HLT8E29");
   hltTag_ = iConfig.getUntrackedParameter<std::string>("hltTag", "HLT_Ele*");
  
   delRMatchingCut_ = iConfig.getUntrackedParameter<double>("triggerDelRMatch", 0.30);
   // ******************************************** //
   //Trigger path VS l1 trigger filter. Trigger Path is default.
   //   isFilter_ = iConfig.getUntrackedParameter<bool>("isTriggerFilter",false);
   //   printIndex_ = iConfig.getUntrackedParameter<bool>("verbose",false);
  
   produces<edm::PtrVector<object> >();
   produces<edm::RefToBaseVector<object> >("R");
  
   filterName_ = "";
 }

References TriggerMatchProducer< object >::_inputProducer, TriggerMatchProducer< object >::_inputProducerToken, TriggerMatchProducer< object >::delRMatchingCut_, TriggerMatchProducer< object >::filterName_, edm::ParameterSet::getUntrackedParameter(), TriggerMatchProducer< object >::hltTag_, AlCaHLTBitMon_QueryRunRegistry::string, TriggerMatchProducer< object >::triggerEventTag_, TriggerMatchProducer< object >::triggerEventToken_, TriggerMatchProducer< object >::triggerResultsTag_, and TriggerMatchProducer< object >::triggerResultsToken_.

◆ ~TriggerMatchProducer()

template<class object >

TriggerMatchProducer< object >::~TriggerMatchProducer ( )

override

Definition at line 89 of file TriggerMatchProducer.h.

89 {}

Member Function Documentation

◆ beginRun()

template<class object >

void TriggerMatchProducer< object >::beginRun	(	edm::Run const &	iRun,
		edm::EventSetup const &	iSetup
	)

overrideprivate

Definition at line 241 of file TriggerMatchProducer.h.

                                                                                            {
   //   std::cout << "calling init(" << "iRun" << ", " << "iSetup" << ", " << triggerEventTag_.process() << ", " << "changed_" << ") in beginRun()" << std::endl;
   if (!hltPrescaleProvider_.init(iRun, iSetup, triggerEventTag_.process(), changed_)) {
     edm::LogError("TriggerMatchProducer") << "Error! Can't initialize HLTConfigProvider";
     throw cms::Exception("HLTConfigProvider::init() returned non 0");
   }
   // HLTConfigProvider const&  hltConfig = hltPrescaleProvider_.hltConfigProvider();
   //   if(printIndex_ && changed_)
   //     std::cout << "HLT configuration changed !" << std::endl;
   //  std::vector<std::string> filters = hltConfig.moduleLabels( hltTag_.label() );
 }

References Exception.

◆ produce()

template<class object >

void TriggerMatchProducer< object >::produce	(	edm::Event &	event,
		const edm::EventSetup &	eventSetup
	)

overrideprivate

Definition at line 97 of file TriggerMatchProducer.h.

                                                                                            {
   using namespace std;
   using namespace edm;
   using namespace reco;
   using namespace trigger;
  
   HLTConfigProvider const& hltConfig = hltPrescaleProvider_.hltConfigProvider();
  
   // Create the output collection
   std::unique_ptr<edm::RefToBaseVector<object> > outColRef(new edm::RefToBaseVector<object>);
   std::unique_ptr<edm::PtrVector<object> > outColPtr(new edm::PtrVector<object>);
  
   // Get the input collection
   edm::Handle<edm::View<object> > candHandle;
   try {
     event.getByToken(_inputProducerToken, candHandle);
   } catch (cms::Exception& ex) {
     edm::LogError("TriggerMatchProducer") << "Error! Can't get collection: " << _inputProducer;
     throw ex;
   }
  
   // Trigger Info
   edm::Handle<trigger::TriggerEvent> trgEvent;
   event.getByToken(triggerEventToken_, trgEvent);
   edm::Handle<edm::TriggerResults> pTrgResults;
   event.getByToken(triggerResultsToken_, pTrgResults);
  
   //gracefully choose the single appropriate HLT path from the list of desired paths
   std::vector<std::string> activeHLTPathsInThisEvent = hltConfig.triggerNames();
   std::map<std::string, bool> triggerInMenu;
   std::map<std::string, bool> triggerUnprescaled;
   //    for (std::vector<edm::InputTag>::const_iterator iMyHLT = hltTags_.begin();
   //         iMyHLT != hltTags_.end(); ++iMyHLT) {
   //      if ( triggerInMenu.find((*iMyHLT).label()) == triggerInMenu.end() )
   //        triggerInMenu[(*iMyHLT).label()] = false;
   //      if ( triggerUnprescaled.find((*iMyHLT).label()) == triggerUnprescaled.end() )
   //        triggerUnprescaled[(*iMyHLT).label()] = false;
   //    }
   for (std::vector<std::string>::const_iterator iHLT = activeHLTPathsInThisEvent.begin();
        iHLT != activeHLTPathsInThisEvent.end();
        ++iHLT) {
     //        cout << "######## " << *iHLT << endl;
  
     if (TString(*iHLT).Contains(TRegexp(hltTag_))) {
       triggerInMenu[*iHLT] = true;
       if (hltPrescaleProvider_.prescaleValue(event, eventSetup, *iHLT) == 1)
         triggerUnprescaled[*iHLT] = true;
     }
   }
  
   // Some sanity checks
   if (not trgEvent.isValid()) {
     edm::LogInfo("info") << "******** Following Trigger Summary Object Not Found: " << triggerEventTag_;
  
     event.put(std::move(outColRef), "R");
     event.put(std::move(outColPtr));
     return;
   }
  
   //---------------------------------------------------------------------------
  
   edm::InputTag filterTag;
   // loop over these objects to see whether they match
   const trigger::TriggerObjectCollection& TOC(trgEvent->getObjects());
  
   std::vector<int> index;
   std::vector<std::string> filters;
   //    if(isFilter_){
   //-----------------------------------------------------------------------
   for (std::map<std::string, bool>::const_iterator iMyHLT = triggerInMenu.begin(); iMyHLT != triggerInMenu.end();
        ++iMyHLT) {
     if (!(iMyHLT->second && triggerUnprescaled[iMyHLT->first]))
       continue;
  
     int triggerIndex = -1;
     edm::InputTag filterTag;
     try {
       filters = hltConfig.moduleLabels(iMyHLT->first);
       triggerIndex = hltConfig.triggerIndex(iMyHLT->first);
     } catch (std::exception const&) {
       cout << "bad trigger\n";
     }
     // Results from TriggerResults product
     if (triggerIndex == -1 || !(pTrgResults->wasrun(triggerIndex)) || !(pTrgResults->accept(triggerIndex)) ||
         (pTrgResults->error(triggerIndex))) {
       continue;
     }
  
     for (std::vector<std::string>::iterator filter = filters.begin(); filter != filters.end(); ++filter) {
       edm::InputTag testTag(*filter, "", triggerEventTag_.process());
       int testindex = trgEvent->filterIndex(testTag);
       if (!(testindex >= trgEvent->sizeFilters())) {
         filterName_ = *filter;
         filterTag = testTag;
       }
     }
  
     //using last filter tag
     index.push_back(trgEvent->filterIndex(filterTag));
     //        std::cout << "TrgPath" << iMyHLT->first << "hltTag_.label() " <<
     //   filterTag.label() << "   filter name " <<
     //   filterName_ << "  sizeFilters " <<
     //   trgEvent->sizeFilters() << std::endl;
   }
  
   // Loop over the candidate collection
   edm::PtrVector<object> ptrVect;
   edm::RefToBaseVector<object> refs;
   for (size_t i = 0; i < candHandle->size(); ++i) {
     ptrVect.push_back(candHandle->ptrAt(i));
     refs.push_back(candHandle->refAt(i));
   }
   // find how many objects there are
   unsigned int counter = 0;
   for (typename edm::View<object>::const_iterator j = candHandle->begin(); j != candHandle->end(); ++j, ++counter) {
     bool hltTrigger = false;
     for (unsigned int idx = 0; idx < index.size(); ++idx) {
       if (hltTrigger)
         continue;
       const trigger::Keys& KEYS(trgEvent->filterKeys(index[idx]));
       const size_type nK(KEYS.size());
       // Get cut decision for each candidate
       // Did this candidate cause a HLT trigger?
  
       for (int ipart = 0; ipart != nK; ++ipart) {
         const trigger::TriggerObject& TO = TOC[KEYS[ipart]];
         double dRval = deltaR(j->eta(), j->phi(), TO.eta(), TO.phi());
         hltTrigger = dRval < delRMatchingCut_;
         if (hltTrigger)
           break;
       }
     }
  
     if (hltTrigger) {
       outColRef->push_back(refs[counter]);
       outColPtr->push_back(ptrVect[counter]);
     }
   }
   event.put(std::move(outColRef), "R");
   event.put(std::move(outColPtr));
 }