EmDQM Class Reference

#include <EmDQM.h>

Inheritance diagram for EmDQM:

Public Member Functions
void	analyze (const edm::Event &event, const edm::EventSetup &) override
void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
void	dqmBeginRun (edm::Run const &, edm::EventSetup const &) override
void	dqmEndRun (edm::Run const &, edm::EventSetup const &) override
	EmDQM (const edm::ParameterSet &pset)
	Constructor. More...
	~EmDQM () override
	Destructor. More...
Public Member Functions inherited from DQMOneEDAnalyzer<>
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) override
void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final
	DQMOneEDAnalyzer ()
void	endRun (edm::Run const &, edm::EventSetup const &) final
void	endRunProduce (edm::Run &run, edm::EventSetup const &setup) final
virtual bool	getCanSaveByLumi ()
Public Member Functions inherited from edm::one::EDProducer< edm::EndRunProducer, edm::one::WatchRuns, edm::Accumulator, Args... >
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
SerialTaskQueue *	globalLuminosityBlocksQueue () final
SerialTaskQueue *	globalRunsQueue () final
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete
bool	wantsGlobalLuminosityBlocks () const final
bool	wantsGlobalRuns () const final
bool	wantsInputProcessBlocks () const final
bool	wantsProcessBlocks () const final
Public Member Functions inherited from edm::one::EDProducerBase
	EDProducerBase ()
ModuleDescription const &	moduleDescription () const
bool	wantsStreamLuminosityBlocks () const
bool	wantsStreamRuns () const
	~EDProducerBase () override
Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const
	ProducerBase ()
std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const
std::vector< bool > const &	recordProvenanceList () const
void	registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...
void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)
TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...
	~ProducerBase () noexcept(false) override
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...
	EDConsumerBase ()
	EDConsumerBase (EDConsumerBase const &)=delete
	EDConsumerBase (EDConsumerBase &&)=default
ESResolverIndex const *	esGetTokenIndices (edm::Transition iTrans) const
std::vector< ESResolverIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const
std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const
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::array< std::vector< ModuleDescription const *> *, NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, 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
void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)
ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &)
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
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 DQMOneEDAnalyzer<>
typedef dqm::reco::DQMStore	DQMStore
typedef dqm::reco::MonitorElement	MonitorElement
Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase	ModuleType
Public Types inherited from edm::ProducerBase
template<typename T >
using	BranchAliasSetterT = ProductRegistryHelper::BranchAliasSetterT< T >
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const *, const char *, edm::ProductResolverIndex > >
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Static Public Member Functions inherited from edm::one::EDProducerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
Protected Member Functions inherited from edm::ProducerBase
template<Transition Tr = Transition::Event>
auto	produces (std::string instanceName) noexcept
	declare what type of product will make and with which optional label More...
template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)
template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)
template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)
template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()
template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)
template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()
template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)
template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()
template<Transition Tr = Transition::Event>
auto	produces () noexcept
ProducesCollector	producesCollector ()
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept
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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)
template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()
template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)
template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...
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)
void	resetItemsToGetFrom (BranchType iType)
Protected Attributes inherited from DQMOneEDAnalyzer<>
edm::EDPutTokenT< DQMToken >	runToken_

Detailed Description

Definition at line 63 of file EmDQM.h.

Constructor & Destructor Documentation

EmDQM()

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

explicit

Constructor.

Definition at line 11 of file EmDQM.cc.

References ProducerED_cfi::InputTag, and muonDTDigis_cfi::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::~EmDQM ( )

override

Destructor.

Definition at line 603 of file EmDQM.cc.

{}

Member Function Documentation

analyze()

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

overridevirtual

Reimplemented from DQMOneEDAnalyzer<>.

Definition at line 733 of file EmDQM.cc.

