#include <TopSingleLeptonDQM.h>

Public Types
enum	Level { STANDARD, VERBOSE, DEBUG }
	different verbosity levels More...

Public Member Functions
void	book (DQMStore::IBooker &ibooker)
	book histograms in subdirectory directory More...

void	fill (const edm::Event &event, const edm::EventSetup &setup)
	fill monitor histograms with electronId and jetCorrections More...

	MonitorEnsemble (const char *label, const edm::ParameterSet &cfg, edm::ConsumesCollector &&iC)
	default contructor More...

	~MonitorEnsemble ()
	default destructor More...

Private Member Functions
bool	booked (const std::string histName) const
	check if histogram was booked More...

void	fill (const edm::Event &event, const edm::TriggerResults &triggerTable, std::string channel, const std::vector< std::string > labels) const
	fill trigger monitoring histograms More...

void	fill (const std::string histName, double value) const
	fill histogram if it had been booked before More...

void	fill (const std::string histName, double xValue, double yValue) const
	fill histogram if it had been booked before (2-dim version) More...

void	fill (const std::string histName, double xValue, double yValue, double zValue) const
	fill histogram if it had been booked before (2-dim version) More...

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

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

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

Private Attributes
edm::EDGetTokenT< reco::JetTagCollection >	btagCSV_

double	btagCSVWP_

edm::EDGetTokenT< reco::JetTagCollection >	btagEff_
	btag discriminator labels More...

double	btagEffWP_
	btag working points More...

edm::EDGetTokenT< reco::JetTagCollection >	btagPur_

double	btagPurWP_

edm::EDGetTokenT< reco::JetTagCollection >	btagVtx_

double	btagVtxWP_

std::string	directory_

double	eidCutValue_

edm::EDGetTokenT< edm::View< reco::PFCandidate > >	elecs_

std::unique_ptr< StringCutObjectSelector< reco::PFCandidate > >	elecSelect_
	extra selection on electrons More...

edm::EDGetTokenT< edm::ValueMap< float > >	electronId_
	electronId label More...

std::map< std::string, MonitorElement * >	hists_
	histogram container More...

bool	includeBTag_

std::string	jetCorrector_
	jetCorrector More...

edm::EDGetTokenT< reco::JetIDValueMap >	jetIDLabel_
	jetID as an extra selection type More...

std::unique_ptr< StringCutObjectSelector< reco::JetID > >	jetIDSelect_

std::unique_ptr< StringCutObjectSelector< reco::PFJet > >	jetlooseSelection_

edm::EDGetTokenT< edm::View< reco::Jet > >	jets_
	input sources for monitoring More...

std::string	jetSelect_
	extra selection on jets More...

std::unique_ptr< StringCutObjectSelector< reco::PFJet > >	jetSelection_

std::string	label_
	instance label More...

int	logged_
	number of logged interesting events More...

double	lowerEdge_
	mass window upper and lower edge More...

std::vector< edm::EDGetTokenT< edm::View< reco::MET > > >	mets_
	considers a vector of METs More...

edm::EDGetTokenT< reco::JetCorrector >	mJetCorrector

std::unique_ptr< StringCutObjectSelector< reco::PFCandidate > >	muonIso_
	extra isolation criterion on muon More...

edm::EDGetTokenT< edm::View< reco::PFCandidate > >	muons_

std::unique_ptr< StringCutObjectSelector< reco::PFCandidate > >	muonSelect_
	extra selection on muons More...

edm::EDGetTokenT< edm::View< reco::Vertex > >	pvs_

std::unique_ptr< StringCutObjectSelector< reco::Vertex > >	pvSelect_

edm::InputTag	rhoTag

edm::EDConsumerBase	tmpConsumerBase

std::vector< std::string >	triggerPaths_

edm::EDGetTokenT< edm::TriggerResults >	triggerTable_
	trigger table More...

double	upperEdge_

Level	verbosity_
	verbosity level for booking More...

Detailed Description

Definition at line 53 of file TopSingleLeptonDQM.h.

Member Enumeration Documentation

◆ Level

enum TopSingleLepton::MonitorEnsemble::Level

different verbosity levels

Enumerator
STANDARD
VERBOSE
DEBUG

Definition at line 56 of file TopSingleLeptonDQM.h.

56 { STANDARD, VERBOSE, DEBUG };

Constructor & Destructor Documentation

◆ MonitorEnsemble()

MonitorEnsemble::MonitorEnsemble	(	const char *	label,
		const edm::ParameterSet &	cfg,
		edm::ConsumesCollector &&	iC
	)

default contructor

