#include <CandidateTriggerObjectProducer.h>

Inheritance diagram for CandidateTriggerObjectProducer:

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

	~CandidateTriggerObjectProducer ()

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

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

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

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Member Functions
virtual void	beginJob ()

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

virtual void	endJob ()

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

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

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 ( const edm::ParameterSet & ps )

explicit

Definition at line 20 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 ( )

Definition at line 36 of file CandidateTriggerObjectProducer.cc.

37 {

38 }

Member Function Documentation

virtual void CandidateTriggerObjectProducer::beginJob ( void )

inlineprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 31 of file CandidateTriggerObjectProducer.h.

31 {} ;

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

overrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 44 of file CandidateTriggerObjectProducer.cc.

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

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

virtual void CandidateTriggerObjectProducer::endJob ( void )

inlineprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 33 of file CandidateTriggerObjectProducer.h.

33 {} ;

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

overrideprivatevirtual

Implements edm::EDProducer.

Definition at line 61 of file CandidateTriggerObjectProducer.cc.

References assert(), coll, edm::Event::getByToken(), HltComparatorCreateWorkflow::hltConfig, HLTPrescaleProvider::hltConfigProvider(), hltPrescaleProvider_, i, trigger::TriggerObject::id(), edm::HandleBase::isValid(), bookConverter::max, gen::n, reco::Particle::p4(), trigger::TriggerObject::particle(), makeHLTPrescaleTable::prescales, HLTPrescaleProvider::prescaleValues(), edm::InputTag::process(), edm::Event::put(), dt_dqm_sourceclient_common_cff::reco, AlCaHLTBitMon_QueryRunRegistry::string, triggerEventHandle_, triggerEventTag_, triggerEventToken_, edm::TriggerNames::triggerIndex(), triggerName_, edm::Event::triggerNames(), triggerResultsHandle_, and triggerResultsToken_.

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

 {
   using namespace edm;
   using namespace reco;
   using namespace trigger;
 
   std::auto_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(coll);
   return;
 }