#include <HLTFiltCand.h>

Inheritance diagram for HLTFiltCand:

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

bool	hltFilter (edm::Event &, const edm::EventSetup &, trigger::TriggerFilterObjectWithRefs &filterproduct) const override

	~HLTFiltCand () override

Public Member Functions inherited from HLTFilter
	HLTFilter (const edm::ParameterSet &config)

int	module (edm::Event const &) const

const std::string *	moduleLabel () const

int	path (edm::Event const &) const

const std::string *	pathName (edm::Event const &) const

std::pair< int, int >	pmid (edm::Event const &) const

bool	saveTags () const

	~HLTFilter () override

Public Member Functions inherited from edm::global::EDFilter<>
	EDFilter ()=default

Public Member Functions inherited from edm::global::EDFilterBase
	EDFilterBase ()

ModuleDescription const &	moduleDescription () const

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

virtual	~ProducerBase () noexcept(false)

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

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

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

virtual	~EDConsumerBase () noexcept(false)

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

Static Public Member Functions inherited from HLTFilter
static void	makeHLTFilterDescription (edm::ParameterSetDescription &desc)

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Attributes
edm::InputTag	ecalTag_

edm::EDGetTokenT< reco::RecoEcalCandidateCollection >	ecalToken_

edm::InputTag	elecTag_

edm::EDGetTokenT< reco::ElectronCollection >	elecToken_

edm::InputTag	jetsTag_

edm::EDGetTokenT< reco::CaloJetCollection >	jetsToken_

edm::InputTag	metsTag_

edm::EDGetTokenT< reco::CaloMETCollection >	metsToken_

edm::InputTag	mhtsTag_

edm::EDGetTokenT< reco::METCollection >	mhtsToken_

double	min_Pt_

edm::InputTag	muonTag_

edm::EDGetTokenT< reco::RecoChargedCandidateCollection >	muonToken_

edm::InputTag	photTag_

edm::EDGetTokenT< reco::RecoEcalCandidateCollection >	photToken_

edm::InputTag	tausTag_

edm::EDGetTokenT< reco::CaloJetCollection >	tausToken_

edm::InputTag	trckTag_

edm::EDGetTokenT< reco::RecoChargedCandidateCollection >	trckToken_

Additional Inherited Members
Public Types inherited from edm::global::EDFilterBase
typedef EDFilterBase	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 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 is an HLTFilter (-> EDFilter) implementing a very basic HLT trigger acting on candidates, requiring a g/e/m/j tuple above pt cuts

Author: Martin Grunewald

See header file for documentation

Author: Martin Grunewald

This class is an HLTFilter (-> EDFilter) implementing a minimum-bias HLT trigger acting on candidates, requiring tracks in Pixel det

Author: Mika Huhtinen

Definition at line 36 of file HLTFiltCand.h.

Constructor & Destructor Documentation

HLTFiltCand::HLTFiltCand ( const edm::ParameterSet & iConfig )

explicit

Definition at line 44 of file HLTFiltCand.cc.

References ecalTag_, elecTag_, edm::InputTag::encode(), jetsTag_, LogDebug, metsTag_, mhtsTag_, min_Pt_, muonTag_, photTag_, tausTag_, trckTag_, and ~HLTFiltCand().

                                                        : HLTFilter(iConfig),
   photTag_ (iConfig.getParameter<edm::InputTag>("photTag")),
   elecTag_ (iConfig.getParameter<edm::InputTag>("elecTag")),
   muonTag_ (iConfig.getParameter<edm::InputTag>("muonTag")),
   tausTag_ (iConfig.getParameter<edm::InputTag>("tausTag")),
   jetsTag_ (iConfig.getParameter<edm::InputTag>("jetsTag")),
   metsTag_ (iConfig.getParameter<edm::InputTag>("metsTag")),
   mhtsTag_ (iConfig.getParameter<edm::InputTag>("mhtsTag")),
   trckTag_ (iConfig.getParameter<edm::InputTag>("trckTag")),
   ecalTag_ (iConfig.getParameter<edm::InputTag>("ecalTag")),
   photToken_ (consumes<reco::RecoEcalCandidateCollection>   (photTag_)),
   elecToken_ (consumes<reco::ElectronCollection>            (elecTag_)),
   muonToken_ (consumes<reco::RecoChargedCandidateCollection>(muonTag_)),
   tausToken_ (consumes<reco::CaloJetCollection>             (tausTag_)),
   jetsToken_ (consumes<reco::CaloJetCollection>             (jetsTag_)),
   metsToken_ (consumes<reco::CaloMETCollection>             (metsTag_)),
   mhtsToken_ (consumes<reco::METCollection>                 (mhtsTag_)),
   trckToken_ (consumes<reco::RecoChargedCandidateCollection>(trckTag_)),
   ecalToken_ (consumes<reco::RecoEcalCandidateCollection>   (ecalTag_)),
   min_Pt_  (iConfig.getParameter<double>("MinPt"))
 {
   LogDebug("") << "MinPt cut " << min_Pt_
    << " g: " << photTag_.encode()
    << " e: " << elecTag_.encode()
    << " m: " << muonTag_.encode()
    << " t: " << tausTag_.encode()
    << " j: " << jetsTag_.encode()
    << " M: " << metsTag_.encode()
    << " H: " << mhtsTag_.encode()
    <<" TR: " << trckTag_.encode()
    <<" SC: " << ecalTag_.encode()
    ;
 }

