#include <EmDQM.h>

Inheritance diagram for EmDQM:

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

void	beginJob ()

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

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

	EmDQM (const edm::ParameterSet &pset)
	Constructor. More...

void	endJob ()

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

	~EmDQM () override
	Destructor. More...

Public Member Functions inherited from DQMEDAnalyzer
void	beginRun (edm::Run const &, edm::EventSetup const &) final

void	beginStream (edm::StreamID id) final

	DQMEDAnalyzer (void)

void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

void	endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

uint32_t	streamId () const

Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
	EDAnalyzer ()=default

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

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

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

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

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
bool	checkGeneratedParticlesRequirement (const edm::Event &event)

bool	checkRecoParticlesRequirement (const edm::Event &event)

int	countSubstring (const std::string &, const std::string &)

std::vector< std::vector< std::string > >	findEgammaPaths ()

std::vector< std::string >	getFilterModules (const std::string &)

double	getPrimaryEtCut (const std::string &)

edm::ParameterSet	makePSetForEgammaDoubleEtDeltaPhiFilter (const std::string &)

edm::ParameterSet	makePSetForEgammaGenericFilter (const std::string &)

edm::ParameterSet	makePSetForEgammaGenericQuadraticFilter (const std::string &)

edm::ParameterSet	makePSetForElectronGenericFilter (const std::string &)

edm::ParameterSet	makePSetForEtFilter (const std::string &)

edm::ParameterSet	makePSetForL1SeedFilter (const std::string &)

edm::ParameterSet	makePSetForL1SeedToSuperClusterMatchFilter (const std::string &)

edm::ParameterSet	makePSetForOneOEMinusOneOPFilter (const std::string &)

edm::ParameterSet	makePSetForPixelMatchFilter (const std::string &)

void	SetVarsFromPSet (std::vector< edm::ParameterSet >::iterator)

Private Attributes
bool	autoConfMode_

std::string	dirname_

double	eta2DMax_

std::vector< MonitorElement * >	etagens

std::vector< std::vector< MonitorElement * > >	etahistmatchs

std::vector< std::vector< MonitorElement * > >	etahists

double	etaMax_

std::vector< MonitorElement * >	etaphigens

std::vector< std::vector< MonitorElement * > >	etaphihistmatchs

std::vector< std::vector< MonitorElement * > >	etaphihists

std::vector< MonitorElement * >	etgens

std::vector< std::vector< MonitorElement * > >	ethistmatchs

std::vector< std::vector< MonitorElement * > >	ethists

unsigned int	gencut_

edm::EDGetTokenT< edm::View< reco::Candidate > >	gencutColl_fidDiGamma_token

edm::EDGetTokenT< edm::View< reco::Candidate > >	gencutColl_fidGammaJet_token

edm::EDGetTokenT< edm::View< reco::Candidate > >	gencutColl_fidTripleEle_token

edm::EDGetTokenT< edm::View< reco::Candidate > >	gencutColl_fidWenu_token

edm::EDGetTokenT< edm::View< reco::Candidate > >	gencutColl_fidZee_token

edm::EDGetTokenT< edm::View< reco::Candidate > >	gencutColl_manualConf_token

edm::InputTag	gencutCollection_

double	genEtaAcc_

double	genEtAcc_

edm::EDGetTokenT< edm::View< reco::Candidate > >	genParticles_token

std::vector< std::vector< MonitorElement * > >	histEtaOfHltObjMatchToGens

std::vector< std::vector< MonitorElement * > >	histEtaPhiOfHltObjMatchToGens

std::vector< std::vector< MonitorElement * > >	histEtOfHltObjMatchToGens

HistoFiller< reco::RecoEcalCandidateCollection > *	histoFillerClu

HistoFiller< reco::ElectronCollection > *	histoFillerEle

HistoFiller< l1extra::L1EmParticleCollection > *	histoFillerL1Iso

HistoFiller< l1extra::L1EmParticleCollection > *	histoFillerL1NonIso

HistoFiller< reco::RecoEcalCandidateCollection > *	histoFillerPho

std::vector< std::vector< MonitorElement * > >	histPhiOfHltObjMatchToGens

std::set< std::string >	hltCollectionLabelsFound

std::vector< std::set< std::string > >	hltCollectionLabelsFoundPerPath

std::set< std::string >	hltCollectionLabelsMissed

std::vector< std::set< std::string > >	hltCollectionLabelsMissedPerPath

HLTConfigProvider	hltConfig_
	The instance of the HLTConfigProvider as a data member. More...

edm::EDGetTokenT< edm::TriggerResults >	hltResults_token

bool	isData_

std::vector< std::vector< edm::InputTag > >	isoNames

bool	mcMatchedOnly_

unsigned int	minEtForEtaEffPlot_

unsigned int	nbins2D_

unsigned int	nbins_

std::vector< unsigned int >	nCandCuts

bool	noIsolationPlots_

bool	noPhiPlots_

unsigned int	numOfHLTCollectionLabels

std::vector< edm::ParameterSet >	paramSets

unsigned int	pathIndex

int	pdgGen

double	phi2DMax_

std::vector< MonitorElement * >	phigens

std::vector< std::vector< MonitorElement * > >	phihistmatchs

std::vector< std::vector< MonitorElement * > >	phihists

double	phiMax_

std::vector< std::pair< double, double > >	plotBounds

double	plotEtMin

std::vector< bool >	plotiso

double	plotPtMax

double	plotPtMin

const edm::ParameterSet &	pset

GreaterByPt< reco::Particle >	pTComparator_

GreaterByPt< reco::GenParticle >	pTGenComparator_

double	ptMax_

double	ptMin_

unsigned int	reqNum

std::vector< std::string >	theHLTCollectionHumanNames

std::vector< edm::InputTag >	theHLTCollectionLabels

std::vector< int >	theHLTOutputTypes

edm::InputTag	theL1Seed

std::vector< MonitorElement * >	totalmatchs

std::vector< MonitorElement * >	totals

edm::InputTag	triggerObject_

edm::EDGetTokenT< trigger::TriggerEventWithRefs >	triggerObject_token

bool	useHumanReadableHistTitles_

unsigned int	verbosity_

Static Private Attributes
static const unsigned	OUTPUT_ALL = 3

static const unsigned	OUTPUT_ERRORS = 1

static const unsigned	OUTPUT_SILENT = 0

static const unsigned	OUTPUT_WARNINGS = 2

static const unsigned	TYPE_DOUBLE_ELE = 1

static const unsigned	TYPE_DOUBLE_PHOTON = 3

static const unsigned	TYPE_SINGLE_ELE = 0

static const unsigned	TYPE_SINGLE_PHOTON = 2

static const unsigned	TYPE_TRIPLE_ELE = 4

Friends
class	HistoFiller< l1extra::L1EmParticleCollection >

class	HistoFiller< reco::ElectronCollection >

class	HistoFiller< reco::RecoEcalCandidateCollection >

Additional Inherited Members
Public Types inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
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

Public Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from DQMEDAnalyzer
static std::shared_ptr< dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)

static std::shared_ptr< dqmDetails::NoCache >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)

static void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const , dqmDetails::NoCache )

static void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const , dqmDetails::NoCache )

Static Public Member Functions inherited from edm::stream::EDAnalyzerBase
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

Definition at line 63 of file EmDQM.h.

Constructor & Destructor Documentation

EmDQM::EmDQM ( const edm::ParameterSet & pset )

explicit

Constructor.

Definition at line 12 of file EmDQM.cc.

References autoConfMode_, eta2DMax_, etaMax_, gencutColl_fidDiGamma_token, gencutColl_fidGammaJet_token, gencutColl_fidTripleEle_token, gencutColl_fidWenu_token, gencutColl_fidZee_token, gencutColl_manualConf_token, genEtaAcc_, genEtAcc_, genParticles_token, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), histoFillerClu, histoFillerEle, histoFillerL1Iso, histoFillerL1NonIso, histoFillerPho, hltResults_token, isData_, mcMatchedOnly_, minEtForEtaEffPlot_, nbins2D_, nbins_, noIsolationPlots_, noPhiPlots_, paramSets, phi2DMax_, phiMax_, pset, ptMax_, ptMin_, triggerObject_, triggerObject_token, useHumanReadableHistTitles_, and verbosity_.

                                          : pset(pset_) 
 {
   // are we running in automatic configuration mode with the HLTConfigProvider
   // or with a per path python config file
   autoConfMode_ = pset.getUntrackedParameter<bool>("autoConfMode", false);
 
   // set global parameters
   triggerObject_ = pset_.getParameter<edm::InputTag>("triggerobject");
   verbosity_ = pset_.getUntrackedParameter<unsigned int>("verbosity",0);
   genEtaAcc_ = pset.getParameter<double>("genEtaAcc");
   genEtAcc_ = pset.getParameter<double>("genEtAcc");
   ptMax_ = pset.getUntrackedParameter<double>("PtMax",1000.);
   ptMin_ = pset.getUntrackedParameter<double>("PtMin",0.);
   etaMax_ = pset.getUntrackedParameter<double>("EtaMax", 2.7);
   phiMax_ = pset.getUntrackedParameter<double>("PhiMax", 3.15);
   nbins_ = pset.getUntrackedParameter<unsigned int>("Nbins",40);
   eta2DMax_ = pset.getUntrackedParameter<double>("Eta2DMax", 2.8);
   phi2DMax_ = pset.getUntrackedParameter<double>("Phi2DMax", 3.2);
   nbins2D_ = pset.getUntrackedParameter<unsigned int>("Nbins2D",16);
   minEtForEtaEffPlot_ = pset.getUntrackedParameter<unsigned int>("minEtForEtaEffPlot", 15);
   useHumanReadableHistTitles_ = pset.getUntrackedParameter<bool>("useHumanReadableHistTitles", false);
   mcMatchedOnly_ = pset.getUntrackedParameter<bool>("mcMatchedOnly", true);
   noPhiPlots_ = pset.getUntrackedParameter<bool>("noPhiPlots", true);
   noIsolationPlots_ = pset.getUntrackedParameter<bool>("noIsolationPlots", true);
 
   if (!autoConfMode_) {
     paramSets.push_back(pset);
     isData_ = false;
   } else {
     isData_ = pset.getParameter<bool>("isData");
   }
 
   histoFillerEle      = new HistoFiller<reco::ElectronCollection>(this);
   histoFillerPho      = new HistoFiller<reco::RecoEcalCandidateCollection>(this);
   histoFillerClu      = new HistoFiller<reco::RecoEcalCandidateCollection>(this);
   histoFillerL1Iso    = new HistoFiller<l1extra::L1EmParticleCollection>(this);
   histoFillerL1NonIso = new HistoFiller<l1extra::L1EmParticleCollection>(this);
 
   // consumes
   genParticles_token = consumes<edm::View<reco::Candidate> >(edm::InputTag("genParticles"));
   triggerObject_token = consumes<trigger::TriggerEventWithRefs>(triggerObject_);
   hltResults_token = consumes<edm::TriggerResults>(edm::InputTag("TriggerResults", "", triggerObject_.process()));
   if (autoConfMode_) {
     gencutColl_fidWenu_token = mayConsume<edm::View<reco::Candidate> >(edm::InputTag("fiducialWenu"));
     gencutColl_fidZee_token = mayConsume<edm::View<reco::Candidate> >(edm::InputTag("fiducialZee"));
     gencutColl_fidTripleEle_token = mayConsume<edm::View<reco::Candidate> >(edm::InputTag("fiducialTripleEle"));
     gencutColl_fidGammaJet_token = mayConsume<edm::View<reco::Candidate> >(edm::InputTag("fiducialGammaJet"));
     gencutColl_fidDiGamma_token = mayConsume<edm::View<reco::Candidate> >(edm::InputTag("fiducialDiGamma"));
   } else {
     gencutColl_manualConf_token = consumes<edm::View<reco::Candidate> >(pset.getParameter<edm::InputTag>("cutcollection"));
   }
 }

EmDQM::~EmDQM ( )

override

Destructor.

Definition at line 615 of file EmDQM.cc.

615 {

616 }

Member Function Documentation

void EmDQM::analyze	(	const edm::Event &	event,
		const edm::EventSetup &	setup
	)

override

Definition at line 737 of file EmDQM.cc.