Definition at line 22 of file TopSingleLeptonDQM.cc.

       : label_(label),
         elecSelect_(nullptr),
         pvSelect_(nullptr),
         muonIso_(nullptr),
         muonSelect_(nullptr),
         jetIDSelect_(nullptr),
         jetlooseSelection_(nullptr),
         jetSelection_(nullptr),
         includeBTag_(false),
         lowerEdge_(-1.),
         upperEdge_(-1.),
         logged_(0) {
     // sources have to be given; this PSet is not optional
     edm::ParameterSet sources = cfg.getParameter<edm::ParameterSet>("sources");
     muons_ = iC.consumes<edm::View<reco::PFCandidate>>(sources.getParameter<edm::InputTag>("muons"));
     elecs_ = iC.consumes<edm::View<reco::PFCandidate>>(sources.getParameter<edm::InputTag>("elecs"));
     pvs_ = iC.consumes<edm::View<reco::Vertex>>(sources.getParameter<edm::InputTag>("pvs"));
     jets_ = iC.consumes<edm::View<reco::Jet>>(sources.getParameter<edm::InputTag>("jets"));
     for (edm::InputTag const& tag : sources.getParameter<std::vector<edm::InputTag>>("mets"))
       mets_.push_back(iC.consumes<edm::View<reco::MET>>(tag));
     // electronExtras are optional; they may be omitted or
     // empty
     if (cfg.existsAs<edm::ParameterSet>("elecExtras")) {
       // rho for PF isolation with EA corrections
       // eventrhoToken_ =
       // iC.consumes<double>(edm::InputTag("fixedGridRhoFastjetAll"));
  
       edm::ParameterSet elecExtras = cfg.getParameter<edm::ParameterSet>("elecExtras");
       // select is optional; in case it's not found no
       // selection will be applied
       if (elecExtras.existsAs<std::string>("select")) {
         elecSelect_.reset(
             new StringCutObjectSelector<reco::PFCandidate>(elecExtras.getParameter<std::string>("select")));
       }
  
       if (elecExtras.existsAs<std::string>("rho")) {
         rhoTag = elecExtras.getParameter<edm::InputTag>("rho");
       }
       // electronId is optional; in case it's not found the
       // InputTag will remain empty
       if (elecExtras.existsAs<edm::ParameterSet>("electronId")) {
         edm::ParameterSet elecId = elecExtras.getParameter<edm::ParameterSet>("electronId");
         electronId_ = iC.consumes<edm::ValueMap<float>>(elecId.getParameter<edm::InputTag>("src"));
         eidCutValue_ = elecId.getParameter<double>("cutValue");
       }
     }
     // pvExtras are optional; they may be omitted or empty
     if (cfg.existsAs<edm::ParameterSet>("pvExtras")) {
       edm::ParameterSet pvExtras = cfg.getParameter<edm::ParameterSet>("pvExtras");
       // select is optional; in case it's not found no
       // selection will be applied
       if (pvExtras.existsAs<std::string>("select")) {
         pvSelect_.reset(new StringCutObjectSelector<reco::Vertex>(pvExtras.getParameter<std::string>("select")));
       }
     }
     // muonExtras are optional; they may be omitted or empty
     if (cfg.existsAs<edm::ParameterSet>("muonExtras")) {
       edm::ParameterSet muonExtras = cfg.getParameter<edm::ParameterSet>("muonExtras");
       // select is optional; in case it's not found no
       // selection will be applied
       if (muonExtras.existsAs<std::string>("select")) {
         muonSelect_.reset(
             new StringCutObjectSelector<reco::PFCandidate>(muonExtras.getParameter<std::string>("select")));
       }
       // isolation is optional; in case it's not found no
       // isolation will be applied
       if (muonExtras.existsAs<std::string>("isolation")) {
         muonIso_.reset(
             new StringCutObjectSelector<reco::PFCandidate>(muonExtras.getParameter<std::string>("isolation")));
       }
     }
  
     // jetExtras are optional; they may be omitted or
     // empty
     if (cfg.existsAs<edm::ParameterSet>("jetExtras")) {
       edm::ParameterSet jetExtras = cfg.getParameter<edm::ParameterSet>("jetExtras");
       // jetCorrector is optional; in case it's not found
       // the InputTag will remain empty
       if (jetExtras.existsAs<edm::InputTag>("jetCorrector")) {
         mJetCorrector = iC.consumes<reco::JetCorrector>(jetExtras.getParameter<edm::InputTag>("jetCorrector"));
       }
       // read jetID information if it exists
       if (jetExtras.existsAs<edm::ParameterSet>("jetID")) {
         edm::ParameterSet jetID = jetExtras.getParameter<edm::ParameterSet>("jetID");
         jetIDLabel_ = iC.consumes<reco::JetIDValueMap>(jetID.getParameter<edm::InputTag>("label"));
         jetIDSelect_.reset(new StringCutObjectSelector<reco::JetID>(jetID.getParameter<std::string>("select")));
       }
       // select is optional; in case it's not found no
       // selection will be applied (only implemented for
       // CaloJets at the moment)
       if (jetExtras.existsAs<std::string>("select")) {
         jetSelect_ = jetExtras.getParameter<std::string>("select");
         jetSelection_.reset(new StringCutObjectSelector<reco::PFJet>(jetSelect_));
         jetlooseSelection_.reset(new StringCutObjectSelector<reco::PFJet>(
             "chargedHadronEnergyFraction()>0 && chargedMultiplicity()>0 && chargedEmEnergyFraction()<0.99 && "
             "neutralHadronEnergyFraction()<0.99 && neutralEmEnergyFraction()<0.99 && "
             "(chargedMultiplicity()+neutralMultiplicity())>1"));
       }
       // jetBDiscriminators are optional; in case they are
       // not found the InputTag will remain empty; they
       // consist of pairs of edm::JetFlavorAssociation's &
       // corresponding working points
       includeBTag_ = jetExtras.existsAs<edm::ParameterSet>("jetBTaggers");
       if (includeBTag_) {
         edm::ParameterSet btagCSV =
             jetExtras.getParameter<edm::ParameterSet>("jetBTaggers").getParameter<edm::ParameterSet>("cvsVertex");
         btagCSV_ = iC.consumes<reco::JetTagCollection>(btagCSV.getParameter<edm::InputTag>("label"));
         btagCSVWP_ = btagCSV.getParameter<double>("workingPoint");
       }
     }
  
     // triggerExtras are optional; they may be omitted or empty
     if (cfg.existsAs<edm::ParameterSet>("triggerExtras")) {
       edm::ParameterSet triggerExtras = cfg.getParameter<edm::ParameterSet>("triggerExtras");
       triggerTable_ = iC.consumes<edm::TriggerResults>(triggerExtras.getParameter<edm::InputTag>("src"));
       triggerPaths_ = triggerExtras.getParameter<std::vector<std::string>>("paths");
     }
  
     // massExtras is optional; in case it's not found no mass
     // window cuts are applied for the same flavor monitor
     // histograms
     if (cfg.existsAs<edm::ParameterSet>("massExtras")) {
       edm::ParameterSet massExtras = cfg.getParameter<edm::ParameterSet>("massExtras");
       lowerEdge_ = massExtras.getParameter<double>("lowerEdge");
       upperEdge_ = massExtras.getParameter<double>("upperEdge");
     }
  
     // setup the verbosity level for booking histograms;
     // per default the verbosity level will be set to
     // STANDARD. This will also be the chosen level in
     // the case when the monitoring PSet is not found
     verbosity_ = STANDARD;
     if (cfg.existsAs<edm::ParameterSet>("monitoring")) {
       edm::ParameterSet monitoring = cfg.getParameter<edm::ParameterSet>("monitoring");
       if (monitoring.getParameter<std::string>("verbosity") == "DEBUG")
         verbosity_ = DEBUG;
       if (monitoring.getParameter<std::string>("verbosity") == "VERBOSE")
         verbosity_ = VERBOSE;
       if (monitoring.getParameter<std::string>("verbosity") == "STANDARD")
         verbosity_ = STANDARD;
     }
     // and don't forget to do the histogram booking
     directory_ = cfg.getParameter<std::string>("directory");
   }

References btagCSV_, btagCSVWP_, looper::cfg, DEBUG, directory_, eidCutValue_, singleTopDQM_cfi::elecExtras, elecs_, elecSelect_, electronId_, edm::ParameterSet::getParameter(), includeBTag_, singleTopDQM_cfi::jetExtras, jetIDLabel_, jetIDSelect_, jetlooseSelection_, jets_, jetSelect_, jetSelection_, lowerEdge_, singleTopDQM_cfi::massExtras, mets_, mJetCorrector, singleTopDQM_cfi::monitoring, singleTopDQM_cfi::muonExtras, muonIso_, muons_, muonSelect_, singleTopDQM_cfi::pvExtras, pvs_, pvSelect_, rhoTag, CalibrationSummaryClient_cfi::sources, STANDARD, AlCaHLTBitMon_QueryRunRegistry::string, GlobalPosition_Frontier_DevDB_cff::tag, triggerPaths_, triggerTable_, upperEdge_, VERBOSE, and verbosity_.

◆ ~MonitorEnsemble()

TopSingleLepton::MonitorEnsemble::~MonitorEnsemble ( )

inline

default destructor

Definition at line 62 of file TopSingleLeptonDQM.h.

62 {};

Member Function Documentation

◆ book()

void MonitorEnsemble::book ( DQMStore::IBooker & ibooker )

book histograms in subdirectory directory