HLTFiltCand::~HLTFiltCand ( )

overridedefault

Referenced by HLTFiltCand().

Member Function Documentation

void HLTFiltCand::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 85 of file HLTFiltCand.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), and HLTFilter::makeHLTFilterDescription().

                                                                         {
   edm::ParameterSetDescription desc;
   makeHLTFilterDescription(desc);
   desc.add<edm::InputTag>("photTag",edm::InputTag("photCollection"));
   desc.add<edm::InputTag>("elecTag",edm::InputTag("elecCollection"));
   desc.add<edm::InputTag>("muonTag",edm::InputTag("muonCollection"));
   desc.add<edm::InputTag>("tausTag",edm::InputTag("tausCollection"));
   desc.add<edm::InputTag>("jetsTag",edm::InputTag("jetsCollection"));
   desc.add<edm::InputTag>("metsTag",edm::InputTag("metsCollection"));
   desc.add<edm::InputTag>("mhtsTag",edm::InputTag("mhtsCollection"));
   desc.add<edm::InputTag>("trckTag",edm::InputTag("trckCollection"));
   desc.add<edm::InputTag>("ecalTag",edm::InputTag("ecalCollection"));
   desc.add<double>("MinPt",-1.0);
   descriptions.add("hltFiltCand", desc);
 }

bool HLTFiltCand::hltFilter	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		trigger::TriggerFilterObjectWithRefs &	filterproduct
	)		const

overridevirtual

Implements HLTFilter.

Definition at line 103 of file HLTFiltCand.cc.