References autoConfMode_, checkGeneratedParticlesRequirement(), checkRecoParticlesRequirement(), stringResolutionProvider_cfi::et, PVValHelper::eta, etagens, etaphigens, etgens, HistoFiller< T >::fillHistos(), gencut_, gencutColl_fidDiGamma_token, gencutColl_fidGammaJet_token, gencutColl_fidTripleEle_token, gencutColl_fidWenu_token, gencutColl_fidZee_token, gencutColl_manualConf_token, histoFillerClu, histoFillerEle, histoFillerL1Iso, histoFillerL1NonIso, histoFillerPho, hltCollectionLabelsFound, hltCollectionLabelsFoundPerPath, hltCollectionLabelsMissed, hltCollectionLabelsMissedPerPath, hltConfig_, SelectingProcedure_cff::hltResults, hltResults_token, mps_fire::i, edm::HLTGlobalStatus::index(), createfilelist::int, edm::EventBase::isRealData(), edm::HandleBase::isValid(), mcMatchedOnly_, minEtForEtaEffPlot_, HLTConfigProvider::moduleIndex(), gen::n, nCandCuts, noPhiPlots_, numOfHLTCollectionLabels, OUTPUT_ERRORS, OUTPUT_WARNINGS, paramSets, pathIndex, pdgGen, phi, phigens, plotEtMin, pTComparator_, reqNum, SetVarsFromPSet(), theHLTCollectionLabels, theHLTOutputTypes, totalmatchs, totals, trigger::TriggerCluster, trigger::TriggerElectron, trigger::TriggerL1IsoEG, trigger::TriggerL1NoIsoEG, triggerObject_, triggerObject_token, trigger::TriggerPhoton, and verbosity_.

 {
   // loop over all the trigger path parameter sets
   unsigned int vPos = 0;
   for (std::vector<edm::ParameterSet>::iterator psetIt = paramSets.begin(); psetIt != paramSets.end(); ++psetIt, ++vPos) {
     SetVarsFromPSet(psetIt);
     // get the set forthe current path
     hltCollectionLabelsFound = hltCollectionLabelsFoundPerPath.at(vPos);
     hltCollectionLabelsMissed = hltCollectionLabelsMissedPerPath.at(vPos);
 
     //           Check if there's enough gen particles        //
     //             of interest                                //
     // get the right data according to the trigger path currently looked at
     edm::Handle< edm::View<reco::Candidate> > cutCounter;
     if (autoConfMode_) {
       switch(reqNum) {
          case 1:
             if (pdgGen == 11) event.getByToken(gencutColl_fidWenu_token, cutCounter);
             else event.getByToken(gencutColl_fidGammaJet_token, cutCounter);
             break;
          case 2:
             if (pdgGen == 11) event.getByToken(gencutColl_fidZee_token, cutCounter);
             else event.getByToken(gencutColl_fidDiGamma_token, cutCounter);
             break;
          case 3:
             event.getByToken(gencutColl_fidTripleEle_token, cutCounter);
             break;
       }
     } else {
       event.getByToken(gencutColl_manualConf_token, cutCounter);
     }
     if (cutCounter->size() < (unsigned int)gencut_) {
       //edm::LogWarning("EmDQM") << "Less than "<< gencut_ <<" gen particles with pdgId=" << pdgGen;
       continue;
     }
 
     // fill L1 and HLT info
     // get objects possed by each filter
     edm::Handle<trigger::TriggerEventWithRefs> triggerObj;
     event.getByToken(triggerObject_token,triggerObj);
     if(!triggerObj.isValid()) {
       if (verbosity_ >= OUTPUT_WARNINGS)
          edm::LogWarning("EmDQM") << "parameter triggerobject (" << triggerObject_ << ") does not corresond to a valid TriggerEventWithRefs product. Please check especially the process name (e.g. when running over reprocessed datasets)";
       continue;
     }
 
     // Were enough high energy gen particles found?
     if (event.isRealData()) {
       // running validation on data.
       // TODO: we should check that the entire
       //       run is on the same type (all data or
       //       all MC). Otherwise one gets
       //       uninterpretable results...
       if (!checkRecoParticlesRequirement(event))
         continue;
     }
     else { // MC
       // if no, throw event away
       if (!checkGeneratedParticlesRequirement(event))
         continue;
     }
 
     // It was an event worth keeping. Continue.
 
     //  Fill the bin labeled "Total"                          //
     //   This will be the number of events looked at.         //
     if (!mcMatchedOnly_) totals.at(vPos)->Fill(numOfHLTCollectionLabels+0.5);
     totalmatchs.at(vPos)->Fill(numOfHLTCollectionLabels+0.5);
 
     //               Fill generator info                      //
     // the gencut_ highest Et generator objects of the preselected type are our matches
 
     std::vector<reco::Particle> sortedGen;
     for(edm::View<reco::Candidate>::const_iterator genpart = cutCounter->begin(); genpart != cutCounter->end();genpart++){
       reco::Particle tmpcand(  genpart->charge(), genpart->p4(), genpart->vertex(),genpart->pdgId(),genpart->status() );
       if (tmpcand.et() >= plotEtMin) {
         sortedGen.push_back(tmpcand);
       }
     }
     std::sort(sortedGen.begin(),sortedGen.end(),pTComparator_ );
 
     // Now the collection of gen particles is sorted by pt.
     // So, remove all particles from the collection so that we 
     // only have the top "1 thru gencut_" particles in it
     if (sortedGen.size() < gencut_){
       continue;
     }
     sortedGen.erase(sortedGen.begin()+gencut_,sortedGen.end());
 
     for (unsigned int i = 0 ; i < gencut_ ; i++ ) {
       etgens.at(vPos)->Fill( sortedGen[i].et()  ); //validity has been implicitily checked by the cut on gencut_ above
       if (sortedGen[i].et() > minEtForEtaEffPlot_) {
         etagens.at(vPos)->Fill( sortedGen[i].eta() );
         if (!noPhiPlots_) phigens.at(vPos)->Fill( sortedGen[i].phi() );
          etaphigens.at(vPos)->Fill( sortedGen[i].eta(),sortedGen[i].phi() );
       }
     } // END of loop over Generated particles
     if (gencut_ >= reqNum && !mcMatchedOnly_) totals.at(vPos)->Fill(numOfHLTCollectionLabels+1.5); // this isn't really needed anymore keep for backward comp.
     if (gencut_ >= reqNum) totalmatchs.at(vPos)->Fill(numOfHLTCollectionLabels+1.5); // this isn't really needed anymore keep for backward comp.
             
     bool accepted = true;  // flags that the event has been accepted by all filters before
     edm::Handle<edm::TriggerResults> hltResults;
     event.getByToken(hltResults_token, hltResults);
     //            Loop over filter modules                    //
     for(unsigned int n=0; n < numOfHLTCollectionLabels ; n++) {
       // check that there are not less sortedGen particles than nCandCut requires for this filter
       if (sortedGen.size() < nCandCuts.at(n)) {
          if (verbosity_ >= OUTPUT_ERRORS)
             edm::LogError("EmDQM") << "There are less generated particles than the module '" << theHLTCollectionLabels[n].label() << "' requires.";
          continue;
       }
       std::vector<reco::Particle> sortedGenForFilter(sortedGen);
       sortedGenForFilter.erase(sortedGenForFilter.begin() + nCandCuts.at(n), sortedGenForFilter.end());
 
       // Fill only if this filter was run.
       if (pathIndex != 0 && hltConfig_.moduleIndex(pathIndex, theHLTCollectionLabels[n].label()) > hltResults->index(pathIndex)) break;
       // These numbers are from the Parameter Set, such as:
       //   theHLTOutputTypes = cms.uint32(100)
       switch(theHLTOutputTypes[n]) 
       {
         case trigger::TriggerL1NoIsoEG: // Non-isolated Level 1
           histoFillerL1NonIso->fillHistos(triggerObj,event,vPos,n,sortedGenForFilter,accepted);
           break;
         case trigger::TriggerL1IsoEG: // Isolated Level 1
           histoFillerL1Iso->fillHistos(triggerObj,event,vPos,n,sortedGenForFilter,accepted);
           break;
         case trigger::TriggerPhoton: // Photon 
           histoFillerPho->fillHistos(triggerObj,event,vPos,n,sortedGenForFilter,accepted);
           break;
         case trigger::TriggerElectron: // Electron 
           histoFillerEle->fillHistos(triggerObj,event,vPos,n,sortedGenForFilter,accepted);
           break;
         case trigger::TriggerCluster: // TriggerCluster
           histoFillerClu->fillHistos(triggerObj,event,vPos,n,sortedGenForFilter,accepted);
           break;
         default: 
           throw(cms::Exception("Release Validation Error") << "HLT output type not implemented: theHLTOutputTypes[n]" );
       }
     } // END of loop over filter modules
 
     // earse the dummy and fill with real set
     hltCollectionLabelsFoundPerPath.at(vPos) = hltCollectionLabelsFound;
     hltCollectionLabelsMissedPerPath.at(vPos) = hltCollectionLabelsMissed;
   }
 }

void EmDQM::beginJob ( void )

Definition at line 69 of file EmDQM.cc.

 {
 
 }