Definition at line 168 of file TopSingleLeptonDQM.cc.

                                                      {
     // set up the current directory path
     std::string current(directory_);
     current += label_;
     ibooker.setCurrentFolder(current);
  
     // determine number of bins for trigger monitoring
     // unsigned int nPaths = triggerPaths_.size();
  
     // --- [STANDARD] --- //
     // Run Number
     // hists_["RunNumb_"] = ibooker.book1D("RunNumber", "Run Nr.", 10, 0, 10);
     // instantaneous luminosity
     // hists_["InstLumi_"] = ibooker.book1D("InstLumi", "Inst. Lumi.", 100, 0., 1.e3);
     // number of selected primary vertices
     hists_["pvMult_"] = ibooker.book1D("PvMult", "N_{good pvs}", 50, 0., 50.);
     // pt of the leading muon
     hists_["muonPt_"] = ibooker.book1D("MuonPt", "pt(#mu TightId, TightIso)", 40, 0., 200.);
     // muon multiplicity after  tight Id
     hists_["muonMult_"] = ibooker.book1D("MuonMult", "N_{loose}(#mu)", 10, 0., 10.);
     // muon multiplicity after  isolation
     //hists_["muonMultIso_"] = ibooker.book1D("MuonMultIso",
     //    "N_{TightIso}(#mu)", 10, 0., 10.);
     // muon multiplicity after  tight Id and isolation
     hists_["muonMultTight_"] = ibooker.book1D("MuonMultTight", "N_{TightIso,TightId}(#mu)", 10, 0., 10.);
     // pt of the leading electron
     hists_["elecPt_"] = ibooker.book1D("ElecPt", "pt(e TightId, TightIso)", 40, 0., 200.);
     // electron multiplicity before std isolation
     //hists_["elecMult_"] = ibooker.book1D("ElecMult", "N_{All}(e, tightId)", 10, 0., 10.);
     // electron multiplicity after  std isolation
     //hists_["elecMultIso_"] = ibooker.book1D("ElecMultIso", "N_{Iso}(e, tightId, tightIso)", 10, 0., 10.);
     // multiplicity of jets with pt>30
     hists_["jetMult_"] = ibooker.book1D("JetMult", "N_{30}(jet)", 10, 0., 10.);
     // multiplicity of loose jets with pt>30
     hists_["jetMultLoose_"] = ibooker.book1D("JetMultLoose", "N_{30, loose}(jet)", 10, 0., 10.);
  
     // trigger efficiency estimates for single lepton triggers
     // hists_["triggerEff_"] = ibooker.book1D("TriggerEff",
     //    "Eff(trigger)", nPaths, 0., nPaths);
     // monitored trigger occupancy for single lepton triggers
     // hists_["triggerMon_"] = ibooker.book1D("TriggerMon",
     //    "Mon(trigger)", nPaths, 0., nPaths);
     // MET (pflow)
     hists_["metPflow_"] = ibooker.book1D("METPflow", "MET_{Pflow}", 50, 0., 200.);
     // W mass estimate
     hists_["massW_"] = ibooker.book1D("MassW", "M(W)", 60, 0., 300.);
     // Top mass estimate
     hists_["massTop_"] = ibooker.book1D("MassTop", "M(Top)", 50, 0., 500.);
     // b-tagged Top mass
     hists_["massBTop_"] = ibooker.book1D("MassBTop", "M(Top, 1 b-tag)", 50, 0., 500.);
     // set bin labels for trigger monitoring
     triggerBinLabels(std::string("trigger"), triggerPaths_);
  
     if (verbosity_ == STANDARD)
       return;
  
     // --- [VERBOSE] --- //
     // eta of the leading muon
     hists_["muonEta_"] = ibooker.book1D("MuonEta", "#eta(#mu TightId, TightIso)", 30, -3., 3.);
     // relative isolation of the candidate muon (depending on the decay channel)
     hists_["muonRelIso_"] = ibooker.book1D("MuonRelIso", "Iso_{Rel}(#mu TightId) (#Delta#beta Corrected)", 50, 0., 1.);
     // phi of the leading muon
     hists_["muonPhi_"] = ibooker.book1D("MuonPhi", "#phi(#mu TightId, TightIso)", 40, -4., 4.);
     // eta of the leading electron
     hists_["elecEta_"] = ibooker.book1D("ElecEta", "#eta(e tightId)", 30, -3., 3.);
     // std isolation variable of the leading electron
     hists_["elecRelIso_"] = ibooker.book1D("ElecRelIso", "Iso_{Rel}(e TightId, TightIso)", 50, 0., 1.);
     // phi of the leading electron
     hists_["elecPhi_"] = ibooker.book1D("ElecPhi", "#phi(e tightId)", 40, -4., 4.);
     // multiplicity of tight Id, tight Iso electorns
     hists_["elecMultTight_"] = ibooker.book1D("ElecMultTight", "N_{TightIso,TightId}(e)", 10, 0., 10.);
     // multiplicity of btagged jets (for track counting high efficiency) with
     // pt(L2L3)>30
     // hists_["jetMultBEff_"] = ibooker.book1D("JetMultBEff",
     //    "N_{30}(TCHE)", 10, 0., 10.);
     // btag discriminator for track counting high efficiency for jets with
     // pt(L2L3)>30
     //hists_["jetBDiscEff_"] = ibooker.book1D("JetBDiscEff",
     //    "Disc_{TCHE}(jet)", 100, 0., 10.);
     // eta of the 1. leading jet (corrected to L2+L3)
     hists_["jet1Eta_"] = ibooker.book1D("Jet1Eta", "#eta_{30,loose}(jet1)", 60, -3., 3.);
     // pt of the 1. leading jet (corrected to L2+L3)
     hists_["jet1Pt_"] = ibooker.book1D("Jet1Pt", "pt_{30,loose}(jet1)", 60, 0., 300.);
     // eta of the 2. leading jet (corrected to L2+L3)
     hists_["jet2Eta_"] = ibooker.book1D("Jet2Eta", "#eta_{30,loose}(jet2)", 60, -3., 3.);
     // pt of the 2. leading jet (corrected to L2+L3)
     hists_["jet2Pt_"] = ibooker.book1D("Jet2Pt", "pt_{30,loose}(jet2)", 60, 0., 300.);
     // eta of the 3. leading jet (corrected to L2+L3)
     hists_["jet3Eta_"] = ibooker.book1D("Jet3Eta", "#eta_{30,loose}(jet3)", 60, -3., 3.);
     // pt of the 3. leading jet (corrected to L2+L3)
     hists_["jet3Pt_"] = ibooker.book1D("Jet3Pt", "pt_{30,loose}(jet3)", 60, 0., 300.);
     // eta of the 4. leading jet (corrected to L2+L3)
     hists_["jet4Eta_"] = ibooker.book1D("Jet4Eta", "#eta_{30,loose}(jet4)", 60, -3., 3.);
     // pt of the 4. leading jet (corrected to L2+L3)
     hists_["jet4Pt_"] = ibooker.book1D("Jet4Pt", "pt_{30,loose}(jet4)", 60, 0., 300.);
     // dz for muons (to suppress cosmis)
     hists_["muonDelZ_"] = ibooker.book1D("MuonDelZ", "d_{z}(#mu)", 50, -25., 25.);
     // dxy for muons (to suppress cosmics)
     hists_["muonDelXY_"] = ibooker.book2D("MuonDelXY", "d_{xy}(#mu)", 50, -0.1, 0.1, 50, -0.1, 0.1);
  
     // set axes titles for dxy for muons
     hists_["muonDelXY_"]->setAxisTitle("x [cm]", 1);
     hists_["muonDelXY_"]->setAxisTitle("y [cm]", 2);
  
     if (verbosity_ == VERBOSE)
       return;
  
     // --- [DEBUG] --- //
     // charged hadron isolation component of the candidate muon (depending on the
     // decay channel)
     hists_["muonChHadIso_"] = ibooker.book1D("MuonChHadIsoComp", "ChHad_{IsoComponent}(#mu TightId)", 50, 0., 5.);
     // neutral hadron isolation component of the candidate muon (depending on the
     // decay channel)
     hists_["muonNeHadIso_"] = ibooker.book1D("MuonNeHadIsoComp", "NeHad_{IsoComponent}(#mu TightId)", 50, 0., 5.);
     // photon isolation component of the candidate muon (depending on the decay
     // channel)
     hists_["muonPhIso_"] = ibooker.book1D("MuonPhIsoComp", "Photon_{IsoComponent}(#mu )", 50, 0., 5.);
     // charged hadron isolation component of the candidate electron (depending on
     // the decay channel)
     hists_["elecChHadIso_"] = ibooker.book1D("ElectronChHadIsoComp", "ChHad_{IsoComponent}(e tightId)", 50, 0., 5.);
     // neutral hadron isolation component of the candidate electron (depending on
     // the decay channel)
     hists_["elecNeHadIso_"] = ibooker.book1D("ElectronNeHadIsoComp", "NeHad_{IsoComponent}(e tightId)", 50, 0., 5.);
     // photon isolation component of the candidate electron (depending on the
     // decay channel)
     hists_["elecPhIso_"] = ibooker.book1D("ElectronPhIsoComp", "Photon_{IsoComponent}(e tightId)", 50, 0., 5.);
  
     // multiplicity for combined secondary vertex
     hists_["jetMultBCSVM_"] = ibooker.book1D("JetMultBCSVM", "N_{30}(CSVM)", 10, 0., 10.);
     // btag discriminator for combined secondary vertex
     hists_["jetBCSV_"] = ibooker.book1D("JetDiscCSV", "BJet Disc_{CSV}(JET)", 100, -1., 2.);
     // pt of the 1. leading jet (uncorrected)
     // hists_["jet1PtRaw_"] = ibooker.book1D("Jet1PtRaw", "pt_{Raw}(jet1)", 60, 0., 300.);
     // pt of the 2. leading jet (uncorrected)
     // hists_["jet2PtRaw_"] = ibooker.book1D("Jet2PtRaw", "pt_{Raw}(jet2)", 60, 0., 300.);
     // pt of the 3. leading jet (uncorrected)
     // hists_["jet3PtRaw_"] = ibooker.book1D("Jet3PtRaw", "pt_{Raw}(jet3)", 60, 0., 300.);
     // pt of the 4. leading jet (uncorrected)
     // hists_["jet4PtRaw_"] = ibooker.book1D("Jet4PtRaw", "pt_{Raw}(jet4)", 60, 0., 300.);
     // selected events
     hists_["eventLogger_"] = ibooker.book2D("EventLogger", "Logged Events", 9, 0., 9., 10, 0., 10.);
  
     // set axes titles for selected events
     hists_["eventLogger_"]->getTH1()->SetOption("TEXT");
     hists_["eventLogger_"]->setBinLabel(1, "Run", 1);
     hists_["eventLogger_"]->setBinLabel(2, "Block", 1);
     hists_["eventLogger_"]->setBinLabel(3, "Event", 1);
     hists_["eventLogger_"]->setBinLabel(4, "pt_{30,loose}(jet1)", 1);
     hists_["eventLogger_"]->setBinLabel(5, "pt_{30,loose}(jet2)", 1);
     hists_["eventLogger_"]->setBinLabel(6, "pt_{30,loose}(jet3)", 1);
     hists_["eventLogger_"]->setBinLabel(7, "pt_{30,loose}(jet4)", 1);
     hists_["eventLogger_"]->setBinLabel(8, "M_{W}", 1);
     hists_["eventLogger_"]->setBinLabel(9, "M_{Top}", 1);
     hists_["eventLogger_"]->setAxisTitle("logged evts", 2);
     return;
   }

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), directory_, hists_, label_, dqm::implementation::NavigatorBase::setCurrentFolder(), STANDARD, AlCaHLTBitMon_QueryRunRegistry::string, triggerBinLabels(), triggerPaths_, VERBOSE, and verbosity_.

