#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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

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<>
using	CacheTypes = CacheContexts< T...>

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

template<class object>
class TriggerMatchProducer< object >

Definition at line 30 of file TriggerMatchProducer.h.

Constructor & Destructor Documentation

template<class object >

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

explicit

Definition at line 58 of file TriggerMatchProducer.h.

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_.

     : 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_ = "";
 }

template<class object >

TriggerMatchProducer< object >::~TriggerMatchProducer ( )

override

Definition at line 89 of file TriggerMatchProducer.h.

89 {}

Member Function Documentation

template<class object >

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

overrideprivate

Definition at line 241 of file TriggerMatchProducer.h.

References Exception.

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

template<class object >

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

overrideprivate

Definition at line 97 of file TriggerMatchProducer.h.

References counter, gather_cfg::cout, HLT_FULL_cff::deltaR, trigger::TriggerObject::eta(), cppFunctionSkipper::exception, alcazmumu_cfi::filter, filters, HltComparatorCreateWorkflow::hltConfig, mps_fire::i, dqmiolumiharvest::j, eostools::move(), trigger::TriggerObject::phi(), edm::RefToBaseVector< T >::push_back(), and dt_dqm_sourceclient_common_cff::reco.

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