void EmDQM::bookHistograms	(	DQMStore::IBooker &	iBooker,
		edm::Run const &	iRun,
		edm::EventSetup const &	iSetup
	)

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 398 of file EmDQM.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), dirname_, eta2DMax_, etagens, etahistmatchs, etahists, etaMax_, etaphigens, etaphihistmatchs, etaphihists, etgens, ethistmatchs, ethists, histEtaOfHltObjMatchToGens, histEtaPhiOfHltObjMatchToGens, histEtOfHltObjMatchToGens, histPhiOfHltObjMatchToGens, mps_fire::i, diffTwoXMLs::label, mcMatchedOnly_, nbins2D_, nbins_, noPhiPlots_, numOfHLTCollectionLabels, paramSets, pdgGen, phi2DMax_, phigens, phihistmatchs, phihists, phiMax_, plotPtMax, plotPtMin, MonitorElement::setBinLabel(), DQMStore::IBooker::setCurrentFolder(), SetVarsFromPSet(), AlCaHLTBitMon_QueryRunRegistry::string, theHLTCollectionHumanNames, theHLTCollectionLabels, pileupDistInMC::total, totalmatchs, totals, and useHumanReadableHistTitles_.

 {
    // loop over all the trigger path parameter sets
    for (std::vector<edm::ParameterSet>::iterator psetIt = paramSets.begin(); psetIt != paramSets.end(); ++psetIt) {
       SetVarsFromPSet(psetIt);
 
       iBooker.setCurrentFolder(dirname_);
     
       //  Set up Histogram of Effiency vs Step.                 //
       //   theHLTCollectionLabels is a vector of InputTags      //
       //    from the configuration file.                        //
       // Et & eta distributions
       std::vector<MonitorElement*> etahist;
       std::vector<MonitorElement*> phihist;
       std::vector<MonitorElement*> ethist;
       std::vector<MonitorElement*> etahistmatch;
       std::vector<MonitorElement*> phihistmatch;
       std::vector<MonitorElement*> ethistmatch;
       std::vector<MonitorElement*> histEtOfHltObjMatchToGen;
       std::vector<MonitorElement*> histEtaOfHltObjMatchToGen;
       std::vector<MonitorElement*> histPhiOfHltObjMatchToGen;
       std::vector<MonitorElement*> etaphihist;
       std::vector<MonitorElement*> etaphihistmatch;
       std::vector<MonitorElement*> histEtaPhiOfHltObjMatchToGen; 
       // Plots of efficiency per step
       MonitorElement* total;
       MonitorElement* totalmatch;
       //generator histograms
       MonitorElement* etgen;
       MonitorElement* etagen;
       MonitorElement* phigen;
       MonitorElement* etaphigen;
  
       std::string histName="total_eff";
       std::string histTitle = "total events passing";
       if (!mcMatchedOnly_) {
          // This plot will have bins equal to 2+(number of
          //        HLTCollectionLabels in the config file)
          total = iBooker.book1D(histName.c_str(),histTitle.c_str(),numOfHLTCollectionLabels+2,0,numOfHLTCollectionLabels+2);
          total->setBinLabel(numOfHLTCollectionLabels+1,"Total");
          total->setBinLabel(numOfHLTCollectionLabels+2,"Gen");
          for (unsigned int u=0; u<numOfHLTCollectionLabels; u++) {
             total->setBinLabel(u+1,theHLTCollectionLabels[u].label());
          }
       }
     
       histName="total_eff_MC_matched";
       histTitle="total events passing (mc matched)";
       totalmatch = iBooker.book1D(histName.c_str(),histTitle.c_str(),numOfHLTCollectionLabels+2,0,numOfHLTCollectionLabels+2);
       totalmatch->setBinLabel(numOfHLTCollectionLabels+1,"Total");
       totalmatch->setBinLabel(numOfHLTCollectionLabels+2,"Gen");
       for (unsigned int u=0; u<numOfHLTCollectionLabels; u++) {
          totalmatch->setBinLabel(u+1,theHLTCollectionLabels[u].label());
       }
     
       MonitorElement* tmphisto;
       //MonitorElement* tmpiso;
     
       // Set up generator-level histograms                      //
       std::string pdgIdString;
       switch(pdgGen) {
       case 11:
         pdgIdString="Electron";break;
       case 22:
         pdgIdString="Photon";break;
       default:
         pdgIdString="Particle";
       }
     
       histName = "gen_et";
       histTitle= "E_{T} of " + pdgIdString + "s" ;
       etgen =  iBooker.book1D(histName.c_str(),histTitle.c_str(),nbins_,plotPtMin,plotPtMax);
       histName = "gen_eta";
       histTitle= "#eta of "+ pdgIdString +"s " ;
       etagen = iBooker.book1D(histName.c_str(),histTitle.c_str(),nbins_,-etaMax_, etaMax_);
       histName = "gen_phi";
       histTitle= "#phi of "+ pdgIdString +"s " ;
       if (!noPhiPlots_) phigen = iBooker.book1D(histName.c_str(),histTitle.c_str(),nbins_,-phiMax_, phiMax_);
       histName = "gen_etaphi";
       histTitle= "#eta-#phi of "+ pdgIdString +"s " ;
       etaphigen = iBooker.book2D(histName.c_str(),histTitle.c_str(), nbins2D_-2,-eta2DMax_, eta2DMax_,nbins2D_,-phi2DMax_, phi2DMax_); 
       //  Set up histograms of HLT objects                      //
       // Determine what strings to use for histogram titles
       std::vector<std::string> HltHistTitle;
       if ( theHLTCollectionHumanNames.size() == numOfHLTCollectionLabels && useHumanReadableHistTitles_ ) {
         HltHistTitle = theHLTCollectionHumanNames;
       } else {
         for (unsigned int i =0; i < numOfHLTCollectionLabels; i++) {
           HltHistTitle.push_back(theHLTCollectionLabels[i].label());
         }
       }
      
       for(unsigned int i = 0; i< numOfHLTCollectionLabels ; i++){
         if (!mcMatchedOnly_) {
            // Et distribution of HLT objects passing filter i
            histName = theHLTCollectionLabels[i].label()+"et_all";
            histTitle = HltHistTitle[i]+" Et (ALL)";
            tmphisto =  iBooker.book1D(histName.c_str(),histTitle.c_str(),nbins_,plotPtMin,plotPtMax);
            ethist.push_back(tmphisto);
            
            // Eta distribution of HLT objects passing filter i
            histName = theHLTCollectionLabels[i].label()+"eta_all";
            histTitle = HltHistTitle[i]+" #eta (ALL)";
            tmphisto =  iBooker.book1D(histName.c_str(),histTitle.c_str(),nbins_,-etaMax_, etaMax_);
            etahist.push_back(tmphisto);          
 
            if (!noPhiPlots_) {
              // Phi distribution of HLT objects passing filter i
              histName = theHLTCollectionLabels[i].label()+"phi_all";
              histTitle = HltHistTitle[i]+" #phi (ALL)";
              tmphisto =  iBooker.book1D(histName.c_str(),histTitle.c_str(),nbins_,-phiMax_, phiMax_);
              phihist.push_back(tmphisto);
            }
     
            histName = theHLTCollectionLabels[i].label()+"etaphi_all";
            histTitle = HltHistTitle[i]+" #eta-#phi (ALL)";
            tmphisto =  iBooker.book2D(histName.c_str(),histTitle.c_str(),nbins2D_-2,-eta2DMax_, eta2DMax_,nbins2D_,-phi2DMax_, phi2DMax_);
            etaphihist.push_back(tmphisto);
 
    
            // Et distribution of HLT object that is closest delta-R match to sorted gen particle(s)
            histName  = theHLTCollectionLabels[i].label()+"et";
            histTitle = HltHistTitle[i]+" Et";
            tmphisto  = iBooker.book1D(histName.c_str(),histTitle.c_str(),nbins_,plotPtMin,plotPtMax);
            histEtOfHltObjMatchToGen.push_back(tmphisto);
     
            // eta distribution of HLT object that is closest delta-R match to sorted gen particle(s)
            histName  = theHLTCollectionLabels[i].label()+"eta";
            histTitle = HltHistTitle[i]+" eta";
            tmphisto  = iBooker.book1D(histName.c_str(),histTitle.c_str(),nbins_,-etaMax_, etaMax_);
            histEtaOfHltObjMatchToGen.push_back(tmphisto);
     
            if (!noPhiPlots_) {
              // phi distribution of HLT object that is closest delta-R match to sorted gen particle(s)
              histName  = theHLTCollectionLabels[i].label()+"phi";
              histTitle = HltHistTitle[i]+" phi";
              tmphisto  = iBooker.book1D(histName.c_str(),histTitle.c_str(),nbins_,-phiMax_, phiMax_);
              histPhiOfHltObjMatchToGen.push_back(tmphisto);
            }
 
            histName  = theHLTCollectionLabels[i].label()+"etaphi";
            histTitle = HltHistTitle[i]+" eta-phi";
            tmphisto  = iBooker.book2D(histName.c_str(),histTitle.c_str(),nbins2D_-2,-eta2DMax_, eta2DMax_,nbins2D_,-phi2DMax_, phi2DMax_);
            histEtaPhiOfHltObjMatchToGen.push_back(tmphisto);
        }
     
         // Et distribution of gen object matching HLT object passing filter i
         histName = theHLTCollectionLabels[i].label()+"et_MC_matched";
         histTitle = HltHistTitle[i]+" Et (MC matched)";
         tmphisto =  iBooker.book1D(histName.c_str(),histTitle.c_str(),nbins_,plotPtMin,plotPtMax);
         ethistmatch.push_back(tmphisto);
         
         // Eta distribution of gen object matching HLT object passing filter i
         histName = theHLTCollectionLabels[i].label()+"eta_MC_matched";
         histTitle = HltHistTitle[i]+" #eta (MC matched)";
         tmphisto =  iBooker.book1D(histName.c_str(),histTitle.c_str(),nbins_,-etaMax_, etaMax_);
         etahistmatch.push_back(tmphisto);
     
         if (!noPhiPlots_) {
           // Phi distribution of gen object matching HLT object passing filter i
           histName = theHLTCollectionLabels[i].label()+"phi_MC_matched";
           histTitle = HltHistTitle[i]+" #phi (MC matched)";
           tmphisto =  iBooker.book1D(histName.c_str(),histTitle.c_str(),nbins_,-phiMax_, phiMax_);
           phihistmatch.push_back(tmphisto);
         }
 
         histName = theHLTCollectionLabels[i].label()+"etaphi_MC_matched";
         histTitle = HltHistTitle[i]+" #eta-#phi (MC matched)";
         tmphisto =  iBooker.book2D(histName.c_str(),histTitle.c_str(),nbins2D_-2,-eta2DMax_, eta2DMax_,nbins2D_,-phi2DMax_, phi2DMax_);
         etaphihistmatch.push_back(tmphisto);
       }
 
       // Et & eta distributions
       etahists.push_back(etahist);
       phihists.push_back(phihist);
       ethists.push_back(ethist);
       etahistmatchs.push_back(etahistmatch);
       phihistmatchs.push_back(phihistmatch);
       ethistmatchs.push_back(ethistmatch);
       histEtOfHltObjMatchToGens.push_back(histEtOfHltObjMatchToGen);
       histEtaOfHltObjMatchToGens.push_back(histEtaOfHltObjMatchToGen);
       histPhiOfHltObjMatchToGens.push_back(histPhiOfHltObjMatchToGen);
       etaphihists.push_back(etaphihist);
       etaphihistmatchs.push_back(etaphihistmatch);
       histEtaPhiOfHltObjMatchToGens.push_back(histEtaPhiOfHltObjMatchToGen);
       // commented out because uses data not included in HTLDEBUG and uses
       // Isolation distributions
       //etahistisos.push_back(etahistiso);
       //phihistisos.push_back(phihistiso);
       //ethistisos.push_back(ethistiso);
       //etahistisomatchs.push_back(etahistisomatch);
       //phihistisomatchs.push_back(phihistisomatch);
       //ethistisomatchs.push_back(ethistisomatch);
       //histEtIsoOfHltObjMatchToGens.push_back(histEtIsoOfHltObjMatchToGen); 
       //histEtaIsoOfHltObjMatchToGens.push_back(histEtaIsoOfHltObjMatchToGen);
       //histPhiIsoOfHltObjMatchToGens.push_back(histPhiIsoOfHltObjMatchToGen);
 
       totals.push_back(total);
       totalmatchs.push_back(totalmatch);
       etgens.push_back(etgen);
       etagens.push_back(etagen);
       phigens.push_back(phigen);
      etaphigens.push_back(etaphigen);
    }
 }

bool EmDQM::checkGeneratedParticlesRequirement ( const edm::Event & event )

private

helper to check whether there were enough generator level electrons/photons (MC) or enough reco level electrons/photons to analyze this event.

Returns: if the event has enough of these candidates.

Definition at line 619 of file EmDQM.cc.

References funct::abs(), reco::LeafCandidate::et(), PVValHelper::eta, gencut_, genEtaAcc_, GenHFHadronMatcher_cfi::genParticles, genParticles_token, mps_fire::i, edm::HandleBase::isValid(), OUTPUT_WARNINGS, pdgGen, plotEtMin, pTGenComparator_, and verbosity_.

Referenced by analyze().

 {
    // Decide if this was an event of interest.               //
    //  Did the highest energy particles happen               //
    //  to have |eta| < 2.5 ?  Then continue.                 //
    edm::Handle< edm::View<reco::Candidate> > genParticles;
    event.getByToken(genParticles_token, genParticles);
    if(!genParticles.isValid()) {
      if (verbosity_ >= OUTPUT_WARNINGS)
         edm::LogWarning("EmDQM") << "genParticles invalid.";
      return false;
    }
 
    std::vector<reco::LeafCandidate> allSortedGenParticles;
 
    for(edm::View<reco::Candidate>::const_iterator currentGenParticle = genParticles->begin(); currentGenParticle != genParticles->end(); currentGenParticle++){
 
      // TODO: do we need to check the states here again ?
      // in principle, there should collections produced with the python configuration
      // (other than 'genParticles') which fulfill these criteria
      if (  !( abs((*currentGenParticle).pdgId())==pdgGen  && (*currentGenParticle).status()==1 && (*currentGenParticle).et() > 2.0)  )  continue;
 
      reco::LeafCandidate tmpcand( *(currentGenParticle) );
 
      if (tmpcand.et() < plotEtMin) continue;
 
      allSortedGenParticles.push_back(tmpcand);
    }
 
    std::sort(allSortedGenParticles.begin(), allSortedGenParticles.end(),pTGenComparator_);
 
    // return false if not enough particles found
    if (allSortedGenParticles.size() < gencut_)
      return false;
 
    // additional check (this might be legacy code and we need to check
    // whether this should not be removed ?)
 
    // We now have a sorted collection of all generated particles
    // with pdgId = pdgGen.
    // Loop over them to see if the top gen particles have eta within acceptance
   // bool keepEvent = true;
    for (unsigned int i = 0 ; i < gencut_ ; i++ ) {
      bool inECALgap = fabs(allSortedGenParticles[i].eta()) > 1.4442 && fabs(allSortedGenParticles[i].eta()) < 1.556;
      if ( (fabs(allSortedGenParticles[i].eta()) > genEtaAcc_) || inECALgap ) {
        //edm::LogWarning("EmDQM") << "Throwing event away. Gen particle with pdgId="<< allSortedGenParticles[i].pdgId() <<"; et="<< allSortedGenParticles[i].et() <<"; and eta="<< allSortedGenParticles[i].eta() <<" beyond acceptance.";
        return false;
      }
    }
 
    // all tests passed
    return true;
 }

bool EmDQM::checkRecoParticlesRequirement ( const edm::Event & event )

private

similar to checkGeneratedParticlesRequirement(..) but for reconstructed particles. For the moment, there are some additional requirements in the MC version so we can't use the same code for both cases.

Definition at line 676 of file EmDQM.cc.

References autoConfMode_, gencut_, gencutColl_fidDiGamma_token, gencutColl_fidGammaJet_token, gencutColl_fidTripleEle_token, gencutColl_fidWenu_token, gencutColl_fidZee_token, gencutColl_manualConf_token, edm::HandleBase::isValid(), OUTPUT_WARNINGS, pdgGen, plotEtMin, reqNum, and verbosity_.

Referenced by analyze().

 {
   // note that this code is very similar to the one in checkGeneratedParticlesRequirement(..)
   // and hopefully can be merged with it at some point in the future
 
   edm::Handle< edm::View<reco::Candidate> > referenceParticles;
   // get the right data according to the trigger path currently looked at
   if (autoConfMode_) {
     switch(reqNum) {
        case 1:
           if (pdgGen == 11) event.getByToken(gencutColl_fidWenu_token, referenceParticles);
           else event.getByToken(gencutColl_fidGammaJet_token, referenceParticles);
           break;
        case 2:
           if (pdgGen == 11) event.getByToken(gencutColl_fidZee_token, referenceParticles);
           else event.getByToken(gencutColl_fidDiGamma_token, referenceParticles);
           break;
        case 3:
           event.getByToken(gencutColl_fidTripleEle_token, referenceParticles);
           break;
     }
   } else {
     event.getByToken(gencutColl_manualConf_token, referenceParticles);
   }
   if(!referenceParticles.isValid()) {
      if (verbosity_ >= OUTPUT_WARNINGS)
         edm::LogWarning("EmDQM") << "referenceParticles invalid.";
      return false;
   }
 
   std::vector<const reco::Candidate *> allSortedReferenceParticles;
 
   for(edm::View<reco::Candidate>::const_iterator currentReferenceParticle = referenceParticles->begin();
       currentReferenceParticle != referenceParticles->end();
       currentReferenceParticle++)
   {
      if ( currentReferenceParticle->et() <= 2.0)
        continue;
 
      // Note that for determining the overall efficiency,
      // we should only allow
      //
      // HOWEVER: for turn-on curves, we need to let
      //          more electrons pass
      if (currentReferenceParticle->et() < plotEtMin)
        continue;
 
      // TODO: instead of filling a new vector we could simply count here...
      allSortedReferenceParticles.push_back(&(*currentReferenceParticle));
   }
 
    // std::sort(allSortedReferenceParticles.begin(), allSortedReferenceParticles.end(),pTComparator_);
 
    // return false if not enough particles found
    return allSortedReferenceParticles.size() >= gencut_;
 }

int EmDQM::countSubstring	(	const std::string &	str,
		const std::string &	sub
	)

private

Definition at line 1099 of file EmDQM.cc.

References KineDebug3::count(), and PFRecoTauDiscriminationByIsolation_cfi::offset.

Referenced by findEgammaPaths(), and makePSetForL1SeedFilter().

 {
     if (sub.length() == 0) return 0;
     int count = 0;
     for (size_t offset = str.find(sub); offset != std::string::npos;
      offset = str.find(sub, offset + sub.length()))
     {
         ++count;
     }
     return count;
 }

void EmDQM::dqmBeginRun	(	edm::Run const &	iRun,
		edm::EventSetup const &	iSetup
	)

overridevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 75 of file EmDQM.cc.

 {
    bool changed(true);
    if (hltConfig_.init(iRun, iSetup, triggerObject_.process(), changed)) {
 
       // if init returns TRUE, initialisation has succeeded!
 
       if (autoConfMode_) {
         if (verbosity_ >= OUTPUT_ALL) {
            // Output general information on the menu
            edm::LogPrint("EmDQM") << "inited=" << hltConfig_.inited();
            edm::LogPrint("EmDQM") << "changed=" << hltConfig_.changed();
            edm::LogPrint("EmDQM") << "processName=" << hltConfig_.processName();
            edm::LogPrint("EmDQM") << "tableName=" << hltConfig_.tableName();
            edm::LogPrint("EmDQM") << "size=" << hltConfig_.size();
            edm::LogInfo("EmDQM") << "The following filter types are not analyzed: \n" 
                                   << "\tHLTGlobalSumsMET\n"
                                   << "\tHLTHtMhtFilter\n"
                                   << "\tHLTMhtFilter\n"
                                   << "\tHLTJetTag\n"
                                   << "\tHLT1CaloJet\n"
                                   << "\tHLT1CaloMET\n"
                                   << "\tHLT1CaloBJet\n"
                                   << "\tHLT1Tau\n"
                                   << "\tHLT1PFTau\n"
                                   << "\tPFTauSelector\n"
                                   << "\tHLT1PFJet\n"
                                   << "\tHLTPFJetCollectionsFilter\n"
                                   << "\tHLTPFJetCollectionsVBFFilter\n"
                                   << "\tHLTPFJetTag\n"
                                   << "\tEtMinCaloJetSelector\n"
                                   << "\tEtMinPFJetSelector\n"
                                   << "\tLargestEtCaloJetSelector\n"
                                   << "\tLargestEtPFJetSelector\n"
                                   << "\tHLTEgammaTriggerFilterObjectWrapper\n"
                                   << "\tHLTEgammaDoubleLegCombFilter\n"
                                   << "\tHLT2ElectronTau\n"
                                   << "\tHLT2ElectronMET\n"
                                   << "\tHLT2ElectronPFTau\n"
                                   << "\tHLTPMMassFilter\n"
                                   << "\tHLTHcalTowerFilter\n"
                                   << "\tHLT1Photon\n"
                                   << "\tHLTRFilter\n"
                                   << "\tHLTRHemisphere\n"
                                   << "\tHLTElectronPFMTFilter\n"
                                   << "\tPrimaryVertexObjectFilter\n"
                                   << "\tHLTEgammaAllCombMassFilter\n"
                                   << "\tHLTMuon*\n"
                                   ;
         }
 
 
         // All electron and photon paths
         std::vector<std::vector<std::string> > egammaPaths = findEgammaPaths();
         //std::cout << "Found " << egammaPaths[TYPE_SINGLE_ELE].size() << " single electron paths" << std::endl;
         //std::cout << "Found " << egammaPaths[TYPE_DOUBLE_ELE].size() << " double electron paths" << std::endl;
         //std::cout << "Found " << egammaPaths[TYPE_TRIPLE_ELE].size() << " triple electron paths" << std::endl;
         //std::cout << "Found " << egammaPaths[TYPE_SINGLE_PHOTON].size() << " single photon paths" << std::endl;
         //std::cout << "Found " << egammaPaths[TYPE_DOUBLE_PHOTON].size() << " double photon paths" << std::endl;
 
         std::vector<std::string> filterModules;
 
         for (unsigned int j=0; j < egammaPaths.size() ; j++) {
            if (verbosity_ >= OUTPUT_ALL) {
               switch(j) {
                  case TYPE_SINGLE_ELE:
                     edm::LogPrint("EmDQM") << "/////////////////////////////////////////\nSingle electron paths: ";
                     break;
                  case TYPE_DOUBLE_ELE:
                     edm::LogPrint("EmDQM") << "/////////////////////////////////////////\nDouble electron paths: ";
                     break;
                  case TYPE_TRIPLE_ELE:
                     edm::LogPrint("EmDQM") << "/////////////////////////////////////////\nTriple electron paths: ";
                     break;
                  case TYPE_SINGLE_PHOTON:
                     edm::LogPrint("EmDQM") << "/////////////////////////////////////////\nSingle photon paths: ";
                     break;
                  case TYPE_DOUBLE_PHOTON:
                     edm::LogPrint("EmDQM") << "/////////////////////////////////////////\nDouble photon paths: ";
                     break;
               }
            }
 
            for (unsigned int i=0; i < egammaPaths.at(j).size() ; i++) {
               // get pathname of this trigger 
               const std::string pathName = egammaPaths.at(j).at(i);
               if (verbosity_ >= OUTPUT_ALL)
                  edm::LogPrint("EmDQM") << "Path: " << pathName;
 
               // get filters of the current path
               filterModules = getFilterModules(pathName);
 
               //--------------------       
               edm::ParameterSet paramSet;
 
               paramSet.addUntrackedParameter("pathIndex", hltConfig_.triggerIndex(pathName));
               paramSet.addParameter("@module_label", hltConfig_.removeVersion(pathName) + "_DQM");
               //paramSet.addParameter("@module_label", pathName + "_DQM");
 
               // plotting parameters (untracked because they don't affect the physics)
               double genEtMin = getPrimaryEtCut(pathName);
               if (genEtMin >= 0) {
                  paramSet.addUntrackedParameter("genEtMin", genEtMin);
               } else {
                  if (verbosity_ >= OUTPUT_WARNINGS)
                     edm::LogWarning("EmDQM") << "Pathname: '" << pathName << "':  Unable to determine a minimum Et. Will not include this path in the validation.";
                  continue;
               }
 
               // set the x axis of the et plots to some reasonable value based
               // on the primary et cut determined from the path name
               double ptMax = ptMax_;
               double ptMin = ptMin_;
               if (ptMax < (1.2*genEtMin)) {
                  paramSet.addUntrackedParameter<double>("PtMax", (10*ceil(0.12 * genEtMin)));
                  paramSet.addUntrackedParameter<double>("PtMin", (10*ceil(0.12 * genEtMin) - ptMax + ptMin));
               }
               else {
                  paramSet.addUntrackedParameter<double>("PtMax", ptMax);
                  paramSet.addUntrackedParameter<double>("PtMin", ptMin);
               }
 
               //preselction cuts 
               switch (j) {
                  case TYPE_SINGLE_ELE:
                     paramSet.addParameter<unsigned>("reqNum", 1);
                     paramSet.addParameter<int>("pdgGen", 11);
                     paramSet.addParameter<edm::InputTag>("cutcollection", edm::InputTag("fiducialWenu"));
                     paramSet.addParameter<int>("cutnum", 1);
                     break;
                  case TYPE_DOUBLE_ELE:
                     paramSet.addParameter<unsigned>("reqNum", 2);
                     paramSet.addParameter<int>("pdgGen", 11);
                     paramSet.addParameter<edm::InputTag>("cutcollection", edm::InputTag("fiducialZee"));
                     paramSet.addParameter<int>("cutnum", 2);
                     break;
                  case TYPE_TRIPLE_ELE:
                     paramSet.addParameter<unsigned>("reqNum", 3);
                     paramSet.addParameter<int>("pdgGen", 11);
                     paramSet.addParameter<edm::InputTag>("cutcollection", edm::InputTag("fiducialTripleEle"));
                     paramSet.addParameter<int>("cutnum", 3);
                     break;
                  case TYPE_SINGLE_PHOTON:
                     paramSet.addParameter<unsigned>("reqNum", 1);
                     paramSet.addParameter<int>("pdgGen", 22);
                     paramSet.addParameter<edm::InputTag>("cutcollection", edm::InputTag("fiducialGammaJet"));
                     paramSet.addParameter<int>("cutnum", 1);
                     break;
                  case TYPE_DOUBLE_PHOTON:
                     paramSet.addParameter<unsigned>("reqNum", 2);
                     paramSet.addParameter<int>("pdgGen", 22);
                     paramSet.addParameter<edm::InputTag>("cutcollection", edm::InputTag("fiducialDiGamma"));
                     paramSet.addParameter<int>("cutnum", 2);
               }
               //--------------------
 
               // TODO: extend this
               if (isData_) paramSet.addParameter<edm::InputTag>("cutcollection", edm::InputTag("gsfElectrons"));
 
               std::vector<edm::ParameterSet> filterVPSet;
               edm::ParameterSet filterPSet;
               std::string moduleLabel;
 
               // loop over filtermodules of current trigger path
               for (std::vector<std::string>::iterator filter = filterModules.begin(); filter != filterModules.end(); ++filter) {
                  std::string moduleType = hltConfig_.modulePSet(*filter).getParameter<std::string>("@module_type");
                  moduleLabel = hltConfig_.modulePSet(*filter).getParameter<std::string>("@module_label");
 
                  // first check if it is a filter we are not interrested in
                  if (moduleType == "Pythia6GeneratorFilter" ||
                      moduleType == "HLTTriggerTypeFilter" ||
                      moduleType == "HLTLevel1Activity" ||
                      moduleType == "HLTPrescaler" ||
                      moduleType == "HLTBool")
                     continue;
 
                  // now check for the known filter types
                  if (moduleType == "HLTLevel1GTSeed") {
                     filterPSet = makePSetForL1SeedFilter(moduleLabel);
                  }
                  else if (moduleType == "HLTEgammaL1MatchFilterRegional") {
                     filterPSet = makePSetForL1SeedToSuperClusterMatchFilter(moduleLabel);
                  }
                  else if (moduleType == "HLTEgammaEtFilter") {
                     filterPSet = makePSetForEtFilter(moduleLabel);
                  }
                  else if (moduleType == "HLTElectronOneOEMinusOneOPFilterRegional") {
                     filterPSet = makePSetForOneOEMinusOneOPFilter(moduleLabel);
                  }
                  else if (moduleType == "HLTElectronPixelMatchFilter") {
                     filterPSet = makePSetForPixelMatchFilter(moduleLabel);
                  }
                  else if (moduleType == "HLTEgammaGenericFilter") {
                     filterPSet = makePSetForEgammaGenericFilter(moduleLabel);
                  }
                  else if (moduleType == "HLTEgammaGenericQuadraticFilter") {
                     filterPSet = makePSetForEgammaGenericQuadraticFilter(moduleLabel);
                  }
                  else if (moduleType == "HLTElectronGenericFilter") {
                     filterPSet = makePSetForElectronGenericFilter(moduleLabel);
                  }
                  else if (moduleType == "HLTEgammaDoubleEtDeltaPhiFilter") {
                     filterPSet = makePSetForEgammaDoubleEtDeltaPhiFilter(moduleLabel);
                  }
                  else if (moduleType == "HLTGlobalSumsMET"
                           || moduleType == "HLTHtMhtFilter"
                           || moduleType == "HLTMhtFilter"
                           || moduleType == "HLTJetTag"
                           || moduleType == "HLT1CaloJet"
                           || moduleType == "HLT1CaloMET"
                           || moduleType == "HLT1CaloBJet"
                           || moduleType == "HLT1Tau"
                           || moduleType == "HLT1PFTau"
                           || moduleType == "PFTauSelector"
                           || moduleType == "HLT1PFJet"
                           || moduleType == "HLTPFJetCollectionsFilter"
                           || moduleType == "HLTPFJetCollectionsVBFFilter"
                           || moduleType == "HLTPFJetTag"
                           || moduleType == "EtMinCaloJetSelector"
                           || moduleType == "EtMinPFJetSelector"
                           || moduleType == "LargestEtCaloJetSelector"
                           || moduleType == "LargestEtPFJetSelector"
                           || moduleType == "HLTEgammaTriggerFilterObjectWrapper"  // 'fake' filter
                           || moduleType == "HLTEgammaDoubleLegCombFilter" // filter does not put anything in TriggerEventWithRefs
                           || moduleType == "HLT2ElectronMET"
                           || moduleType == "HLT2ElectronTau"
                           || moduleType == "HLT2ElectronPFTau"
                           || moduleType == "HLTPMMassFilter"
                           || moduleType == "HLTHcalTowerFilter"
                           || moduleType == "HLT1Photon"
                           || moduleType == "HLTRFilter"
                           || moduleType == "HLTRHemisphere"
                           || moduleType == "HLTElectronPFMTFilter"
                           || moduleType == "PrimaryVertexObjectFilter"
                           || moduleType == "HLTEgammaAllCombMassFilter"
                           || moduleType.find("HLTMuon") != std::string::npos
                          )
                     continue;
                  else {
                     if (verbosity_ >= OUTPUT_WARNINGS)
                        edm::LogWarning("EmDQM")  << "No parameter set for filter '" << moduleLabel << "' with filter type '" << moduleType << "' added. Module will not be analyzed.";
                     continue;
                  }
 
                  // something went wrong when the parameter set is empty. 
                  if (!filterPSet.empty()) {
                     if (!hltConfig_.modulePSet(moduleLabel).exists("saveTags")) {
                        // make sure that 'theHLTOutputTypes' before an unseeded filter in a photon path is set to trigger::TriggerPhoton
                        // this is coupled to the parameter 'saveTag = true'
                        if (moduleLabel.find("Unseeded") != std::string::npos && (j == TYPE_DOUBLE_PHOTON || j == TYPE_SINGLE_PHOTON)) {
                           filterVPSet.back().addParameter<int>("theHLTOutputTypes", trigger::TriggerPhoton);
                        }
                     }
                     // if ncandcut is -1 (when parsing for the number of particles in the name of the L1seed filter fails),
                     // fall back to setting ncandcut to the number of particles needed for the given path.
                     if (filterPSet.getParameter<int>("ncandcut") < 0) {
                       edm::LogPrint("EmDQM") << "No number of candidates for filter " << moduleLabel << " found. Set to " << paramSet.getParameter<int>("cutnum") << ", determined from path name.";
                       filterPSet.addParameter<int>("ncandcut", paramSet.getParameter<int>("cutnum"));
                     } else if (filterPSet.getParameter<int>("ncandcut") > paramSet.getParameter<int>("cutnum")) {
                       edm::LogInfo("EmDQM") << "Changed required number of candidates from " << paramSet.getParameter<int>("cutnum") << " to " << filterPSet.getParameter<int>("ncandcut") << " for filter " << moduleLabel;
                       paramSet.addParameter<int>("cutnum", filterPSet.getParameter<int>("ncandcut"));
                       paramSet.addParameter<unsigned>("reqNum", (unsigned)filterPSet.getParameter<int>("ncandcut"));
                     }
 
                     filterVPSet.push_back(filterPSet);
                  }
                  else
                     break;
 
               } // end loop over filter modules of current trigger path
 
               // do not include this path when an empty filterPSet is detected.
               if (!filterPSet.empty()) {
                  std::string lastModuleName = filterPSet.getParameter<edm::InputTag>("HLTCollectionLabels").label();
                  if (!hltConfig_.modulePSet(lastModuleName).exists("saveTags")) {
                     // make sure that 'theHLTOutputTypes' of the last filter of a photon path is set to trigger::TriggerPhoton
                     // this is coupled to the parameter 'saveTag = true'
                     if ((j == TYPE_SINGLE_PHOTON || j == TYPE_DOUBLE_PHOTON) && pathName.rfind("Ele") == std::string::npos) {
                        filterVPSet.back().addParameter<int>("theHLTOutputTypes", trigger::TriggerPhoton);
                     }
                  }
                  paramSet.addParameter<std::vector<edm::ParameterSet> >("filters", filterVPSet);
               }
               else {
                  if (verbosity_ >= OUTPUT_ALL)
                     edm::LogPrint("EmDQM") << "Will not include this path in the validation due to errors while generating the parameter set.";
                  continue;
               }
 
               // dump generated parameter set
               //std::cout << paramSet.dump() << std::endl;
 
               paramSets.push_back(paramSet);
            } // loop over all paths of this analysis type
 
         } // loop over analysis types (single ele etc.)
       }
 
       hltCollectionLabelsFoundPerPath.reserve(paramSets.size());
       hltCollectionLabelsMissedPerPath.reserve(paramSets.size());
 
       // loop over all the trigger path parameter sets
       for (std::vector<edm::ParameterSet>::iterator psetIt = paramSets.begin(); psetIt != paramSets.end(); ++psetIt) {
          hltCollectionLabelsFoundPerPath.push_back(hltCollectionLabelsFound);
          hltCollectionLabelsMissedPerPath.push_back(hltCollectionLabelsMissed);
       }
 
       if (changed) {
          // The HLT config has actually changed wrt the previous Run, hence rebook your
          // histograms or do anything else dependent on the revised HLT config
       }
    } else {
       // if init returns FALSE, initialisation has NOT succeeded, which indicates a problem
       // with the file and/or code and needs to be investigated!
       if (verbosity_ >= OUTPUT_ERRORS)
          edm::LogError("EmDQM") << " HLT config extraction failure with process name '" << triggerObject_.process() << "'.";
       // In this case, all access methods will return empty values!
    }
 }