◆ booked()

bool TopSingleLepton::MonitorEnsemble::booked ( const std::string histName ) const

inlineprivate

check if histogram was booked

Definition at line 86 of file TopSingleLeptonDQM.h.

86 { return hists_.find(histName) != hists_.end(); };

References hists_.

Referenced by fill().

◆ fill() [1/5]

void MonitorEnsemble::fill	(	const edm::Event &	event,
		const edm::EventSetup &	setup
	)

fill monitor histograms with electronId and jetCorrections

Definition at line 325 of file TopSingleLeptonDQM.cc.

                                                                               {
     // fetch trigger event if configured such
     edm::Handle<edm::TriggerResults> triggerTable;
  
     if (!triggerTable_.isUninitialized()) {
       if (!event.getByToken(triggerTable_, triggerTable))
         return;
     }
  
     /*
   ------------------------------------------------------------
  
   Primary Vertex Monitoring
  
   ------------------------------------------------------------
   */
     // fill monitoring plots for primary verices
     edm::Handle<edm::View<reco::Vertex>> pvs;
  
     if (!event.getByToken(pvs_, pvs))
       return;
     const reco::Vertex& Pvertex = pvs->front();
     unsigned int pvMult = 0;
     for (edm::View<reco::Vertex>::const_iterator pv = pvs->begin(); pv != pvs->end(); ++pv) {
       if (!pvSelect_ || (*pvSelect_)(*pv))
         pvMult++;
     }
     fill("pvMult_", pvMult);
  
     /*
   ------------------------------------------------------------
  
   Electron Monitoring
  
   ------------------------------------------------------------
   */
  
     // fill monitoring plots for electrons
     edm::Handle<edm::View<reco::PFCandidate>> elecs;
     edm::Handle<double> _rhoHandle;
     event.getByLabel(rhoTag, _rhoHandle);
     if (!event.getByToken(elecs_, elecs))
       return;
  
     // check availability of electron id
     edm::Handle<edm::ValueMap<float>> electronId;
     if (!electronId_.isUninitialized()) {
       if (!event.getByToken(electronId_, electronId))
         return;
     }
  
     // loop electron collection
     unsigned int eMult = 0, eMultIso = 0;
     std::vector<const reco::PFCandidate*> isoElecs;
     for (edm::View<reco::PFCandidate>::const_iterator elec = elecs->begin(); elec != elecs->end(); ++elec) {
       if (elec->gsfElectronRef().isNull()) {
         continue;
       }
       reco::GsfElectronRef gsf_el = elec->gsfElectronRef();
       // restrict to electrons with good electronId
       if (electronId_.isUninitialized()
               ? true
               : ((double)(*electronId)[gsf_el] >=
                  eidCutValue_)) {  //This Electron Id is not currently used, but we can keep this for future needs
         if (!elecSelect_ || (*elecSelect_)(*elec)) {
           double el_ChHadIso = gsf_el->pfIsolationVariables().sumChargedHadronPt;
           double el_NeHadIso = gsf_el->pfIsolationVariables().sumNeutralHadronEt;
           double el_PhIso = gsf_el->pfIsolationVariables().sumPhotonEt;
           double absEta = std::fabs(gsf_el->superCluster()->eta());
  
           //Effective Area computation
           double eA = 0;
           if (absEta < 1.000)
             eA = 0.1703;
           else if (absEta < 1.479)
             eA = 0.1715;
           else if (absEta < 2.000)
             eA = 0.1213;
           else if (absEta < 2.200)
             eA = 0.1230;
           else if (absEta < 2.300)
             eA = 0.1635;
           else if (absEta < 2.400)
             eA = 0.1937;
           else if (absEta < 5.000)
             eA = 0.2393;
  
           double rho = _rhoHandle.isValid() ? (float)(*_rhoHandle) : 0;
           double el_pfRelIso = (el_ChHadIso + max(0., el_NeHadIso + el_PhIso - rho * eA)) / gsf_el->pt();
  
           //Only TightId
           if (eMult == 0) {  // Restricted to the leading tight electron
             fill("elecRelIso_", el_pfRelIso);
             fill("elecChHadIso_", el_ChHadIso);
             fill("elecNeHadIso_", el_NeHadIso);
             fill("elecPhIso_", el_PhIso);
           }
           ++eMult;
  
           if (!((el_pfRelIso < 0.0588 && absEta < 1.479) || (el_pfRelIso < 0.0571 && absEta > 1.479)))
             continue;  // PF Isolation with Effective Area Corrections according to https://twiki.cern.ch/twiki/bin/viewauth/CMS/CutBasedElectronIdentificationRun2
  
           // TightId and TightIso
           if (eMultIso == 0) {  //Only leading
             fill("elecPt_", elec->pt());
             fill("elecEta_", elec->eta());
             fill("elecPhi_", elec->phi());
           }
           ++eMultIso;
         }
       }
     }
     //fill("elecMult_", eMult);
     fill("elecMultTight_", eMultIso);
  
     /*
   ------------------------------------------------------------
  
   Muon Monitoring
  
   ------------------------------------------------------------
   */
  
     // fill monitoring plots for muons
     unsigned int mMult = 0, mTight = 0, mTightId = 0;
  
     edm::Handle<edm::View<reco::PFCandidate>> muons;
     edm::View<reco::PFCandidate>::const_iterator muonit;
  
     if (!event.getByToken(muons_, muons))
       return;
  
     for (edm::View<reco::PFCandidate>::const_iterator muonit = muons->begin(); muonit != muons->end(); ++muonit) {
       if (muonit->muonRef().isNull())
         continue;
       reco::MuonRef muon = muonit->muonRef();
  
       // restrict to globalMuons
       if (muon->isGlobalMuon()) {
         fill("muonDelZ_", muon->innerTrack()->vz());  // CB using inner track!
         fill("muonDelXY_", muon->innerTrack()->vx(), muon->innerTrack()->vy());
  
         // apply preselection
         if ((!muonSelect_ || (*muonSelect_)(*muonit))) {
           mMult++;
           double chHadPt = muon->pfIsolationR04().sumChargedHadronPt;
           double neHadEt = muon->pfIsolationR04().sumNeutralHadronEt;
           double phoEt = muon->pfIsolationR04().sumPhotonEt;
           double pfRelIso = (chHadPt + max(0., neHadEt + phoEt - 0.5 * muon->pfIsolationR04().sumPUPt)) /
                             muon->pt();  // CB dBeta corrected iso!
  
           if (!(muon->isGlobalMuon() && muon->isPFMuon() && muon->globalTrack()->normalizedChi2() < 10. &&
                 muon->globalTrack()->hitPattern().numberOfValidMuonHits() > 0 && muon->numberOfMatchedStations() > 1 &&
                 muon->innerTrack()->hitPattern().numberOfValidPixelHits() > 0 &&
                 muon->innerTrack()->hitPattern().trackerLayersWithMeasurement() > 5 &&
                 fabs(muon->muonBestTrack()->dxy(Pvertex.position())) < 0.2 &&
                 fabs(muon->muonBestTrack()->dz(Pvertex.position())) < 0.5))
             continue;  //Only tight muons
  
           if (mTightId == 0) {
             fill("muonRelIso_", pfRelIso);
             fill("muonChHadIso_", chHadPt);
             fill("muonNeHadIso_", neHadEt);
             fill("muonPhIso_", phoEt);
           }
           mTightId++;
  
           if (!(pfRelIso < 0.15))
             continue;  //Tight Iso
  
           if (mTight == 0) {  //Leading tightId tightIso muon
             fill("muonPt_", muon->pt());
             fill("muonEta_", muon->eta());
             fill("muonPhi_", muon->phi());
           }
           mTight++;
         }
       }
     }
     fill("muonMult_", mMult);
     fill("muonMultTight_", mTight);
  
     /*
   ------------------------------------------------------------
  
   Jet Monitoring
  
   ------------------------------------------------------------
   */
  
     // check availability of the btaggers
     edm::Handle<reco::JetTagCollection> btagEff, btagPur, btagVtx, btagCSV;
     if (includeBTag_) {
       if (!event.getByToken(btagCSV_, btagCSV))
         return;
     }
  
     edm::Handle<reco::JetCorrector> corrector;
     event.getByToken(mJetCorrector, corrector);
     if (!event.getByToken(mJetCorrector, corrector))
       return;
  
     // loop jet collection
     std::vector<reco::Jet> correctedJets;
     std::vector<double> JetTagValues;
     unsigned int mult = 0, multLoose = 0, multCSV = 0;
  
     edm::Handle<edm::View<reco::Jet>> jets;
     if (!event.getByToken(jets_, jets)) {
       return;
     }
  
     for (edm::View<reco::Jet>::const_iterator jet = jets->begin(); jet != jets->end(); ++jet) {
       bool isLoose = false;
       // check additional jet selection for pf jets
       if (dynamic_cast<const reco::PFJet*>(&*jet)) {
         reco::PFJet sel = dynamic_cast<const reco::PFJet&>(*jet);
         if ((*jetlooseSelection_)(sel))
           isLoose = true;
         sel.scaleEnergy(corrector->correction(*jet));
         if (!(*jetSelection_)(sel))
           continue;
       }
  
       // prepare jet to fill monitor histograms
       reco::Jet monitorJet = *jet;
  
       ++mult;  // determine jet (no Id) multiplicity
       monitorJet.scaleEnergy(corrector->correction(*jet));
  
       if (isLoose) {  //Loose Id
         unsigned int idx = jet - jets->begin();
         correctedJets.push_back(monitorJet);
         if (includeBTag_) {
           // fill b-discriminators
           edm::RefToBase<reco::Jet> jetRef = jets->refAt(idx);
           fill("jetBCSV_", (*btagCSV)[jetRef]);
           if ((*btagCSV)[jetRef] > btagCSVWP_)
             ++multCSV;
           // Fill a vector with Jet b-tag WP for later M3+1tag calculation: CSV
           // tagger
           JetTagValues.push_back((*btagCSV)[jetRef]);
         }
  
         // fill pt/eta for the leading four jets
         if (multLoose == 0) {
           fill("jet1Pt_", monitorJet.pt());
           fill("jet1Eta_", monitorJet.eta());
         };
         if (multLoose == 1) {
           fill("jet2Pt_", monitorJet.pt());
           fill("jet2Eta_", monitorJet.eta());
         }
         if (multLoose == 2) {
           fill("jet3Pt_", monitorJet.pt());
           fill("jet3Eta_", monitorJet.eta());
         }
         if (multLoose == 3) {
           fill("jet4Pt_", monitorJet.pt());
           fill("jet4Eta_", monitorJet.eta());
         }
         multLoose++;
       }
     }
     fill("jetMult_", mult);
     fill("jetMultLoose_", multLoose);
     fill("jetMultBCSVM_", multCSV);
  
     /*
   ------------------------------------------------------------
  
   MET Monitoring
  
   ------------------------------------------------------------
   */
  
     // fill monitoring histograms for met
     for (std::vector<edm::EDGetTokenT<edm::View<reco::MET>>>::const_iterator met_ = mets_.begin(); met_ != mets_.end();
          ++met_) {
       edm::Handle<edm::View<reco::MET>> met;
       if (!event.getByToken(*met_, met))
         continue;
       if (met->begin() != met->end()) {  //If we ever have to use more than one type of met again
         unsigned int idx = met_ - mets_.begin();
         if (idx == 0)
           fill("metPflow_", met->begin()->et());
       }
     }
  
     /*
   ------------------------------------------------------------
  
   Event Monitoring
  
   ------------------------------------------------------------
   */
  
     // fill W boson and top mass estimates
  
     Calculate eventKinematics(MAXJETS, WMASS);
     double wMass = eventKinematics.massWBoson(correctedJets);
     double topMass = eventKinematics.massTopQuark(correctedJets);
     if (wMass >= 0 && topMass >= 0) {
       fill("massW_", wMass);
       fill("massTop_", topMass);
     }
  
     // Fill M3 with Btag (CSV Tight) requirement
  
     if (!includeBTag_)
       return;
     if (correctedJets.size() != JetTagValues.size())
       return;
     double btopMass = eventKinematics.massBTopQuark(correctedJets, JetTagValues, btagCSVWP_);
     if (btopMass >= 0)
       fill("massBTop_", btopMass);
  
     // fill plots for trigger monitoring
     if ((lowerEdge_ == -1. && upperEdge_ == -1.) || (lowerEdge_ < wMass && wMass < upperEdge_)) {
       if (!triggerTable_.isUninitialized())
         fill(event, *triggerTable, "trigger", triggerPaths_);
       if (logged_ <= hists_.find("eventLogger_")->second->getNbinsY()) {
         // log runnumber, lumi block, event number & some
         // more pysics infomation for interesting events
         fill("eventLogger_", 0.5, logged_ + 0.5, event.eventAuxiliary().run());
         fill("eventLogger_", 1.5, logged_ + 0.5, event.eventAuxiliary().luminosityBlock());
         fill("eventLogger_", 2.5, logged_ + 0.5, event.eventAuxiliary().event());
         if (!correctedJets.empty())
           fill("eventLogger_", 3.5, logged_ + 0.5, correctedJets[0].pt());
         if (correctedJets.size() > 1)
           fill("eventLogger_", 4.5, logged_ + 0.5, correctedJets[1].pt());
         if (correctedJets.size() > 2)
           fill("eventLogger_", 5.5, logged_ + 0.5, correctedJets[2].pt());
         if (correctedJets.size() > 3)
           fill("eventLogger_", 6.5, logged_ + 0.5, correctedJets[3].pt());
         fill("eventLogger_", 7.5, logged_ + 0.5, wMass);
         fill("eventLogger_", 8.5, logged_ + 0.5, topMass);
         ++logged_;
       }
     }
   }