References EgHLTOffHistBins_cfi::et, PVValHelper::eta, JetHT_cfg::hltResults, mps_fire::i, createfilelist::int, edm::HandleBase::isValid(), dqmiodumpmetadata::n, doubleEle5SWL1RDQM_cfi::pdgGen, phi, electronDQMIsoDist_cfi::reqNum, jetUpdater_cfi::sort, photon_test_cff::theHLTCollectionLabels, electronDQMIsoDist_cfi::theHLTOutputTypes, trigger::TriggerCluster, trigger::TriggerElectron, trigger::TriggerL1IsoEG, trigger::TriggerL1NoIsoEG, and trigger::TriggerPhoton.

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

bookHistograms()

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

overridevirtual

Implements DQMOneEDAnalyzer<>.

Definition at line 376 of file EmDQM.cc.

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), B2GTnPMonitor_cfi::histTitle, mps_fire::i, label, doubleEle5SWL1RDQM_cfi::pdgGen, dqm::impl::MonitorElement::setBinLabel(), dqm::implementation::NavigatorBase::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, photon_test_cff::theHLTCollectionLabels, and dqmMemoryStats::total.

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

checkGeneratedParticlesRequirement()

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 606 of file EmDQM.cc.

References funct::abs(), reco::LeafCandidate::et(), PVValHelper::eta, AJJGenJetFilter_cfi::genParticles, mps_fire::i, doubleEle5SWL1RDQM_cfi::pdgGen, and jetUpdater_cfi::sort.

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

checkRecoParticlesRequirement()

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 669 of file EmDQM.cc.

References edm::HandleBase::isValid(), doubleEle5SWL1RDQM_cfi::pdgGen, and electronDQMIsoDist_cfi::reqNum.

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

countSubstring()

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

private

Definition at line 1118 of file EmDQM.cc.

References submitPVResolutionJobs::count, hltrates_dqm_sourceclient-live_cfg::offset, and str.

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

dqmBeginRun()

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

overridevirtual

Reimplemented from DQMOneEDAnalyzer<>.

Definition at line 64 of file EmDQM.cc.

References edm::ParameterSet::addParameter(), edm::ParameterSet::addUntrackedParameter(), reco::ceil(), edm::ParameterSet::empty(), ALCARECOTkAlBeamHalo_cff::filter, EgammaHLTValidationUtils::findEgammaPaths(), HLT_Ele8_CaloIdT_TrkIdVL_DQM_cfi::genEtMin, edm::ParameterSet::getParameter(), mps_fire::i, ProducerED_cfi::InputTag, dqmiolumiharvest::j, label, EgammaHLTValidationUtils::makePSetForEgammaGenericFilter(), EgammaHLTValidationUtils::makePSetForElectronGenericFilter(), EgammaHLTValidationUtils::makePSetForEtFilter(), EgammaHLTValidationUtils::makePSetForL1SeedFilter(), EgammaHLTValidationUtils::makePSetForL1SeedToSuperClusterMatchFilter(), EgammaHLTValidationUtils::makePSetForOneOEMinusOneOPFilter(), EgammaHLTValidationUtils::makePSetForPixelMatchFilter(), HerwigMaxPtPartonFilter_cfi::moduleLabel, hltMonBTagIPClient_cfi::pathName, AlignmentTrackSelector_cfi::ptMax, ptMin, AlCaHLTBitMon_QueryRunRegistry::string, and trigger::TriggerPhoton.

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

dqmEndRun()

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

overridevirtual

Reimplemented from DQMOneEDAnalyzer<>.

Definition at line 1078 of file EmDQM.cc.

References getBeamSpotDB::atag, submitPVResolutionJobs::count, ProducerED_cfi::InputTag, jetUpdater_cfi::sort, and makeGlobalPositionRcd_cfg::tag.

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

    for (const auto &tag : hltCollectionLabelsMissedPerPath.at(vPos)) {
      auto atag = edm::InputTag(tag);
      if ((hltCollectionLabelsFoundPerPath.at(vPos)).count(atag.encode()) == 0)
        // never found
        labelsNeverFound.push_back(atag.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:";

    for (auto const &tag : labelsNeverFound) {
      if (verbosity_ >= OUTPUT_ALL)
        edm::LogPrint("EmDQM") << "  " << tag;
    }
  }
}