void EmDQM::endJob ( void )

Definition at line 1092 of file EmDQM.cc.

 {
 
 }

void EmDQM::endRun	(	edm::Run const &	iRun,
		edm::EventSetup const &	iSetup
	)

overridevirtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 1049 of file EmDQM.cc.

References KineDebug3::count(), edm::InputTag::encode(), hltCollectionLabelsFoundPerPath, hltCollectionLabelsMissedPerPath, OUTPUT_ALL, OUTPUT_WARNINGS, paramSets, SetVarsFromPSet(), GlobalPosition_Frontier_DevDB_cff::tag, and verbosity_.

 {
    // loop over all the trigger path parameter sets
    unsigned int vPos = 0;
    for (std::vector<edm::ParameterSet>::iterator psetIt = paramSets.begin(); psetIt != paramSets.end(); ++psetIt, ++vPos) {
       SetVarsFromPSet(psetIt);
 
       // print information about hltCollectionLabels which were not found
       // (but only those which were never found)
 
       // check which ones were never found
       std::vector<std::string> labelsNeverFound;
       
       BOOST_FOREACH(const edm::InputTag &tag, hltCollectionLabelsMissedPerPath.at(vPos))
       {
         if ((hltCollectionLabelsFoundPerPath.at(vPos)).count(tag.encode()) == 0)
           // never found
           labelsNeverFound.push_back(tag.encode());
 
       } // loop over all tags which were missed at least once
 
       if (labelsNeverFound.empty())
         continue;
 
       std::sort(labelsNeverFound.begin(), labelsNeverFound.end());
 
       // there was at least one label which was never found
       // (note that this could also be because the corresponding
       // trigger path slowly fades out to zero efficiency)
       if (verbosity_ >= OUTPUT_WARNINGS)
          edm::LogWarning("EmDQM") << "There were some HLTCollectionLabels which were never found:";
 
       BOOST_FOREACH(const edm::InputTag &tag, labelsNeverFound)
       {
         if (verbosity_ >= OUTPUT_ALL)
            edm::LogPrint("EmDQM") << "  " << tag;
       }
    }
 }

std::vector< std::vector< std::string > > EmDQM::findEgammaPaths ( )

private

Definition at line 1114 of file EmDQM.cc.

References countSubstring(), hltConfig_, mps_fire::i, callgraph::path, HLTConfigProvider::size(), AlCaHLTBitMon_QueryRunRegistry::string, HLTConfigProvider::triggerName(), TYPE_DOUBLE_ELE, TYPE_DOUBLE_PHOTON, TYPE_SINGLE_ELE, TYPE_SINGLE_PHOTON, and TYPE_TRIPLE_ELE.

Referenced by dqmBeginRun().

 {
    std::vector<std::vector<std::string> > Paths(5);
    // Loop over all paths in the menu
    for (unsigned int i=0; i<hltConfig_.size(); i++) {
 
       std::string path = hltConfig_.triggerName(i);
 
       // Find electron and photon paths and classify them
       if (int(path.find("HLT_")) == 0) {    // Path should start with 'HLT_'
 
          int scCount = countSubstring(path, "_SC");
          int eleCount = countSubstring(path, "Ele");
          int doubleEleCount = countSubstring(path, "DoubleEle");
          int doubleSCCount = countSubstring(path, "DiSC");
          int tripleEleCount = countSubstring(path, "TripleEle");
          int photonCount = countSubstring(path, "hoton");
          int doublePhotonCount = countSubstring(path, "DoublePhoton") + countSubstring(path, "Diphoton");
 
          int totEleCount = 2*tripleEleCount + doubleEleCount + eleCount + scCount + 2*doubleSCCount;
          int totPhotonCount = doublePhotonCount + photonCount;
 
          if (totEleCount + totPhotonCount < 1) continue;
          switch (totEleCount) {
             case 1:
                Paths[TYPE_SINGLE_ELE].push_back(path);
                //std::cout << "Electron \t" << path << std::endl;
                break;
             case 2:
                Paths[TYPE_DOUBLE_ELE].push_back(path);
                //std::cout << "DoubleElectron \t" << path << std::endl;
                break;
             case 3:
                Paths[TYPE_TRIPLE_ELE].push_back(path);
                //std::cout << "TripleElectron \t" << path << std::endl;
                break;
          }
 
          switch (totPhotonCount) {
             case 1:
                Paths[TYPE_SINGLE_PHOTON].push_back(path);
                //std::cout << "Photon \t\t" << path << std::endl;
                break;
             case 2:
                Paths[TYPE_DOUBLE_PHOTON].push_back(path);
                //std::cout << "DoublePhoton \t" << path << std::endl;
                break;
          }
       }
       //std::cout << i << " triggerName: " << path << " containing " << hltConfig_.size(i) << " modules."<< std::endl;
    }
    return Paths;
 }

std::vector< std::string > EmDQM::getFilterModules ( const std::string & path )

private

Definition at line 1171 of file EmDQM.cc.

