CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Public Types | Public Member Functions | Private Member Functions | Private Attributes
TopDiLeptonOffline::MonitorEnsemble Class Reference

#include <TopDiLeptonOfflineDQM.h>

Public Types

enum  DecayChannel {
  NONE, DIMUON, DIELEC, ELECMU,
  NONE, DIMUON, DIELEC, ELECMU
}
 different decay channels More...
 
enum  DecayChannel {
  NONE, DIMUON, DIELEC, ELECMU,
  NONE, DIMUON, DIELEC, ELECMU
}
 different decay channels More...
 
enum  Level {
  STANDARD, VERBOSE, DEBUG, STANDARD,
  VERBOSE, DEBUG
}
 different verbosity levels More...
 
enum  Level {
  STANDARD, VERBOSE, DEBUG, STANDARD,
  VERBOSE, DEBUG
}
 different verbosity levels More...
 
typedef
reco::LeafCandidate::LorentzVector 		LorentzVector
 
typedef
reco::LeafCandidate::LorentzVector 		LorentzVector
 

Public Member Functions

void book (std::string directory)
 book histograms in subdirectory directory More...
 
void book (std::string directory)
 book histograms in subdirectory directory More...
 
void fill (const edm::Event &event, const edm::EventSetup &setup)
 fill monitor histograms with electronId and jetCorrections 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)
 default contructor More...
 
 MonitorEnsemble (const char *label, const edm::ParameterSet &cfg)
 default contructor More...
 
 ~MonitorEnsemble ()
 default destructor More...
 
 ~MonitorEnsemble ()
 default destructor More...
 

Private Member Functions

bool booked (const std::string histName) const
 check if histogram was booked More...
 
bool booked (const std::string histName) const
 check if histogram was booked More...
 
DecayChannel decayChannel (const std::vector< const reco::Muon * > &muons, const std::vector< const reco::GsfElectron * > &elecs) const
 determine dileptonic decay channel More...
 
DecayChannel decayChannel (const std::vector< const reco::Muon * > &muons, const std::vector< const reco::GsfElectron * > &elecs) const
 determine dileptonic decay channel 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 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 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) 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...
 
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...
 
void loggerBinLabels (std::string hist)
 set labels for event logging histograms More...
 
void loggerBinLabels (std::string hist)
 set labels for event logging histograms More...
 
std::string monitorPath (const std::string &label) const
 
std::string monitorPath (const std::string &label) const
 
std::string selectionPath (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...
 
void triggerBinLabels (std::string channel, const std::vector< std::string > &labels)
 set configurable labels for trigger monitoring histograms More...
 

Private Attributes

int diElecLogged_
 
int diMuonLogged_
 
std::vector< std::string > diMuonPaths_
 trigger paths for di muon channel More...
 
int eidPattern_
 
StringCutObjectSelector
< reco::GsfElectron > * 		elecIso_
 extra isolation criterion on electron More...
 
int elecMuLogged_
 number of logged interesting events More...
 
std::vector< std::string > elecMuPaths_
 
edm::InputTag elecs_
 input sources for monitoring More...
 
StringCutObjectSelector
< reco::GsfElectron > * 		elecSelect_
 extra selection on electrons More...
 
edm::InputTag electronId_
 electronId label More...
 
std::map< std::string,
MonitorElement * > 		hists_
 histogram container More...
 
std::string jetCorrector_
 jetCorrector More...
 
edm::InputTag jetIDLabel_
 jetID as an extra selection type More...
 
StringCutObjectSelector
< reco::JetID > * 		jetIDSelect_
 extra jetID selection on calo jets More...
 
edm::InputTag jets_
 
std::string jetSelect_
 
std::string label_
 instance label More...
 
double lowerEdge_
 mass window upper and lower edge More...
 
std::vector< edm::InputTag > mets_
 considers a vector of METs More...
 
StringCutObjectSelector
< reco::Muon > * 		muonIso_
 extra isolation criterion on muon More...
 
edm::InputTag muons_
 
StringCutObjectSelector
< reco::Muon > * 		muonSelect_
 extra selection on muons More...
 
DQMStore * store_
 storage manager More...
 
edm::InputTag triggerTable_
 trigger table More...
 
double upperEdge_
 
Level verbosity_
 verbosity level for booking More...
 

Detailed Description

Definition at line 39 of file TopDiLeptonOfflineDQM.h.

Member Typedef Documentation

typedef reco::LeafCandidate::LorentzVector TopDiLeptonOffline::MonitorEnsemble::LorentzVector

make clear which LorentzVector to use for jet, electrons and muon buffering

Definition at line 45 of file TopDiLeptonOfflineDQM.h.

typedef reco::LeafCandidate::LorentzVector TopDiLeptonOffline::MonitorEnsemble::LorentzVector

make clear which LorentzVector to use for jet, electrons and muon buffering

Definition at line 46 of file TopHLTDiLeptonOfflineDQM.h.

Member Enumeration Documentation

enum TopDiLeptonOffline::MonitorEnsemble::DecayChannel

different decay channels

Enumerator
NONE 
DIMUON 
DIELEC 
ELECMU 
NONE 
DIMUON 
DIELEC 
ELECMU 

Definition at line 47 of file TopDiLeptonOfflineDQM.h.

47 { NONE, DIMUON, DIELEC, ELECMU };
enum TopDiLeptonOffline::MonitorEnsemble::DecayChannel

different decay channels

Enumerator
NONE 
DIMUON 
DIELEC 
ELECMU 
NONE 
DIMUON 
DIELEC 
ELECMU 

Definition at line 48 of file TopHLTDiLeptonOfflineDQM.h.

48 { NONE, DIMUON, DIELEC, ELECMU };
enum TopDiLeptonOffline::MonitorEnsemble::Level

different verbosity levels

Enumerator
STANDARD 
VERBOSE 
DEBUG 
STANDARD 
VERBOSE 
DEBUG 

Definition at line 42 of file TopDiLeptonOfflineDQM.h.

42 { STANDARD, VERBOSE, DEBUG };
enum TopDiLeptonOffline::MonitorEnsemble::Level

different verbosity levels

Enumerator
STANDARD 
VERBOSE 
DEBUG 
STANDARD 
VERBOSE 
DEBUG 

Definition at line 43 of file TopHLTDiLeptonOfflineDQM.h.

43 { STANDARD, VERBOSE, DEBUG };

Constructor & Destructor Documentation

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

default contructor

Definition at line 11 of file TopDiLeptonOfflineDQM.cc.

References book(), DEBUG, diMuonPaths_, eidPattern_, elecIso_, elecMuPaths_, elecs_, elecSelect_, electronId_, edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), jetCorrector_, bTagSequences_cff::jetID, jetIDLabel_, jetIDSelect_, jets_, jetSelect_, lowerEdge_, mets_, muonIso_, muons_, muonSelect_, STANDARD, AlCaHLTBitMon_QueryRunRegistry::string, triggerTable_, upperEdge_, VERBOSE, and verbosity_.

