#include <HLTriggerOffline/B2G/src/B2GDoubleLeptonHLTValidation.cc>

Inheritance diagram for B2GDoubleLeptonHLTValidation:

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

	~B2GDoubleLeptonHLTValidation () override

Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &ev, edm::EventSetup const &es) final

virtual void	analyze (edm::Event const &, edm::EventSetup const &)

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) override

void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final

virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)

	DQMEDAnalyzer ()

	DQMEDAnalyzer (DQMEDAnalyzer const &)=delete

	DQMEDAnalyzer (DQMEDAnalyzer &&)=delete

void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) override

void	endLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup) final

void	endRun (edm::Run const &run, edm::EventSetup const &setup) override

void	endRunProduce (edm::Run &run, edm::EventSetup const &setup) override

	~DQMEDAnalyzer () override=default

Public Member Functions inherited from edm::one::EDProducer< edm::Accumulator, edm::EndLuminosityBlockProducer, edm::EndRunProducer, edm::one::WatchLuminosityBlocks, edm::one::WatchRuns >
	EDProducer ()=default

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

Public Member Functions inherited from edm::one::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

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

	~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 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

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) 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 edm::one::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override

std::string	monitorPath (const std::string &label) const

void	triggerBinLabels (const std::vector< std::string > &labels)
	set configurable labels for trigger monitoring histograms More...

Private Attributes
edm::Ptr< reco::GsfElectron >	elec_

double	etaElectrons_

double	etaMuons_

MonitorElement *	hDenLeptonEta

MonitorElement *	hDenLeptonPt

MonitorElement *	hDenTriggerMon

MonitorElement *	hNumLeptonEta

MonitorElement *	hNumLeptonPt

MonitorElement *	hNumTriggerMon

bool	isAll_ = false

double	isoElectrons_

double	isoMuons_

bool	isSel_ = false

unsigned int	minElectrons_

unsigned int	minLeptons_

unsigned int	minMuons_

edm::Ptr< reco::Muon >	mu_

double	ptElectrons_

double	ptMuons_

std::string	sDir_

std::string	sElectrons_

std::string	sMuons_

std::string	sTrigger_

edm::EDGetTokenT< edm::View< reco::GsfElectron > >	tokElectrons_

edm::EDGetTokenT< edm::View< reco::Muon > >	tokMuons_

edm::EDGetTokenT< edm::TriggerResults >	tokTrigger_

std::vector< std::string >	vsPaths_

Additional Inherited Members
Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase	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)

Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_

edm::EDPutTokenT< DQMToken >	runToken_

Detailed Description

Description: compute efficiencies of trigger paths on offline reco selection with respect to pt and eta

Implementation: harvesting

Description:

Description: compute efficiencies of trigger paths on offline reco selection with respect to subleading lepton pt and eta

Implementation: harvesting

Definition at line 48 of file B2GDoubleLeptonHLTValidation.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 123 of file B2GDoubleLeptonHLTValidation.h.

References sElectrons_, sMuons_, sTrigger_, tokElectrons_, tokMuons_, and tokTrigger_.

                                                                                          :
   sDir_(iConfig.getUntrackedParameter<std::string>("sDir","HLTValidation/B2G/Efficiencies/")),
   sElectrons_(iConfig.getUntrackedParameter<std::string>("sElectrons","gsfElectrons")),
   ptElectrons_(iConfig.getUntrackedParameter<double>("ptElectrons",0.)),
   etaElectrons_(iConfig.getUntrackedParameter<double>("etaElectrons",0.)),
   isoElectrons_(iConfig.getUntrackedParameter<double>("isoElectrons",0.)),
   minElectrons_(iConfig.getUntrackedParameter<unsigned int>("minElectrons",0)),
   sMuons_(iConfig.getUntrackedParameter<std::string>("sMuons","muons")),
   ptMuons_(iConfig.getUntrackedParameter<double>("ptMuons",0.)),
   etaMuons_(iConfig.getUntrackedParameter<double>("etaMuons",0.)),
   isoMuons_(iConfig.getUntrackedParameter<double>("isoMuons",0.)),
   minMuons_(iConfig.getUntrackedParameter<unsigned int>("minMuons",0)),
   minLeptons_(iConfig.getUntrackedParameter<unsigned int>("minLeptons",0)),
   sTrigger_(iConfig.getUntrackedParameter<std::string>("sTrigger","TriggerResults")),
   vsPaths_(iConfig.getUntrackedParameter< std::vector<std::string> >("vsPaths"))
 
 {
   // Electrons
   tokElectrons_ = consumes< edm::View<reco::GsfElectron> >(edm::InputTag(sElectrons_));
   // Muons
   tokMuons_ = consumes< edm::View<reco::Muon> >(edm::InputTag(sMuons_));
   // Trigger
   tokTrigger_ = consumes<edm::TriggerResults>(edm::InputTag(sTrigger_, "", "HLT"));
 }

B2GDoubleLeptonHLTValidation::~B2GDoubleLeptonHLTValidation ( )

override

Definition at line 149 of file B2GDoubleLeptonHLTValidation.h.

References DEFINE_FWK_MODULE.

 {
  
    // do anything here that needs to be done at desctruction time
    // (e.g. close files, deallocate resources etc.)
 
 }

Member Function Documentation

void B2GDoubleLeptonHLTValidation::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 45 of file B2GDoubleLeptonHLTValidation.cc.

References MillePedeFileConverter_cfg::e, elec_, nano_cff::electrons, reco::LeafCandidate::eta(), etaElectrons_, etaMuons_, MonitorElement::Fill(), edm::Event::getByToken(), hDenLeptonEta, hDenLeptonPt, hDenTriggerMon, hNumLeptonEta, hNumLeptonPt, hNumTriggerMon, mps_fire::i, training_settings::idx, isAll_, edm::Ptr< T >::isNonnull(), isSel_, funct::m, minElectrons_, minLeptons_, minMuons_, mu_, extraflags_cff::muons, reco::LeafCandidate::pt(), ptElectrons_, ptMuons_, tokElectrons_, tokMuons_, tokTrigger_, edm::TriggerNames::triggerNames(), edm::Event::triggerNames(), and vsPaths_.

 { 
   using namespace edm;
 
   isAll_ = false; isSel_ = false;
 
   // Electrons 
   Handle< edm::View<reco::GsfElectron> > electrons;
   if (!iEvent.getByToken(tokElectrons_,electrons))
     edm::LogWarning("B2GDoubleLeptonHLTValidation") << "Electrons collection not found \n";
   unsigned int nGoodE = 0;
   for(edm::View<reco::GsfElectron>::const_iterator e = electrons->begin(); e != electrons->end(); ++e){
     if (e->pt() < ptElectrons_) continue;
     if (fabs(e->eta()) > etaElectrons_) continue;
     nGoodE++;
     //leptons come sorted so use only 2nd
     if (nGoodE == 2) elec_ = electrons->ptrAt( e - electrons->begin());
   }
   // Muons 
   Handle< edm::View<reco::Muon> > muons;
   if (!iEvent.getByToken(tokMuons_,muons))
     edm::LogWarning("B2GDoubleLeptonHLTValidation") << "Muons collection not found \n";
   unsigned int nGoodM = 0;
   for(edm::View<reco::Muon>::const_iterator m = muons->begin(); m != muons->end(); ++m){
     if (!m->isPFMuon() || !m->isGlobalMuon()) continue;
     if (m->pt() < ptMuons_) continue;
     if (fabs(m->eta()) > etaMuons_) continue;
     nGoodM++;
     //leptons come sorted so use only 2nd
     if (nGoodM == 2) mu_ = muons->ptrAt( m - muons->begin() );
   }
 
   if (nGoodE >= minElectrons_ && nGoodM >= minMuons_ && nGoodE + nGoodM >= minLeptons_) isAll_ = true;
 
 
   //Trigger
   Handle<edm::TriggerResults> triggerTable;
   if (!iEvent.getByToken(tokTrigger_,triggerTable))
     edm::LogWarning("B2GDoubleLeptonHLTValidation") << "Trigger collection not found \n";
   const edm::TriggerNames& triggerNames = iEvent.triggerNames(*triggerTable);
   bool isInteresting = false;
   for (unsigned int i=0; i<triggerNames.triggerNames().size(); ++i) {
     for (unsigned int j=0; j<vsPaths_.size(); j++) {
       if (triggerNames.triggerNames()[i].find(vsPaths_[j]) != std::string::npos) {
         isInteresting = true; 
         break;
       }
     }
     if (isInteresting) break;
   }
 
   if (isAll_ && isInteresting) isSel_ = true;
   else isSel_ = false;
 
   //Histos
   if (isAll_) {
     //here and below, change to nGoodE/M instead of min since we are taking subleading
     if (nGoodE > 1 && elec_.isNonnull() ) {
       hDenLeptonPt->Fill(elec_->pt());
       hDenLeptonEta->Fill(elec_->eta());
     }
     if (nGoodM > 1 && mu_.isNonnull() ) {
       hDenLeptonPt->Fill(mu_->pt());
       hDenLeptonEta->Fill(mu_->eta());
     }
     for(unsigned int idx=0; idx<vsPaths_.size(); ++idx){
       hDenTriggerMon->Fill(idx+0.5);
     }
 
   }
   if (isSel_) {
     if (nGoodE > 1 && elec_.isNonnull() ) {
       hNumLeptonPt->Fill(elec_->pt());
       hNumLeptonEta->Fill(elec_->eta());
     }
     if (nGoodM > 1 && mu_.isNonnull() ) {
       hNumLeptonPt->Fill(mu_->pt());
       hNumLeptonEta->Fill(mu_->eta());
     }
 
     for (unsigned int i=0; i<triggerNames.triggerNames().size(); ++i) {
       for (unsigned int j=0; j<vsPaths_.size(); j++) {
         if (triggerNames.triggerNames()[i].find(vsPaths_[j]) != std::string::npos) {
           hNumTriggerMon->Fill(j+0.5 );
         }
       }
     }
   }
 }

void B2GDoubleLeptonHLTValidation::bookHistograms	(	DQMStore::IBooker &	dbe,
		edm::Run const &	,
		edm::EventSetup const &
	)

overrideprivatevirtual

Implements DQMEDAnalyzer.

Definition at line 138 of file B2GDoubleLeptonHLTValidation.cc.

References DQMStore::IBooker::book1D(), hDenLeptonEta, hDenLeptonPt, hDenTriggerMon, hNumLeptonEta, hNumLeptonPt, hNumTriggerMon, sDir_, DQMStore::IBooker::setCurrentFolder(), triggerBinLabels(), and vsPaths_.

 {
   dbe.setCurrentFolder(sDir_);
   hDenLeptonPt  = dbe.book1D("PtLeptonAll", "PtLeptonAll", 50, 0., 2500.);
   hDenLeptonEta = dbe.book1D("EtaLeptonAll", "EtaLeptonAll", 30, -3. , 3.);
   hNumLeptonPt  = dbe.book1D("PtLeptonSel", "PtLeptonSel", 50, 0., 2500.);
   hNumLeptonEta = dbe.book1D("EtaLeptonSel", "EtaLeptonSel", 30, -3. , 3.);
   // determine number of bins for trigger monitoring
   unsigned int nPaths = vsPaths_.size();
   // monitored trigger occupancy for single lepton triggers
   hNumTriggerMon    = dbe.book1D("TriggerMonSel" , "TriggerMonSel", nPaths, 0.,  nPaths);
   hDenTriggerMon    = dbe.book1D("TriggerMonAll" , "TriggerMonAll", nPaths, 0.,  nPaths);
   // set bin labels for trigger monitoring
   triggerBinLabels(vsPaths_);
 }

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

static

Definition at line 157 of file B2GDoubleLeptonHLTValidation.cc.

References edm::ConfigurationDescriptions::addDefault(), and edm::ParameterSetDescription::setUnknown().

                                                                                          {
   //The following says we do not know what parameters are allowed so do no validation
   // Please change this to state exactly what you do use, even if it is no parameters
   edm::ParameterSetDescription desc;
   desc.setUnknown();
   descriptions.addDefault(desc);
 }

std::string B2GDoubleLeptonHLTValidation::monitorPath ( const std::string & label ) const

inlineprivate

deduce monitorPath from label, the label is expected to be of type 'selectionPath:monitorPath'

Definition at line 61 of file B2GDoubleLeptonHLTValidation.h.

References tablePrinter::labels, and triggerBinLabels().

Referenced by triggerBinLabels().

61 { return label.substr(label.find(':')+1); };

diffTwoXMLs.label

label

Definition: diffTwoXMLs.py:42

void B2GDoubleLeptonHLTValidation::triggerBinLabels ( const std::vector< std::string > & labels )

inlineprivate

set configurable labels for trigger monitoring histograms

Definition at line 104 of file B2GDoubleLeptonHLTValidation.h.

References hDenTriggerMon, hNumTriggerMon, training_settings::idx, monitorPath(), and MonitorElement::setBinLabel().

Referenced by bookHistograms(), and monitorPath().

 {
   for(unsigned int idx=0; idx<labels.size(); ++idx){
     hNumTriggerMon->setBinLabel( idx+1, "["+monitorPath(labels[idx])+"]", 1);
     hDenTriggerMon->setBinLabel( idx+1, "["+monitorPath(labels[idx])+"]", 1);
   }
 }