References btagCSV_, btagCSVWP_, pfClustersFromHGC3DClusters_cfi::corrector, eidCutValue_, singleTopDQM_cfi::elecs, elecs_, elecSelect_, topSingleLeptonDQM_PU_cfi::electronId, electronId_, reco::LeafCandidate::eta(), dqmMemoryStats::float, hists_, training_settings::idx, includeBTag_, edm::EDGetTokenT< T >::isUninitialized(), edm::HandleBase::isValid(), metsig::jet, jetlooseSelection_, singleTopDQM_cfi::jets, jets_, jetSelection_, logged_, lowerEdge_, Calculate::massBTopQuark(), Calculate::massTopQuark(), Calculate::massWBoson(), SiStripPI::max, TopSingleLepton::MAXJETS, BTaggingMonitor_cfi::met, mets_, mJetCorrector, VarParsing::mult, PDWG_BPHSkim_cff::muons, muons_, muonSelect_, reco::Vertex::position(), DiDispStaMuonMonitor_cfi::pt, reco::LeafCandidate::pt(), MetAnalyzer::pv(), FSQDQM_cfi::pvs, pvs_, pvSelect_, rhoTag, reco::Jet::scaleEnergy(), EgammaValidation_Wenu_cff::sel, triggerPaths_, triggerTable_, funct::true, upperEdge_, pseudoTop_cfi::wMass, and TopSingleLepton::WMASS.