11  :
12  label_(label), eidPattern_(0), elecIso_(0), elecSelect_(0), muonIso_(0), muonSelect_(0), jetIDSelect_(0),
13  lowerEdge_(-1.), upperEdge_(-1.), elecMuLogged_(0), diMuonLogged_(0), diElecLogged_(0)
14  {
15  // sources have to be given; this PSet is not optional
16  edm::ParameterSet sources=cfg.getParameter<edm::ParameterSet>("sources");
17  muons_= sources.getParameter<edm::InputTag>("muons");
18  elecs_= sources.getParameter<edm::InputTag>("elecs");
19  jets_ = sources.getParameter<edm::InputTag>("jets" );
20  mets_ = sources.getParameter<std::vector<edm::InputTag> >("mets" );
21 
22  // elecExtras are optional; they may be omitted or empty
23  if( cfg.existsAs<edm::ParameterSet>("elecExtras") ){
24  edm::ParameterSet elecExtras=cfg.getParameter<edm::ParameterSet>("elecExtras");
25  // select is optional; in case it's not found no
26  // selection will be applied
27  if( elecExtras.existsAs<std::string>("select") ){
28  elecSelect_= new StringCutObjectSelector<reco::GsfElectron>(elecExtras.getParameter<std::string>("select"));
29  }
30  // isolation is optional; in case it's not found no
31  // isolation will be applied
32  if( elecExtras.existsAs<std::string>("isolation") ){
33  elecIso_= new StringCutObjectSelector<reco::GsfElectron>(elecExtras.getParameter<std::string>("isolation"));
34  }
35  // electronId is optional; in case it's not found the
36  // InputTag will remain empty
37  if( elecExtras.existsAs<edm::ParameterSet>("electronId") ){
38  edm::ParameterSet elecId=elecExtras.getParameter<edm::ParameterSet>("electronId");
39  electronId_= elecId.getParameter<edm::InputTag>("src");
40  eidPattern_= elecId.getParameter<int>("pattern");
41  }
42  }
43  // muonExtras are optional; they may be omitted or empty
44  if( cfg.existsAs<edm::ParameterSet>("muonExtras") ){
45  edm::ParameterSet muonExtras=cfg.getParameter<edm::ParameterSet>("muonExtras");
46  // select is optional; in case it's not found no
47  // selection will be applied
48  if( muonExtras.existsAs<std::string>("select") ){
49  muonSelect_= new StringCutObjectSelector<reco::Muon>(muonExtras.getParameter<std::string>("select"));
50  }
51  // isolation is optional; in case it's not found no
52  // isolation will be applied
53  if( muonExtras.existsAs<std::string>("isolation") ){
54  muonIso_= new StringCutObjectSelector<reco::Muon>(muonExtras.getParameter<std::string>("isolation"));
55  }
56  }
57  // jetExtras are optional; they may be omitted or empty
58  if( cfg.existsAs<edm::ParameterSet>("jetExtras") ){
59  edm::ParameterSet jetExtras=cfg.getParameter<edm::ParameterSet>("jetExtras");
60  // jetCorrector is optional; in case it's not found
61  // the InputTag will remain empty
62  if( jetExtras.existsAs<std::string>("jetCorrector") ){
63  jetCorrector_= jetExtras.getParameter<std::string>("jetCorrector");
64  }
65  // read jetID information if it exists
66  if(jetExtras.existsAs<edm::ParameterSet>("jetID")){
67  edm::ParameterSet jetID=jetExtras.getParameter<edm::ParameterSet>("jetID");
68  jetIDLabel_ =jetID.getParameter<edm::InputTag>("label");
69  jetIDSelect_= new StringCutObjectSelector<reco::JetID>(jetID.getParameter<std::string>("select"));
70  }
71  // select is optional; in case it's not found no
72  // selection will be applied (only implemented for
73  // CaloJets at the moment)
74  if( jetExtras.existsAs<std::string>("select") ){
75  jetSelect_= jetExtras.getParameter<std::string>("select");
76  }
77  }
78  // triggerExtras are optional; they may be omitted or empty
79  if( cfg.existsAs<edm::ParameterSet>("triggerExtras") ){
80  edm::ParameterSet triggerExtras=cfg.getParameter<edm::ParameterSet>("triggerExtras");
81  triggerTable_=triggerExtras.getParameter<edm::InputTag>("src");
82  elecMuPaths_ =triggerExtras.getParameter<std::vector<std::string> >("pathsELECMU");
83  diMuonPaths_ =triggerExtras.getParameter<std::vector<std::string> >("pathsDIMUON");
84  }
85  // massExtras is optional; in case it's not found no mass
86  // window cuts are applied for the same flavor monitor
87  // histograms
88  if( cfg.existsAs<edm::ParameterSet>("massExtras") ){
89  edm::ParameterSet massExtras=cfg.getParameter<edm::ParameterSet>("massExtras");
90  lowerEdge_= massExtras.getParameter<double>("lowerEdge");
91  upperEdge_= massExtras.getParameter<double>("upperEdge");
92  }
93 
94  // setup the verbosity level for booking histograms;
95  // per default the verbosity level will be set to
96  // STANDARD. This will also be the chosen level in
97  // the case when the monitoring PSet is not found
98  verbosity_=STANDARD;
99  if( cfg.existsAs<edm::ParameterSet>("monitoring") ){
100  edm::ParameterSet monitoring=cfg.getParameter<edm::ParameterSet>("monitoring");
101  if(monitoring.getParameter<std::string>("verbosity") == "DEBUG" )
102  verbosity_= DEBUG;
103  if(monitoring.getParameter<std::string>("verbosity") == "VERBOSE" )
104  verbosity_= VERBOSE;
105  if(monitoring.getParameter<std::string>("verbosity") == "STANDARD")
106  verbosity_= STANDARD;
107  }
108  // and don't forget to do the histogram booking
109  book(cfg.getParameter<std::string>("directory"));
110  }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
TopDiLeptonOffline::MonitorEnsemble::jetIDSelect_
StringCutObjectSelector< reco::JetID > * jetIDSelect_
extra jetID selection on calo jets
Definition: TopDiLeptonOfflineDQM.h:132
edm::ParameterSet::existsAs
bool existsAs(std::string const &parameterName, bool trackiness=true) const
checks if a parameter exists as a given type
Definition: ParameterSet.h:187
TopDiLeptonOffline::MonitorEnsemble::elecIso_
StringCutObjectSelector< reco::GsfElectron > * elecIso_
extra isolation criterion on electron
Definition: TopDiLeptonOfflineDQM.h:118
TopDiLeptonOffline::MonitorEnsemble::elecMuLogged_
int elecMuLogged_
number of logged interesting events
Definition: TopDiLeptonOfflineDQM.h:140
TopDiLeptonOffline::MonitorEnsemble::elecs_
edm::InputTag elecs_
input sources for monitoring
Definition: TopDiLeptonOfflineDQM.h:92
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
bTagSequences_cff.jetID
tuple jetID
Definition: bTagSequences_cff.py:4
TopDiLeptonOffline::MonitorEnsemble::muonIso_
StringCutObjectSelector< reco::Muon > * muonIso_
extra isolation criterion on muon
Definition: TopDiLeptonOfflineDQM.h:123
TopDiLeptonOffline::MonitorEnsemble::electronId_
edm::InputTag electronId_
electronId label
Definition: TopDiLeptonOfflineDQM.h:105
TopDiLeptonOffline::MonitorEnsemble::muonSelect_
StringCutObjectSelector< reco::Muon > * muonSelect_
extra selection on muons
Definition: TopDiLeptonOfflineDQM.h:125
TopDiLeptonOffline::MonitorEnsemble::book
void book(std::string directory)
book histograms in subdirectory directory
Definition: TopDiLeptonOfflineDQM.cc:113
TopDiLeptonOffline::MonitorEnsemble::diMuonPaths_
std::vector< std::string > diMuonPaths_
trigger paths for di muon channel
Definition: TopDiLeptonOfflineDQM.h:102
TopDiLeptonOffline::MonitorEnsemble::lowerEdge_
double lowerEdge_
mass window upper and lower edge
Definition: TopDiLeptonOfflineDQM.h:137
TopDiLeptonOffline::MonitorEnsemble::verbosity_
Level verbosity_
verbosity level for booking
Definition: TopDiLeptonOfflineDQM.h:84
TopDiLeptonOffline::MonitorEnsemble::elecSelect_
StringCutObjectSelector< reco::GsfElectron > * elecSelect_
extra selection on electrons
Definition: TopDiLeptonOfflineDQM.h:120
TopDiLeptonOffline::MonitorEnsemble::mets_
std::vector< edm::InputTag > mets_
considers a vector of METs
Definition: TopDiLeptonOfflineDQM.h:94
TopDiLeptonOffline::MonitorEnsemble::elecMuPaths_
std::vector< std::string > elecMuPaths_
Definition: TopDiLeptonOfflineDQM.h:100
TopDiLeptonOffline::MonitorEnsemble::jetIDLabel_
edm::InputTag jetIDLabel_
jetID as an extra selection type
Definition: TopDiLeptonOfflineDQM.h:130
TopDiLeptonOffline::MonitorEnsemble::triggerTable_
edm::InputTag triggerTable_
trigger table
Definition: TopDiLeptonOfflineDQM.h:97
TopDiLeptonOffline::MonitorEnsemble::~MonitorEnsemble ( )
inline

default destructor

Definition at line 53 of file TopDiLeptonOfflineDQM.h.

53 {};
TopDiLeptonOffline::MonitorEnsemble::MonitorEnsemble ( const char *  label,
const edm::ParameterSet &  cfg 
)

default contructor

TopDiLeptonOffline::MonitorEnsemble::~MonitorEnsemble ( )
inline

default destructor

Definition at line 54 of file TopHLTDiLeptonOfflineDQM.h.

54 {};

Member Function Documentation

void MonitorEnsemble::book ( std::string  directory)

book histograms in subdirectory directory

Definition at line 113 of file TopDiLeptonOfflineDQM.cc.

References DQMStore::book1D(), DQMStore::book2D(), cond::rpcobimon::current, diMuonPaths_, elecMuPaths_, hists_, label_, loggerBinLabels(), cppFunctionSkipper::operator, DQMStore::setCurrentFolder(), STANDARD, store_, AlCaHLTBitMon_QueryRunRegistry::string, triggerBinLabels(), VERBOSE, and verbosity_.

Referenced by MonitorEnsemble().