References accept(), trigger::TriggerFilterObjectWithRefs::addCollectionTag(), trigger::TriggerRefsCollections::addObject(), SoftLeptonByDistance_cfi::distance, ecalTag_, ecalToken_, elecTag_, elecToken_, electrons_cff::electrons, edm::Event::getByToken(), fwrapper::jets, jetsTag_, jetsToken_, LogDebug, TtSemiLepSignalSelMVAComputer_cfi::mets, metsTag_, metsToken_, mhtsTag_, mhtsToken_, min_Pt_, extraflags_cff::muons, muonTag_, muonToken_, nano_cff::photons, photTag_, photToken_, HLTFilter::saveTags(), nano_cff::taus, tausTag_, tausToken_, trckTag_, trckToken_, trigger::TriggerCluster, trigger::TriggerElectron, trigger::TriggerJet, trigger::TriggerMET, trigger::TriggerMHT, trigger::TriggerMuon, trigger::TriggerPhoton, trigger::TriggerTau, and trigger::TriggerTrack.

 {
    using namespace std;
    using namespace edm;
    using namespace reco;
    using namespace trigger;
 
    // All HLT filters must create and fill an HLT filter object,
    // recording any reconstructed physics objects satisfying (or not)
    // this HLT filter, and place it in the Event.
 
    // The filter object
    if (saveTags()) {
      filterproduct.addCollectionTag(photTag_);
      filterproduct.addCollectionTag(elecTag_);
      filterproduct.addCollectionTag(muonTag_);
      filterproduct.addCollectionTag(tausTag_);
      filterproduct.addCollectionTag(jetsTag_);
      filterproduct.addCollectionTag(metsTag_);
      filterproduct.addCollectionTag(mhtsTag_);
      filterproduct.addCollectionTag(trckTag_);
      filterproduct.addCollectionTag(ecalTag_);
    }
 
    // Specific filter code
 
    // get hold of products from Event
 
    Handle<RecoEcalCandidateCollection>   photons;
    Handle<ElectronCollection> electrons;
    Handle<RecoChargedCandidateCollection>     muons;
    Handle<CaloJetCollection>  taus;
    Handle<CaloJetCollection>  jets;
    Handle<CaloMETCollection>  mets;
    Handle<METCollection>      mhts;
    Handle<RecoChargedCandidateCollection> trcks;
    Handle<RecoEcalCandidateCollection>    ecals;
 
    iEvent.getByToken(photToken_,photons  );
    iEvent.getByToken(elecToken_,electrons);
    iEvent.getByToken(muonToken_,muons    );
    iEvent.getByToken(tausToken_,taus     );
    iEvent.getByToken(jetsToken_,jets     );
    iEvent.getByToken(metsToken_,mets     );
    iEvent.getByToken(mhtsToken_,mhts     );
    iEvent.getByToken(trckToken_,trcks    );
    iEvent.getByToken(ecalToken_,ecals    );
 
 
    // look for at least one g,e,m,t,j,M,H,TR,SC above its pt cut
 
    // photons
    int nphot(0);
    auto aphot(photons->begin());
    auto ophot(photons->end());
    RecoEcalCandidateCollection::const_iterator iphot;
    for (iphot=aphot; iphot!=ophot; iphot++) {
      if (iphot->pt() >= min_Pt_) {
        nphot++;
        RecoEcalCandidateRef ref(RecoEcalCandidateRef(photons,distance(aphot,iphot)));
        filterproduct.addObject(TriggerPhoton,ref);
      }
    }
 
    // electrons
    int nelec(0);
    auto aelec(electrons->begin());
    auto oelec(electrons->end());
    ElectronCollection::const_iterator ielec;
    for (ielec=aelec; ielec!=oelec; ielec++) {
      if (ielec->pt() >= min_Pt_) {
        nelec++;
        ElectronRef ref(ElectronRef(electrons,distance(aelec,ielec)));
        filterproduct.addObject(-TriggerElectron,ref);
      }
    }
 
    // muon
    int nmuon(0);
    auto amuon(muons->begin());
    auto omuon(muons->end());
    RecoChargedCandidateCollection::const_iterator imuon;
    for (imuon=amuon; imuon!=omuon; imuon++) {
      if (imuon->pt() >= min_Pt_) {
        nmuon++;
        RecoChargedCandidateRef ref(RecoChargedCandidateRef(muons,distance(amuon,imuon)));
        filterproduct.addObject(TriggerMuon,ref);
      }
    }
 
    // taus (are stored as jets)
    int ntaus(0);
    auto ataus(taus->begin());
    auto otaus(taus->end());
    CaloJetCollection::const_iterator itaus;
    for (itaus=ataus; itaus!=otaus; itaus++) {
      if (itaus->pt() >= min_Pt_) {
        ntaus++;
        CaloJetRef ref(CaloJetRef(taus,distance(ataus,itaus)));
        filterproduct.addObject(-TriggerTau,ref);
      }
    }
 
    // jets
    int njets(0);
    auto ajets(jets->begin());
    auto ojets(jets->end());
    CaloJetCollection::const_iterator ijets;
    for (ijets=ajets; ijets!=ojets; ijets++) {
      if (ijets->pt() >= min_Pt_) {
        njets++;
        CaloJetRef ref(CaloJetRef(jets,distance(ajets,ijets)));
        filterproduct.addObject(TriggerJet,ref);
      }
    }
 
    // mets
    int nmets(0);
    auto amets(mets->begin());
    auto omets(mets->end());
    CaloMETCollection::const_iterator imets;
    for (imets=amets; imets!=omets; imets++) {
      if (imets->pt() >= min_Pt_) {
        nmets++;
        CaloMETRef ref(CaloMETRef(mets,distance(amets,imets)));
        filterproduct.addObject(TriggerMET,ref);
      }
    }
 
    // mhts
    int nmhts(0);
    auto amhts(mhts->begin());
    auto omhts(mhts->end());
    METCollection::const_iterator imhts;
    for (imhts=amhts; imhts!=omhts; imhts++) {
      if (imhts->pt() >= min_Pt_) {
        nmhts++;
        METRef ref(METRef(mhts,distance(amhts,imhts)));
        filterproduct.addObject(TriggerMHT,ref);
      }
    }
 
    // trcks
    int ntrck(0);
    auto atrcks(trcks->begin());
    auto otrcks(trcks->end());
    RecoChargedCandidateCollection::const_iterator itrcks;
    for (itrcks=atrcks; itrcks!=otrcks; itrcks++) {
      if (itrcks->pt() >= min_Pt_) {
        ntrck++;
        RecoChargedCandidateRef ref(RecoChargedCandidateRef(trcks,distance(atrcks,itrcks)));
        filterproduct.addObject(TriggerTrack,ref);
      }
    }
 
    // ecals
    int necal(0);
    auto aecals(ecals->begin());
    auto oecals(ecals->end());
    RecoEcalCandidateCollection::const_iterator iecals;
    for (iecals=aecals; iecals!=oecals; iecals++) {
      if (iecals->pt() >= min_Pt_) {
        necal++;
        RecoEcalCandidateRef ref(RecoEcalCandidateRef(ecals,distance(aecals,iecals)));
        filterproduct.addObject(TriggerCluster,ref);
      }
    }
 
    // error case
    // filterproduct.addObject(0,Ref<vector<int> >());
 
    // final filter decision:
    const bool accept ( (nphot>0) && (nelec>0) && (nmuon>0) && (ntaus>0) &&
                //   (njets>0) && (nmets>0) && (nmhts>=0) && (ntrck>0) && (necal>0) );
                (njets>0) && (nmets>0) && (ntrck>0) && (necal>0) );
 
    LogDebug("") << "Number of g/e/m/t/j/M/H/TR/SC objects accepted:"
         << " " << nphot
         << " " << nelec
         << " " << nmuon
         << " " << ntaus
         << " " << njets
         << " " << nmets
         << " " << nmhts
         << " " << ntrck
         << " " << necal
                 ;
 
    // return with final filter decision
    return accept;
 }