Referenced by fill().

◆ fill() [2/5]

void MonitorEnsemble::fill	(	const edm::Event &	event,
		const edm::TriggerResults &	triggerTable,
		std::string	channel,
		const std::vector< std::string >	labels
	)		const

inlineprivate

fill trigger monitoring histograms

Definition at line 196 of file TopSingleLeptonDQM.h.

                                                                              {
     for (unsigned int idx = 0; idx < labels.size(); ++idx) {
       if (accept(event, triggerTable, monitorPath(labels[idx]))) {
         fill(channel + "Mon_", idx + 0.5);
         // take care to fill triggerMon_ before evts is being called
         int evts = hists_.find(channel + "Mon_")->second->getBinContent(idx + 1);
         double value = hists_.find(channel + "Eff_")->second->getBinContent(idx + 1);
         fill(
             channel + "Eff_", idx + 0.5, 1. / evts * (accept(event, triggerTable, selectionPath(labels[idx])) - value));
       }
     }
   }

References accept(), fill(), hists_, training_settings::idx, SummaryClient_cfi::labels, monitorPath(), and selectionPath().

◆ fill() [3/5]

void TopSingleLepton::MonitorEnsemble::fill	(	const std::string	histName,
		double	value
	)		const

inlineprivate

fill histogram if it had been booked before