114  {
115  //set up the current directory path
116  std::string current(directory); current+=label_;
117  store_=edm::Service<DQMStore>().operator->();
118  store_->setCurrentFolder(current);
119 
120  // determine number of bins for trigger monitoring
121  unsigned int nElecMu=elecMuPaths_.size();
122  unsigned int nDiMuon=diMuonPaths_.size();
123 
124  // --- [STANDARD] --- //
125  // invariant mass of opposite charge lepton pair (only filled for same flavor)
126  hists_["invMass_" ] = store_->book1D("InvMass" , "M(lep1, lep2)" , 80, 0., 320.);
127  // invariant mass of opposite charge lepton pair (only filled for same flavor)
128  hists_["invMassLog_" ] = store_->book1D("InvMassLog" , "log_{10}(M(lep1, lep2))" , 80, .1, 2.5);
129  // invariant mass of same charge lepton pair (log10 for low mass region, only filled for same flavor)
130  hists_["invMassWC_" ] = store_->book1D("InvMassWC" , "M_{WC}(L1, L2)" , 80, 0., 320.);
131  // invariant mass of same charge lepton pair (log10 for low mass region, only filled for same flavor)
132  hists_["invMassWCLog_"] = store_->book1D("InvMassLogWC", "log_{10}(M_{WC})" , 80, .1, 2.5);
133  // decay channel [1]: muon/muon, [2]:elec/elec, [3]:elec/muon
134  hists_["decayChannel_"] = store_->book1D("DecayChannel", "Decay Channel" , 3, 0, 3);
135  // trigger efficiency estimates for the electron muon channel
136  hists_["elecMuEff_" ] = store_->book1D("ElecMuEff" , "Eff(e/#mu paths)" , nElecMu, 0., nElecMu);
137  // monitored trigger occupancy for the electron muon channel
138  hists_["elecMuMon_" ] = store_->book1D("ElecMuMon" , "Mon(e/#mu paths)" , nElecMu, 0., nElecMu);
139  // trigger efficiency estimates for the di muon channel
140  hists_["diMuonEff_" ] = store_->book1D("DiMuonEff" , "Eff(#mu/#mu paths)" , nDiMuon, 0., nDiMuon);
141  // monitored trigger occupancy for the di muon channel
142  hists_["diMuonMon_" ] = store_->book1D("DiMuonMon" , "Mon(#mu/#mu paths)" , nDiMuon, 0., nDiMuon);
143  // pt of the leading lepton
144  hists_["lep1Pt_" ] = store_->book1D("LeptPt" , "pt(lep1)" , 50, 0., 200.);
145  // pt of the 2. leading lepton
146  hists_["lep2Pt_" ] = store_->book1D("Lep2Pt" , "pt(lep2)" , 50, 0., 200.);
147  // multiplicity of jets with pt>30 (corrected to L2+L3)
148  hists_["jetMult_" ] = store_->book1D("JetMult" , "N_{30}(jet)" , 10, 0., 10.);
149  // MET (calo)
150  hists_["metCalo_" ] = store_->book1D("METCalo" , "MET_{Calo}" , 50, 0., 200.);
151 
152  // set bin labels for trigger monitoring
153  triggerBinLabels(std::string("elecMu"), elecMuPaths_);
154  triggerBinLabels(std::string("diMuon"), diMuonPaths_);
155  // set bin labels for decayChannel_
156  hists_["decayChannel_"]->setBinLabel( 1, "#mu e" , 1);
157  hists_["decayChannel_"]->setBinLabel( 2, "#mu #mu", 1);
158  hists_["decayChannel_"]->setBinLabel( 3, "e e" , 1);
159 
160  if( verbosity_==STANDARD) return;
161 
162  // --- [VERBOSE] --- //
163  // mean eta of the candidate leptons
164  hists_["sumEtaL1L2_" ] = store_->book1D("SumEtaL1L2" , "<#eta>(lep1, lep2)" , 30, -5., 5.);
165  // deltaEta between the 2 candidate leptons
166  hists_["dEtaL1L2_" ] = store_->book1D("DEtaL1L2" , "#Delta#eta(lep1,lep2)" , 30, 0., 3.);
167  // deltaPhi between the 2 candidate leptons
168  hists_["dPhiL1L2_" ] = store_->book1D("DPhiL1L2" , "#Delta#phi(lep1,lep2)" , 32, 0., 3.2);
169  // pt of the candidate electron (depending on the decay channel)
170  hists_["elecPt_" ] = store_->book1D("ElecPt" , "pt(e)" , 50, 0., 200.);
171  // relative isolation of the candidate electron (depending on the decay channel)
172  hists_["elecRelIso_" ] = store_->book1D("ElecRelIso" , "Iso_{Rel}(e)" , 50, 0., 1.);
173  // pt of the canddiate muon (depending on the decay channel)
174  hists_["muonPt_" ] = store_->book1D("MuonPt" , "pt(#mu)" , 50, 0., 200.);
175  // relative isolation of the candidate muon (depending on the decay channel)
176  hists_["muonRelIso_" ] = store_->book1D("MuonRelIso" , "Iso_{Rel}(#mu)" , 50, 0., 1.);
177  // pt of the 1. leading jet (corrected to L2+L3)
178  hists_["jet1Pt_" ] = store_->book1D("Jet1Pt" , "pt_{L2L3}(jet1)" , 60, 0., 300.);
179  // pt of the 2. leading jet (corrected to L2+L3)
180  hists_["jet2Pt_" ] = store_->book1D("Jet2Pt" , "pt_{L2L3}(jet2)" , 60, 0., 300.);
181  // MET (PF)
182  hists_["metPflow_" ] = store_->book1D("METPflow" , "MET_{Pflow}" , 50, 0., 200.);
183  // MET (TC)
184  hists_["metTC_" ] = store_->book1D("METTC" , "MET_{TC}" , 50, 0., 200.);
185  // dz for muons (to suppress cosmis)
186  hists_["muonDelZ_" ] = store_->book1D("MuonDelZ" , "d_{z}(#mu)" , 50, -25., 25.);
187  // dxy for muons (to suppress cosmics)
188  hists_["muonDelXY_" ] = store_->book2D("MuonDelXY" , "d_{xy}(#mu)" , 50, -0.1, 0.1, 50, -0.1, 0.1 );
189  // lepton multiplicity after std isolation
190  hists_["lepMultIso_" ] = store_->book2D("LepMultIso" , "N_{Iso}(e) vs N_{Iso}(#mu)" , 5, 0., 5., 5, 0., 5.);
191 
192  // set axes titles for dxy for muons
193  hists_["muonDelXY_" ]->setAxisTitle( "x [cm]", 1); hists_["muonDelXY_" ]->setAxisTitle( "y [cm]", 2);
194  // set axes titles for lepton multiplicity after std isolation
195  hists_["lepMultIso_" ]->setAxisTitle( "N_{Iso}(#mu)", 1); hists_["lepMultIso_" ]->setAxisTitle( "N_{Iso}(elec)", 2);
196 
197  if( verbosity_==VERBOSE) return;
198 
199  // --- [DEBUG] --- //
200  // electron multiplicity after std isolation
201  hists_["elecMultIso_" ] = store_->book1D("ElecMultIso" , "N_{Iso}(e)" , 10, 0., 10.);
202  // muon multiplicity after std isolation
203  hists_["muonMultIso_" ] = store_->book1D("MuonMultIso" , "N_{Iso}(#mu)" , 10, 0., 10.);
204  // calo isolation of the candidate muon (depending on the decay channel)
205  hists_["muonCalIso_" ] = store_->book1D("MuonCalIso" , "Iso_{Cal}(#mu)" , 50, 0., 1.);
206  // track isolation of the candidate muon (depending on the decay channel)
207  hists_["muonTrkIso_" ] = store_->book1D("MuonTrkIso" , "Iso_{Trk}(#mu)" , 50, 0., 1.);
208  // calo isolation of the candidate electron (depending on the decay channel)
209  hists_["elecCalIso_" ] = store_->book1D("ElecCalIso" , "Iso_{Cal}(e)" , 50, 0., 1.);
210  // track isolation of the candidate electron (depending on the decay channel)
211  hists_["elecTrkIso_" ] = store_->book1D("ElecTrkIso" , "Iso_{Trk}(e)" , 50, 0., 1.);
212  // eta of the leading jet
213  hists_["jet1Eta_" ] = store_->book1D("Jet1Eta" , "#eta(jet1)" , 30, -5., 5.);
214  // eta of the 2. leading jet
215  hists_["jet2Eta_" ] = store_->book1D("Jet2Eta" , "#eta(jet2)" , 30, -5., 5.);
216  // pt of the 1. leading jet (not corrected)
217  hists_["jet1PtRaw_" ] = store_->book1D("Jet1PtRaw" , "pt_{Raw}(jet1)" , 60, 0., 300.);
218  // pt of the 2. leading jet (not corrected)
219  hists_["jet2PtRaw_" ] = store_->book1D("Jet2PtRaw" , "pt_{Raw}(jet2)" , 60, 0., 300.);
220  // deltaEta between the 2 leading jets
221  hists_["dEtaJet1Jet2_"] = store_->book1D("DEtaJet1Jet2", "#Delta#eta(jet1,jet2)" , 30, 0., 3.);
222  // deltaEta between the lepton and the leading jet
223  hists_["dEtaJet1Lep1_"] = store_->book1D("DEtaJet1Lep1", "#Delta#eta(jet1,lep1)" , 30, 0., 3.);
224  // deltaEta between the lepton and MET
225  hists_["dEtaLep1MET_" ] = store_->book1D("DEtaLep1MET" , "#Delta#eta(lep1,MET)" , 30, 0., 3.);
226  // deltaEta between leading jet and MET
227  hists_["dEtaJet1MET_" ] = store_->book1D("DEtaJet1MET" , "#Delta#eta(jet1,MET)" , 30, 0., 3.);
228  // deltaPhi of 2 leading jets
229  hists_["dPhiJet1Jet2_"] = store_->book1D("DPhiJet1Jet2", "#Delta#phi(jet1,jet2)" , 32, 0., 3.2);
230  // deltaPhi of 1. lepton and 1. jet
231  hists_["dPhiJet1Lep1_"] = store_->book1D("DPhiJet1Lep1", "#Delta#phi(jet1,lep1)" , 32, 0., 3.2);
232  // deltaPhi of 1. lepton and MET
233  hists_["dPhiLep1MET_" ] = store_->book1D("DPhiLep1MET" , "#Delta#phi(lep1,MET)" , 32, 0., 3.2);
234  // deltaPhi of 1. jet and MET
235  hists_["dPhiJet1MET_" ] = store_->book1D("DPhiJet1MET" , "#Delta#phi(jet1,MET)" , 32, 0., 3.2);
236  // selected dimuon events
237  hists_["diMuonLogger_"] = store_->book2D("DiMuonLogger", "Logged DiMuon Events" , 8, 0., 8., 10, 0., 10.);
238  // selected dielec events
239  hists_["diElecLogger_"] = store_->book2D("DiElecLogger", "Logged DiElec Events" , 8, 0., 8., 10, 0., 10.);
240  // selected elemu events
241  hists_["elecMuLogger_"] = store_->book2D("ElecMuLogger", "Logged ElecMu Events" , 8, 0., 8., 10, 0., 10.);
242 
243  // set bin labels for trigger monitoring
244  loggerBinLabels(std::string("diMuonLogger_"));
245  loggerBinLabels(std::string("diElecLogger_"));
246  loggerBinLabels(std::string("elecMuLogger_"));
247  return;
248  }
DQMStore::book1D
MonitorElement * book1D(const char *name, const char *title, int nchX, double lowX, double highX)
Book 1D histogram.
Definition: DQMStore.cc:722
TopDiLeptonOffline::MonitorEnsemble::loggerBinLabels
void loggerBinLabels(std::string hist)
set labels for event logging histograms
Definition: TopDiLeptonOfflineDQM.h:148
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
TopDiLeptonOffline::MonitorEnsemble::diMuonPaths_
std::vector< std::string > diMuonPaths_
trigger paths for di muon channel
Definition: TopDiLeptonOfflineDQM.h:102
TopDiLeptonOffline::MonitorEnsemble::verbosity_
Level verbosity_
verbosity level for booking
Definition: TopDiLeptonOfflineDQM.h:84
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:144
TopDiLeptonOffline::MonitorEnsemble::elecMuPaths_
std::vector< std::string > elecMuPaths_
Definition: TopDiLeptonOfflineDQM.h:100
DQMStore::book2D
MonitorElement * book2D(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY)
Book 2D histogram.
Definition: DQMStore.cc:850
DQMStore::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:434
TopDiLeptonOffline::MonitorEnsemble::triggerBinLabels
void triggerBinLabels(std::string channel, const std::vector< std::string > labels)
set configurable labels for trigger monitoring histograms
Definition: TopDiLeptonOfflineDQM.h:175
void TopDiLeptonOffline::MonitorEnsemble::book ( std::string  directory)