findEgammaPaths()

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

private

Definition at line 1130 of file EmDQM.cc.

References mps_fire::i, castor_dqm_sourceclient_file_cfg::path, HLTTauDQMOffline_cfi::Paths, and AlCaHLTBitMon_QueryRunRegistry::string.

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

getFilterModules()

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

private

Definition at line 1186 of file EmDQM.cc.

References filters, mps_fire::i, castor_dqm_sourceclient_file_cfg::path, and AlCaHLTBitMon_QueryRunRegistry::string.

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

getPrimaryEtCut()

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

private

Definition at line 1211 of file EmDQM.cc.

References EgHLTOffEleSelection_cfi::minEt, and castor_dqm_sourceclient_file_cfg::path.

                                                   {
  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 = std::stod(what[2]);
  }

  return minEt;
}

makePSetForEgammaDoubleEtDeltaPhiFilter()

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

private

Definition at line 1362 of file EmDQM.cc.

References edm::ParameterSet::addParameter(), ProducerED_cfi::InputTag, EcalCalibMonitorClient_cfi::moduleName, AlCaHLTBitMon_QueryRunRegistry::string, and trigger::TriggerCluster.

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

makePSetForEgammaGenericFilter()

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

private

Definition at line 1379 of file EmDQM.cc.

References edm::ParameterSet::addParameter(), ProducerED_cfi::InputTag, EcalCalibMonitorClient_cfi::moduleName, AlCaHLTBitMon_QueryRunRegistry::string, trigger::TriggerCluster, trigger::TriggerPhoton, and HLT_2024v10_cff::varTag.

                                                                                 {
  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 == "EgammaHLTR9IDProducer" ||                      // R9 ID
      inputType == "EgammaHLTClusterShapeProducer" ||              // cluster shape
      inputType == "EgammaHLTGsfTrackVarProducer" ||               // GSF track deta and dphi filter
      inputType == "EgammaHLTBcHcalIsolationProducersRegional" ||  // HCAL isolation, or H for H/E (based on CaloTowers)
      inputType == "EgammaHLTHcalVarProducerFromRecHit" ||         // HCAL isolation, or H for H/E (based on RecHits)
      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();
}

makePSetForEgammaGenericQuadraticFilter()

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

private

Definition at line 1464 of file EmDQM.cc.

References edm::ParameterSet::addParameter(), ProducerED_cfi::InputTag, EcalCalibMonitorClient_cfi::moduleName, AlCaHLTBitMon_QueryRunRegistry::string, trigger::TriggerCluster, trigger::TriggerPhoton, and HLT_2024v10_cff::varTag.

                                                                                          {
  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 == "EgammaHLTR9IDProducer" ||                      // R9 ID
      inputType == "EgammaHLTClusterShapeProducer" ||              // cluster shape
      inputType == "EgammaHLTBcHcalIsolationProducersRegional" ||  // HCAL isolation, or H for H/E (based on CaloTowers)
      inputType == "EgammaHLTHcalVarProducerFromRecHit" ||         // HCAL isolation, or H for H/E (based on RecHits)
      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();
}

makePSetForElectronGenericFilter()

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

private

Definition at line 1547 of file EmDQM.cc.

References edm::ParameterSet::addParameter(), ProducerED_cfi::InputTag, EcalCalibMonitorClient_cfi::moduleName, AlCaHLTBitMon_QueryRunRegistry::string, trigger::TriggerElectron, and HLT_2024v10_cff::varTag.

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

makePSetForEtFilter()

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

private

Definition at line 1311 of file EmDQM.cc.

References edm::ParameterSet::addParameter(), ProducerED_cfi::InputTag, EcalCalibMonitorClient_cfi::moduleName, AlCaHLTBitMon_QueryRunRegistry::string, and trigger::TriggerCluster.

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