Definition at line 88 of file TopSingleLeptonDQM.h.

                                                             {
       if (booked(histName))
         hists_.find(histName)->second->Fill(value);
     };

References booked(), and hists_.

◆ fill() [4/5]

void TopSingleLepton::MonitorEnsemble::fill	(	const std::string	histName,
		double	xValue,
		double	yValue
	)		const

inlineprivate

fill histogram if it had been booked before (2-dim version)

Definition at line 93 of file TopSingleLeptonDQM.h.

                                                                             {
       if (booked(histName))
         hists_.find(histName)->second->Fill(xValue, yValue);
     };

References booked(), and hists_.

◆ fill() [5/5]

void TopSingleLepton::MonitorEnsemble::fill	(	const std::string	histName,
		double	xValue,
		double	yValue,
		double	zValue
	)		const

inlineprivate

fill histogram if it had been booked before (2-dim version)

Definition at line 98 of file TopSingleLeptonDQM.h.

                                                                                            {
       if (booked(histName))
         hists_.find(histName)->second->Fill(xValue, yValue, zValue);
     };

References booked(), and hists_.

◆ monitorPath()

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

inlineprivate

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

Definition at line 72 of file TopSingleLeptonDQM.h.

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

References label.

Referenced by fill(), and triggerBinLabels().

◆ selectionPath()

std::string TopSingleLepton::MonitorEnsemble::selectionPath ( const std::string & label ) const

inlineprivate

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

Definition at line 75 of file TopSingleLeptonDQM.h.

75 { return label.substr(0, label.find(':')); };

References label.

Referenced by fill(), and triggerBinLabels().

◆ triggerBinLabels()

void MonitorEnsemble::triggerBinLabels	(	std::string	channel,
		const std::vector< std::string >	labels
	)

inlineprivate

set configurable labels for trigger monitoring histograms

Definition at line 188 of file TopSingleLeptonDQM.h.

                                                                                                     {
     for (unsigned int idx = 0; idx < labels.size(); ++idx) {
       hists_[channel + "Mon_"]->setBinLabel(idx + 1, "[" + monitorPath(labels[idx]) + "]", 1);
       hists_[channel + "Eff_"]->setBinLabel(
           idx + 1, "[" + selectionPath(labels[idx]) + "]|[" + monitorPath(labels[idx]) + "]", 1);
     }
   }

References hists_, training_settings::idx, SummaryClient_cfi::labels, monitorPath(), and selectionPath().

Referenced by book().

Member Data Documentation

◆ btagCSV_

edm::EDGetTokenT<reco::JetTagCollection> TopSingleLepton::MonitorEnsemble::btagCSV_

private

Definition at line 172 of file TopSingleLeptonDQM.h.

Referenced by fill(), and MonitorEnsemble().

◆ btagCSVWP_

double TopSingleLepton::MonitorEnsemble::btagCSVWP_

private

Definition at line 174 of file TopSingleLeptonDQM.h.

Referenced by fill(), and MonitorEnsemble().

◆ btagEff_

edm::EDGetTokenT<reco::JetTagCollection> TopSingleLepton::MonitorEnsemble::btagEff_

private

btag discriminator labels

Definition at line 172 of file TopSingleLeptonDQM.h.

◆ btagEffWP_

double TopSingleLepton::MonitorEnsemble::btagEffWP_

private

btag working points

Definition at line 174 of file TopSingleLeptonDQM.h.

◆ btagPur_

edm::EDGetTokenT<reco::JetTagCollection> TopSingleLepton::MonitorEnsemble::btagPur_

private

Definition at line 172 of file TopSingleLeptonDQM.h.

◆ btagPurWP_

double TopSingleLepton::MonitorEnsemble::btagPurWP_

private

Definition at line 174 of file TopSingleLeptonDQM.h.

◆ btagVtx_

edm::EDGetTokenT<reco::JetTagCollection> TopSingleLepton::MonitorEnsemble::btagVtx_

private

Definition at line 172 of file TopSingleLeptonDQM.h.

◆ btagVtxWP_

double TopSingleLepton::MonitorEnsemble::btagVtxWP_

private

Definition at line 174 of file TopSingleLeptonDQM.h.

◆ directory_

std::string TopSingleLepton::MonitorEnsemble::directory_

private

Definition at line 185 of file TopSingleLeptonDQM.h.

Referenced by book(), and MonitorEnsemble().

◆ eidCutValue_

double TopSingleLepton::MonitorEnsemble::eidCutValue_

private

electronId pattern we expect the following pattern: 0: fails 1: passes electron ID only 2: passes electron Isolation only 3: passes electron ID and Isolation only 4: passes conversion rejection 5: passes conversion rejection and ID 6: passes conversion rejection and Isolation 7: passes the whole selection As described on https://twiki.cern.ch/twiki/bin/view/CMS/SimpleCutBasedEleID

Definition at line 138 of file TopSingleLeptonDQM.h.

Referenced by fill(), and MonitorEnsemble().

◆ elecs_

edm::EDGetTokenT<edm::View<reco::PFCandidate> > TopSingleLepton::MonitorEnsemble::elecs_

private

Definition at line 113 of file TopSingleLeptonDQM.h.

Referenced by fill(), and MonitorEnsemble().

◆ elecSelect_

std::unique_ptr<StringCutObjectSelector<reco::PFCandidate> > TopSingleLepton::MonitorEnsemble::elecSelect_

private

extra selection on electrons

Definition at line 145 of file TopSingleLeptonDQM.h.

Referenced by fill(), and MonitorEnsemble().

◆ electronId_

edm::EDGetTokenT<edm::ValueMap<float> > TopSingleLepton::MonitorEnsemble::electronId_

private

electronId label

Definition at line 122 of file TopSingleLeptonDQM.h.

Referenced by fill(), and MonitorEnsemble().

◆ hists_

std::map<std::string, MonitorElement*> TopSingleLepton::MonitorEnsemble::hists_

private

histogram container

Definition at line 182 of file TopSingleLeptonDQM.h.

Referenced by book(), booked(), fill(), and triggerBinLabels().

◆ includeBTag_

bool TopSingleLepton::MonitorEnsemble::includeBTag_

private

include btag information or not to be determined from the cfg

Definition at line 170 of file TopSingleLeptonDQM.h.

Referenced by fill(), and MonitorEnsemble().

◆ jetCorrector_

std::string TopSingleLepton::MonitorEnsemble::jetCorrector_

private

jetCorrector

Definition at line 158 of file TopSingleLeptonDQM.h.

◆ jetIDLabel_

edm::EDGetTokenT<reco::JetIDValueMap> TopSingleLepton::MonitorEnsemble::jetIDLabel_

private

jetID as an extra selection type

Definition at line 161 of file TopSingleLeptonDQM.h.