References filters, hltConfig_, mps_fire::i, HLTConfigProvider::moduleEDMType(), HLTConfigProvider::moduleLabel(), HLTConfigProvider::moduleType(), HLTConfigProvider::size(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by dqmBeginRun().

 {
    std::vector<std::string> filters;
 
    //std::cout << "Pathname: " << path << std::endl;
 
    // Loop over all modules in the path
    for (unsigned int i=0; i<hltConfig_.size(path); i++) {
 
       std::string module = hltConfig_.moduleLabel(path, i);
       std::string moduleType = hltConfig_.moduleType(module);
       std::string moduleEDMType = hltConfig_.moduleEDMType(module);
 
       // Find filters
       if (moduleEDMType == "EDFilter" || moduleType.find("Filter") != std::string::npos) {  // older samples may not have EDMType data included
          filters.push_back(module);
          //std::cout << i << "    moduleLabel: " << module << "    moduleType: " << moduleType << "    moduleEDMType: " << moduleEDMType << std::endl;
       }
    }
    return filters;
 }

double EmDQM::getPrimaryEtCut ( const std::string & path )

private

Definition at line 1196 of file EmDQM.cc.

Referenced by dqmBeginRun().

 {
    double minEt = -1;
 
    boost::regex reg("^HLT_.*?(Ele|hoton|EG|SC)([[:digit:]]+).*");
 
    boost::smatch what;
    if (boost::regex_match(path, what, reg, boost::match_extra))
    {
      minEt = boost::lexical_cast<double>(what[2]); 
    }
 
    return minEt;
 }

edm::ParameterSet EmDQM::makePSetForEgammaDoubleEtDeltaPhiFilter ( const std::string & moduleName )

private

Definition at line 1341 of file EmDQM.cc.

References edm::ParameterSet::addParameter(), edm::InputTag::process(), AlCaHLTBitMon_QueryRunRegistry::string, trigger::TriggerCluster, and triggerObject_.

Referenced by dqmBeginRun().

 {
   edm::ParameterSet retPSet;
  
   retPSet.addParameter<std::vector<double> >("PlotBounds", std::vector<double>(2, 0.0));
   //retPSet.addParameter<edm::InputTag>("HLTCollectionLabels", edm::InputTag(moduleName, "", processName_));
   retPSet.addParameter<edm::InputTag>("HLTCollectionLabels", edm::InputTag(moduleName, "", triggerObject_.process()));
   retPSet.addParameter<std::vector<edm::InputTag> >("IsoCollections", std::vector<edm::InputTag>(1, std::string("none")));
   retPSet.addParameter<int>("theHLTOutputTypes", trigger::TriggerCluster);
   retPSet.addParameter<int>("ncandcut", 2);
 
   return retPSet;
 }

edm::ParameterSet EmDQM::makePSetForEgammaGenericFilter ( const std::string & moduleName )

private

Definition at line 1358 of file EmDQM.cc.

References edm::ParameterSet::addParameter(), edm::ParameterSet::getParameter(), hltConfig_, edm::InputTag::label(), HLTConfigProvider::modulePSet(), HLTConfigProvider::moduleType(), OUTPUT_ERRORS, edm::InputTag::process(), HLTConfigProvider::saveTags(), AlCaHLTBitMon_QueryRunRegistry::string, trigger::TriggerCluster, triggerObject_, trigger::TriggerPhoton, and verbosity_.

Referenced by dqmBeginRun().

 {
   edm::ParameterSet retPSet;
 
   // example usages of HLTEgammaGenericFilter are:
   //   R9 shape filter                        hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolR9ShapeFilter 
   //   cluster shape filter                   hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolClusterShapeFilter 
   //   Ecal isolation filter                  hltL1NonIsoHLTNonIsoSingleElectronEt17TIghterEleIdIsolEcalIsolFilter
   //   H/E filter                             hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolHEFilter
   //   HCAL isolation filter                  hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolHcalIsolFilter
 
   // infer the type of filter by the type of the producer which
   // generates the collection used to cut on this
   edm::InputTag varTag = hltConfig_.modulePSet(moduleName).getParameter<edm::InputTag>("varTag");
   //edm::InputTag nonIsoTag = hltConfig_.modulePSet(moduleName).getParameter<edm::InputTag>("");
   //std::cout << "varTag.label " << varTag.label() << " nonIsoTag.label " << nonIsoTag.label() << std::endl;
 
   std::string inputType = hltConfig_.moduleType(varTag.label());
   //std::cout << "inputType " << inputType << " moduleName " << moduleName << std::endl;
 
   //--------------------
   // sanity check: non-isolated path should be produced by the
   // same type of module
 
   // first check that the non-iso tag is non-empty
   //if (nonIsoTag.label().empty()) {
   //  edm::LogError("EmDQM") << "nonIsoTag of HLTEgammaGenericFilter '" << moduleName <<  "' is empty.";
   //  return retPSet;
   //}
   //if (inputType != hltConfig_.moduleType(nonIsoTag.label())) {
   //  edm::LogError("EmDQM") << "C++ Type of varTag '" << inputType << "' and nonIsoTag '" << hltConfig_.moduleType(nonIsoTag.label()) << "' are not the same for HLTEgammaGenericFilter '" << moduleName <<  "'.";
   //  return retPSet;
   //}
   //--------------------
 
   // parameter saveTag determines the output type
   if (hltConfig_.saveTags(moduleName))
      retPSet.addParameter<int>("theHLTOutputTypes", trigger::TriggerPhoton);  
   else
      retPSet.addParameter<int>("theHLTOutputTypes", trigger::TriggerCluster);
 
   std::vector<edm::InputTag> isoCollections;
   isoCollections.push_back(varTag);
   //if (!nonIsoTag.label().empty())
   //   isoCollections.push_back(nonIsoTag);
 
   //--------------------
   // the following cases seem to have identical PSets ?
   //--------------------
 
   if (inputType == "EgammaHLTR9Producer" ||                       // R9 shape
       inputType == "EgammaHLTR9IDProducer" ||                     // R9 ID
       inputType == "EgammaHLTClusterShapeProducer" ||             // cluster shape
       inputType == "EgammaHLTEcalRecIsolationProducer" ||         // ecal isolation
       inputType == "EgammaHLTHcalIsolationProducersRegional" ||   // HCAL isolation and HE
       inputType == "EgammaHLTGsfTrackVarProducer" ||              // GSF track deta and dphi filter
       inputType == "EgammaHLTBcHcalIsolationProducersRegional" || // HCAL isolation and HE
       inputType == "EgammaHLTEcalPFClusterIsolationProducer" ||   // ECAL PF isolation filter
       inputType == "EgammaHLTHcalPFClusterIsolationProducer" ||   // HCAL PF isolation filter
       inputType == "EgammaHLTElectronTrackIsolationProducers"     // Track isolation filter
      ) {
     retPSet.addParameter<std::vector<double> >("PlotBounds", std::vector<double>(2, 0.0));
     //retPSet.addParameter<edm::InputTag>("HLTCollectionLabels", edm::InputTag(moduleName, "", processName_));
     retPSet.addParameter<edm::InputTag>("HLTCollectionLabels", edm::InputTag(moduleName, "", triggerObject_.process()));
     retPSet.addParameter<std::vector<edm::InputTag> >("IsoCollections", isoCollections);
     retPSet.addParameter<int>("ncandcut", hltConfig_.modulePSet(moduleName).getParameter<int>("ncandcut"));
 
     return retPSet;
   }
 
   if (verbosity_ >= OUTPUT_ERRORS)
      edm::LogError("EmDQM") << "Can't determine what the HLTEgammaGenericFilter '" << moduleName <<  "' should do: uses a collection produced by a module of C++ type '" << inputType << "'.";
   return edm::ParameterSet();
 }

edm::ParameterSet EmDQM::makePSetForEgammaGenericQuadraticFilter ( const std::string & moduleName )

private

Definition at line 1436 of file EmDQM.cc.

References edm::ParameterSet::addParameter(), edm::ParameterSet::getParameter(), hltConfig_, edm::InputTag::label(), HLTConfigProvider::modulePSet(), HLTConfigProvider::moduleType(), OUTPUT_ERRORS, edm::InputTag::process(), HLTConfigProvider::saveTags(), AlCaHLTBitMon_QueryRunRegistry::string, trigger::TriggerCluster, triggerObject_, trigger::TriggerPhoton, and verbosity_.

Referenced by dqmBeginRun().

 {
   edm::ParameterSet retPSet;
 
   // example usages of HLTEgammaGenericFilter are:
   //   R9 shape filter                        hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolR9ShapeFilter 
   //   cluster shape filter                   hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolClusterShapeFilter 
   //   Ecal isolation filter                  hltL1NonIsoHLTNonIsoSingleElectronEt17TIghterEleIdIsolEcalIsolFilter
   //   H/E filter                             hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolHEFilter
   //   HCAL isolation filter                  hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolHcalIsolFilter
 
   // infer the type of filter by the type of the producer which
   // generates the collection used to cut on this
   edm::InputTag varTag = hltConfig_.modulePSet(moduleName).getParameter<edm::InputTag>("varTag");
   //edm::InputTag nonIsoTag = hltConfig_.modulePSet(moduleName).getParameter<edm::InputTag>("nonIsoTag");
   //std::cout << "varTag.label " << varTag.label() << " nonIsoTag.label " << nonIsoTag.label() << std::endl;
 
   std::string inputType = hltConfig_.moduleType(varTag.label());
   //std::cout << "inputType " << inputType << " moduleName " << moduleName << std::endl;
 
   //--------------------
   // sanity check: non-isolated path should be produced by the
   // same type of module
 
   // first check that the non-iso tag is non-empty
   //if (nonIsoTag.label().empty()) {
   //  edm::LogError("EmDQM") << "nonIsoTag of HLTEgammaGenericFilter '" << moduleName <<  "' is empty.";
   //  return retPSet;
   //}
   //if (inputType != hltConfig_.moduleType(nonIsoTag.label())) {
   //  edm::LogError("EmDQM") << "C++ Type of varTag '" << inputType << "' and nonIsoTag '" << hltConfig_.moduleType(nonIsoTag.label()) << "' are not the same for HLTEgammaGenericFilter '" << moduleName <<  "'.";
   //  return retPSet;
   //}
   //--------------------
 
   // parameter saveTag determines the output type
   if (hltConfig_.saveTags(moduleName))
      retPSet.addParameter<int>("theHLTOutputTypes", trigger::TriggerPhoton);  
   else
      retPSet.addParameter<int>("theHLTOutputTypes", trigger::TriggerCluster);
 
   std::vector<edm::InputTag> isoCollections;
   isoCollections.push_back(varTag);
   //if (!nonIsoTag.label().empty())
   //   isoCollections.push_back(nonIsoTag);
 
   //--------------------
   // the following cases seem to have identical PSets ?
   //--------------------
 
   if (inputType == "EgammaHLTR9Producer" ||                            // R9 shape
       inputType == "EgammaHLTR9IDProducer" ||                          // R9 ID
       inputType == "EgammaHLTClusterShapeProducer" ||                  // cluster shape
       inputType == "EgammaHLTEcalRecIsolationProducer" ||              // ecal isolation
       inputType == "EgammaHLTHcalIsolationProducersRegional" ||        // HCAL isolation and HE
       inputType == "EgammaHLTBcHcalIsolationProducersRegional" ||      // HCAL isolation and HE
       inputType == "EgammaHLTEcalPFClusterIsolationProducer" ||        // ECAL PF isolation filter
       inputType == "EgammaHLTHcalPFClusterIsolationProducer" ||        // HCAL PF isolation filter
       inputType == "EgammaHLTPhotonTrackIsolationProducersRegional"    // Photon track isolation
      ) {
     retPSet.addParameter<std::vector<double> >("PlotBounds", std::vector<double>(2, 0.0));
     //retPSet.addParameter<edm::InputTag>("HLTCollectionLabels", edm::InputTag(moduleName, "", processName_));
     retPSet.addParameter<edm::InputTag>("HLTCollectionLabels", edm::InputTag(moduleName, "", triggerObject_.process()));
     retPSet.addParameter<std::vector<edm::InputTag> >("IsoCollections", isoCollections);
     retPSet.addParameter<int>("ncandcut", hltConfig_.modulePSet(moduleName).getParameter<int>("ncandcut"));
 
     return retPSet;
   }
  
   if (verbosity_ >= OUTPUT_ERRORS)
      edm::LogError("EmDQM") << "Can't determine what the HLTEgammaGenericQuadraticFilter '" << moduleName <<  "' should do: uses a collection produced by a module of C++ type '" << inputType << "'.";
   return edm::ParameterSet();
 }

edm::ParameterSet EmDQM::makePSetForElectronGenericFilter ( const std::string & moduleName )

private

Definition at line 1513 of file EmDQM.cc.

References edm::ParameterSet::addParameter(), edm::ParameterSet::getParameter(), hltConfig_, edm::InputTag::label(), HLTConfigProvider::modulePSet(), HLTConfigProvider::moduleType(), OUTPUT_ERRORS, edm::InputTag::process(), AlCaHLTBitMon_QueryRunRegistry::string, trigger::TriggerElectron, triggerObject_, and verbosity_.

Referenced by dqmBeginRun().

 {
   edm::ParameterSet retPSet;
 
   // example usages of HLTElectronGenericFilter are:
   //
   // deta filter      hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolDetaFilter
   // dphi filter      hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolDphiFilter
   // track isolation  hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolTrackIsolFilter
 
   // infer the type of filter by the type of the producer which
   // generates the collection used to cut on this
   edm::InputTag varTag = hltConfig_.modulePSet(moduleName).getParameter<edm::InputTag>("varTag");
   //edm::InputTag nonIsoTag = hltConfig_.modulePSet(moduleName).getParameter<edm::InputTag>("nonIsoTag");
   //std::cout << "varTag.label " << varTag.label() << " nonIsoTag.label " << nonIsoTag.label() << std::endl;
 
   std::string inputType = hltConfig_.moduleType(varTag.label());
   //std::cout << "inputType iso " << inputType << " inputType noniso " << hltConfig_.moduleType(nonIsoTag.label()) << " moduleName " << moduleName << std::endl;
 
   //--------------------
   // sanity check: non-isolated path should be produced by the
   // same type of module
   //if (nonIsoTag.label().empty()) {
   //  edm::LogError("EmDQM") << "nonIsoTag of HLTElectronGenericFilter '" << moduleName <<  "' is empty.";
   //  return retPSet;
   //}
   //if (inputType != hltConfig_.moduleType(nonIsoTag.label())) {
   //  edm::LogError("EmDQM") << "C++ Type of varTag '" << inputType << "' and nonIsoTag '" << hltConfig_.moduleType(nonIsoTag.label()) << "' are not the same for HLTElectronGenericFilter '" << moduleName <<  "'.";
   //  return retPSet;
   //}
   //--------------------
 
   // the type of object to look for seems to be the
   // same for all uses of HLTEgammaGenericFilter
   retPSet.addParameter<int>("theHLTOutputTypes", trigger::TriggerElectron);
 
   std::vector<edm::InputTag> isoCollections;
   isoCollections.push_back(varTag);
   //if (!nonIsoTag.label().empty())
   //   isoCollections.push_back(nonIsoTag);
 
   //--------------------
   // the following cases seem to have identical PSets ?
   //--------------------
 
   // note that whether deta or dphi is used is determined from
   // the product instance (not the module label)
   if (inputType == "EgammaHLTElectronDetaDphiProducer" ||           // deta and dphi filter
       inputType == "EgammaHLTElectronTrackIsolationProducers"       // track isolation
      ) {
     retPSet.addParameter<std::vector<double> >("PlotBounds", std::vector<double>(2, 0.0));
     //retPSet.addParameter<edm::InputTag>("HLTCollectionLabels", edm::InputTag(moduleName, "", processName_));
     retPSet.addParameter<edm::InputTag>("HLTCollectionLabels", edm::InputTag(moduleName, "", triggerObject_.process()));
     retPSet.addParameter<std::vector<edm::InputTag> >("IsoCollections", isoCollections);
     retPSet.addParameter<int>("ncandcut", hltConfig_.modulePSet(moduleName).getParameter<int>("ncandcut"));
 
     return retPSet;
   }
 
   if (verbosity_ >= OUTPUT_ERRORS)
      edm::LogError("EmDQM") << "Can't determine what the HLTElectronGenericFilter '" << moduleName <<  "' should do: uses a collection produced by a module of C++ type '" << inputType << "'.";
   return edm::ParameterSet();
 }

edm::ParameterSet EmDQM::makePSetForEtFilter ( const std::string & moduleName )

private

Definition at line 1290 of file EmDQM.cc.

References edm::ParameterSet::addParameter(), edm::ParameterSet::getParameter(), hltConfig_, HLTConfigProvider::modulePSet(), edm::InputTag::process(), AlCaHLTBitMon_QueryRunRegistry::string, trigger::TriggerCluster, and triggerObject_.

Referenced by dqmBeginRun().

 {
   edm::ParameterSet retPSet;
   
   retPSet.addParameter<std::vector<double> >("PlotBounds", std::vector<double>(2, 0.0));
   //retPSet.addParameter<edm::InputTag>("HLTCollectionLabels", edm::InputTag(moduleName, "", processName_));
   retPSet.addParameter<edm::InputTag>("HLTCollectionLabels", edm::InputTag(moduleName, "", triggerObject_.process()));
   retPSet.addParameter<std::vector<edm::InputTag> >("IsoCollections", std::vector<edm::InputTag>(1, std::string("none")));
   retPSet.addParameter<int>("theHLTOutputTypes", trigger::TriggerCluster);
   retPSet.addParameter<int>("ncandcut", hltConfig_.modulePSet(moduleName).getParameter<int>("ncandcut"));
 
   return retPSet;
 }

edm::ParameterSet EmDQM::makePSetForL1SeedFilter ( const std::string & moduleName )

private

Definition at line 1214 of file EmDQM.cc.

References edm::ParameterSet::addParameter(), countSubstring(), edm::InputTag::process(), AlCaHLTBitMon_QueryRunRegistry::string, trigger::TriggerL1NoIsoEG, and triggerObject_.

Referenced by dqmBeginRun().

 {
   // generates a PSet to analyze the behaviour of an L1 seed.
   //
   // moduleName is the name of the HLT module which filters
   // on the L1 seed.
   edm::ParameterSet retPSet;
   
   retPSet.addParameter<std::vector<double> >("PlotBounds", std::vector<double>(2, 0.0));
   //retPSet.addParameter<edm::InputTag>("HLTCollectionLabels", edm::InputTag(moduleName, "", processName_));
   retPSet.addParameter<edm::InputTag>("HLTCollectionLabels", edm::InputTag(moduleName, "", triggerObject_.process()));
   retPSet.addParameter<std::vector<edm::InputTag> >("IsoCollections", std::vector<edm::InputTag>(1, std::string("none")));
   retPSet.addParameter<int>("theHLTOutputTypes", trigger::TriggerL1NoIsoEG);
   
   // as HLTLevel1GTSeed has no parameter ncandcut we determine the value from the name of the filter
 
   int orCount = countSubstring(moduleName, "OR") + countSubstring(moduleName, "Or");
   int egCount = countSubstring(moduleName, "EG");
   int dEgCount = countSubstring(moduleName, "DoubleEG");
   int tEgCount = countSubstring(moduleName, "TripleEG");
 
   int candCount = 2*tEgCount + dEgCount + egCount;
   // if L1 is and OR of triggers try the assumption that all of them are similar first and if not take the lowest number. If this is not successful, let the path name decide
   if (orCount > 0 && candCount > 0) {
      if (egCount % (orCount+1) == 0 && dEgCount % (orCount+1) == 0 && tEgCount % (orCount+1) == 0) candCount /= (orCount+1);
      else if (egCount-dEgCount-tEgCount > 0) candCount = 1; // at least one singleEG present
      else if (dEgCount > 0) candCount = 2; // at least one doubleEG and no singleEG present
      else if (tEgCount > 0) candCount = 3; // only tripleEG present
      else candCount = -1;
   }
 
   switch (candCount) {
      case 0:
         retPSet.addParameter<int>("ncandcut", 0);
         break;
      case 1:
         retPSet.addParameter<int>("ncandcut", 1);
         break;
      case 2:
         retPSet.addParameter<int>("ncandcut", 2);
         break;
      case 3:
         retPSet.addParameter<int>("ncandcut", 3);
         break;
      default:
         retPSet.addParameter<int>("ncandcut", -1);
   }
 
   return retPSet;
 }

edm::ParameterSet EmDQM::makePSetForL1SeedToSuperClusterMatchFilter ( const std::string & moduleName )

private

Definition at line 1268 of file EmDQM.cc.

References edm::ParameterSet::addParameter(), edm::ParameterSet::getParameter(), hltConfig_, HLTConfigProvider::modulePSet(), edm::InputTag::process(), AlCaHLTBitMon_QueryRunRegistry::string, trigger::TriggerCluster, and triggerObject_.

Referenced by dqmBeginRun().

 {
   // generates a PSet to analyze the behaviour of L1 to supercluster match filter.
   //
   // moduleName is the name of the HLT module which requires the match
   // between supercluster and L1 seed.
   //
   edm::ParameterSet retPSet;
   
   retPSet.addParameter<std::vector<double> >("PlotBounds", std::vector<double>(2, 0.0));
   //retPSet.addParameter<edm::InputTag>("HLTCollectionLabels", edm::InputTag(moduleName, "", processName_));
   retPSet.addParameter<edm::InputTag>("HLTCollectionLabels", edm::InputTag(moduleName, "", triggerObject_.process()));
   retPSet.addParameter<std::vector<edm::InputTag> >("IsoCollections", std::vector<edm::InputTag>(1, std::string("none")));
   retPSet.addParameter<int>("theHLTOutputTypes", trigger::TriggerCluster);
   retPSet.addParameter<int>("ncandcut", hltConfig_.modulePSet(moduleName).getParameter<int>("ncandcut"));
 
   return retPSet;
 }

edm::ParameterSet EmDQM::makePSetForOneOEMinusOneOPFilter ( const std::string & moduleName )

private

Definition at line 1307 of file EmDQM.cc.

References edm::ParameterSet::addParameter(), edm::ParameterSet::getParameter(), hltConfig_, HLTConfigProvider::modulePSet(), edm::InputTag::process(), AlCaHLTBitMon_QueryRunRegistry::string, trigger::TriggerElectron, and triggerObject_.

Referenced by dqmBeginRun().

 {
   edm::ParameterSet retPSet;
   
   retPSet.addParameter<std::vector<double> >("PlotBounds", std::vector<double>(2, 0.0));
   //retPSet.addParameter<edm::InputTag>("HLTCollectionLabels", edm::InputTag(moduleName, "", processName_));
   retPSet.addParameter<edm::InputTag>("HLTCollectionLabels", edm::InputTag(moduleName, "", triggerObject_.process()));
   retPSet.addParameter<std::vector<edm::InputTag> >("IsoCollections", std::vector<edm::InputTag>(1, std::string("none")));
   retPSet.addParameter<int>("theHLTOutputTypes", trigger::TriggerElectron);
   retPSet.addParameter<int>("ncandcut", hltConfig_.modulePSet(moduleName).getParameter<int>("ncandcut"));
 
   return retPSet;
 }

edm::ParameterSet EmDQM::makePSetForPixelMatchFilter ( const std::string & moduleName )

private

Definition at line 1324 of file EmDQM.cc.

References edm::ParameterSet::addParameter(), edm::ParameterSet::getParameter(), hltConfig_, HLTConfigProvider::modulePSet(), edm::InputTag::process(), AlCaHLTBitMon_QueryRunRegistry::string, trigger::TriggerCluster, and triggerObject_.

Referenced by dqmBeginRun().

 {
   edm::ParameterSet retPSet;
  
   retPSet.addParameter<std::vector<double> >("PlotBounds", std::vector<double>(2, 0.0));
   //retPSet.addParameter<edm::InputTag>("HLTCollectionLabels", edm::InputTag(moduleName, "", processName_));
   retPSet.addParameter<edm::InputTag>("HLTCollectionLabels", edm::InputTag(moduleName, "", triggerObject_.process()));
   retPSet.addParameter<std::vector<edm::InputTag> >("IsoCollections", std::vector<edm::InputTag>(1, std::string("none")));
   retPSet.addParameter<int>("theHLTOutputTypes", trigger::TriggerCluster);
   retPSet.addParameter<int>("ncandcut", hltConfig_.modulePSet(moduleName).getParameter<int>("ncandcut"));
 
   return retPSet;
 }

void EmDQM::SetVarsFromPSet ( std::vector< edm::ParameterSet >::iterator psetIt )

private

Definition at line 1579 of file EmDQM.cc.

References DEFINE_FWK_MODULE, dirname_, filters, gencut_, gencutCollection_, mps_fire::i, isoNames, nCandCuts, noIsolationPlots_, numOfHLTCollectionLabels, pathIndex, pdgGen, plotBounds, plotEtMin, plotiso, plotPtMax, plotPtMin, reqNum, AlCaHLTBitMon_QueryRunRegistry::string, theHLTCollectionHumanNames, theHLTCollectionLabels, and theHLTOutputTypes.

Referenced by analyze(), bookHistograms(), and endRun().

 {
   dirname_="HLT/HLTEgammaValidation/"+psetIt->getParameter<std::string>("@module_label");
  
   pathIndex = psetIt->getUntrackedParameter<unsigned int>("pathIndex", 0);
   // parameters for generator study
   reqNum    = psetIt->getParameter<unsigned int>("reqNum");
   pdgGen    = psetIt->getParameter<int>("pdgGen");
   // plotting parameters (untracked because they don't affect the physics)
   plotEtMin  = psetIt->getUntrackedParameter<double>("genEtMin",0.);
   plotPtMin  = psetIt->getUntrackedParameter<double>("PtMin",0.);
   plotPtMax  = psetIt->getUntrackedParameter<double>("PtMax",1000.);
  
   //preselction cuts 
   gencutCollection_= psetIt->getParameter<edm::InputTag>("cutcollection");
   gencut_          = psetIt->getParameter<int>("cutnum");
  
   //         Read in the Vector of Parameter Sets.          //
   //           Information for each filter-step             //
   std::vector<edm::ParameterSet> filters = 
        psetIt->getParameter<std::vector<edm::ParameterSet> >("filters");
  
   // empty vectors of parameters from previous paths
   theHLTCollectionLabels.clear();
   theHLTOutputTypes.clear();
   theHLTCollectionHumanNames.clear();
   plotBounds.clear();
   isoNames.clear();
   plotiso.clear();
   nCandCuts.clear();
 
   int i = 0;
   for(std::vector<edm::ParameterSet>::iterator filterconf = filters.begin() ; filterconf != filters.end() ; filterconf++)
   {
  
     theHLTCollectionLabels.push_back(filterconf->getParameter<edm::InputTag>("HLTCollectionLabels"));
     theHLTOutputTypes.push_back(filterconf->getParameter<int>("theHLTOutputTypes"));
     // Grab the human-readable name, if it is not specified, use the Collection Label
     theHLTCollectionHumanNames.push_back(filterconf->getUntrackedParameter<std::string>("HLTCollectionHumanName",theHLTCollectionLabels[i].label()));
  
     std::vector<double> bounds = filterconf->getParameter<std::vector<double> >("PlotBounds");
     // If the size of plot "bounds" vector != 2, abort
     assert(bounds.size() == 2);
     plotBounds.push_back(std::pair<double,double>(bounds[0],bounds[1]));
     isoNames.push_back(filterconf->getParameter<std::vector<edm::InputTag> >("IsoCollections"));
 
     //for (unsigned int i=0; i<isoNames.back().size(); i++) {
     //  switch(theHLTOutputTypes.back())  {
     //  case trigger::TriggerL1NoIsoEG:
     //    histoFillerL1NonIso->isoNameTokens_.push_back(consumes<edm::AssociationMap<edm::OneToValue<l1extra::L1EmParticleCollection , float>>>(isoNames.back()[i]));
     //    break;
     //  case trigger::TriggerL1IsoEG: // Isolated Level 1
     //    histoFillerL1Iso->isoNameTokens_.push_back(consumes<edm::AssociationMap<edm::OneToValue<l1extra::L1EmParticleCollection , float>>>(isoNames.back()[i]));
     //    break;
     //  case trigger::TriggerPhoton: // Photon 
     //    histoFillerPho->isoNameTokens_.push_back(consumes<edm::AssociationMap<edm::OneToValue<reco::RecoEcalCandidateCollection , float>>>(isoNames.back()[i]));
     //    break;
     //  case trigger::TriggerElectron: // Electron 
     //    histoFillerEle->isoNameTokens_.push_back(consumes<edm::AssociationMap<edm::OneToValue<reco::ElectronCollection , float>>>(isoNames.back()[i]));
     //    break;
     //  case trigger::TriggerCluster: // TriggerCluster
     //    histoFillerClu->isoNameTokens_.push_back(consumes<edm::AssociationMap<edm::OneToValue<reco::RecoEcalCandidateCollection , float>>>(isoNames.back()[i]));
     //    break;
     //  default:
     //    throw(cms::Exception("Release Validation Error") << "HLT output type not implemented: theHLTOutputTypes[n]" );
     //  }
     //}
 
     // If the size of the isoNames vector is not greater than zero, abort
     assert(!isoNames.back().empty());
     if (isoNames.back().at(0).label()=="none") {
       plotiso.push_back(false);
     } else {
       if (!noIsolationPlots_) plotiso.push_back(true);
       else plotiso.push_back(false);
     }
     nCandCuts.push_back(filterconf->getParameter<int>("ncandcut"));
     i++;
   } // END of loop over parameter sets
  
   // Record number of HLTCollectionLabels
   numOfHLTCollectionLabels = theHLTCollectionLabels.size();
 }

Friends And Related Function Documentation

friend class HistoFiller< l1extra::L1EmParticleCollection >

friend

Definition at line 68 of file EmDQM.h.

friend class HistoFiller< reco::ElectronCollection >

friend

Definition at line 66 of file EmDQM.h.

friend class HistoFiller< reco::RecoEcalCandidateCollection >

friend

Definition at line 67 of file EmDQM.h.

Member Data Documentation

bool EmDQM::autoConfMode_

private

Definition at line 97 of file EmDQM.h.

Referenced by analyze(), checkRecoParticlesRequirement(), dqmBeginRun(), and EmDQM().

std::string EmDQM::dirname_

private

Definition at line 88 of file EmDQM.h.

Referenced by bookHistograms(), and SetVarsFromPSet().

double EmDQM::eta2DMax_

private

Definition at line 111 of file EmDQM.h.

Referenced by bookHistograms(), and EmDQM().

std::vector<MonitorElement*> EmDQM::etagens

private

Definition at line 217 of file EmDQM.h.

Referenced by analyze(), and bookHistograms().

std::vector<std::vector<MonitorElement*> > EmDQM::etahistmatchs

private

Definition at line 203 of file EmDQM.h.

Referenced by bookHistograms().

std::vector<std::vector<MonitorElement*> > EmDQM::etahists

private

Definition at line 200 of file EmDQM.h.

Referenced by bookHistograms().

double EmDQM::etaMax_

private

Definition at line 108 of file EmDQM.h.

Referenced by bookHistograms(), and EmDQM().

std::vector<MonitorElement*> EmDQM::etaphigens

private

Definition at line 219 of file EmDQM.h.

Referenced by analyze(), and bookHistograms().

std::vector<std::vector<MonitorElement*> > EmDQM::etaphihistmatchs

private

Definition at line 210 of file EmDQM.h.

Referenced by bookHistograms().

std::vector<std::vector<MonitorElement*> > EmDQM::etaphihists

private

Definition at line 209 of file EmDQM.h.

Referenced by bookHistograms().

std::vector<MonitorElement*> EmDQM::etgens

private

Definition at line 216 of file EmDQM.h.

Referenced by analyze(), and bookHistograms().

std::vector<std::vector<MonitorElement*> > EmDQM::ethistmatchs

private

Definition at line 205 of file EmDQM.h.

Referenced by bookHistograms().

std::vector<std::vector<MonitorElement*> > EmDQM::ethists

private

Definition at line 202 of file EmDQM.h.

Referenced by bookHistograms().

unsigned int EmDQM::gencut_

private

number of generator level particles (electrons/photons) required (for MC)

Definition at line 185 of file EmDQM.h.

Referenced by analyze(), checkGeneratedParticlesRequirement(), checkRecoParticlesRequirement(), and SetVarsFromPSet().

edm::EDGetTokenT<edm::View<reco::Candidate> > EmDQM::gencutColl_fidDiGamma_token

private

Definition at line 232 of file EmDQM.h.

Referenced by analyze(), checkRecoParticlesRequirement(), and EmDQM().

edm::EDGetTokenT<edm::View<reco::Candidate> > EmDQM::gencutColl_fidGammaJet_token

private

Definition at line 231 of file EmDQM.h.

Referenced by analyze(), checkRecoParticlesRequirement(), and EmDQM().

edm::EDGetTokenT<edm::View<reco::Candidate> > EmDQM::gencutColl_fidTripleEle_token

private

Definition at line 230 of file EmDQM.h.

Referenced by analyze(), checkRecoParticlesRequirement(), and EmDQM().

edm::EDGetTokenT<edm::View<reco::Candidate> > EmDQM::gencutColl_fidWenu_token

private

Definition at line 228 of file EmDQM.h.

Referenced by analyze(), checkRecoParticlesRequirement(), and EmDQM().

edm::EDGetTokenT<edm::View<reco::Candidate> > EmDQM::gencutColl_fidZee_token

private

Definition at line 229 of file EmDQM.h.

Referenced by analyze(), checkRecoParticlesRequirement(), and EmDQM().

edm::EDGetTokenT<edm::View<reco::Candidate> > EmDQM::gencutColl_manualConf_token

private

Definition at line 233 of file EmDQM.h.

Referenced by analyze(), checkRecoParticlesRequirement(), and EmDQM().

edm::InputTag EmDQM::gencutCollection_

private

collection which should be used for generator particles (MC) or reconstructed particles (data).

This collection is used for matching the HLT objects against (e.g. match the HLT object to generated particles or reconstructed electrons/photons).

Definition at line 182 of file EmDQM.h.

Referenced by SetVarsFromPSet().

double EmDQM::genEtaAcc_

private

Definition at line 103 of file EmDQM.h.

Referenced by checkGeneratedParticlesRequirement(), and EmDQM().

double EmDQM::genEtAcc_

private

Definition at line 104 of file EmDQM.h.

Referenced by EmDQM().

edm::EDGetTokenT<edm::View<reco::Candidate> > EmDQM::genParticles_token

private

Definition at line 225 of file EmDQM.h.

Referenced by checkGeneratedParticlesRequirement(), and EmDQM().

std::vector<std::vector<MonitorElement*> > EmDQM::histEtaOfHltObjMatchToGens

private

Definition at line 207 of file EmDQM.h.

Referenced by bookHistograms().

std::vector<std::vector<MonitorElement*> > EmDQM::histEtaPhiOfHltObjMatchToGens

private

Definition at line 211 of file EmDQM.h.

Referenced by bookHistograms().

std::vector<std::vector<MonitorElement*> > EmDQM::histEtOfHltObjMatchToGens

private

Definition at line 206 of file EmDQM.h.

Referenced by bookHistograms().

HistoFiller<reco::RecoEcalCandidateCollection>* EmDQM::histoFillerClu

private

Definition at line 91 of file EmDQM.h.

Referenced by analyze(), and EmDQM().

HistoFiller<reco::ElectronCollection>* EmDQM::histoFillerEle

private

Definition at line 90 of file EmDQM.h.

Referenced by analyze(), and EmDQM().

HistoFiller<l1extra::L1EmParticleCollection>* EmDQM::histoFillerL1Iso

private

Definition at line 94 of file EmDQM.h.

Referenced by analyze(), and EmDQM().

HistoFiller<l1extra::L1EmParticleCollection>* EmDQM::histoFillerL1NonIso

private

Definition at line 92 of file EmDQM.h.

Referenced by analyze(), and EmDQM().

HistoFiller<reco::RecoEcalCandidateCollection>* EmDQM::histoFillerPho

private

Definition at line 93 of file EmDQM.h.

Referenced by analyze(), and EmDQM().

std::vector<std::vector<MonitorElement*> > EmDQM::histPhiOfHltObjMatchToGens

private

Definition at line 208 of file EmDQM.h.

Referenced by bookHistograms().

std::set<std::string> EmDQM::hltCollectionLabelsFound

private

Definition at line 189 of file EmDQM.h.

Referenced by analyze(), and dqmBeginRun().

std::vector<std::set<std::string> > EmDQM::hltCollectionLabelsFoundPerPath

private

which hltCollectionLabels were SEEN at least once

Definition at line 188 of file EmDQM.h.

Referenced by analyze(), dqmBeginRun(), and endRun().

std::set<std::string> EmDQM::hltCollectionLabelsMissed

private

Definition at line 193 of file EmDQM.h.

Referenced by analyze(), and dqmBeginRun().

std::vector<std::set<std::string> > EmDQM::hltCollectionLabelsMissedPerPath

private

which hltCollectionLabels were MISSED at least once

Definition at line 192 of file EmDQM.h.

Referenced by analyze(), dqmBeginRun(), and endRun().

HLTConfigProvider EmDQM::hltConfig_

private

The instance of the HLTConfigProvider as a data member.

Definition at line 135 of file EmDQM.h.

Referenced by analyze(), dqmBeginRun(), findEgammaPaths(), getFilterModules(), makePSetForEgammaGenericFilter(), makePSetForEgammaGenericQuadraticFilter(), makePSetForElectronGenericFilter(), makePSetForEtFilter(), makePSetForL1SeedToSuperClusterMatchFilter(), makePSetForOneOEMinusOneOPFilter(), and makePSetForPixelMatchFilter().

edm::EDGetTokenT<edm::TriggerResults> EmDQM::hltResults_token

private

Definition at line 227 of file EmDQM.h.

Referenced by analyze(), and EmDQM().

bool EmDQM::isData_

private

Definition at line 105 of file EmDQM.h.

Referenced by dqmBeginRun(), and EmDQM().

std::vector<std::vector<edm::InputTag> > EmDQM::isoNames

private

Definition at line 165 of file EmDQM.h.

Referenced by SetVarsFromPSet().

bool EmDQM::mcMatchedOnly_

private

Definition at line 116 of file EmDQM.h.

Referenced by analyze(), bookHistograms(), and EmDQM().

unsigned int EmDQM::minEtForEtaEffPlot_

private

Definition at line 114 of file EmDQM.h.

Referenced by analyze(), and EmDQM().

unsigned int EmDQM::nbins2D_

private

Definition at line 113 of file EmDQM.h.

Referenced by bookHistograms(), and EmDQM().

unsigned int EmDQM::nbins_

private

Definition at line 110 of file EmDQM.h.

Referenced by bookHistograms(), and EmDQM().

std::vector<unsigned int> EmDQM::nCandCuts

private

Definition at line 167 of file EmDQM.h.

Referenced by analyze(), and SetVarsFromPSet().

bool EmDQM::noIsolationPlots_

private

Definition at line 118 of file EmDQM.h.

Referenced by EmDQM(), and SetVarsFromPSet().

bool EmDQM::noPhiPlots_

private

Definition at line 117 of file EmDQM.h.

Referenced by analyze(), bookHistograms(), and EmDQM().

unsigned int EmDQM::numOfHLTCollectionLabels

private

Definition at line 160 of file EmDQM.h.

Referenced by analyze(), bookHistograms(), and SetVarsFromPSet().

const unsigned EmDQM::OUTPUT_ALL = 3

staticprivate

Definition at line 248 of file EmDQM.h.

Referenced by dqmBeginRun(), and endRun().

const unsigned EmDQM::OUTPUT_ERRORS = 1

staticprivate

Definition at line 246 of file EmDQM.h.

Referenced by analyze(), dqmBeginRun(), makePSetForEgammaGenericFilter(), makePSetForEgammaGenericQuadraticFilter(), and makePSetForElectronGenericFilter().

const unsigned EmDQM::OUTPUT_SILENT = 0

staticprivate

Definition at line 245 of file EmDQM.h.

const unsigned EmDQM::OUTPUT_WARNINGS = 2

staticprivate

Definition at line 247 of file EmDQM.h.

Referenced by analyze(), checkGeneratedParticlesRequirement(), checkRecoParticlesRequirement(), dqmBeginRun(), and endRun().

std::vector<edm::ParameterSet> EmDQM::paramSets

private

Definition at line 156 of file EmDQM.h.

Referenced by analyze(), bookHistograms(), dqmBeginRun(), EmDQM(), and endRun().

unsigned int EmDQM::pathIndex

private

Definition at line 158 of file EmDQM.h.

Referenced by analyze(), and SetVarsFromPSet().

int EmDQM::pdgGen

private

Definition at line 170 of file EmDQM.h.

Referenced by analyze(), bookHistograms(), checkGeneratedParticlesRequirement(), checkRecoParticlesRequirement(), and SetVarsFromPSet().

double EmDQM::phi2DMax_

private

Definition at line 112 of file EmDQM.h.

Referenced by bookHistograms(), and EmDQM().

std::vector<MonitorElement*> EmDQM::phigens

private

Definition at line 218 of file EmDQM.h.

Referenced by analyze(), and bookHistograms().

std::vector<std::vector<MonitorElement*> > EmDQM::phihistmatchs

private

Definition at line 204 of file EmDQM.h.

Referenced by bookHistograms().

std::vector<std::vector<MonitorElement*> > EmDQM::phihists

private

Definition at line 201 of file EmDQM.h.

Referenced by bookHistograms().

double EmDQM::phiMax_

private

Definition at line 109 of file EmDQM.h.

Referenced by bookHistograms(), and EmDQM().

std::vector<std::pair<double,double> > EmDQM::plotBounds

private

Definition at line 166 of file EmDQM.h.

Referenced by SetVarsFromPSet().

double EmDQM::plotEtMin

private

Definition at line 172 of file EmDQM.h.

Referenced by analyze(), checkGeneratedParticlesRequirement(), checkRecoParticlesRequirement(), and SetVarsFromPSet().

std::vector<bool> EmDQM::plotiso

private

Definition at line 164 of file EmDQM.h.

Referenced by SetVarsFromPSet().

double EmDQM::plotPtMax

private

Definition at line 174 of file EmDQM.h.

Referenced by bookHistograms(), and SetVarsFromPSet().

double EmDQM::plotPtMin

private

Definition at line 173 of file EmDQM.h.

Referenced by bookHistograms(), and SetVarsFromPSet().

const edm::ParameterSet& EmDQM::pset

private

Definition at line 99 of file EmDQM.h.

Referenced by EmDQM().

GreaterByPt<reco::Particle> EmDQM::pTComparator_

private

Definition at line 221 of file EmDQM.h.

Referenced by analyze().

GreaterByPt<reco::GenParticle> EmDQM::pTGenComparator_

private

Definition at line 222 of file EmDQM.h.

Referenced by checkGeneratedParticlesRequirement().

double EmDQM::ptMax_

private

Definition at line 106 of file EmDQM.h.

Referenced by dqmBeginRun(), and EmDQM().

double EmDQM::ptMin_

private

Definition at line 107 of file EmDQM.h.

Referenced by dqmBeginRun(), and EmDQM().

unsigned int EmDQM::reqNum

private

Definition at line 169 of file EmDQM.h.

Referenced by analyze(), checkRecoParticlesRequirement(), and SetVarsFromPSet().

std::vector<std::string> EmDQM::theHLTCollectionHumanNames

private

Definition at line 161 of file EmDQM.h.

Referenced by bookHistograms(), and SetVarsFromPSet().

std::vector<edm::InputTag> EmDQM::theHLTCollectionLabels

private

Definition at line 159 of file EmDQM.h.

Referenced by analyze(), bookHistograms(), and SetVarsFromPSet().

std::vector<int> EmDQM::theHLTOutputTypes

private

Definition at line 163 of file EmDQM.h.

Referenced by analyze(), and SetVarsFromPSet().

edm::InputTag EmDQM::theL1Seed

private

Definition at line 162 of file EmDQM.h.

std::vector<MonitorElement*> EmDQM::totalmatchs

private

Definition at line 214 of file EmDQM.h.

Referenced by analyze(), and bookHistograms().

std::vector<MonitorElement*> EmDQM::totals

private

Definition at line 213 of file EmDQM.h.

Referenced by analyze(), and bookHistograms().

edm::InputTag EmDQM::triggerObject_

private

Definition at line 101 of file EmDQM.h.

Referenced by analyze(), dqmBeginRun(), EmDQM(), makePSetForEgammaDoubleEtDeltaPhiFilter(), makePSetForEgammaGenericFilter(), makePSetForEgammaGenericQuadraticFilter(), makePSetForElectronGenericFilter(), makePSetForEtFilter(), makePSetForL1SeedFilter(), makePSetForL1SeedToSuperClusterMatchFilter(), makePSetForOneOEMinusOneOPFilter(), and makePSetForPixelMatchFilter().

edm::EDGetTokenT<trigger::TriggerEventWithRefs> EmDQM::triggerObject_token

private

Definition at line 226 of file EmDQM.h.

Referenced by analyze(), and EmDQM().

const unsigned EmDQM::TYPE_DOUBLE_ELE = 1

staticprivate

Definition at line 239 of file EmDQM.h.

Referenced by dqmBeginRun(), and findEgammaPaths().

const unsigned EmDQM::TYPE_DOUBLE_PHOTON = 3

staticprivate

Definition at line 241 of file EmDQM.h.

Referenced by dqmBeginRun(), and findEgammaPaths().

const unsigned EmDQM::TYPE_SINGLE_ELE = 0

staticprivate

Definition at line 238 of file EmDQM.h.

Referenced by dqmBeginRun(), and findEgammaPaths().

const unsigned EmDQM::TYPE_SINGLE_PHOTON = 2

staticprivate

Definition at line 240 of file EmDQM.h.

Referenced by dqmBeginRun(), and findEgammaPaths().

const unsigned EmDQM::TYPE_TRIPLE_ELE = 4

staticprivate

Definition at line 242 of file EmDQM.h.

Referenced by dqmBeginRun(), and findEgammaPaths().

bool EmDQM::useHumanReadableHistTitles_

private

Definition at line 115 of file EmDQM.h.

Referenced by bookHistograms(), and EmDQM().

unsigned int EmDQM::verbosity_

private

Definition at line 102 of file EmDQM.h.

Referenced by analyze(), checkGeneratedParticlesRequirement(), checkRecoParticlesRequirement(), dqmBeginRun(), EmDQM(), endRun(), makePSetForEgammaGenericFilter(), makePSetForEgammaGenericQuadraticFilter(), and makePSetForElectronGenericFilter().

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation