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