book histograms in subdirectory directory

bool TopDiLeptonOffline::MonitorEnsemble::booked ( const std::string  histName) const
inlineprivate

check if histogram was booked

Definition at line 78 of file TopDiLeptonOfflineDQM.h.

References hists_.

Referenced by fill().

78 { return hists_.find(histName.c_str())!=hists_.end(); };
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:144
bool TopDiLeptonOffline::MonitorEnsemble::booked ( const std::string  histName) const
inlineprivate

check if histogram was booked

Definition at line 79 of file TopHLTDiLeptonOfflineDQM.h.

References hists_.

79 { return hists_.find(histName.c_str())!=hists_.end(); };
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:144
MonitorEnsemble::DecayChannel MonitorEnsemble::decayChannel ( const std::vector< const reco::Muon * > &  muons,
const std::vector< const reco::GsfElectron * > &  elecs 
) const
inlineprivate

determine dileptonic decay channel

Definition at line 198 of file TopDiLeptonOfflineDQM.h.

References DIELEC, DIMUON, ELECMU, and NONE.

Referenced by fill().

199  {
200  DecayChannel type=NONE;
201  if( muons.size()>1 ){ type=DIMUON; } else if( elecs.size()>1 ){ type=DIELEC; } else if( !elecs.empty() && !muons.empty() ){ type=ELECMU; }
202  return type;
203  }
type
type
Definition: HCALResponse.h:21
patZpeak.muons
tuple muons
Definition: patZpeak.py:38
DecayChannel TopDiLeptonOffline::MonitorEnsemble::decayChannel ( const std::vector< const reco::Muon * > &  muons,
const std::vector< const reco::GsfElectron * > &  elecs 
) const
private

determine dileptonic decay channel

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

fill monitor histograms with electronId and jetCorrections

Definition at line 251 of file TopDiLeptonOfflineDQM.cc.

References DeDxDiscriminatorTools::charge(), decayChannel(), reco::deltaPhi(), reco::deltaR(), DIELEC, diElecLogged_, DIMUON, diMuonLogged_, diMuonPaths_, eidPattern_, elecIso_, ELECMU, elecMuLogged_, elecMuPaths_, elecs_, elecSelect_, electronId_, reco::LeafCandidate::et(), eta(), edm::EventAuxiliary::event(), edm::Event::eventAuxiliary(), edm::EventSetup::find(), edm::Event::getByLabel(), JetCorrector::getJetCorrector(), hists_, customizeTrackingMonitorSeedNumber::idx, metsig::jet, jetCorrector_, bTagSequences_cff::jetID, jetIDLabel_, jetIDSelect_, fwrapper::jets, jets_, jetSelect_, edm::InputTag::label(), lowerEdge_, edm::EventAuxiliary::luminosityBlock(), CaloMET_cfi::met, mets_, VarParsing::mult, metsig::muon, muonIso_, patZpeak::muons, muons_, muonSelect_, muon::overlap(), phi, reco::LeafCandidate::pt(), edm::EventAuxiliary::run(), reco::Jet::scaleEnergy(), EgammaValidation_Wenu_cff::sel, triggerTable_, and upperEdge_.

Referenced by fill().