makePSetForL1SeedFilter()

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

private

Definition at line 1226 of file EmDQM.cc.

References edm::ParameterSet::addParameter(), ProducerED_cfi::InputTag, EcalCalibMonitorClient_cfi::moduleName, AlCaHLTBitMon_QueryRunRegistry::string, and trigger::TriggerL1NoIsoEG.

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

makePSetForL1SeedToSuperClusterMatchFilter()

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

private

Definition at line 1288 of file EmDQM.cc.

References edm::ParameterSet::addParameter(), ProducerED_cfi::InputTag, EcalCalibMonitorClient_cfi::moduleName, AlCaHLTBitMon_QueryRunRegistry::string, and trigger::TriggerCluster.

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

makePSetForOneOEMinusOneOPFilter()

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

private

Definition at line 1328 of file EmDQM.cc.

References edm::ParameterSet::addParameter(), ProducerED_cfi::InputTag, EcalCalibMonitorClient_cfi::moduleName, AlCaHLTBitMon_QueryRunRegistry::string, and trigger::TriggerElectron.

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

makePSetForPixelMatchFilter()

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

private

Definition at line 1345 of file EmDQM.cc.

References edm::ParameterSet::addParameter(), ProducerED_cfi::InputTag, EcalCalibMonitorClient_cfi::moduleName, AlCaHLTBitMon_QueryRunRegistry::string, and trigger::TriggerCluster.

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

SetVarsFromPSet()

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

private

Definition at line 1621 of file EmDQM.cc.

References cms::cuda::assert(), filters, mps_fire::i, doubleEle5SWL1RDQM_cfi::pdgGen, electronDQMIsoDist_cfi::reqNum, AlCaHLTBitMon_QueryRunRegistry::string, photon_test_cff::theHLTCollectionLabels, and electronDQMIsoDist_cfi::theHLTOutputTypes.

                                                                     {
  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

HistoFiller< l1extra::L1EmParticleCollection >

friend class HistoFiller< l1extra::L1EmParticleCollection >

friend

Definition at line 67 of file EmDQM.h.

HistoFiller< reco::ElectronCollection >

friend class HistoFiller< reco::ElectronCollection >

friend

Definition at line 65 of file EmDQM.h.

HistoFiller< reco::RecoEcalCandidateCollection >

friend class HistoFiller< reco::RecoEcalCandidateCollection >

friend

Definition at line 66 of file EmDQM.h.

Member Data Documentation

autoConfMode_

bool EmDQM::autoConfMode_

private

Definition at line 94 of file EmDQM.h.

dirname_

std::string EmDQM::dirname_

private

Definition at line 85 of file EmDQM.h.

eta2DMax_

double EmDQM::eta2DMax_

private

Definition at line 106 of file EmDQM.h.

etagens

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

private

Definition at line 212 of file EmDQM.h.

etahistmatchs

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

private

Definition at line 198 of file EmDQM.h.

etahists

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

private

Definition at line 195 of file EmDQM.h.

etaMax_

double EmDQM::etaMax_

private

Definition at line 103 of file EmDQM.h.

etaphigens

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

private

Definition at line 214 of file EmDQM.h.

etaphihistmatchs

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

private

Definition at line 205 of file EmDQM.h.

etaphihists

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

private

Definition at line 204 of file EmDQM.h.

etgens

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

private

Definition at line 211 of file EmDQM.h.

ethistmatchs

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

private

Definition at line 200 of file EmDQM.h.

ethists

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

private

Definition at line 197 of file EmDQM.h.

gencut_

unsigned int EmDQM::gencut_

private

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

Definition at line 181 of file EmDQM.h.

gencutColl_fidDiGamma_token

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

private

Definition at line 227 of file EmDQM.h.

gencutColl_fidGammaJet_token

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

private

Definition at line 226 of file EmDQM.h.

gencutColl_fidTripleEle_token

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

private

Definition at line 225 of file EmDQM.h.

gencutColl_fidWenu_token

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

private

Definition at line 223 of file EmDQM.h.

gencutColl_fidZee_token

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

private

Definition at line 224 of file EmDQM.h.

gencutColl_manualConf_token

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

private

Definition at line 228 of file EmDQM.h.

gencutCollection_

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 177 of file EmDQM.h.

genEtaAcc_

double EmDQM::genEtaAcc_

private

Definition at line 98 of file EmDQM.h.

genEtAcc_

double EmDQM::genEtAcc_

private

Definition at line 99 of file EmDQM.h.

genParticles_token

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

private

Definition at line 220 of file EmDQM.h.

histEtaOfHltObjMatchToGens

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

private

Definition at line 202 of file EmDQM.h.

histEtaPhiOfHltObjMatchToGens

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

private

Definition at line 206 of file EmDQM.h.

histEtOfHltObjMatchToGens

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

private

Definition at line 201 of file EmDQM.h.

histoFillerClu

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

private

Definition at line 88 of file EmDQM.h.

histoFillerEle

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

private

Definition at line 87 of file EmDQM.h.

histoFillerL1Iso

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

private

Definition at line 91 of file EmDQM.h.

histoFillerL1NonIso

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

private

Definition at line 89 of file EmDQM.h.

histoFillerPho

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

private

Definition at line 90 of file EmDQM.h.

histPhiOfHltObjMatchToGens

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

private

Definition at line 203 of file EmDQM.h.

hltCollectionLabelsFound

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

private

Definition at line 185 of file EmDQM.h.

hltCollectionLabelsFoundPerPath

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

private

which hltCollectionLabels were SEEN at least once

Definition at line 184 of file EmDQM.h.

hltCollectionLabelsMissed

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

private

Definition at line 189 of file EmDQM.h.

hltCollectionLabelsMissedPerPath

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

private

which hltCollectionLabels were MISSED at least once

Definition at line 188 of file EmDQM.h.

hltConfig_

HLTConfigProvider EmDQM::hltConfig_

private

The instance of the HLTConfigProvider as a data member.

Definition at line 130 of file EmDQM.h.

hltResults_token

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

private

Definition at line 222 of file EmDQM.h.

isData_

bool EmDQM::isData_

private

Definition at line 100 of file EmDQM.h.

isoNames

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

private

Definition at line 160 of file EmDQM.h.

mcMatchedOnly_

bool EmDQM::mcMatchedOnly_

private

Definition at line 111 of file EmDQM.h.

minEtForEtaEffPlot_

unsigned int EmDQM::minEtForEtaEffPlot_

private

Definition at line 109 of file EmDQM.h.

nbins2D_

unsigned int EmDQM::nbins2D_

private

Definition at line 108 of file EmDQM.h.

nbins_

unsigned int EmDQM::nbins_

private

Definition at line 105 of file EmDQM.h.

nCandCuts

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

private

Definition at line 162 of file EmDQM.h.

noIsolationPlots_

bool EmDQM::noIsolationPlots_

private

Definition at line 113 of file EmDQM.h.

noPhiPlots_

bool EmDQM::noPhiPlots_

private

Definition at line 112 of file EmDQM.h.

numOfHLTCollectionLabels

unsigned int EmDQM::numOfHLTCollectionLabels

private

Definition at line 155 of file EmDQM.h.

OUTPUT_ALL

const unsigned EmDQM::OUTPUT_ALL = 3

staticprivate

Definition at line 243 of file EmDQM.h.

OUTPUT_ERRORS

const unsigned EmDQM::OUTPUT_ERRORS = 1

staticprivate

Definition at line 241 of file EmDQM.h.

OUTPUT_SILENT

const unsigned EmDQM::OUTPUT_SILENT = 0

staticprivate

Definition at line 240 of file EmDQM.h.

OUTPUT_WARNINGS

const unsigned EmDQM::OUTPUT_WARNINGS = 2

staticprivate

Definition at line 242 of file EmDQM.h.

paramSets

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

private

Definition at line 151 of file EmDQM.h.

pathIndex

unsigned int EmDQM::pathIndex

private

Definition at line 153 of file EmDQM.h.

pdgGen

int EmDQM::pdgGen

private

Definition at line 165 of file EmDQM.h.

phi2DMax_

double EmDQM::phi2DMax_

private

Definition at line 107 of file EmDQM.h.

phigens

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

private

Definition at line 213 of file EmDQM.h.

phihistmatchs

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

private

Definition at line 199 of file EmDQM.h.

phihists

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

private

Definition at line 196 of file EmDQM.h.

phiMax_

double EmDQM::phiMax_

private

Definition at line 104 of file EmDQM.h.

plotBounds

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

private

Definition at line 161 of file EmDQM.h.

plotEtMin

double EmDQM::plotEtMin

private

Definition at line 167 of file EmDQM.h.

plotiso

std::vector<bool> EmDQM::plotiso

private

Definition at line 159 of file EmDQM.h.

plotPtMax

double EmDQM::plotPtMax

private

Definition at line 169 of file EmDQM.h.

plotPtMin

double EmDQM::plotPtMin

private

Definition at line 168 of file EmDQM.h.

pTComparator_

GreaterByPt<reco::Particle> EmDQM::pTComparator_

private

Definition at line 216 of file EmDQM.h.

pTGenComparator_

GreaterByPt<reco::GenParticle> EmDQM::pTGenComparator_

private

Definition at line 217 of file EmDQM.h.

ptMax_

double EmDQM::ptMax_

private

Definition at line 101 of file EmDQM.h.

ptMin_

double EmDQM::ptMin_

private

Definition at line 102 of file EmDQM.h.

reqNum

unsigned int EmDQM::reqNum

private

Definition at line 164 of file EmDQM.h.

theHLTCollectionHumanNames

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

private

Definition at line 156 of file EmDQM.h.

theHLTCollectionLabels

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

private

Definition at line 154 of file EmDQM.h.

theHLTOutputTypes

std::vector<int> EmDQM::theHLTOutputTypes

private

Definition at line 158 of file EmDQM.h.

theL1Seed

edm::InputTag EmDQM::theL1Seed

private

Definition at line 157 of file EmDQM.h.

totalmatchs

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

private

Definition at line 209 of file EmDQM.h.

totals

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

private

Definition at line 208 of file EmDQM.h.

triggerObject_

edm::InputTag EmDQM::triggerObject_

private

Definition at line 96 of file EmDQM.h.

triggerObject_token

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

private

Definition at line 221 of file EmDQM.h.

TYPE_DOUBLE_ELE

const unsigned EmDQM::TYPE_DOUBLE_ELE = 1

staticprivate

Definition at line 234 of file EmDQM.h.

TYPE_DOUBLE_PHOTON

const unsigned EmDQM::TYPE_DOUBLE_PHOTON = 3

staticprivate

Definition at line 236 of file EmDQM.h.

TYPE_SINGLE_ELE

const unsigned EmDQM::TYPE_SINGLE_ELE = 0

staticprivate

Definition at line 233 of file EmDQM.h.

TYPE_SINGLE_PHOTON

const unsigned EmDQM::TYPE_SINGLE_PHOTON = 2

staticprivate

Definition at line 235 of file EmDQM.h.

TYPE_TRIPLE_ELE

const unsigned EmDQM::TYPE_TRIPLE_ELE = 4

staticprivate

Definition at line 237 of file EmDQM.h.

useHumanReadableHistTitles_

bool EmDQM::useHumanReadableHistTitles_

private

Definition at line 110 of file EmDQM.h.

verbosity_

unsigned int EmDQM::verbosity_

private

Definition at line 97 of file EmDQM.h.