CMS 3D CMS Logo
SingleTopTChannelLeptonDQM.cc
Go to the documentation of this file.
1 #include "DQM/Physics/src/SingleTopTChannelLeptonDQM.h"
2 #include "DataFormats/BTauReco/interface/JetTag.h"
3 #include "DataFormats/GsfTrackReco/interface/GsfTrack.h"
4 #include "DataFormats/JetReco/interface/CaloJet.h"
5 #include "DataFormats/JetReco/interface/PFJet.h"
6 #include "DataFormats/Math/interface/deltaR.h"
7 #include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"
8 #include "DataFormats/VertexReco/interface/Vertex.h"
9 #include "JetMETCorrections/Objects/interface/JetCorrectionsRecord.h"
10 #include <iostream>
11 #include <memory>
12 
13 #include "FWCore/Framework/interface/ConsumesCollector.h"
14 #include "FWCore/Framework/interface/EDConsumerBase.h"
15 #include "FWCore/Utilities/interface/EDGetToken.h"
16 using namespace std;
17 namespace SingleTopTChannelLepton {
18 
19  // maximal number of leading jets
20  // to be used for top mass estimate
21  static const unsigned int MAXJETS = 4;
22  // nominal mass of the W boson to
23  // be used for the top mass estimate
24  static const double WMASS = 80.4;
25 
26  MonitorEnsemble::MonitorEnsemble(const char* label,
27  const edm::ParameterSet& cfg,
28  const edm::VParameterSet& vcfg,
29  edm::ConsumesCollector&& iC)
30  : label_(label),
31  elecSelect_(nullptr),
32  pvSelect_(nullptr),
33  muonIso_(nullptr),
34  muonSelect_(nullptr),
35  jetIDSelect_(nullptr),
36  jetlooseSelection_(nullptr),
37  jetSelection_(nullptr),
38  includeBTag_(false),
39  lowerEdge_(-1.),
40  upperEdge_(-1.),
41  logged_(0) {
42  // sources have to be given; this PSet is not optional
43  edm::ParameterSet sources = cfg.getParameter<edm::ParameterSet>("sources");
44  muons_ = iC.consumes<edm::View<reco::PFCandidate>>(sources.getParameter<edm::InputTag>("muons"));
45  elecs_ = iC.consumes<edm::View<reco::PFCandidate>>(sources.getParameter<edm::InputTag>("elecs"));
46  jets_ = iC.consumes<edm::View<reco::Jet>>(sources.getParameter<edm::InputTag>("jets"));
47  for (edm::InputTag const& tag : sources.getParameter<std::vector<edm::InputTag>>("mets"))
48  mets_.push_back(iC.consumes<edm::View<reco::MET>>(tag));
49  pvs_ = iC.consumes<edm::View<reco::Vertex>>(sources.getParameter<edm::InputTag>("pvs"));
50  // electronExtras are optional; they may be omitted or
51  // empty
52  if (cfg.existsAs<edm::ParameterSet>("elecExtras")) {
53  // rho for PF isolation with EA corrections
54  // eventrhoToken_ =
55  // iC.consumes<double>(edm::InputTag("fixedGridRhoFastjetAll"));
56 
57  edm::ParameterSet elecExtras = cfg.getParameter<edm::ParameterSet>("elecExtras");
58  // select is optional; in case it's not found no
59  // selection will be applied
60  if (elecExtras.existsAs<std::string>("select")) {
61  elecSelect_ = std::make_unique<StringCutObjectSelector<reco::PFCandidate>>(
62  elecExtras.getParameter<std::string>("select"));
63  }
64 
65  if (elecExtras.existsAs<std::string>("rho")) {
66  rhoTag = elecExtras.getParameter<edm::InputTag>("rho");
67  }
68  // electronId is optional; in case it's not found the
69  // InputTag will remain empty
70  if (elecExtras.existsAs<edm::ParameterSet>("electronId")) {
71  edm::ParameterSet elecId = elecExtras.getParameter<edm::ParameterSet>("electronId");
72  electronId_ = iC.consumes<edm::ValueMap<float>>(elecId.getParameter<edm::InputTag>("src"));
73  eidCutValue_ = elecId.getParameter<double>("cutValue");
74  }
75  }
76  // pvExtras are optional; they may be omitted or empty
77  if (cfg.existsAs<edm::ParameterSet>("pvExtras")) {
78  edm::ParameterSet pvExtras = cfg.getParameter<edm::ParameterSet>("pvExtras");
79  // select is optional; in case it's not found no
80  // selection will be applied
81  if (pvExtras.existsAs<std::string>("select")) {
82  pvSelect_ =
83  std::make_unique<StringCutObjectSelector<reco::Vertex>>(pvExtras.getParameter<std::string>("select"));
84  }
85  }
86  // muonExtras are optional; they may be omitted or empty
87  if (cfg.existsAs<edm::ParameterSet>("muonExtras")) {
88  edm::ParameterSet muonExtras = cfg.getParameter<edm::ParameterSet>("muonExtras");
89  // select is optional; in case it's not found no
90  // selection will be applied
91  if (muonExtras.existsAs<std::string>("select")) {
92  muonSelect_ = std::make_unique<StringCutObjectSelector<reco::PFCandidate>>(
93  muonExtras.getParameter<std::string>("select"));
94  }
95  // isolation is optional; in case it's not found no
96  // isolation will be applied
97  if (muonExtras.existsAs<std::string>("isolation")) {
98  muonIso_ = std::make_unique<StringCutObjectSelector<reco::PFCandidate>>(
99  muonExtras.getParameter<std::string>("isolation"));
100  }
101  }
102 
103  // jetExtras are optional; they may be omitted or
104  // empty
105  if (cfg.existsAs<edm::ParameterSet>("jetExtras")) {
106  edm::ParameterSet jetExtras = cfg.getParameter<edm::ParameterSet>("jetExtras");
107  // jetCorrector is optional; in case it's not found
108  // the InputTag will remain empty
109  if (jetExtras.existsAs<edm::InputTag>("jetCorrector")) {
110  mJetCorrector = iC.consumes<reco::JetCorrector>(jetExtras.getParameter<edm::InputTag>("jetCorrector"));
111  }
112  // read jetID information if it exists
113  if (jetExtras.existsAs<edm::ParameterSet>("jetID")) {
114  edm::ParameterSet jetID = jetExtras.getParameter<edm::ParameterSet>("jetID");
115  jetIDLabel_ = iC.consumes<reco::JetIDValueMap>(jetID.getParameter<edm::InputTag>("label"));
116  jetIDSelect_ =
117  std::make_unique<StringCutObjectSelector<reco::JetID>>(jetID.getParameter<std::string>("select"));
118  }
119  // select is optional; in case it's not found no
120  // selection will be applied (only implemented for
121  // CaloJets at the moment)
122  if (jetExtras.existsAs<std::string>("select")) {
123  jetSelect_ = jetExtras.getParameter<std::string>("select");
124  jetSelection_ = std::make_unique<StringCutObjectSelector<reco::PFJet>>(jetSelect_);
125  jetlooseSelection_ = std::make_unique<StringCutObjectSelector<reco::PFJet>>(
126  "chargedHadronEnergyFraction()>0 && chargedMultiplicity()>0 && chargedEmEnergyFraction()<0.99 && "
127  "neutralHadronEnergyFraction()<0.99 && neutralEmEnergyFraction()<0.99 && "
128  "(chargedMultiplicity()+neutralMultiplicity())>1");
129  }
130 
131  // jetBDiscriminators are optional; in case they are
132  // not found the InputTag will remain empty; they
133  // consist of pairs of edm::JetFlavorAssociation's &
134  // corresponding working points
135  includeBTag_ = jetExtras.existsAs<edm::ParameterSet>("jetBTaggers");
136  if (includeBTag_) {
137  edm::ParameterSet btagCSV =
138  jetExtras.getParameter<edm::ParameterSet>("jetBTaggers").getParameter<edm::ParameterSet>("cvsVertex");
139  btagCSV_ = iC.consumes<reco::JetTagCollection>(btagCSV.getParameter<edm::InputTag>("label"));
140  btagCSVWP_ = btagCSV.getParameter<double>("workingPoint");
141  }
142  }
143 
144  // triggerExtras are optional; they may be omitted or empty
145  if (cfg.existsAs<edm::ParameterSet>("triggerExtras")) {
146  edm::ParameterSet triggerExtras = cfg.getParameter<edm::ParameterSet>("triggerExtras");
147  triggerTable_ = iC.consumes<edm::TriggerResults>(triggerExtras.getParameter<edm::InputTag>("src"));
148  triggerPaths_ = triggerExtras.getParameter<std::vector<std::string>>("paths");
149  }
150 
151  // massExtras is optional; in case it's not found no mass
152  // window cuts are applied for the same flavor monitor
153  // histograms
154  if (cfg.existsAs<edm::ParameterSet>("massExtras")) {
155  edm::ParameterSet massExtras = cfg.getParameter<edm::ParameterSet>("massExtras");
156  lowerEdge_ = massExtras.getParameter<double>("lowerEdge");
157  upperEdge_ = massExtras.getParameter<double>("upperEdge");
158  }
159 
160  // setup the verbosity level for booking histograms;
161  // per default the verbosity level will be set to
162  // STANDARD. This will also be the chosen level in
163  // the case when the monitoring PSet is not found
164  verbosity_ = STANDARD;
165  if (cfg.existsAs<edm::ParameterSet>("monitoring")) {
166  edm::ParameterSet monitoring = cfg.getParameter<edm::ParameterSet>("monitoring");
167  if (monitoring.getParameter<std::string>("verbosity") == "DEBUG")
168  verbosity_ = DEBUG;
169  if (monitoring.getParameter<std::string>("verbosity") == "VERBOSE")
170  verbosity_ = VERBOSE;
171  if (monitoring.getParameter<std::string>("verbosity") == "STANDARD")
172  verbosity_ = STANDARD;
173  }
174  // and don't forget to do the histogram booking
175  directory_ = cfg.getParameter<std::string>("directory");
176  }
177 
178  void MonitorEnsemble::book(DQMStore::IBooker& ibooker) {
179  // set up the current directory path
180  std::string current(directory_);
181  current += label_;
182  ibooker.setCurrentFolder(current);
183 
184  // --- [STANDARD] --- //
185  // number of selected primary vertices
186  hists_["pvMult_"] = ibooker.book1D("PvMult", "N_{good pvs}", 50, 0., 50.);
187  // pt of the leading muon
188  hists_["muonPt_"] = ibooker.book1D("MuonPt", "pt(#mu TightId, TightIso)", 40, 0., 200.);
189  // muon multiplicity before std isolation
190  hists_["muonMult_"] = ibooker.book1D("MuonMult", "N_{loose}(#mu)", 10, 0., 10.);
191  // muon multiplicity tight Id and tight Iso
192  hists_["muonMultTight_"] = ibooker.book1D("MuonMultTight", "N_{TightIso,TightId}(#mu)", 10, 0., 10.);
193  // pt of the leading electron
194  hists_["elecPt_"] = ibooker.book1D("ElecPt", "pt(e TightId, TightIso)", 40, 0., 200.);
195  // multiplicity of jets with pt>30 (corrected to L1+L2+L3)
196  hists_["jetMult_"] = ibooker.book1D("JetMult", "N_{30}(jet)", 10, 0., 10.);
197  // multiplicity of loose Id jets with pt>30
198  hists_["jetLooseMult_"] = ibooker.book1D("JetLooseMult", "N_{30,loose}(jet)", 10, 0., 10.);
199 
200  // MET (pflow)
201  hists_["metPflow_"] = ibooker.book1D("METPflow", "MET_{Pflow}", 50, 0., 200.);
202  // W mass estimate
203  hists_["massW_"] = ibooker.book1D("MassW", "M(W)", 60, 0., 300.);
204  // Top mass estimate
205  hists_["massTop_"] = ibooker.book1D("MassTop", "M(Top)", 50, 0., 500.);
206  // W mass transverse estimate mu
207  hists_["MTWm_"] = ibooker.book1D("MTWm", "M_{T}^{W}(#mu)", 60, 0., 300.);
208  // Top mass transverse estimate mu
209  hists_["mMTT_"] = ibooker.book1D("mMTT", "M_{T}^{t}(#mu)", 50, 0., 500.);
210 
211  // W mass transverse estimate e
212  hists_["MTWe_"] = ibooker.book1D("MTWe", "M_{T}^{W}(e)", 60, 0., 300.);
213  // Top mass transverse estimate e
214  hists_["eMTT_"] = ibooker.book1D("eMTT", "M_{T}^{t}(e)", 50, 0., 500.);
215 
216  // set bin labels for trigger monitoring
217  triggerBinLabels(std::string("trigger"), triggerPaths_);
218 
219  if (verbosity_ == STANDARD)
220  return;
221 
222  // --- [VERBOSE] --- //
223 
224  // eta of the leading muon
225  hists_["muonEta_"] = ibooker.book1D("MuonEta", "#eta(#mu TightId, TightIso)", 30, -3., 3.);
226  // relative isolation of the candidate muon (depending on the decay channel)
227  hists_["muonRelIso_"] = ibooker.book1D("MuonRelIso", "Iso_{Rel}(#mu TightId) (#Delta#beta Corrected)", 50, 0., 1.);
228  // phi of the leading muon
229  hists_["muonPhi_"] = ibooker.book1D("MuonPhi", "#phi(#mu TightId, TightIso)", 40, -4., 4.);
230  // eta of the leading electron
231  hists_["elecEta_"] = ibooker.book1D("ElecEta", "#eta(e tightId, TightIso)", 30, -3., 3.);
232  // std isolation variable of the leading electron
233  hists_["elecRelIso_"] = ibooker.book1D("ElecRelIso", "Iso_{Rel}(e TightId)", 50, 0., 1.);
234  // phi of the leading electron
235  hists_["elecPhi_"] = ibooker.book1D("ElecPhi", "#phi(e tightId, TightIso)", 40, -4., 4.);
236  // multiplicity of tight Id, tight Iso electorns
237  hists_["elecMultTight_"] = ibooker.book1D("ElecMultTight", "N_{TightIso,TightId}(e)", 10, 0., 10.);
238 
239  hists_["jet1Eta_"] = ibooker.book1D("Jet1Eta", "#eta_{30,loose}(jet1)", 60, -3., 3.);
240  // pt of the 1. leading jet (corrected to L2+L3)
241  hists_["jet1Pt_"] = ibooker.book1D("Jet1Pt", "pt_{30,loose}(jet1)", 60, 0., 300.);
242  // eta of the 2. leading jet (corrected to L2+L3)
243  hists_["jet2Eta_"] = ibooker.book1D("Jet2Eta", "#eta_{30,loose}(jet2)", 60, -3., 3.);
244  // pt of the 2. leading jet (corrected to L2+L3)
245  hists_["jet2Pt_"] = ibooker.book1D("Jet2Pt", "pt_{30,loose}(jet2)", 60, 0., 300.);
246 
247  // dz for muons (to suppress cosmis)
248  hists_["muonDelZ_"] = ibooker.book1D("MuonDelZ", "d_{z}(#mu)", 50, -25., 25.);
249  // dxy for muons (to suppress cosmics)
250  hists_["muonDelXY_"] = ibooker.book2D("MuonDelXY", "d_{xy}(#mu)", 50, -0.1, 0.1, 50, -0.1, 0.1);
251 
252  // set axes titles for dxy for muons
253  hists_["muonDelXY_"]->setAxisTitle("x [cm]", 1);
254  hists_["muonDelXY_"]->setAxisTitle("y [cm]", 2);
255 
256  if (verbosity_ == VERBOSE)
257  return;
258 
259  // --- [DEBUG] --- //
260  // charged hadron isolation component of the candidate muon (depending on the
261  // decay channel)
262  hists_["muonChHadIso_"] = ibooker.book1D("MuonChHadIsoComp", "ChHad_{IsoComponent}(#mu TightId)", 50, 0., 5.);
263  // neutral hadron isolation component of the candidate muon (depending on the
264  // decay channel)
265  hists_["muonNeHadIso_"] = ibooker.book1D("MuonNeHadIsoComp", "NeHad_{IsoComponent}(#mu TightId)", 50, 0., 5.);
266  // photon isolation component of the candidate muon (depending on the decay
267  // channel)
268  hists_["muonPhIso_"] = ibooker.book1D("MuonPhIsoComp", "Photon_{IsoComponent}(#mu TightId)", 50, 0., 5.);
269  // charged hadron isolation component of the candidate electron (depending on
270  // the decay channel)
271  hists_["elecChHadIso_"] = ibooker.book1D("ElectronChHadIsoComp", "ChHad_{IsoComponent}(e tightId)", 50, 0., 5.);
272  // neutral hadron isolation component of the candidate electron (depending on
273  // the decay channel)
274  hists_["elecNeHadIso_"] = ibooker.book1D("ElectronNeHadIsoComp", "NeHad_{IsoComponent}(e tightId)", 50, 0., 5.);
275  // photon isolation component of the candidate electron (depending on the
276  // decay channel)
277  hists_["elecPhIso_"] = ibooker.book1D("ElectronPhIsoComp", "Photon_{IsoComponent}(e tightId)", 50, 0., 5.);
278 
279  // multiplicity for combined secondary vertex
280  hists_["jetMultBCSVM_"] = ibooker.book1D("JetMultBCSVM", "N_{30}(CSVM)", 10, 0., 10.);
281  // btag discriminator for combined secondary vertex
282  hists_["jetBCSV_"] = ibooker.book1D("JetDiscCSV", "BJet Disc_{CSV}(JET)", 100, -1., 2.);
283  // pt of the 1. leading jet (uncorrected)
284  // hists_["jet1PtRaw_"] = ibooker.book1D("Jet1PtRaw", "pt_{Raw}(jet1)", 60, 0., 300.);
285  // pt of the 2. leading jet (uncorrected)
286  // hists_["jet2PtRaw_"] = ibooker.book1D("Jet2PtRaw", "pt_{Raw}(jet2)", 60, 0., 300.);
287  // pt of the 3. leading jet (uncorrected)
288  // hists_["jet3PtRaw_"] = ibooker.book1D("Jet3PtRaw", "pt_{Raw}(jet3)", 60, 0., 300.);
289  // pt of the 4. leading jet (uncorrected)
290  // hists_["jet4PtRaw_"] = ibooker.book1D("Jet4PtRaw", "pt_{Raw}(jet4)", 60, 0., 300.);
291  // selected events
292  hists_["eventLogger_"] = ibooker.book2D("EventLogger", "Logged Events", 9, 0., 9., 10, 0., 10.);
293 
294  // set axes titles for selected events
295  hists_["eventLogger_"]->getTH1()->SetOption("TEXT");
296  hists_["eventLogger_"]->setBinLabel(1, "Run", 1);
297  hists_["eventLogger_"]->setBinLabel(2, "Block", 1);
298  hists_["eventLogger_"]->setBinLabel(3, "Event", 1);
299  hists_["eventLogger_"]->setBinLabel(4, "pt_{30,loose}(jet1)", 1);
300  hists_["eventLogger_"]->setBinLabel(5, "pt_{30,loose}(jet2)", 1);
301  hists_["eventLogger_"]->setBinLabel(6, "pt_{30,loose}(jet3)", 1);
302  hists_["eventLogger_"]->setBinLabel(7, "pt_{30,loose}(jet4)", 1);
303  hists_["eventLogger_"]->setBinLabel(8, "M_{W}", 1);
304  hists_["eventLogger_"]->setBinLabel(9, "M_{Top}", 1);
305  hists_["eventLogger_"]->setAxisTitle("logged evts", 2);
306  return;
307  }
308 
309  void MonitorEnsemble::fill(const edm::Event& event, const edm::EventSetup& setup) {
310  // fetch trigger event if configured such
311  edm::Handle<edm::TriggerResults> triggerTable;
312 
313  /*
314  ------------------------------------------------------------
315 
316  Primary Vertex Monitoring
317 
318  ------------------------------------------------------------
319  */
320 
321  // fill monitoring plots for primary verices
322  edm::Handle<edm::View<reco::Vertex>> pvs;
323 
324  if (!event.getByToken(pvs_, pvs))
325  return;
326  const reco::Vertex& Pvertex = pvs->front();
327  unsigned int pvMult = 0;
328  for (edm::View<reco::Vertex>::const_iterator pv = pvs->begin(); pv != pvs->end(); ++pv) {
329  if (!pvSelect_ || (*pvSelect_)(*pv))
330  pvMult++;
331  }
332  fill("pvMult_", pvMult);
333  /*
334  ------------------------------------------------------------
335 
336  Electron Monitoring
337 
338  ------------------------------------------------------------
339  */
340 
341  // fill monitoring plots for electrons
342  edm::Handle<edm::View<reco::PFCandidate>> elecs;
343  reco::GsfElectron e;
344  edm::Handle<double> _rhoHandle;
345  event.getByLabel(rhoTag, _rhoHandle);
346 
347  if (!event.getByToken(elecs_, elecs))
348  return;
349 
350  // check availability of electron id
351  edm::Handle<edm::ValueMap<float>> electronId;
352  if (!electronId_.isUninitialized()) {
353  if (!event.getByToken(electronId_, electronId)) {
354  return;
355  }
356  }
357  // loop electron collection
358  unsigned int eMult = 0, eMultIso = 0;
359  std::vector<const reco::PFCandidate*> isoElecs;
360 
361  for (edm::View<reco::PFCandidate>::const_iterator elec = elecs->begin(); elec != elecs->end(); ++elec) {
362  if (elec->gsfElectronRef().isNull()) {
363  continue;
364  }
365  reco::GsfElectronRef gsf_el = elec->gsfElectronRef();
366  // restrict to electrons with good electronId
367  if (electronId_.isUninitialized()
368  ? true
369  : ((double)(*electronId)[gsf_el] >=
370  eidCutValue_)) { //This Electron Id is not currently used, but we can keep this for future needs
371  if (!elecSelect_ || (*elecSelect_)(*elec)) {
372  double el_ChHadIso = gsf_el->pfIsolationVariables().sumChargedHadronPt;
373  double el_NeHadIso = gsf_el->pfIsolationVariables().sumNeutralHadronEt;
374  double el_PhIso = gsf_el->pfIsolationVariables().sumPhotonEt;
375  double absEta = std::abs(gsf_el->superCluster()->eta());
376 
377  //Effective Area computation
378  double eA = 0;
379  if (absEta < 1.000)
380  eA = 0.1703;
381  else if (absEta < 1.479)
382  eA = 0.1715;
383  else if (absEta < 2.000)
384  eA = 0.1213;
385  else if (absEta < 2.200)
386  eA = 0.1230;
387  else if (absEta < 2.300)
388  eA = 0.1635;
389  else if (absEta < 2.400)
390  eA = 0.1937;
391  else if (absEta < 5.000)
392  eA = 0.2393;
393 
394  double rho = _rhoHandle.isValid() ? (float)(*_rhoHandle) : 0;
395  double el_pfRelIso = (el_ChHadIso + max(0., el_NeHadIso + el_PhIso - rho * eA)) / gsf_el->pt();
396 
397  //Only TightId
398  if (eMult == 0) { // Restricted to the leading tight electron
399  fill("elecRelIso_", el_pfRelIso);
400  fill("elecChHadIso_", el_ChHadIso);
401  fill("elecNeHadIso_", el_NeHadIso);
402  fill("elecPhIso_", el_PhIso);
403  }
404  ++eMult;
405 
406  if (!((el_pfRelIso < 0.0588 && absEta < 1.479) || (el_pfRelIso < 0.0571 && absEta > 1.479)))
407  continue; // PF Isolation with Effective Area Corrections according to https://twiki.cern.ch/twiki/bin/viewauth/CMS/CutBasedElectronIdentificationRun2
408 
409  // TightId and TightIso
410  if (eMultIso == 0) { //Only leading
411  e = *gsf_el;
412  fill("elecPt_", gsf_el->pt());
413  fill("elecEta_", gsf_el->eta());
414  fill("elecPhi_", gsf_el->phi());
415  }
416  ++eMultIso;
417  }
418  }
419  }
420  //fill("elecMult_", eMult);
421  fill("elecMultTight_", eMultIso);
422 
423  /*
424  ------------------------------------------------------------
425 
426  Muon Monitoring
427 
428  ------------------------------------------------------------
429  */
430 
431  // fill monitoring plots for muons
432  unsigned int mMult = 0, mTight = 0, mTightId = 0;
433 
434  edm::Handle<edm::View<reco::PFCandidate>> muons;
435  edm::View<reco::PFCandidate>::const_iterator muonit;
436  reco::MuonRef muon;
437  reco::Muon mu;
438 
439  if (!event.getByToken(muons_, muons))
440  return;
441 
442  for (edm::View<reco::PFCandidate>::const_iterator muonit = muons->begin(); muonit != muons->end(); ++muonit) {
443  if (muonit->muonRef().isNull())
444  continue;
445  reco::MuonRef muon = muonit->muonRef();
446 
447  // restrict to globalMuons
448  if (muon->isGlobalMuon()) {
449  fill("muonDelZ_", muon->innerTrack()->vz()); // CB using inner track!
450  fill("muonDelXY_", muon->innerTrack()->vx(), muon->innerTrack()->vy());
451 
452  // apply preselection
453  if ((!muonSelect_ || (*muonSelect_)(*muonit))) {
454  mMult++;
455  double chHadPt = muon->pfIsolationR04().sumChargedHadronPt;
456  double neHadEt = muon->pfIsolationR04().sumNeutralHadronEt;
457  double phoEt = muon->pfIsolationR04().sumPhotonEt;
458  double pfRelIso = (chHadPt + max(0., neHadEt + phoEt - 0.5 * muon->pfIsolationR04().sumPUPt)) /
459  muon->pt(); // CB dBeta corrected iso!
460 
461  if (!(muon->isGlobalMuon() && muon->isPFMuon() && muon->globalTrack()->normalizedChi2() < 10. &&
462  muon->globalTrack()->hitPattern().numberOfValidMuonHits() > 0 && muon->numberOfMatchedStations() > 1 &&
463  muon->innerTrack()->hitPattern().numberOfValidPixelHits() > 0 &&
464  muon->innerTrack()->hitPattern().trackerLayersWithMeasurement() > 5 &&
465  fabs(muon->muonBestTrack()->dxy(Pvertex.position())) < 0.2 &&
466  fabs(muon->muonBestTrack()->dz(Pvertex.position())) < 0.5))
467  continue; //Only tight muons
468 
469  if (mTightId == 0) {
470  fill("muonRelIso_", pfRelIso);
471  fill("muonChHadIso_", chHadPt);
472  fill("muonNeHadIso_", neHadEt);
473  fill("muonPhIso_", phoEt);
474  }
475  mTightId++;
476 
477  if (!(pfRelIso < 0.15))
478  continue; //Tight Iso
479 
480  if (mTight == 0) { //Leading tightId tightIso muon
481  mu = *(muon);
482  fill("muonPt_", muon->pt());
483  fill("muonEta_", muon->eta());
484  fill("muonPhi_", muon->phi());
485  }
486  mTight++;
487  }
488  }
489  }
490  fill("muonMult_", mMult);
491  fill("muonMultTight_", mTight);
492 
493  /*
494  ------------------------------------------------------------
495 
496  Jet Monitoring
497 
498  ------------------------------------------------------------
499  */
500 
501  // check availability of the btaggers
502  edm::Handle<reco::JetTagCollection> btagEff, btagPur, btagVtx, btagCSV;
503  if (includeBTag_) {
504  if (!event.getByToken(btagCSV_, btagCSV))
505  return;
506  }
507 
508  edm::Handle<reco::JetCorrector> corrector;
509  event.getByToken(mJetCorrector, corrector);
510  if (!event.getByToken(mJetCorrector, corrector))
511  return;
512  // load jet
513  // corrector if configured such
514  // const JetCorrector* corrector = 0;
515  // if (!jetCorrector_.empty()) {
516 
517  // check whether a jet correcto is in the event setup or not
518  // if (setup.find(edm::eventsetup::EventSetupRecordKey::makeKey<
519  // JetCorrectionsRecord>())) {
520  // corrector = JetCorrector::getJetCorrector(jetCorrector_, setup);
521  // } else {
522  // edm::LogVerbatim("SingleTopTChannelLeptonDQM")
523  // << "\n"
524  // << "-----------------------------------------------------------------"
525  // "-------------------- \n"
526  // << " No JetCorrectionsRecord available from EventSetup:\n"
527  // << " - Jets will not be corrected.\n"
528  // << " - If you want to change this add the following lines to your "
529  // "cfg file:\n"
530  // << "\n"
531  // << " ## load jet corrections\n"
532  // << " "
533  // "process.load(\"JetMETCorrections.Configuration."
534  // "JetCorrectionServicesAllAlgos_cff\") \n"
535  // << " process.prefer(\"ak5CaloL2L3\")\n"
536  // << "\n"
537  // << "-----------------------------------------------------------------"
538  // "-------------------- \n";
539  // }
540  //}
541  // loop jet collection
542  std::vector<reco::Jet> correctedJets;
543  std::vector<double> JetTagValues;
544  reco::Jet TaggedJetCand;
545  unsigned int mult = 0, multLoose = 0, multCSV = 0;
546  vector<double> bJetDiscVal;
547 
548  edm::Handle<edm::View<reco::Jet>> jets;
549  if (!event.getByToken(jets_, jets)) {
550  return;
551  }
552 
553  for (edm::View<reco::Jet>::const_iterator jet = jets->begin(); jet != jets->end(); ++jet) {
554  bool isLoose = false;
555  // check jetID for calo jets, keep functionality if we ever want to go back to those
556  // unsigned int idx = jet - jets->begin();
557  // if (dynamic_cast<const reco::CaloJet*>(&*jet)) {
558  // if (jetIDSelect_ &&
559  // dynamic_cast<const reco::CaloJet*>(jets->refAt(idx).get())) {
560  // if (!(*jetIDSelect_)((*jetID)[jets->refAt(idx)])) continue;
561  // }
562  // }
563 
564  // check additional jet selection for pf jets
565  if (dynamic_cast<const reco::PFJet*>(&*jet)) {
566  reco::PFJet sel = dynamic_cast<const reco::PFJet&>(*jet);
567  if ((*jetlooseSelection_)(sel))
568  isLoose = true;
569  sel.scaleEnergy(corrector->correction(*jet));
570  if (!(*jetSelection_)(sel))
571  continue;
572  // else if (dynamic_cast<const reco::CaloJet*>(&*jet)) {
573  // reco::CaloJet sel = dynamic_cast<const reco::CaloJet&>(*jet);
574  // sel.scaleEnergy(corrector ? corrector->correction(*jet) : 1.);
575  // if ( jetSelectCalo==nullptr)
576  // jetSelectCalo.reset(new StringCutObjectSelector<reco::CaloJet>(jetSelect_));
577  // if (!((*jetSelectCalo)(sel))) {
578  // continue;
579  // }
580  }
581  // else {
582  // reco::Jet sel = *jet;
583  // sel.scaleEnergy(corrector ? corrector->correction(*jet) : 1.);
584  // if ( jetSelectJet==nullptr)
585  // jetSelectJet.reset(new StringCutObjectSelector<reco::Jet>(jetSelect_));
586  //
587  // if (!((*jetSelectJet)(sel))) continue;
588  // }
589 
590  // prepare jet to fill monitor histograms
591  reco::Jet monitorJet = *jet;
592 
593  ++mult; // determine jet (no Id) multiplicity
594  monitorJet.scaleEnergy(corrector->correction(*jet));
595 
596  if (isLoose) { //Loose Id
597  unsigned int idx = jet - jets->begin();
598  correctedJets.push_back(monitorJet);
599  if (includeBTag_) {
600  // fill b-discriminators
601  edm::RefToBase<reco::Jet> jetRef = jets->refAt(idx);
602  fill("jetBCSV_", (*btagCSV)[jetRef]);
603  if ((*btagCSV)[jetRef] > btagCSVWP_) {
604  if (multCSV == 0) {
605  TaggedJetCand = monitorJet;
606  bJetDiscVal.push_back((*btagCSV)[jetRef]);
607  } else if (multCSV == 1) {
608  bJetDiscVal.push_back((*btagCSV)[jetRef]);
609  if (bJetDiscVal[1] > bJetDiscVal[0])
610  TaggedJetCand = monitorJet;
611  }
612  ++multCSV;
613  }
614  JetTagValues.push_back((*btagCSV)[jetRef]);
615  }
616 
617  // fill pt/eta for the leading four jets
618  if (multLoose == 0) {
619  fill("jet1Pt_", monitorJet.pt());
620  fill("jet1Eta_", monitorJet.eta());
621  };
622  if (multLoose == 1) {
623  fill("jet2Pt_", monitorJet.pt());
624  fill("jet2Eta_", monitorJet.eta());
625  }
626  multLoose++;
627  }
628  }
629  fill("jetMult_", mult);
630  fill("jetMultLoose_", multLoose);
631  fill("jetMultBCSVM_", multCSV);
632 
633  /*
634  ------------------------------------------------------------
635 
636  MET Monitoring
637 
638  ------------------------------------------------------------
639  */
640 
641  // fill monitoring histograms for met
642  reco::MET mET;
643  for (std::vector<edm::EDGetTokenT<edm::View<reco::MET>>>::const_iterator met_ = mets_.begin(); met_ != mets_.end();
644  ++met_) {
645  edm::Handle<edm::View<reco::MET>> met;
646  if (!event.getByToken(*met_, met))
647  continue;
648  if (met->begin() != met->end()) {
649  unsigned int idx = met_ - mets_.begin();
650  if (idx == 0) {
651  fill("metPflow_", met->begin()->et());
652  mET = *(met->begin());
653  }
654  }
655  }
656 
657  /*
658  ------------------------------------------------------------
659 
660  Event Monitoring
661 
662  ------------------------------------------------------------
663  */
664 
665  // fill W boson and top mass estimates
666  Calculate eventKinematics(MAXJETS, WMASS);
667  double wMass = eventKinematics.massWBoson(correctedJets);
668  double topMass = eventKinematics.massTopQuark(correctedJets);
669  if (wMass >= 0 && topMass >= 0) {
670  fill("massW_", wMass);
671  fill("massTop_", topMass);
672  }
673  // fill plots for trigger monitoring
674  if ((lowerEdge_ == -1. && upperEdge_ == -1.) || (lowerEdge_ < wMass && wMass < upperEdge_)) {
675  if (!triggerTable_.isUninitialized())
676  fill(event, *triggerTable, "trigger", triggerPaths_);
677  if (logged_ <= hists_.find("eventLogger_")->second->getNbinsY()) {
678  // log runnumber, lumi block, event number & some
679  // more pysics infomation for interesting events
680  fill("eventLogger_", 0.5, logged_ + 0.5, event.eventAuxiliary().run());
681  fill("eventLogger_", 1.5, logged_ + 0.5, event.eventAuxiliary().luminosityBlock());
682  fill("eventLogger_", 2.5, logged_ + 0.5, event.eventAuxiliary().event());
683  if (!correctedJets.empty())
684  fill("eventLogger_", 3.5, logged_ + 0.5, correctedJets[0].pt());
685  if (correctedJets.size() > 1)
686  fill("eventLogger_", 4.5, logged_ + 0.5, correctedJets[1].pt());
687  if (correctedJets.size() > 2)
688  fill("eventLogger_", 5.5, logged_ + 0.5, correctedJets[2].pt());
689  if (correctedJets.size() > 3)
690  fill("eventLogger_", 6.5, logged_ + 0.5, correctedJets[3].pt());
691  fill("eventLogger_", 7.5, logged_ + 0.5, wMass);
692  fill("eventLogger_", 8.5, logged_ + 0.5, topMass);
693  ++logged_;
694  }
695  }
696  if (multCSV != 0 && mTight == 1) {
697  double mtW = eventKinematics.tmassWBoson(&mu, mET, TaggedJetCand);
698  fill("MTWm_", mtW);
699  double MTT = eventKinematics.tmassTopQuark(&mu, mET, TaggedJetCand);
700  fill("mMTT_", MTT);
701  }
702 
703  if (multCSV != 0 && eMultIso == 1) {
704  double mtW = eventKinematics.tmassWBoson(&e, mET, TaggedJetCand);
705  fill("MTWe_", mtW);
706  double MTT = eventKinematics.tmassTopQuark(&e, mET, TaggedJetCand);
707  fill("eMTT_", MTT);
708  }
709  }
710 } // namespace SingleTopTChannelLepton
711 
712 SingleTopTChannelLeptonDQM::SingleTopTChannelLeptonDQM(const edm::ParameterSet& cfg)
713  : vertexSelect_(nullptr),
714  beamspot_(""),
715  beamspotSelect_(nullptr),
716  MuonStep(nullptr),
717  PFMuonStep(nullptr),
718  ElectronStep(nullptr),
719  PFElectronStep(nullptr),
720  PvStep(nullptr),
721  METStep(nullptr) {
722  JetSteps.clear();
723  CaloJetSteps.clear();
724  PFJetSteps.clear();
725  // configure preselection
726  edm::ParameterSet presel = cfg.getParameter<edm::ParameterSet>("preselection");
727  if (presel.existsAs<edm::ParameterSet>("trigger")) {
728  edm::ParameterSet trigger = presel.getParameter<edm::ParameterSet>("trigger");
729  triggerTable__ = consumes<edm::TriggerResults>(trigger.getParameter<edm::InputTag>("src"));
730  triggerPaths_ = trigger.getParameter<std::vector<std::string>>("select");
731  }
732  if (presel.existsAs<edm::ParameterSet>("beamspot")) {
733  edm::ParameterSet beamspot = presel.getParameter<edm::ParameterSet>("beamspot");
734  beamspot_ = beamspot.getParameter<edm::InputTag>("src");
735  beamspot__ = consumes<reco::BeamSpot>(beamspot.getParameter<edm::InputTag>("src"));
736  beamspotSelect_ =
737  std::make_unique<StringCutObjectSelector<reco::BeamSpot>>(beamspot.getParameter<std::string>("select"));
738  }
739  // configure the selection
740  std::vector<edm::ParameterSet> sel = cfg.getParameter<std::vector<edm::ParameterSet>>("selection");
741 
742  for (unsigned int i = 0; i < sel.size(); ++i) {
743  selectionOrder_.push_back(sel.at(i).getParameter<std::string>("label"));
744  selection_[selectionStep(selectionOrder_.back())] =
745  std::make_pair(sel.at(i),
746  std::make_unique<SingleTopTChannelLepton::MonitorEnsemble>(
747  selectionStep(selectionOrder_.back()).c_str(),
748  cfg.getParameter<edm::ParameterSet>("setup"),
749  cfg.getParameter<std::vector<edm::ParameterSet>>("selection"),
750  consumesCollector()));
751  }
752  for (std::vector<std::string>::const_iterator selIt = selectionOrder_.begin(); selIt != selectionOrder_.end();
753  ++selIt) {
754  std::string key = selectionStep(*selIt), type = objectType(*selIt);
755  if (selection_.find(key) != selection_.end()) {
756  using std::unique_ptr;
757 
758  if (type == "muons") {
759  MuonStep = std::make_unique<SelectionStep<reco::Muon>>(selection_[key].first, consumesCollector());
760  }
761  if (type == "muons/pf") {
762  PFMuonStep = std::make_unique<SelectionStep<reco::PFCandidate>>(selection_[key].first, consumesCollector());
763  }
764  if (type == "elecs") {
765  ElectronStep = std::make_unique<SelectionStep<reco::GsfElectron>>(selection_[key].first, consumesCollector());
766  }
767  if (type == "elecs/pf") {
768  PFElectronStep = std::make_unique<SelectionStep<reco::PFCandidate>>(selection_[key].first, consumesCollector());
769  }
770  if (type == "pvs") {
771  PvStep = std::make_unique<SelectionStep<reco::Vertex>>(selection_[key].first, consumesCollector());
772  }
773  if (type == "jets") {
774  JetSteps.push_back(std::make_unique<SelectionStep<reco::Jet>>(selection_[key].first, consumesCollector()));
775  }
776  if (type == "jets/pf") {
777  PFJetSteps.push_back(std::make_unique<SelectionStep<reco::PFJet>>(selection_[key].first, consumesCollector()));
778  }
779  if (type == "jets/calo") {
780  CaloJetSteps.push_back(
781  std::make_unique<SelectionStep<reco::CaloJet>>(selection_[key].first, consumesCollector()));
782  }
783  if (type == "met") {
784  METStep = std::make_unique<SelectionStep<reco::MET>>(selection_[key].first, consumesCollector());
785  }
786  }
787  }
788 }
789 void SingleTopTChannelLeptonDQM::bookHistograms(DQMStore::IBooker& ibooker, edm::Run const&, edm::EventSetup const&) {
790  for (auto selIt = selection_.begin(); selIt != selection_.end(); ++selIt) {
791  selIt->second.second->book(ibooker);
792  }
793 }
794 void SingleTopTChannelLeptonDQM::analyze(const edm::Event& event, const edm::EventSetup& setup) {
795  if (!triggerTable__.isUninitialized()) {
796  edm::Handle<edm::TriggerResults> triggerTable;
797  if (!event.getByToken(triggerTable__, triggerTable))
798  return;
799  if (!accept(event, *triggerTable, triggerPaths_))
800  return;
801  }
802  if (!beamspot__.isUninitialized()) {
803  edm::Handle<reco::BeamSpot> beamspot;
804  if (!event.getByToken(beamspot__, beamspot))
805  return;
806  if (!(*beamspotSelect_)(*beamspot))
807  return;
808  }
809  // apply selection steps
810  unsigned int passed = 0;
811  unsigned int nJetSteps = -1;
812  unsigned int nPFJetSteps = -1;
813  unsigned int nCaloJetSteps = -1;
814  for (std::vector<std::string>::const_iterator selIt = selectionOrder_.begin(); selIt != selectionOrder_.end();
815  ++selIt) {
816  std::string key = selectionStep(*selIt), type = objectType(*selIt);
817  if (selection_.find(key) != selection_.end()) {
818  if (type == "empty") {
819  selection_[key].second->fill(event, setup);
820  }
821  if (type == "presel") {
822  selection_[key].second->fill(event, setup);
823  }
824  if (type == "elecs" && ElectronStep != nullptr) {
825  if (ElectronStep->select(event)) {
826  ++passed;
827  selection_[key].second->fill(event, setup);
828  } else
829  break;
830  }
831  if (type == "elecs/pf" && PFElectronStep != nullptr) {
832  if (PFElectronStep->select(event, "electron")) {
833  ++passed;
834 
835  selection_[key].second->fill(event, setup);
836 
837  } else
838  break;
839  }
840  if (type == "muons" && MuonStep != nullptr) {
841  if (MuonStep->select(event)) {
842  ++passed;
843  selection_[key].second->fill(event, setup);
844  } else
845  break;
846  }
847  if (type == "muons/pf" && PFMuonStep != nullptr) {
848  if (PFMuonStep->select(event, "muon")) {
849  ++passed;
850  selection_[key].second->fill(event, setup);
851  } else
852  break;
853  }
854  if (type == "jets") {
855  nJetSteps++;
856  if (JetSteps[nJetSteps]) {
857  if (JetSteps[nJetSteps]->select(event, setup)) {
858  ++passed;
859  selection_[key].second->fill(event, setup);
860  } else
861  break;
862  }
863  }
864  if (type == "jets/pf") {
865  nPFJetSteps++;
866  if (PFJetSteps[nPFJetSteps]) {
867  if (PFJetSteps[nPFJetSteps]->select(event, setup)) {
868  ++passed;
869  selection_[key].second->fill(event, setup);
870  } else
871  break;
872  }
873  }
874  if (type == "jets/calo") {
875  nCaloJetSteps++;
876  if (CaloJetSteps[nCaloJetSteps]) {
877  if (CaloJetSteps[nCaloJetSteps]->select(event, setup)) {
878  ++passed;
879  selection_[key].second->fill(event, setup);
880  } else
881  break;
882  }
883  }
884  if (type == "met" && METStep != nullptr) {
885  if (METStep->select(event)) {
886  ++passed;
887  selection_[key].second->fill(event, setup);
888  } else
889  break;
890  }
891  }
892  }
893 }
SingleTopTChannelLeptonDQM::selectionStep
std::string selectionStep(const std::string &label)
Definition: SingleTopTChannelLeptonDQM.h:298
SingleTopTChannelLepton::MonitorEnsemble::jetlooseSelection_
std::unique_ptr< StringCutObjectSelector< reco::PFJet > > jetlooseSelection_
Definition: SingleTopTChannelLeptonDQM.h:174
PDWG_BPHSkim_cff.muons
muons
Definition: PDWG_BPHSkim_cff.py:47
SingleTopTChannelLepton::MonitorEnsemble::triggerPaths_
std::vector< std::string > triggerPaths_
Definition: SingleTopTChannelLeptonDQM.h:131
JetTag.h
reco::Jet::scaleEnergy
virtual void scaleEnergy(double fScale)
scale energy of the jet
CaloJet.h
mps_fire.i
i
Definition: mps_fire.py:428
SingleTopTChannelLepton::MonitorEnsemble::electronId_
edm::EDGetTokenT< edm::ValueMap< float > > electronId_
electronId label
Definition: SingleTopTChannelLeptonDQM.h:135
reco::Jet
Base class for all types of Jets.
Definition: Jet.h:20
SingleTopTChannelLepton::MonitorEnsemble::includeBTag_
bool includeBTag_
Definition: SingleTopTChannelLeptonDQM.h:181
dqmMemoryStats.float
float
Definition: dqmMemoryStats.py:127
SingleTopTChannelLepton::MonitorEnsemble::btagCSV_
edm::EDGetTokenT< reco::JetTagCollection > btagCSV_
Definition: SingleTopTChannelLeptonDQM.h:184
funct::false
false
Definition: Factorize.h:29
SingleTopTChannelLepton::MonitorEnsemble::jetSelect_
std::string jetSelect_
Definition: SingleTopTChannelLeptonDQM.h:178
muon
Definition: MuonCocktails.h:17
PFCandidate.h
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
amptDefaultParameters_cff.mu
mu
Definition: amptDefaultParameters_cff.py:16
edm::Run
Definition: Run.h:45
edm::EDGetTokenT
Definition: EDGetToken.h:33
SingleTopTChannelLeptonDQM::SingleTopTChannelLeptonDQM
SingleTopTChannelLeptonDQM(const edm::ParameterSet &cfg)
default constructor
Definition: SingleTopTChannelLeptonDQM.cc:712
SingleTopTChannelLepton::MonitorEnsemble::jetIDSelect_
std::unique_ptr< StringCutObjectSelector< reco::JetID > > jetIDSelect_
extra jetID selection on calo jets
Definition: SingleTopTChannelLeptonDQM.h:173
singleTopDQM_cfi.select
select
Definition: singleTopDQM_cfi.py:50
PFJet.h
singleTopDQM_cfi.elecExtras
elecExtras
Definition: singleTopDQM_cfi.py:52
reco::JetCorrector
Definition: JetCorrector.h:33
SingleTopTChannelLepton::MonitorEnsemble::label_
std::string label_
instance label
Definition: SingleTopTChannelLeptonDQM.h:112
dqm::implementation::NavigatorBase::setCurrentFolder
virtual void setCurrentFolder(std::string const &fullpath)
Definition: DQMStore.cc:32
SingleTopTChannelLepton::MonitorEnsemble::pvs_
edm::EDGetTokenT< edm::View< reco::Vertex > > pvs_
Definition: SingleTopTChannelLeptonDQM.h:121
SingleTopTChannelLeptonDQM::triggerTable__
edm::EDGetTokenT< edm::TriggerResults > triggerTable__
trigger table
Definition: SingleTopTChannelLeptonDQM.h:298
edm::EDGetTokenT::isUninitialized
constexpr bool isUninitialized() const noexcept
Definition: EDGetToken.h:99
edm::VParameterSet
std::vector< ParameterSet > VParameterSet
Definition: ParameterSet.h:34
edm::EDConsumerBase::consumesCollector
ConsumesCollector consumesCollector()
Use a ConsumesCollector to gather consumes information from helper functions.
Definition: EDConsumerBase.cc:47
SingleTopTChannelLeptonDQM::sel
std::vector< edm::ParameterSet > sel
Definition: SingleTopTChannelLeptonDQM.h:340
CalibrationSummaryClient_cfi.sources
sources
Definition: CalibrationSummaryClient_cfi.py:23
reco::Vertex::position
const Point & position() const
position
Definition: Vertex.h:114
HLTObjectsMonitor_cfi.beamspot
beamspot
Definition: HLTObjectsMonitor_cfi.py:11
SingleTopTChannelLeptonDQM::PvStep
std::unique_ptr< SelectionStep< reco::Vertex > > PvStep
Definition: SingleTopTChannelLeptonDQM.h:333
SingleTopTChannelLepton::MonitorEnsemble::fill
void fill(const edm::Event &event, const edm::EventSetup &setup)
fill monitor histograms with electronId and jetCorrections
Definition: SingleTopTChannelLeptonDQM.cc:309
singleTopDQM_cfi.jets
jets
Definition: singleTopDQM_cfi.py:42
SingleTopTChannelLeptonDQM::ElectronStep
std::unique_ptr< SelectionStep< reco::GsfElectron > > ElectronStep
Definition: SingleTopTChannelLeptonDQM.h:331
SingleTopTChannelLepton::MonitorEnsemble::mJetCorrector
edm::EDGetTokenT< reco::JetCorrector > mJetCorrector
Definition: SingleTopTChannelLeptonDQM.h:137
reco::LeafCandidate::pt
double pt() const final
transverse momentum
Definition: LeafCandidate.h:146
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:171
topSingleLeptonDQM_PU_cfi.electronId
electronId
when omitted electron plots will be filled w/o cut on electronId
Definition: topSingleLeptonDQM_PU_cfi.py:39
Calculate
Helper class for the calculation of a top and a W boson mass estime.
Definition: TopDQMHelpers.h:128
SingleTopTChannelLeptonDQM::MuonStep
std::unique_ptr< SelectionStep< reco::Muon > > MuonStep
Definition: SingleTopTChannelLeptonDQM.h:329
SingleTopTChannelLepton::MonitorEnsemble::lowerEdge_
double lowerEdge_
mass window upper and lower edge
Definition: SingleTopTChannelLeptonDQM.h:189
edm::Handle< edm::TriggerResults >
singleTopDQM_cfi.setup
setup
Definition: singleTopDQM_cfi.py:37
reco::Muon
Definition: Muon.h:27
edm::Ref
Definition: AssociativeIterator.h:58
BTaggingMonitor_cfi.met
met
Definition: BTaggingMonitor_cfi.py:84
heavyIonCSV_trainingSettings.idx
idx
Definition: heavyIonCSV_trainingSettings.py:5
pfClustersFromHGC3DClusters_cfi.corrector
corrector
Definition: pfClustersFromHGC3DClusters_cfi.py:5
SingleTopTChannelLepton::MonitorEnsemble::VERBOSE
Definition: SingleTopTChannelLeptonDQM.h:58
JetCorrectionsRecord.h
SingleTopTChannelLepton::MonitorEnsemble::DEBUG
Definition: SingleTopTChannelLeptonDQM.h:58
SingleTopTChannelLeptonDQM.h
accept
bool accept(const edm::Event &event, const edm::TriggerResults &triggerTable, const std::string &triggerPath)
Definition: TopDQMHelpers.h:31
reco::MET
Definition: MET.h:41
SingleTopTChannelLepton::MonitorEnsemble::book
void book(DQMStore::IBooker &ibooker)
book histograms in subdirectory directory
Definition: SingleTopTChannelLeptonDQM.cc:178
SingleTopTChannelLepton::MonitorEnsemble::triggerTable_
edm::EDGetTokenT< edm::TriggerResults > triggerTable_
trigger table
Definition: SingleTopTChannelLeptonDQM.h:127
SingleTopTChannelLeptonDQM::beamspotSelect_
std::unique_ptr< StringCutObjectSelector< reco::BeamSpot > > beamspotSelect_
string cut selector
Definition: SingleTopTChannelLeptonDQM.h:316
singleTopDQM_cfi.pvExtras
pvExtras
Definition: singleTopDQM_cfi.py:49
GlobalPosition_Frontier_DevDB_cff.tag
tag
Definition: GlobalPosition_Frontier_DevDB_cff.py:11
HLT_FULL_cff.muon
muon
Definition: HLT_FULL_cff.py:11710
singleTopDQM_cfi.muonExtras
muonExtras
Definition: singleTopDQM_cfi.py:56
beamspot
Definition: BeamSpotWrite2Txt.h:8
singleTopDQM_cfi.elecs
elecs
Definition: singleTopDQM_cfi.py:41
reco::GsfElectron
Definition: GsfElectron.h:34
SingleTopTChannelLepton::MonitorEnsemble::elecs_
edm::EDGetTokenT< edm::View< reco::PFCandidate > > elecs_
Definition: SingleTopTChannelLeptonDQM.h:120
SingleTopTChannelLeptonDQM::objectType
std::string objectType(const std::string &label)
Definition: SingleTopTChannelLeptonDQM.h:295
EDGetToken.h
first
auto first
Definition: CAHitNtupletGeneratorKernelsImpl.h:112
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
SingleTopTChannelLepton::MonitorEnsemble::elecSelect_
std::unique_ptr< StringCutObjectSelector< reco::PFCandidate > > elecSelect_
extra selection on electrons
Definition: SingleTopTChannelLeptonDQM.h:155
Vertex.h
edm::AssociationVector
Definition: AssociationVector.h:67
SingleTopTChannelLepton::MonitorEnsemble::jets_
edm::EDGetTokenT< edm::View< reco::Jet > > jets_
input sources for monitoring
Definition: SingleTopTChannelLeptonDQM.h:117
SingleTopTChannelLepton::MonitorEnsemble::triggerBinLabels
void triggerBinLabels(std::string channel, const std::vector< std::string > labels)
set configurable labels for trigger monitoring histograms
Definition: SingleTopTChannelLeptonDQM.h:207
singleTopDQM_cfi.massExtras
massExtras
Definition: singleTopDQM_cfi.py:70
edm::View< reco::PFCandidate >
funct::true
true
Definition: Factorize.h:173
SingleTopTChannelLeptonDQM::JetSteps
std::vector< std::unique_ptr< SelectionStep< reco::Jet > > > JetSteps
Definition: SingleTopTChannelLeptonDQM.h:335
SingleTopTChannelLeptonDQM::PFElectronStep
std::unique_ptr< SelectionStep< reco::PFCandidate > > PFElectronStep
Definition: SingleTopTChannelLeptonDQM.h:332
edm::ParameterSet
Definition: ParameterSet.h:47
SingleTopTChannelLepton::WMASS
static const double WMASS
Definition: SingleTopTChannelLeptonDQM.cc:24
SingleTopTChannelLepton::MonitorEnsemble::muonSelect_
std::unique_ptr< StringCutObjectSelector< reco::PFCandidate > > muonSelect_
extra selection on muons
Definition: SingleTopTChannelLeptonDQM.h:166
EDConsumerBase.h
SingleTopTChannelLeptonDQM::selectionOrder_
std::vector< std::string > selectionOrder_
Definition: SingleTopTChannelLeptonDQM.h:320
reco::LeafCandidate::eta
double eta() const final
momentum pseudorapidity
Definition: LeafCandidate.h:152
deltaR.h
SiStripPI::max
Definition: SiStripPayloadInspectorHelper.h:169
SingleTopTChannelLepton::MAXJETS
static const unsigned int MAXJETS
Definition: SingleTopTChannelLeptonDQM.cc:21
SingleTopTChannelLepton::MonitorEnsemble::jetIDLabel_
edm::EDGetTokenT< reco::JetIDValueMap > jetIDLabel_
jetID as an extra selection type
Definition: SingleTopTChannelLeptonDQM.h:170
type
type
Definition: SiPixelVCal_PayloadInspector.cc:37
SingleTopTChannelLepton::MonitorEnsemble::hists_
std::map< std::string, MonitorElement * > hists_
Definition: SingleTopTChannelLeptonDQM.h:195
SingleTopTChannelLeptonDQM::beamspot_
edm::InputTag beamspot_
beamspot
Definition: SingleTopTChannelLeptonDQM.h:313
SingleTopTChannelLeptonDQM::PFJetSteps
std::vector< std::unique_ptr< SelectionStep< reco::PFJet > > > PFJetSteps
Definition: SingleTopTChannelLeptonDQM.h:337
SingleTopTChannelLepton::MonitorEnsemble::logged_
int logged_
number of logged interesting events
Definition: SingleTopTChannelLeptonDQM.h:192
MetAnalyzer.pv
def pv(vc)
Definition: MetAnalyzer.py:7
SingleTopTChannelLepton::MonitorEnsemble::jetSelection_
std::unique_ptr< StringCutObjectSelector< reco::PFJet > > jetSelection_
Definition: SingleTopTChannelLeptonDQM.h:175
SingleTopTChannelLeptonDQM::selection_
std::map< std::string, std::pair< edm::ParameterSet, std::unique_ptr< SingleTopTChannelLepton::MonitorEnsemble > > > selection_
Definition: SingleTopTChannelLeptonDQM.h:327
GsfTrack.h
SingleTopTChannelLeptonDQM::CaloJetSteps
std::vector< std::unique_ptr< SelectionStep< reco::CaloJet > > > CaloJetSteps
Definition: SingleTopTChannelLeptonDQM.h:336
SingleTopTChannelLepton::MonitorEnsemble::STANDARD
Definition: SingleTopTChannelLeptonDQM.h:58
SingleTopTChannelLeptonDQM::bookHistograms
void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
Definition: SingleTopTChannelLeptonDQM.cc:789
trackerHitRTTI::vector
Definition: trackerHitRTTI.h:21
SingleTopTChannelLeptonDQM::METStep
std::unique_ptr< SelectionStep< reco::MET > > METStep
Definition: SingleTopTChannelLeptonDQM.h:339
edm::EventSetup
Definition: EventSetup.h:58
FSQDQM_cfi.pvs
pvs
Definition: FSQDQM_cfi.py:12
looper.cfg
cfg
Definition: looper.py:297
Calculate::massTopQuark
double massTopQuark(const std::vector< reco::Jet > &jets)
calculate t-quark mass estimate
Definition: TopDQMHelpers.cc:19
cms::cuda::device::unique_ptr
std::unique_ptr< T, impl::DeviceDeleter > unique_ptr
Definition: device_unique_ptr.h:33
SingleTopTChannelLeptonDQM::analyze
void analyze(const edm::Event &event, const edm::EventSetup &setup) override
do this during the event loop
Definition: SingleTopTChannelLeptonDQM.cc:794
Calculate::tmassWBoson
double tmassWBoson(reco::RecoCandidate *lep, const reco::MET &met, const reco::Jet &b)
calculate W boson transverse mass estimate
Definition: TopDQMHelpers.cc:31
SingleTopTChannelLepton::MonitorEnsemble::directory_
std::string directory_
Definition: SingleTopTChannelLeptonDQM.h:198
SingleTopTChannelLepton::MonitorEnsemble::pvSelect_
std::unique_ptr< StringCutObjectSelector< reco::Vertex > > pvSelect_
Definition: SingleTopTChannelLeptonDQM.h:160
Calculate::tmassTopQuark
double tmassTopQuark(reco::RecoCandidate *lep, const reco::MET &met, const reco::Jet &b)
calculate top quark transverse mass estimate
Definition: TopDQMHelpers.cc:37
SingleTopTChannelLepton::MonitorEnsemble::upperEdge_
double upperEdge_
Definition: SingleTopTChannelLeptonDQM.h:189
std
Definition: JetResolutionObject.h:76
singleTopDQM_cfi.jetExtras
jetExtras
Definition: singleTopDQM_cfi.py:60
SingleTopTChannelLepton::MonitorEnsemble::btagCSVWP_
double btagCSVWP_
Definition: SingleTopTChannelLeptonDQM.h:187
SingleTopTChannelLeptonDQM::PFMuonStep
std::unique_ptr< SelectionStep< reco::PFCandidate > > PFMuonStep
Definition: SingleTopTChannelLeptonDQM.h:330
singleTopDQM_cfi.monitoring
monitoring
Definition: singleTopDQM_cfi.py:46
SingleTopTChannelLeptonDQM::triggerPaths_
std::vector< std::string > triggerPaths_
trigger paths
Definition: SingleTopTChannelLeptonDQM.h:305
metsig::jet
Definition: SignAlgoResolutions.h:47
edm::ValueMap< float >
dqm::implementation::IBooker::book2D
MonitorElement * book2D(TString const &name, TString const &title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, FUNC onbooking=NOOP())
Definition: DQMStore.h:177
TriggerAnalyzer.passed
passed
Definition: TriggerAnalyzer.py:62
reco::PFJet
Jets made from PFObjects.
Definition: PFJet.h:20
pseudoTop_cfi.wMass
wMass
Definition: pseudoTop_cfi.py:12
Calculate::massWBoson
double massWBoson(const std::vector< reco::Jet > &jets)
calculate W boson mass estimate
Definition: TopDQMHelpers.cc:13
SingleTopTChannelLepton::MonitorEnsemble::muons_
edm::EDGetTokenT< edm::View< reco::PFCandidate > > muons_
Definition: SingleTopTChannelLeptonDQM.h:118
SelectionStep
Templated helper class to allow a selection on a certain object collection.
Definition: TopDQMHelpers.h:238
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
edm::RefToBase< reco::Jet >
VarParsing.mult
mult
Definition: VarParsing.py:659
dqm::implementation::IBooker
Definition: DQMStore.h:43
edm::View::const_iterator
boost::indirect_iterator< typename seq_t::const_iterator > const_iterator
Definition: View.h:86
SingleTopTChannelLeptonDQM::beamspot__
edm::EDGetTokenT< reco::BeamSpot > beamspot__
Definition: SingleTopTChannelLeptonDQM.h:314
trigger
Definition: HLTPrescaleTableCond.h:8
SingleTopTChannelLepton::MonitorEnsemble::rhoTag
edm::InputTag rhoTag
Definition: SingleTopTChannelLeptonDQM.h:156
ConsumesCollector.h
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
SingleTopTChannelLepton::MonitorEnsemble::eidCutValue_
double eidCutValue_
Definition: SingleTopTChannelLeptonDQM.h:151
EgammaValidation_Wenu_cff.sel
sel
Definition: EgammaValidation_Wenu_cff.py:33
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
event
Definition: event.py:1
SingleTopTChannelLepton
Definition: SingleTopTChannelLeptonDQM.cc:17
SingleTopTChannelLepton::MonitorEnsemble::mets_
std::vector< edm::EDGetTokenT< edm::View< reco::MET > > > mets_
considers a vector of METs
Definition: SingleTopTChannelLeptonDQM.h:114
edm::Event
Definition: Event.h:73
crabWrapper.key
key
Definition: crabWrapper.py:19
edm::InputTag
Definition: InputTag.h:15
edm::ConsumesCollector
Definition: ConsumesCollector.h:45
label
const char * label
Definition: PFTauDecayModeTools.cc:11
edm::TriggerResults
Definition: TriggerResults.h:35
reco::Vertex
Definition: Vertex.h:35
SingleTopTChannelLepton::MonitorEnsemble::muonIso_
std::unique_ptr< StringCutObjectSelector< reco::PFCandidate > > muonIso_
extra isolation criterion on muon
Definition: SingleTopTChannelLeptonDQM.h:163
dqm::implementation::IBooker::book1D
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX, FUNC onbooking=NOOP())
Definition: DQMStore.h:98
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
SingleTopTChannelLepton::MonitorEnsemble::verbosity_
Level verbosity_
verbosity level for booking
Definition: SingleTopTChannelLeptonDQM.h:106
Generated for CMSSW Reference Manual by doxygen 1.8.16