252  {
253  // fetch trigger event if configured such
254  edm::Handle<edm::TriggerResults> triggerTable;
255  if(!triggerTable_.label().empty()) {
256  if( !event.getByLabel(triggerTable_, triggerTable) ) return;
257  }
258 
259  /*
260  ------------------------------------------------------------
261 
262  Muon Selection
263 
264  ------------------------------------------------------------
265  */
266 
267  // buffer isolated muons
268  std::vector<const reco::Muon*> isoMuons;
269 
270  edm::Handle<edm::View<reco::Muon> > muons;
271  if( !event.getByLabel(muons_, muons) ) return;
272 
273  for(edm::View<reco::Muon>::const_iterator muon=muons->begin(); muon!=muons->end(); ++muon){
274  // restrict to globalMuons
275  if( muon->isGlobalMuon() ){
276  fill("muonDelZ_" , muon->globalTrack()->vz());
277  fill("muonDelXY_", muon->globalTrack()->vx(), muon->globalTrack()->vy());
278  // apply preselection
279  if(!muonSelect_ || (*muonSelect_)(*muon)){
280  double isolationTrk = muon->pt()/(muon->pt()+muon->isolationR03().sumPt);
281  double isolationCal = muon->pt()/(muon->pt()+muon->isolationR03().emEt+muon->isolationR03().hadEt);
282  double isolationRel = (muon->isolationR03().sumPt+muon->isolationR03().emEt+muon->isolationR03().hadEt)/muon->pt();
283  fill("muonTrkIso_" , isolationTrk); fill("muonCalIso_" , isolationCal); fill("muonRelIso_" , isolationRel);
284  if(!muonIso_ || (*muonIso_)(*muon)) isoMuons.push_back(&(*muon));
285  }
286  }
287  }
288  fill("muonMultIso_", isoMuons.size());
289 
290  /*
291  ------------------------------------------------------------
292 
293  Electron Selection
294 
295  ------------------------------------------------------------
296  */
297 
298  // buffer isolated electronss
299  std::vector<const reco::GsfElectron*> isoElecs;
300  edm::Handle<edm::ValueMap<float> > electronId;
301  if(!electronId_.label().empty()) {
302  if( !event.getByLabel(electronId_, electronId) ) return;
303  }
304 
305  edm::Handle<edm::View<reco::GsfElectron> > elecs;
306  if( !event.getByLabel(elecs_, elecs) ) return;
307 
308  for(edm::View<reco::GsfElectron>::const_iterator elec=elecs->begin(); elec!=elecs->end(); ++elec){
309  // restrict to electrons with good electronId
310  int idx = elec-elecs->begin();
311  if( electronId_.label().empty() ? true : ((int)(*electronId)[elecs->refAt(idx)] & eidPattern_) ){
312  // apply preselection
313  if(!elecSelect_ || (*elecSelect_)(*elec)){
314  double isolationTrk = elec->pt()/(elec->pt()+elec->dr03TkSumPt());
315  double isolationCal = elec->pt()/(elec->pt()+elec->dr03EcalRecHitSumEt()+elec->dr03HcalTowerSumEt());
316  double isolationRel = (elec->dr03TkSumPt()+elec->dr03EcalRecHitSumEt()+elec->dr03HcalTowerSumEt())/elec->pt();
317  fill("elecTrkIso_" , isolationTrk); fill("elecCalIso_" , isolationCal); fill("elecRelIso_" , isolationRel);
318  if(!elecIso_ || (*elecIso_)(*elec)) isoElecs.push_back(&(*elec));
319  }
320  }
321  }
322  fill("elecMultIso_", isoElecs.size());
323 
324  /*
325  ------------------------------------------------------------
326 
327  Jet Selection
328 
329  ------------------------------------------------------------
330  */
331 
332  const JetCorrector* corrector=0;
333  if(!jetCorrector_.empty()){
334  // check whether a jet correcto is in the event setup or not
335  if(setup.find( edm::eventsetup::EventSetupRecordKey::makeKey<JetCorrectionsRecord>() )){
336  corrector = JetCorrector::getJetCorrector(jetCorrector_, setup);
337  }
338  else{
339  edm::LogVerbatim( "TopDiLeptonOfflineDQM" )
340  << "\n"
341  << "------------------------------------------------------------------------------------- \n"
342  << " No JetCorrectionsRecord available from EventSetup: \n"
343  << " - Jets will not be corrected. \n"
344  << " - If you want to change this add the following lines to your cfg file: \n"
345  << " \n"
346  << " ## load jet corrections \n"
347  << " process.load(\"JetMETCorrections.Configuration.JetCorrectionServicesAllAlgos_cff\") \n"
348  << " process.prefer(\"ak5CaloL2L3\") \n"
349  << " \n"
350  << "------------------------------------------------------------------------------------- \n";
351  }
352  }
353 
354  unsigned int mult=0;
355  // buffer leadingJets
356  std::vector<reco::Jet> leadingJets;
357  edm::Handle<edm::View<reco::Jet> > jets;
358  if( !event.getByLabel(jets_, jets) ) return;
359 
360  edm::Handle<reco::JetIDValueMap> jetID;
361  if(jetIDSelect_){
362  if( !event.getByLabel(jetIDLabel_, jetID) ) return;
363  }
364 
365  for(edm::View<reco::Jet>::const_iterator jet=jets->begin(); jet!=jets->end(); ++jet){
366  unsigned int idx=jet-jets->begin();
367  if( jetIDSelect_ && dynamic_cast<const reco::CaloJet*>(jets->refAt(idx).get())){
368  if(!(*jetIDSelect_)((*jetID)[jets->refAt(idx)])) continue;
369  }
370  // chekc additional jet selection for calo, pf and bare reco jets
371  if(dynamic_cast<const reco::CaloJet*>(&*jet)){
372  reco::CaloJet sel = dynamic_cast<const reco::CaloJet&>(*jet); sel.scaleEnergy(corrector ? corrector->correction(*jet) : 1.);
373  StringCutObjectSelector<reco::CaloJet> jetSelect(jetSelect_); if(!jetSelect(sel)){ continue;}
374  }
375  else if(dynamic_cast<const reco::PFJet*>(&*jet)){
376  reco::PFJet sel= dynamic_cast<const reco::PFJet&>(*jet); sel.scaleEnergy(corrector ? corrector->correction(*jet) : 1.);
377  StringCutObjectSelector<reco::PFJet> jetSelect(jetSelect_); if(!jetSelect(sel)) continue;
378  }
379  else{
380  reco::Jet sel = *jet; sel.scaleEnergy(corrector ? corrector->correction(*jet) : 1.);
381  StringCutObjectSelector<reco::Jet> jetSelect(jetSelect_); if(!jetSelect(sel)) continue;
382  }
383  // check for overlaps
384  bool overlap=false;
385  for(std::vector<const reco::GsfElectron*>::const_iterator elec=isoElecs.begin(); elec!=isoElecs.end(); ++elec){
386  if(reco::deltaR((*elec)->eta(), (*elec)->phi(), jet->eta(), jet->phi())<0.4){overlap=true; break;}
387  } if(overlap){continue;}
388  // prepare jet to fill monitor histograms
389  reco::Jet monitorJet=*jet; monitorJet.scaleEnergy(corrector ? corrector->correction(*jet) : 1.);
390  ++mult; // determine jet multiplicity
391  if(idx==0) {
392  leadingJets.push_back(monitorJet);
393  fill("jet1Pt_" , monitorJet.pt());
394  fill("jet1PtRaw_" , jet->pt() );
395  fill("jet1Eta_" , jet->eta());
396  }
397  if(idx==1) {
398  leadingJets.push_back(monitorJet);
399  fill("jet2Pt_" , monitorJet.pt());
400  fill("jet2PtRaw_" , jet->pt() );
401  fill("jet2Eta_" , jet->eta());
402  }
403  }
404  if(leadingJets.size()>1){
405  fill("dEtaJet1Jet2_" , leadingJets[0].eta()-leadingJets[1].eta());
406  fill("dPhiJet1Jet2_" , reco::deltaPhi(leadingJets[0].phi(), leadingJets[1].phi()));
407  if( !isoMuons.empty() ){
408  if( isoElecs.empty() || isoMuons[0]->pt()>isoElecs[0]->pt() ){
409  fill("dEtaJet1Lep1_" , isoMuons[0]->eta()-leadingJets[0].eta());
410  fill("dPhiJet1Lep1_" , reco::deltaPhi(isoMuons[0]->phi() , leadingJets[0].phi()));
411  }
412  }
413  if( !isoElecs.empty() ){
414  if( isoMuons.empty() || isoElecs[0]->pt()>isoMuons[0]->pt() ){
415  fill("dEtaJet1Lep1_" , isoElecs[0]->eta()-leadingJets[0].eta());
416  fill("dPhiJet1Lep1_" , reco::deltaPhi(isoElecs[0]->phi() , leadingJets[0].phi()));
417  }
418  }
419  }
420  fill("jetMult_", mult);
421 
422  /*
423  ------------------------------------------------------------
424 
425  MET Selection
426 
427  ------------------------------------------------------------
428  */
429 
430  // buffer for event logging
431  reco::MET caloMET;
432  for(std::vector<edm::InputTag>::const_iterator met_=mets_.begin(); met_!=mets_.end(); ++met_){
433 
434  edm::Handle<edm::View<reco::MET> > met;
435  if( !event.getByLabel(*met_, met) ) continue;
436 
437  if(met->begin()!=met->end()){
438  unsigned int idx=met_-mets_.begin();
439  if(idx==0){
440  caloMET=*met->begin();
441  fill("metCalo_", met->begin()->et());
442  if(!leadingJets.empty()){
443  fill("dEtaJet1MET_" , leadingJets[0].eta()-met->begin()->eta());
444  fill("dPhiJet1MET_" , reco::deltaPhi(leadingJets[0].phi(), met->begin()->phi()));
445  }
446  if( !isoMuons.empty() ){
447  if( isoElecs.empty() || isoMuons[0]->pt()>isoElecs[0]->pt() ){
448  fill("dEtaLep1MET_" , isoMuons[0]->eta()-met->begin()->eta());
449  fill("dPhiLep1MET_" , reco::deltaPhi(isoMuons[0]->phi(), met->begin()->phi()));
450  }
451  }
452  if( !isoElecs.empty() ){
453  if( isoMuons.empty() || isoElecs[0]->pt()>isoMuons[0]->pt() ){
454  fill("dEtaLep1MET_" , isoElecs[0]->eta()-met->begin()->eta());
455  fill("dPhiLep1MET_" , reco::deltaPhi(isoElecs[0]->phi(), met->begin()->phi()));
456  }
457  }
458  }
459  if(idx==1){ fill("metTC_" , met->begin()->et());}
460  if(idx==2){ fill("metPflow_", met->begin()->et());}
461  }
462  }
463 
464 
465  /*
466  ------------------------------------------------------------
467 
468  Event Monitoring
469 
470  ------------------------------------------------------------
471  */
472 
473  // check number of isolated leptons
474  fill("lepMultIso_", isoMuons.size(), isoElecs.size());
475  // ELECMU channel
476  if( decayChannel(isoMuons, isoElecs) == ELECMU ){
477  fill("decayChannel_", 0.5);
478  double mass = (isoElecs[0]->p4()+isoMuons[0]->p4()).mass();
479  if( (lowerEdge_==-1. && upperEdge_==-1.) || (lowerEdge_<mass && mass<upperEdge_) ){
480  fill("dEtaL1L2_" , isoElecs[0]->eta()-isoMuons[0]->eta());
481  fill("sumEtaL1L2_", (isoElecs[0]->eta()+isoMuons[0]->eta())/2);
482  fill("dPhiL1L2_" , reco::deltaPhi(isoElecs[0]->phi(), isoMuons[0]->eta()));
483  fill("elecPt_", isoElecs[0]->pt()); fill("muonPt_", isoMuons[0]->pt());
484  fill("lep1Pt_", isoElecs[0]->pt()>isoMuons[0]->pt() ? isoElecs[0]->pt() : isoMuons[0]->pt());
485  fill("lep2Pt_", isoElecs[0]->pt()>isoMuons[0]->pt() ? isoMuons[0]->pt() : isoElecs[0]->pt());
486  // fill plots for trigger monitoring
487  if(!triggerTable_.label().empty()) fill(event, *triggerTable, "elecMu", elecMuPaths_);
488  if(elecMuLogged_<=hists_.find("elecMuLogger_")->second->getNbinsY()){
489  // log runnumber, lumi block, event number & some
490  // more pysics infomation for interesting events
491  fill("elecMuLogger_", 0.5, elecMuLogged_+0.5, event.eventAuxiliary().run());
492  fill("elecMuLogger_", 1.5, elecMuLogged_+0.5, event.eventAuxiliary().luminosityBlock());
493  fill("elecMuLogger_", 2.5, elecMuLogged_+0.5, event.eventAuxiliary().event());
494  fill("elecMuLogger_", 3.5, elecMuLogged_+0.5, isoMuons[0]->pt());
495  fill("elecMuLogger_", 4.5, elecMuLogged_+0.5, isoElecs[0]->pt());
496  if(leadingJets.size()>0) fill("elecMuLogger_", 5.5, elecMuLogged_+0.5, leadingJets[0].pt());
497  if(leadingJets.size()>1) fill("elecMuLogger_", 6.5, elecMuLogged_+0.5, leadingJets[1].pt());
498  fill("elecMuLogger_", 7.5, elecMuLogged_+0.5, caloMET.et());
499  ++elecMuLogged_;
500  }
501  }
502  }
503 
504  // DIMUON channel
505  if( decayChannel(isoMuons, isoElecs) == DIMUON ){
506  fill("decayChannel_", 1.5);
507  int charge = isoMuons[0]->charge()*isoMuons[1]->charge();
508  double mass = (isoMuons[0]->p4()+isoMuons[1]->p4()).mass();
509  fill(charge<0 ? "invMass_" : "invMassWC_" , mass );
510  fill(charge<0 ? "invMassLog_" : "invMassWCLog_" , log10(mass));
511  if((lowerEdge_==-1. && upperEdge_==-1.) || (lowerEdge_<mass && mass<upperEdge_) ){
512  fill("dEtaL1L2" , isoMuons[0]->eta()-isoMuons[1]->eta() );
513  fill("sumEtaL1L2", (isoMuons[0]->eta()+isoMuons[1]->eta())/2);
514  fill("dPhiL1L2" , reco::deltaPhi(isoMuons[0]->phi(),isoMuons[1]->phi()) );
515  fill("muonPt_", isoMuons[0]->pt()); fill("muonPt_", isoMuons[1]->pt());
516  fill("lep1Pt_", isoMuons[0]->pt()); fill("lep2Pt_", isoMuons[1]->pt());
517  // fill plots for trigger monitoring
518  if(!triggerTable_.label().empty()) fill(event, *triggerTable, "diMuon", diMuonPaths_);
519  if(diMuonLogged_<=hists_.find("diMuonLogger_")->second->getNbinsY()){
520  // log runnumber, lumi block, event number & some
521  // more pysics infomation for interesting events
522  fill("diMuonLogger_", 0.5, diMuonLogged_+0.5, event.eventAuxiliary().run());
523  fill("diMuonLogger_", 1.5, diMuonLogged_+0.5, event.eventAuxiliary().luminosityBlock());
524  fill("diMuonLogger_", 2.5, diMuonLogged_+0.5, event.eventAuxiliary().event());
525  fill("diMuonLogger_", 3.5, diMuonLogged_+0.5, isoMuons[0]->pt());
526  fill("diMuonLogger_", 4.5, diMuonLogged_+0.5, isoMuons[1]->pt());
527  if(leadingJets.size()>0) fill("diMuonLogger_", 5.5, diMuonLogged_+0.5, leadingJets[0].pt());
528  if(leadingJets.size()>1) fill("diMuonLogger_", 6.5, diMuonLogged_+0.5, leadingJets[1].pt());
529  fill("diMuonLogger_", 7.5, diMuonLogged_+0.5, caloMET.et());
530  ++diMuonLogged_;
531  }
532  }
533  }
534 
535  // DIELEC channel
536  if( decayChannel(isoMuons, isoElecs) == DIELEC ){
537  int charge = isoElecs[0]->charge()*isoElecs[1]->charge();
538  double mass = (isoElecs[0]->p4()+isoElecs[1]->p4()).mass();
539  fill("decayChannel_", 2.5);
540  fill(charge<0 ? "invMass_" : "invMassWC_" , mass );
541  fill(charge<0 ? "invMassLog_" : "invMassWCLog_" , log10(mass));
542  if((lowerEdge_==-1. && upperEdge_==-1.) || (lowerEdge_<mass && mass<upperEdge_) ){
543  fill("dEtaL1L2" , isoElecs[0]->eta()-isoElecs[1]->eta() );
544  fill("sumEtaL1L2", (isoElecs[0]->eta()+isoElecs[1]->eta())/2);
545  fill("dPhiL1L2" , reco::deltaPhi(isoElecs[0]->phi(),isoElecs[1]->phi()) );
546  fill("elecPt_", isoElecs[0]->pt()); fill("elecPt_", isoElecs[1]->pt());
547  fill("lep1Pt_", isoElecs[0]->pt()); fill("lep2Pt_", isoElecs[1]->pt());
548  if(diElecLogged_<=hists_.find("diElecLogger_")->second->getNbinsY()){
549  // log runnumber, lumi block, event number & some
550  // more pysics infomation for interesting events
551  fill("diElecLogger_", 0.5, diElecLogged_+0.5, event.eventAuxiliary().run());
552  fill("diElecLogger_", 1.5, diElecLogged_+0.5, event.eventAuxiliary().luminosityBlock());
553  fill("diElecLogger_", 2.5, diElecLogged_+0.5, event.eventAuxiliary().event());
554  fill("diElecLogger_", 3.5, diElecLogged_+0.5, isoElecs[0]->pt());
555  fill("diElecLogger_", 4.5, diElecLogged_+0.5, isoElecs[1]->pt());
556  if(leadingJets.size()>0) fill("diElecLogger_", 5.5, diElecLogged_+0.5, leadingJets[0].pt());
557  if(leadingJets.size()>1) fill("diElecLogger_", 6.5, diElecLogged_+0.5, leadingJets[1].pt());
558  fill("diElecLogger_", 7.5, diElecLogged_+0.5, caloMET.et());
559  ++diElecLogged_;
560  }
561  }
562  }
563  }
TopDiLeptonOffline::MonitorEnsemble::jetIDSelect_
StringCutObjectSelector< reco::JetID > * jetIDSelect_
extra jetID selection on calo jets
Definition: TopDiLeptonOfflineDQM.h:132
reco::LeafCandidate::et
virtual double et() const GCC11_FINAL
transverse energy
Definition: LeafCandidate.h:136
edm::View::const_iterator
boost::indirect_iterator< typename seq_t::const_iterator > const_iterator
Definition: View.h:81
CaloMET_cfi.met
tuple met
Definition: CaloMET_cfi.py:18
reco::CaloJet
Jets made from CaloTowers.
Definition: CaloJet.h:30
TopDiLeptonOffline::MonitorEnsemble::elecIso_
StringCutObjectSelector< reco::GsfElectron > * elecIso_
extra isolation criterion on electron
Definition: TopDiLeptonOfflineDQM.h:118
reco::Jet
Base class for all types of Jets.
Definition: Jet.h:21
TopDiLeptonOffline::MonitorEnsemble::decayChannel
DecayChannel decayChannel(const std::vector< const reco::Muon * > &muons, const std::vector< const reco::GsfElectron * > &elecs) const
determine dileptonic decay channel
Definition: TopDiLeptonOfflineDQM.h:198
edm::EventAuxiliary::run
RunNumber_t run() const
Definition: EventAuxiliary.h:67
EgammaValidation_Wenu_cff.sel
tuple sel
Definition: EgammaValidation_Wenu_cff.py:33
TopDiLeptonOffline::MonitorEnsemble::elecMuLogged_
int elecMuLogged_
number of logged interesting events
Definition: TopDiLeptonOfflineDQM.h:140
reco::Jet::scaleEnergy
virtual void scaleEnergy(double fScale)
scale energy of the jet
Definition: Jet.cc:445
eta
T eta() const
Definition: Basic3DVectorLD.h:179
TopDiLeptonOffline::MonitorEnsemble::elecs_
edm::InputTag elecs_
input sources for monitoring
Definition: TopDiLeptonOfflineDQM.h:92
DeDxDiscriminatorTools::charge
double charge(const std::vector< uint8_t > &Ampls)
Definition: DeDxDiscriminatorTools.cc:43
TopDiLeptonOffline::MonitorEnsemble::fill
void fill(const edm::Event &event, const edm::EventSetup &setup)
fill monitor histograms with electronId and jetCorrections
Definition: TopDiLeptonOfflineDQM.cc:251
reco::PFJet
Jets made from PFObjects.
Definition: PFJet.h:22
edm::EventAuxiliary::luminosityBlock
LuminosityBlockNumber_t luminosityBlock() const
Definition: EventAuxiliary.h:63
edm::EventSetup::find
const eventsetup::EventSetupRecord * find(const eventsetup::EventSetupRecordKey &) const
Definition: EventSetup.cc:90
muon::overlap
bool overlap(const reco::Muon &muon1, const reco::Muon &muon2, double pullX=1.0, double pullY=1.0, bool checkAdjacentChambers=false)
Definition: MuonSelectors.cc:676
bTagSequences_cff.jetID
tuple jetID
Definition: bTagSequences_cff.py:4
TopDiLeptonOffline::MonitorEnsemble::muonIso_
StringCutObjectSelector< reco::Muon > * muonIso_
extra isolation criterion on muon
Definition: TopDiLeptonOfflineDQM.h:123
TopDiLeptonOffline::MonitorEnsemble::electronId_
edm::InputTag electronId_
electronId label
Definition: TopDiLeptonOfflineDQM.h:105
reco::MET
Definition: MET.h:32
fwrapper::jets
vector< PseudoJet > jets
Definition: fastjetfortran_madfks.cc:43
TopDiLeptonOffline::MonitorEnsemble::muonSelect_
StringCutObjectSelector< reco::Muon > * muonSelect_
extra selection on muons
Definition: TopDiLeptonOfflineDQM.h:125
reco::deltaR
auto deltaR(const T1 &t1, const T2 &t2) -> decltype(t1.eta())
Definition: deltaR.h:30
edm::Event::getByLabel
bool getByLabel(InputTag const &tag, Handle< PROD > &result) const
Definition: Event.h:361
reco::deltaPhi
double deltaPhi(double phi1, double phi2)
Definition: deltaPhi.h:12
edm::Event::eventAuxiliary
EventAuxiliary const & eventAuxiliary() const
Definition: Event.h:65
TopDiLeptonOffline::MonitorEnsemble::diMuonPaths_
std::vector< std::string > diMuonPaths_
trigger paths for di muon channel
Definition: TopDiLeptonOfflineDQM.h:102
customizeTrackingMonitorSeedNumber.idx
tuple idx
DEBUGGING if hasattr(process,&quot;trackMonIterativeTracking2012&quot;): print &quot;trackMonIterativeTracking2012 D...
Definition: customizeTrackingMonitorSeedNumber.py:15
JetCorrector::getJetCorrector
static const JetCorrector * getJetCorrector(const std::string &fName, const edm::EventSetup &fSetup)
retrieve corrector from the event setup. troughs exception if something is missing ...
Definition: JetCorrector.cc:51
TopDiLeptonOffline::MonitorEnsemble::lowerEdge_
double lowerEdge_
mass window upper and lower edge
Definition: TopDiLeptonOfflineDQM.h:137
edm::InputTag::label
std::string const & label() const
Definition: InputTag.h:42
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:144
TopDiLeptonOffline::MonitorEnsemble::elecSelect_
StringCutObjectSelector< reco::GsfElectron > * elecSelect_
extra selection on electrons
Definition: TopDiLeptonOfflineDQM.h:120
patZpeak.muons
tuple muons
Definition: patZpeak.py:38
TopDiLeptonOffline::MonitorEnsemble::mets_
std::vector< edm::InputTag > mets_
considers a vector of METs
Definition: TopDiLeptonOfflineDQM.h:94
TopDiLeptonOffline::MonitorEnsemble::elecMuPaths_
std::vector< std::string > elecMuPaths_
Definition: TopDiLeptonOfflineDQM.h:100
TopDiLeptonOffline::MonitorEnsemble::jetIDLabel_
edm::InputTag jetIDLabel_
jetID as an extra selection type
Definition: TopDiLeptonOfflineDQM.h:130
TopDiLeptonOffline::MonitorEnsemble::triggerTable_
edm::InputTag triggerTable_
trigger table
Definition: TopDiLeptonOfflineDQM.h:97
reco::LeafCandidate::pt
virtual float pt() const GCC11_FINAL
transverse momentum
Definition: LeafCandidate.h:153
edm::EventAuxiliary::event
EventNumber_t event() const
Definition: EventAuxiliary.h:66
phi
Definition: DDAxes.h:10
void TopDiLeptonOffline::MonitorEnsemble::fill ( const edm::Event &  event,
const edm::EventSetup &  setup 
)