Referenced by MonitorEnsemble().

◆ jetIDSelect_

std::unique_ptr<StringCutObjectSelector<reco::JetID> > TopSingleLepton::MonitorEnsemble::jetIDSelect_

private

Definition at line 163 of file TopSingleLeptonDQM.h.

Referenced by MonitorEnsemble().

◆ jetlooseSelection_

std::unique_ptr<StringCutObjectSelector<reco::PFJet> > TopSingleLepton::MonitorEnsemble::jetlooseSelection_

private

Definition at line 166 of file TopSingleLeptonDQM.h.

Referenced by fill(), and MonitorEnsemble().

◆ jets_

edm::EDGetTokenT<edm::View<reco::Jet> > TopSingleLepton::MonitorEnsemble::jets_

private

input sources for monitoring

Definition at line 111 of file TopSingleLeptonDQM.h.

Referenced by fill(), and MonitorEnsemble().

◆ jetSelect_

std::string TopSingleLepton::MonitorEnsemble::jetSelect_

private

extra selection on jets

Definition at line 165 of file TopSingleLeptonDQM.h.

Referenced by MonitorEnsemble().

◆ jetSelection_

std::unique_ptr<StringCutObjectSelector<reco::PFJet> > TopSingleLepton::MonitorEnsemble::jetSelection_

private

Definition at line 167 of file TopSingleLeptonDQM.h.

Referenced by fill(), and MonitorEnsemble().

◆ label_

std::string TopSingleLepton::MonitorEnsemble::label_

private

instance label

Definition at line 107 of file TopSingleLeptonDQM.h.

Referenced by SequenceTypes.DummyModule::__repr__(), Mixins._Labelable::_findDependencies(), book(), and Mixins._Labelable::setLabel().

◆ logged_

int TopSingleLepton::MonitorEnsemble::logged_

private

number of logged interesting events

Definition at line 179 of file TopSingleLeptonDQM.h.

Referenced by fill().

◆ lowerEdge_

double TopSingleLepton::MonitorEnsemble::lowerEdge_

private

mass window upper and lower edge

Definition at line 176 of file TopSingleLeptonDQM.h.

Referenced by fill(), and MonitorEnsemble().

◆ mets_

std::vector<edm::EDGetTokenT<edm::View<reco::MET> > > TopSingleLepton::MonitorEnsemble::mets_

private

considers a vector of METs

Definition at line 109 of file TopSingleLeptonDQM.h.

Referenced by fill(), and MonitorEnsemble().

◆ mJetCorrector

edm::EDGetTokenT<reco::JetCorrector> TopSingleLepton::MonitorEnsemble::mJetCorrector

private

Definition at line 123 of file TopSingleLeptonDQM.h.

Referenced by fill(), and MonitorEnsemble().

◆ muonIso_

std::unique_ptr<StringCutObjectSelector<reco::PFCandidate> > TopSingleLepton::MonitorEnsemble::muonIso_

private

extra isolation criterion on muon

Definition at line 152 of file TopSingleLeptonDQM.h.

Referenced by MonitorEnsemble().

◆ muons_

edm::EDGetTokenT<edm::View<reco::PFCandidate> > TopSingleLepton::MonitorEnsemble::muons_

private

Definition at line 112 of file TopSingleLeptonDQM.h.

Referenced by fill(), and MonitorEnsemble().

◆ muonSelect_

std::unique_ptr<StringCutObjectSelector<reco::PFCandidate> > TopSingleLepton::MonitorEnsemble::muonSelect_

private

extra selection on muons

Definition at line 155 of file TopSingleLeptonDQM.h.

Referenced by fill(), and MonitorEnsemble().

◆ pvs_

edm::EDGetTokenT<edm::View<reco::Vertex> > TopSingleLepton::MonitorEnsemble::pvs_

private

Definition at line 114 of file TopSingleLeptonDQM.h.

Referenced by fill(), and MonitorEnsemble().

◆ pvSelect_

std::unique_ptr<StringCutObjectSelector<reco::Vertex> > TopSingleLepton::MonitorEnsemble::pvSelect_

private

extra selection on primary vertices; meant to investigate the pile-up effect

Definition at line 149 of file TopSingleLeptonDQM.h.

Referenced by fill(), and MonitorEnsemble().

◆ rhoTag

edm::InputTag TopSingleLepton::MonitorEnsemble::rhoTag

private

Definition at line 141 of file TopSingleLeptonDQM.h.

Referenced by fill(), and MonitorEnsemble().

◆ tmpConsumerBase

edm::EDConsumerBase TopSingleLepton::MonitorEnsemble::tmpConsumerBase

private

Definition at line 183 of file TopSingleLeptonDQM.h.

◆ triggerPaths_

std::vector<std::string> TopSingleLepton::MonitorEnsemble::triggerPaths_

private

trigger paths for monitoring, expected to be of form signalPath:MonitorPath

Definition at line 119 of file TopSingleLeptonDQM.h.

Referenced by book(), fill(), and MonitorEnsemble().

◆ triggerTable_

edm::EDGetTokenT<edm::TriggerResults> TopSingleLepton::MonitorEnsemble::triggerTable_

private

trigger table

Definition at line 116 of file TopSingleLeptonDQM.h.

Referenced by fill(), and MonitorEnsemble().

◆ upperEdge_

double TopSingleLepton::MonitorEnsemble::upperEdge_

private

Definition at line 176 of file TopSingleLeptonDQM.h.

Referenced by fill(), and MonitorEnsemble().

◆ verbosity_

Level TopSingleLepton::MonitorEnsemble::verbosity_

private

verbosity level for booking

Definition at line 101 of file TopSingleLeptonDQM.h.

Referenced by book(), and MonitorEnsemble().

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ Level

Constructor & Destructor Documentation

◆ MonitorEnsemble()

◆ ~MonitorEnsemble()

Member Function Documentation

◆ book()

◆ booked()

◆ fill() [1/5]

◆ fill() [2/5]

◆ fill() [3/5]

◆ fill() [4/5]

◆ fill() [5/5]

◆ monitorPath()

◆ selectionPath()

◆ triggerBinLabels()

Member Data Documentation

◆ btagCSV_

◆ btagCSVWP_

◆ btagEff_

◆ btagEffWP_

◆ btagPur_

◆ btagPurWP_

◆ btagVtx_

◆ btagVtxWP_

◆ directory_

◆ eidCutValue_

◆ elecs_

◆ elecSelect_

◆ electronId_

◆ hists_

◆ includeBTag_

◆ jetCorrector_

◆ jetIDLabel_

◆ jetIDSelect_

◆ jetlooseSelection_

◆ jets_

◆ jetSelect_

◆ jetSelection_

◆ label_

◆ logged_

◆ lowerEdge_

◆ mets_

◆ mJetCorrector

◆ muonIso_

◆ muons_

◆ muonSelect_

◆ pvs_

◆ pvSelect_

◆ rhoTag

◆ tmpConsumerBase

◆ triggerPaths_

◆ triggerTable_

◆ upperEdge_

◆ verbosity_