fill monitor histograms with electronId and jetCorrections

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 184 of file TopDiLeptonOfflineDQM.h.

References accept(), fill(), hists_, customizeTrackingMonitorSeedNumber::idx, monitorPath(), selectionPath(), and relativeConstraints::value.

185  {
186  for(unsigned int idx=0; idx<labels.size(); ++idx){
187  if( accept(event, triggerTable, monitorPath(labels[idx])) ){
188  fill((channel+"Mon_").c_str(), idx+0.5 );
189  // take care to fill triggerMon_ before evts is being called
190  int evts = hists_.find((channel+"Mon_").c_str())->second->getBinContent(idx+1);
191  double value = hists_.find((channel+"Eff_").c_str())->second->getBinContent(idx+1);
192  fill((channel+"Eff_").c_str(), idx+0.5, 1./evts*(accept(event, triggerTable, selectionPath(labels[idx]))-value));
193  }
194  }
195  }
TopDiLeptonOffline::MonitorEnsemble::selectionPath
std::string selectionPath(const std::string &label) const
Definition: TopDiLeptonOfflineDQM.h:66
TopDiLeptonOffline::MonitorEnsemble::monitorPath
std::string monitorPath(const std::string &label) const
Definition: TopDiLeptonOfflineDQM.h:63
accept
bool accept(const edm::Event &event, const edm::TriggerResults &triggerTable, const std::string &triggerPath)
Definition: TopDQMHelpers.h:22
TopDiLeptonOffline::MonitorEnsemble::fill
void fill(const edm::Event &event, const edm::EventSetup &setup)
fill monitor histograms with electronId and jetCorrections
Definition: TopDiLeptonOfflineDQM.cc:251
reco_calib_source_client_cfg.labels
tuple labels
Definition: reco_calib_source_client_cfg.py:80
customizeTrackingMonitorSeedNumber.idx
tuple idx
DEBUGGING if hasattr(process,&quot;trackMonIterativeTracking2012&quot;): print &quot;trackMonIterativeTracking2012 D...
Definition: customizeTrackingMonitorSeedNumber.py:15
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:144
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 185 of file TopHLTDiLeptonOfflineDQM.h.

References acceptHLT(), fill(), hists_, customizeTrackingMonitorSeedNumber::idx, monitorPath(), selectionPath(), and relativeConstraints::value.

186  {
187  for(unsigned int idx=0; idx<labels.size(); ++idx){
188  if( acceptHLT(event, triggerTable, monitorPath(labels[idx])) ){
189  fill((channel+"Mon_").c_str(), idx+0.5 );
190  // take care to fill triggerMon_ before evts is being called
191  int evts = hists_.find((channel+"Mon_").c_str())->second->getBinContent(idx+1);
192  double value = hists_.find((channel+"Eff_").c_str())->second->getBinContent(idx+1);
193  fill((channel+"Eff_").c_str(), idx+0.5, 1./evts*(acceptHLT(event, triggerTable, selectionPath(labels[idx]))-value));
194  }
195  }
196  }
TopDiLeptonOffline::MonitorEnsemble::selectionPath
std::string selectionPath(const std::string &label) const
Definition: TopDiLeptonOfflineDQM.h:66
acceptHLT
bool acceptHLT(const edm::Event &event, const edm::TriggerResults &triggerTable, const std::string &triggerPath)
Definition: TopHLTDQMHelper.h:23
TopDiLeptonOffline::MonitorEnsemble::monitorPath
std::string monitorPath(const std::string &label) const
Definition: TopDiLeptonOfflineDQM.h:63
TopDiLeptonOffline::MonitorEnsemble::fill
void fill(const edm::Event &event, const edm::EventSetup &setup)
fill monitor histograms with electronId and jetCorrections
Definition: TopDiLeptonOfflineDQM.cc:251
reco_calib_source_client_cfg.labels
tuple labels
Definition: reco_calib_source_client_cfg.py:80
customizeTrackingMonitorSeedNumber.idx
tuple idx
DEBUGGING if hasattr(process,&quot;trackMonIterativeTracking2012&quot;): print &quot;trackMonIterativeTracking2012 D...
Definition: customizeTrackingMonitorSeedNumber.py:15
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:144
void TopDiLeptonOffline::MonitorEnsemble::fill ( const std::string  histName,
double  value 
) const
inlineprivate

fill histogram if it had been booked before

Definition at line 80 of file TopDiLeptonOfflineDQM.h.

References booked(), hists_, and edm::second().

80 { if(booked(histName.c_str())) hists_.find(histName.c_str())->second->Fill(value); };
TopDiLeptonOffline::MonitorEnsemble::booked
bool booked(const std::string histName) const
check if histogram was booked
Definition: TopDiLeptonOfflineDQM.h:78
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:234
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:144
void TopDiLeptonOffline::MonitorEnsemble::fill ( const std::string  histName,
double  value 
) const
inlineprivate

fill histogram if it had been booked before

Definition at line 81 of file TopHLTDiLeptonOfflineDQM.h.

References booked(), hists_, and edm::second().

81 { if(booked(histName.c_str())) hists_.find(histName.c_str())->second->Fill(value); };
TopDiLeptonOffline::MonitorEnsemble::booked
bool booked(const std::string histName) const
check if histogram was booked
Definition: TopDiLeptonOfflineDQM.h:78
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:234
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:144
void TopDiLeptonOffline::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 82 of file TopDiLeptonOfflineDQM.h.

References booked(), hists_, and edm::second().

82 { if(booked(histName.c_str())) hists_.find(histName.c_str())->second->Fill(xValue, yValue); };
TopDiLeptonOffline::MonitorEnsemble::booked
bool booked(const std::string histName) const
check if histogram was booked
Definition: TopDiLeptonOfflineDQM.h:78
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:234
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:144
void TopDiLeptonOffline::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 83 of file TopHLTDiLeptonOfflineDQM.h.

References booked(), hists_, and edm::second().

83 { if(booked(histName.c_str())) hists_.find(histName.c_str())->second->Fill(xValue, yValue); };
TopDiLeptonOffline::MonitorEnsemble::booked
bool booked(const std::string histName) const
check if histogram was booked
Definition: TopDiLeptonOfflineDQM.h:78
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:234
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:144
void TopDiLeptonOffline::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 84 of file TopDiLeptonOfflineDQM.h.

84 { if(booked(histName.c_str())) hists_.find(histName.c_str())->second->Fill(xValue, yValue, zValue); };
TopDiLeptonOffline::MonitorEnsemble::booked
bool booked(const std::string histName) const
check if histogram was booked
Definition: TopDiLeptonOfflineDQM.h:78
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:234
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:144
void TopDiLeptonOffline::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 85 of file TopHLTDiLeptonOfflineDQM.h.

References booked(), hists_, and edm::second().

85 { if(booked(histName.c_str())) hists_.find(histName.c_str())->second->Fill(xValue, yValue, zValue); };
TopDiLeptonOffline::MonitorEnsemble::booked
bool booked(const std::string histName) const
check if histogram was booked
Definition: TopDiLeptonOfflineDQM.h:78
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:234
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:144
void MonitorEnsemble::loggerBinLabels ( std::string  hist)
inlineprivate

set labels for event logging histograms

Definition at line 148 of file TopDiLeptonOfflineDQM.h.

References hists_.

Referenced by book().

149  {
150  // set axes titles for selected events
151  hists_[hist.c_str()]->getTH1()->SetOption("TEXT");
152  hists_[hist.c_str()]->setBinLabel( 1 , "Run" , 1);
153  hists_[hist.c_str()]->setBinLabel( 2 , "Block" , 1);
154  hists_[hist.c_str()]->setBinLabel( 3 , "Event" , 1);
155  hists_[hist.c_str()]->setBinLabel( 6 , "pt_{L2L3}(jet1)" , 1);
156  hists_[hist.c_str()]->setBinLabel( 7 , "pt_{L2L3}(jet2)" , 1);
157  hists_[hist.c_str()]->setBinLabel( 8 , "MET_{Calo}" , 1);
158  hists_[hist.c_str()]->setAxisTitle("logged evts" , 2);
159 
160  if(hist=="diMuonLogger_"){
161  hists_[hist.c_str()]->setBinLabel( 4 , "pt(muon)" , 1);
162  hists_[hist.c_str()]->setBinLabel( 5 , "pt(muon)" , 1);
163  }
164  if(hist=="diElecLogger_"){
165  hists_[hist.c_str()]->setBinLabel( 4 , "pt(elec)" , 1);
166  hists_[hist.c_str()]->setBinLabel( 5 , "pt(elec)" , 1);
167  }
168  if(hist=="elecMuLogger_"){
169  hists_[hist.c_str()]->setBinLabel( 4 , "pt(elec)" , 1);
170  hists_[hist.c_str()]->setBinLabel( 5 , "pt(muon)" , 1);
171  }
172  }
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:144
void TopDiLeptonOffline::MonitorEnsemble::loggerBinLabels ( std::string  hist)
private

set labels for event logging histograms

std::string TopDiLeptonOffline::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 63 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and triggerBinLabels().

63 { return label.substr(label.find(':')+1); };
std::string TopDiLeptonOffline::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 64 of file TopHLTDiLeptonOfflineDQM.h.

64 { return label.substr(label.find(':')+1); };
std::string TopDiLeptonOffline::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 66 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and triggerBinLabels().

66 { return label.substr(0, label.find(':')); };
std::string TopDiLeptonOffline::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 67 of file TopHLTDiLeptonOfflineDQM.h.

67 { return label.substr(0, label.find(':')); };
void MonitorEnsemble::triggerBinLabels ( std::string  channel,
const std::vector< std::string >  labels 
)
inlineprivate

set configurable labels for trigger monitoring histograms

Definition at line 175 of file TopDiLeptonOfflineDQM.h.

References hists_, customizeTrackingMonitorSeedNumber::idx, monitorPath(), and selectionPath().

Referenced by book().

176  {
177  for(unsigned int idx=0; idx<labels.size(); ++idx){
178  hists_[(channel+"Mon_").c_str()]->setBinLabel( idx+1, "["+monitorPath(labels[idx])+"]", 1);
179  hists_[(channel+"Eff_").c_str()]->setBinLabel( idx+1, "["+selectionPath(labels[idx])+"]|["+monitorPath(labels[idx])+"]", 1);
180  }
181  }
TopDiLeptonOffline::MonitorEnsemble::selectionPath
std::string selectionPath(const std::string &label) const
Definition: TopDiLeptonOfflineDQM.h:66
TopDiLeptonOffline::MonitorEnsemble::monitorPath
std::string monitorPath(const std::string &label) const
Definition: TopDiLeptonOfflineDQM.h:63
reco_calib_source_client_cfg.labels
tuple labels
Definition: reco_calib_source_client_cfg.py:80
customizeTrackingMonitorSeedNumber.idx
tuple idx
DEBUGGING if hasattr(process,&quot;trackMonIterativeTracking2012&quot;): print &quot;trackMonIterativeTracking2012 D...
Definition: customizeTrackingMonitorSeedNumber.py:15
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:144
void MonitorEnsemble::triggerBinLabels ( std::string  channel,
const std::vector< std::string > &  labels 
)
inlineprivate

set configurable labels for trigger monitoring histograms

Definition at line 176 of file TopHLTDiLeptonOfflineDQM.h.

References hists_, customizeTrackingMonitorSeedNumber::idx, monitorPath(), and selectionPath().

177  {
178  for(unsigned int idx=0; idx<labels.size(); ++idx){
179  hists_[(channel+"Mon_").c_str()]->setBinLabel( idx+1, "["+monitorPath(labels[idx])+"]", 1);
180  hists_[(channel+"Eff_").c_str()]->setBinLabel( idx+1, "["+selectionPath(labels[idx])+"]|["+monitorPath(labels[idx])+"]", 1);
181  }
182  }
TopDiLeptonOffline::MonitorEnsemble::selectionPath
std::string selectionPath(const std::string &label) const
Definition: TopDiLeptonOfflineDQM.h:66
TopDiLeptonOffline::MonitorEnsemble::monitorPath
std::string monitorPath(const std::string &label) const
Definition: TopDiLeptonOfflineDQM.h:63
reco_calib_source_client_cfg.labels
tuple labels
Definition: reco_calib_source_client_cfg.py:80
customizeTrackingMonitorSeedNumber.idx
tuple idx
DEBUGGING if hasattr(process,&quot;trackMonIterativeTracking2012&quot;): print &quot;trackMonIterativeTracking2012 D...
Definition: customizeTrackingMonitorSeedNumber.py:15
TopDiLeptonOffline::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
histogram container
Definition: TopDiLeptonOfflineDQM.h:144

Member Data Documentation

int MonitorEnsemble::diElecLogged_
private

Definition at line 140 of file TopDiLeptonOfflineDQM.h.

Referenced by fill().

int MonitorEnsemble::diMuonLogged_
private

Definition at line 140 of file TopDiLeptonOfflineDQM.h.

Referenced by fill().

std::vector< std::string > MonitorEnsemble::diMuonPaths_
private

trigger paths for di muon channel

Definition at line 102 of file TopDiLeptonOfflineDQM.h.

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

int MonitorEnsemble::eidPattern_
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 116 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

StringCutObjectSelector< reco::GsfElectron > * MonitorEnsemble::elecIso_
private

extra isolation criterion on electron

Definition at line 118 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

int MonitorEnsemble::elecMuLogged_
private

number of logged interesting events

Definition at line 140 of file TopDiLeptonOfflineDQM.h.

Referenced by fill().

std::vector< std::string > MonitorEnsemble::elecMuPaths_
private

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

Definition at line 100 of file TopDiLeptonOfflineDQM.h.

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

edm::InputTag MonitorEnsemble::elecs_
private

input sources for monitoring

Definition at line 92 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

StringCutObjectSelector< reco::GsfElectron > * MonitorEnsemble::elecSelect_
private

extra selection on electrons

Definition at line 120 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

edm::InputTag MonitorEnsemble::electronId_
private

electronId label

Definition at line 105 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

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

histogram container

Definition at line 144 of file TopDiLeptonOfflineDQM.h.

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

std::string MonitorEnsemble::jetCorrector_
private

jetCorrector

Definition at line 128 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

edm::InputTag MonitorEnsemble::jetIDLabel_
private

jetID as an extra selection type

Definition at line 130 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

StringCutObjectSelector< reco::JetID > * MonitorEnsemble::jetIDSelect_
private

extra jetID selection on calo jets

Definition at line 132 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

edm::InputTag MonitorEnsemble::jets_
private

Definition at line 92 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

std::string MonitorEnsemble::jetSelect_
private

extra selection on jets (here given as std::string as it depends on the the jet type, which selections are valid and which not)

Definition at line 135 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

std::string MonitorEnsemble::label_
private

instance label

Definition at line 90 of file TopDiLeptonOfflineDQM.h.

Referenced by Mixins._Labelable::_findDependencies(), book(), Mixins._TypedParameterizable::dumpPython(), and Mixins._Labelable::setLabel().

double MonitorEnsemble::lowerEdge_
private

mass window upper and lower edge

Definition at line 137 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

std::vector< edm::InputTag > MonitorEnsemble::mets_
private

considers a vector of METs

Definition at line 94 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

StringCutObjectSelector< reco::Muon > * MonitorEnsemble::muonIso_
private

extra isolation criterion on muon

Definition at line 123 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

edm::InputTag MonitorEnsemble::muons_
private

Definition at line 92 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

StringCutObjectSelector< reco::Muon > * MonitorEnsemble::muonSelect_
private

extra selection on muons

Definition at line 125 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

DQMStore * MonitorEnsemble::store_
private

storage manager

Definition at line 142 of file TopDiLeptonOfflineDQM.h.

Referenced by book().

edm::InputTag MonitorEnsemble::triggerTable_
private

trigger table

Definition at line 97 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

double MonitorEnsemble::upperEdge_
private

Definition at line 137 of file TopDiLeptonOfflineDQM.h.

Referenced by fill(), and MonitorEnsemble().

Level MonitorEnsemble::verbosity_
private

verbosity level for booking

Definition at line 84 of file TopDiLeptonOfflineDQM.h.

Referenced by book(), and MonitorEnsemble().

Generated for CMSSW Reference Manual by doxygen 1.8.5