CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
JetTester.cc
Go to the documentation of this file.
1 // Producer for validation histograms for Calo, JPT and PF jet objects
2 // F. Ratnikov, Sept. 7, 2006
3 // Modified by Chiyoung Jeong, Feb. 2, 2010
4 // Modified by J. Piedra, Sept. 11, 2013
5 
6 #include "JetTester.h"
7 
8 using namespace edm;
9 using namespace reco;
10 using namespace std;
11 
13  mInputCollection (iConfig.getParameter<edm::InputTag> ("src")),
14  mInputGenCollection (iConfig.getParameter<edm::InputTag> ("srcGen")),
15 // rhoTag (iConfig.getParameter<edm::InputTag> ("srcRho")),
16  mOutputFile (iConfig.getUntrackedParameter<std::string>("OutputFile","")),
17  JetType (iConfig.getUntrackedParameter<std::string>("JetType")),
18  mRecoJetPtThreshold (iConfig.getParameter<double> ("recoJetPtThreshold")),
19  mMatchGenPtThreshold (iConfig.getParameter<double> ("matchGenPtThreshold")),
20  mGenEnergyFractionThreshold (iConfig.getParameter<double> ("genEnergyFractionThreshold")),
21  mRThreshold (iConfig.getParameter<double> ("RThreshold")),
22  JetCorrectionService (iConfig.getParameter<std::string> ("JetCorrections"))
23 {
24  std::string inputCollectionLabel(mInputCollection.label());
25 
26  isCaloJet = (std::string("calo")==JetType);
27  isPFJet = (std::string("pf") ==JetType);
28 
29  //consumes
30  pvToken_ = consumes<std::vector<reco::Vertex> >(edm::InputTag("offlinePrimaryVertices"));
31  caloTowersToken_ = consumes<CaloTowerCollection>(edm::InputTag("towerMaker"));
32  if (isCaloJet) caloJetsToken_ = consumes<reco::CaloJetCollection>(mInputCollection);
33  if (isPFJet) pfJetsToken_ = consumes<reco::PFJetCollection>(mInputCollection);
34  genJetsToken_ = consumes<reco::GenJetCollection>(edm::InputTag(mInputGenCollection));
35  evtToken_ = consumes<edm::HepMCProduct>(edm::InputTag("generator"));
36 
37 
38  // Events variables
39  mNvtx = 0;
40 
41  // Jet parameters
42  mEta = 0;
43  mPhi = 0;
44  mEnergy = 0;
45  mP = 0;
46  mPt = 0;
47  mMass = 0;
48  mConstituents = 0;
49  mHadTiming = 0;
50  mEmTiming = 0;
51  mJetArea = 0;
52 // mRho = 0;
53 
54  // Corrected jets
55  mCorrJetPt = 0;
56  mCorrJetEta = 0;
57  mCorrJetPhi = 0;
58  mCorrJetEta_Pt40 = 0;
59  mCorrJetPhi_Pt40 = 0;
60 
61  // Corrected jets profiles
78 
79  // Generation
80  mGenEta = 0;
81  mGenPhi = 0;
82  mGenPt = 0;
83  mGenEtaFirst = 0;
84  mGenPhiFirst = 0;
85  mPtHat = 0;
86  mDeltaEta = 0;
87  mDeltaPhi = 0;
88  mDeltaPt = 0;
89 
105 
106  // Generation profiles
118 
119  // Some jet algebra
120  mEtaFirst = 0;
121  mPhiFirst = 0;
122  mPtFirst = 0;
123  mMjj = 0;
124  mNJetsEta_B_20_40 = 0;
125  mNJetsEta_E_20_40 = 0;
126  mNJetsEta_B_40 = 0;
127  mNJetsEta_E_40 = 0;
128  mNJets1 = 0;
129  mNJets2 = 0;
130 
131 // // PFJet specific
132 // mHadEnergyInHF = 0;
133 // mEmEnergyInHF = 0;
134 // mChargedEmEnergy = 0;
135 // mChargedHadronEnergy = 0;
136 // mNeutralEmEnergy = 0;
137 // mNeutralHadronEnergy = 0;
138 
139  // ---- Calo Jet specific information ----
141  maxEInEmTowers = 0;
143  maxEInHadTowers = 0;
147  emEnergyFraction = 0;
149  hadEnergyInHB = 0;
151  hadEnergyInHO = 0;
153  hadEnergyInHE = 0;
155  hadEnergyInHF = 0;
157  emEnergyInEB = 0;
159  emEnergyInEE = 0;
161  emEnergyInHF = 0;
163  towersArea = 0;
165  n90 = 0;
167  n60 = 0;
168 
169  // ---- JPT Jet specific information ----
171 // elecMultiplicity = 0;
172 
173  // ---- JPT or PF Jet specific information ----
175  muonMultiplicity = 0;
179  chargedEmEnergy = 0;
181  neutralEmEnergy = 0;
194 
195  // ---- PF Jet specific information ----
197  photonEnergy = 0;
201  electronEnergy = 0;
205  muonEnergy = 0;
207  muonEnergyFraction = 0;
209  HFHadronEnergy = 0;
213  HFEMEnergy = 0;
215  HFEMEnergyFraction = 0;
221  photonMultiplicity = 0;
227  HFEMMultiplicity = 0;
229  chargedMuEnergy = 0;
234 
236  HOEnergy = 0;
238  HOEnergyFraction = 0;
239 }
240 
242  edm::Run const & iRun,
243  edm::EventSetup const & ) {
244 
245  ibooker.setCurrentFolder("JetMET/JetValidation/"+mInputCollection.label());
246 
247  double log10PtMin = 0.50;
248  double log10PtMax = 3.75;
249  int log10PtBins = 26;
250 
251  double etaRange[91] = {-6.0, -5.8, -5.6, -5.4, -5.2, -5.0, -4.8, -4.6, -4.4, -4.2,
252  -4.0, -3.8, -3.6, -3.4, -3.2, -3.0, -2.9, -2.8, -2.7, -2.6,
253  -2.5, -2.4, -2.3, -2.2, -2.1, -2.0, -1.9, -1.8, -1.7, -1.6,
254  -1.5, -1.4, -1.3, -1.2, -1.1, -1.0, -0.9, -0.8, -0.7, -0.6,
255  -0.5, -0.4, -0.3, -0.2, -0.1,
256  0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9,
257  1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9,
258  2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9,
259  3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.2, 4.4, 4.6, 4.8,
260  5.0, 5.2, 5.4, 5.6, 5.8, 6.0};
261 
262  // Event variables
263  mNvtx = ibooker.book1D("Nvtx", "number of vertices", 60, 0, 60);
264 
265  // Jet parameters
266  mEta = ibooker.book1D("Eta", "Eta", 120, -6, 6);
267  mPhi = ibooker.book1D("Phi", "Phi", 70, -3.5, 3.5);
268  mPt = ibooker.book1D("Pt", "Pt", 100, 0, 1000);
269  mP = ibooker.book1D("P", "P", 100, 0, 1000);
270  mEnergy = ibooker.book1D("Energy", "Energy", 100, 0, 1000);
271  mMass = ibooker.book1D("Mass", "Mass", 100, 0, 200);
272  mConstituents = ibooker.book1D("Constituents", "Constituents", 100, 0, 100);
273  mHadTiming = ibooker.book1D("HadTiming", "HadTiming", 75, -50, 100);
274  mEmTiming = ibooker.book1D("EmTiming", "EmTiming", 75, -50, 100);
275  mJetArea = ibooker.book1D("JetArea", "JetArea", 100, 0, 4);
276 
277  // Corrected jets
278  if (!JetCorrectionService.empty()) {
279  mCorrJetPt = ibooker.book1D("CorrJetPt", "CorrJetPt", 150, 0, 1500);
280  mCorrJetEta = ibooker.book1D("CorrJetEta", "CorrJetEta Pt>20", 60, -6, 6);
281  mCorrJetPhi = ibooker.book1D("CorrJetPhi", "CorrJetPhi Pt>20", 70, -3.5, 3.5);
282  mCorrJetEta_Pt40 = ibooker.book1D("CorrJetEta_Pt40", "CorrJetEta Pt>40", 60, -6, 6);
283  mCorrJetPhi_Pt40 = ibooker.book1D("CorrJetPhi_Pt40", "CorrJetPhi Pt>40", 70, -3.5, 3.5);
284 
285  // Corrected jets profiles
286  mPtCorrOverReco_Pt_B = ibooker.bookProfile("PtCorrOverReco_Pt_B", "0<|eta|<1.5", log10PtBins, log10PtMin, log10PtMax, 0, 5, " ");
287  mPtCorrOverReco_Pt_E = ibooker.bookProfile("PtCorrOverReco_Pt_E", "1.5<|eta|<3", log10PtBins, log10PtMin, log10PtMax, 0, 5, " ");
288  mPtCorrOverReco_Pt_F = ibooker.bookProfile("PtCorrOverReco_Pt_F", "3<|eta|<6", log10PtBins, log10PtMin, log10PtMax, 0, 5, " ");
289 
290  mPtCorrOverReco_Eta_20_40 = ibooker.bookProfile("PtCorrOverReco_Eta_20_40", "20<genPt<40", 90, etaRange, 0, 5, " ");
291  mPtCorrOverReco_Eta_40_200 = ibooker.bookProfile("PtCorrOverReco_Eta_40_200", "40<genPt<200", 90, etaRange, 0, 5, " ");
292  mPtCorrOverReco_Eta_200_600 = ibooker.bookProfile("PtCorrOverReco_Eta_200_600", "200<genPt<600", 90, etaRange, 0, 5, " ");
293  mPtCorrOverReco_Eta_600_1500 = ibooker.bookProfile("PtCorrOverReco_Eta_600_1500", "600<genPt<1500", 90, etaRange, 0, 5, " ");
294  mPtCorrOverReco_Eta_1500_3500 = ibooker.bookProfile("PtCorrOverReco_Eta_1500_3500", "1500<genPt<3500", 90, etaRange, 0, 5, " ");
295 
296  mPtCorrOverGen_GenPt_B = ibooker.bookProfile("PtCorrOverGen_GenPt_B", "0<|eta|<1.5", log10PtBins, log10PtMin, log10PtMax, 0.8, 1.2, " ");
297  mPtCorrOverGen_GenPt_E = ibooker.bookProfile("PtCorrOverGen_GenPt_E", "1.5<|eta|<3", log10PtBins, log10PtMin, log10PtMax, 0.8, 1.2, " ");
298  mPtCorrOverGen_GenPt_F = ibooker.bookProfile("PtCorrOverGen_GenPt_F", "3<|eta|<6", log10PtBins, log10PtMin, log10PtMax, 0.8, 1.2, " ");
299 
300  mPtCorrOverGen_GenEta_20_40 = ibooker.bookProfile("PtCorrOverGen_GenEta_20_40", "20<genPt<40;#eta", 90, etaRange, 0.8, 1.2, " ");
301  mPtCorrOverGen_GenEta_40_200 = ibooker.bookProfile("PtCorrOverGen_GenEta_40_200", "40<genPt<200;#eta", 90, etaRange, 0.8, 1.2, " ");
302  mPtCorrOverGen_GenEta_200_600 = ibooker.bookProfile("PtCorrOverGen_GenEta_200_600", "200<genPt<600;#eta", 90, etaRange, 0.8, 1.2, " ");
303  mPtCorrOverGen_GenEta_600_1500 = ibooker.bookProfile("PtCorrOverGen_GenEta_600_1500", "600<genPt<1500;#eta", 90, etaRange, 0.8, 1.2, " ");
304  mPtCorrOverGen_GenEta_1500_3500 = ibooker.bookProfile("PtCorrOverGen_GenEta_1500_3500", "1500<genPt<3500;#eta", 90, etaRange, 0.8, 1.2, " ");
305  }
306 
307  mGenEta = ibooker.book1D("GenEta", "GenEta", 120, -6, 6);
308  mGenPhi = ibooker.book1D("GenPhi", "GenPhi", 70, -3.5, 3.5);
309  mGenPt = ibooker.book1D("GenPt", "GenPt", 100, 0, 1000);
310  mGenEtaFirst = ibooker.book1D("GenEtaFirst", "GenEtaFirst", 120, -6, 6);
311  mGenPhiFirst = ibooker.book1D("GenPhiFirst", "GenPhiFirst", 70, -3.5, 3.5);
312  mPtHat = ibooker.book1D("PtHat", "PtHat", 100, 0, 1000);
313  mDeltaEta = ibooker.book1D("DeltaEta", "DeltaEta", 100, -0.5, 0.5);
314  mDeltaPhi = ibooker.book1D("DeltaPhi", "DeltaPhi", 100, -0.5, 0.5);
315  mDeltaPt = ibooker.book1D("DeltaPt", "DeltaPt", 100, -1.0, 1.0);
316 
317  mPtRecoOverGen_B_20_40 = ibooker.book1D("PtRecoOverGen_B_20_40", "20<genpt<40", 50, 0, 2);
318  mPtRecoOverGen_E_20_40 = ibooker.book1D("PtRecoOverGen_E_20_40", "20<genpt<40", 50, 0, 2);
319  mPtRecoOverGen_F_20_40 = ibooker.book1D("PtRecoOverGen_F_20_40", "20<genpt<40", 50, 0, 2);
320  mPtRecoOverGen_B_40_200 = ibooker.book1D("PtRecoOverGen_B_40_200", "40<genpt<200", 50, 0, 2);
321  mPtRecoOverGen_E_40_200 = ibooker.book1D("PtRecoOverGen_E_40_200", "40<genpt<200", 50, 0, 2);
322  mPtRecoOverGen_F_40_200 = ibooker.book1D("PtRecoOverGen_F_40_200", "40<genpt<200", 50, 0, 2);
323  mPtRecoOverGen_B_200_600 = ibooker.book1D("PtRecoOverGen_B_200_600", "200<genpt<600", 50, 0, 2);
324  mPtRecoOverGen_E_200_600 = ibooker.book1D("PtRecoOverGen_E_200_600", "200<genpt<600", 50, 0, 2);
325  mPtRecoOverGen_F_200_600 = ibooker.book1D("PtRecoOverGen_F_200_600", "200<genpt<600", 50, 0, 2);
326  mPtRecoOverGen_B_600_1500 = ibooker.book1D("PtRecoOverGen_B_600_1500", "600<genpt<1500", 50, 0, 2);
327  mPtRecoOverGen_E_600_1500 = ibooker.book1D("PtRecoOverGen_E_600_1500", "600<genpt<1500", 50, 0, 2);
328  mPtRecoOverGen_F_600_1500 = ibooker.book1D("PtRecoOverGen_F_600_1500", "600<genpt<1500", 50, 0, 2);
329  mPtRecoOverGen_B_1500_3500 = ibooker.book1D("PtRecoOverGen_B_1500_3500", "1500<genpt<3500", 50, 0, 2);
330  mPtRecoOverGen_E_1500_3500 = ibooker.book1D("PtRecoOverGen_E_1500_3500", "1500<genpt<3500", 50, 0, 2);
331  mPtRecoOverGen_F_1500_3500 = ibooker.book1D("PtRecoOverGen_F_1500_3500", "1500<genpt<3500", 50, 0, 2);
332 
333  // Generation profiles
334  mPtRecoOverGen_GenPt_B = ibooker.bookProfile("PtRecoOverGen_GenPt_B", "0<|eta|<1.5", log10PtBins, log10PtMin, log10PtMax, 0, 2, " ");
335  mPtRecoOverGen_GenPt_E = ibooker.bookProfile("PtRecoOverGen_GenPt_E", "1.5<|eta|<3", log10PtBins, log10PtMin, log10PtMax, 0, 2, " ");
336  mPtRecoOverGen_GenPt_F = ibooker.bookProfile("PtRecoOverGen_GenPt_F", "3<|eta|<6", log10PtBins, log10PtMin, log10PtMax, 0, 2, " ");
337  mPtRecoOverGen_GenPhi_B = ibooker.bookProfile("PtRecoOverGen_GenPhi_B", "0<|eta|<1.5", 70, -3.5, 3.5, 0, 2, " ");
338  mPtRecoOverGen_GenPhi_E = ibooker.bookProfile("PtRecoOverGen_GenPhi_E", "1.5<|eta|<3", 70, -3.5, 3.5, 0, 2, " ");
339  mPtRecoOverGen_GenPhi_F = ibooker.bookProfile("PtRecoOverGen_GenPhi_F", "3<|eta|<6", 70, -3.5, 3.5, 0, 2, " ");
340  mPtRecoOverGen_GenEta_20_40 = ibooker.bookProfile("PtRecoOverGen_GenEta_20_40", "20<genpt<40", 50, etaRange, 0, 2, " ");
341  mPtRecoOverGen_GenEta_40_200 = ibooker.bookProfile("PtRecoOverGen_GenEta_40_200", "40<genpt<200", 50, etaRange, 0, 2, " ");
342  mPtRecoOverGen_GenEta_200_600 = ibooker.bookProfile("PtRecoOverGen_GenEta_200_600", "200<genpt<600", 50, etaRange, 0, 2, " ");
343  mPtRecoOverGen_GenEta_600_1500 = ibooker.bookProfile("PtRecoOverGen_GenEta_600_1500", "600<genpt<1500", 50, etaRange, 0, 2, " ");
344  mPtRecoOverGen_GenEta_1500_3500 = ibooker.bookProfile("PtRecoOverGen_GenEta_1500_3500", "1500<genpt<3500", 50, etaRange, 0, 2, " ");
345 
346  // Some jet algebra
347  //------------------------------------------------------------------------
348  mEtaFirst = ibooker.book1D("EtaFirst", "EtaFirst", 120, -6, 6);
349  mPhiFirst = ibooker.book1D("PhiFirst", "PhiFirst", 70, -3.5, 3.5);
350  mPtFirst = ibooker.book1D("PtFirst", "PtFirst", 50, 0, 1000);
351  mMjj = ibooker.book1D("Mjj", "Mjj", 100, 0, 2000);
352  mNJetsEta_B_20_40 = ibooker.book1D("NJetsEta_B_20_40", "NJetsEta_B 20<Pt<40", 15, 0, 15);
353  mNJetsEta_E_20_40 = ibooker.book1D("NJetsEta_E_20_40", "NJetsEta_E 20<Pt<40", 15, 0, 15);
354  mNJetsEta_B_40 = ibooker.book1D("NJetsEta_B", "NJetsEta_B 40<Pt", 15, 0, 15);
355  mNJetsEta_E_40 = ibooker.book1D("NJetsEta_E", "NJetsEta_E 40<Pt", 15, 0, 15);
356  mNJets_40 = ibooker.book1D("NJets", "NJets 40>Pt", 15, 0, 15);
357  mNJets1 = ibooker.bookProfile("NJets1", "Number of jets above Pt threshold", 100, 0, 200, 100, 0, 50, "s");
358  mNJets2 = ibooker.bookProfile("NJets2", "Number of jets above Pt threshold", 100, 0, 4000, 100, 0, 50, "s");
359 
360 
361  if (isCaloJet) {
362  maxEInEmTowers = ibooker.book1D("maxEInEmTowers", "maxEInEmTowers", 50,0,500);
363  maxEInHadTowers = ibooker.book1D("maxEInHadTowers", "maxEInHadTowers", 50,0,500);
364  energyFractionHadronic = ibooker.book1D("energyFractionHadronic", "energyFractionHadronic", 50,0,1);
365  emEnergyFraction = ibooker.book1D("emEnergyFraction", "emEnergyFraction", 50,0,1);
366  hadEnergyInHB = ibooker.book1D("hadEnergyInHB", "hadEnergyInHB", 50,0,500);
367  hadEnergyInHO = ibooker.book1D("hadEnergyInHO", "hadEnergyInHO", 50,0,500);
368  hadEnergyInHE = ibooker.book1D("hadEnergyInHE", "hadEnergyInHE", 50,0,500);
369  hadEnergyInHF = ibooker.book1D("hadEnergyInHF", "hadEnergyInHF", 50,0,500);
370  emEnergyInEB = ibooker.book1D("emEnergyInEB", "emEnergyInEB", 50,0,500);
371  emEnergyInEE = ibooker.book1D("emEnergyInEE", "emEnergyInEE", 50,0,500);
372  emEnergyInHF = ibooker.book1D("emEnergyInHF", "emEnergyInHF", 50,0,500);
373  towersArea = ibooker.book1D("towersArea", "towersArea", 50,0,1);
374  n90 = ibooker.book1D("n90", "n90", 30,0,30);
375  n60 = ibooker.book1D("n60", "n60", 30,0,30);
376  }
377 
378  if (isPFJet) {
379  muonMultiplicity = ibooker.book1D("muonMultiplicity", "muonMultiplicity", 10,0,10);
380  chargedMultiplicity = ibooker.book1D("chargedMultiplicity", "chargedMultiplicity", 100,0,100);
381  chargedEmEnergy = ibooker.book1D("chargedEmEnergy", "chargedEmEnergy", 100,0,500);
382  neutralEmEnergy = ibooker.book1D("neutralEmEnergy", "neutralEmEnergy", 100,0,500);
383  chargedHadronEnergy = ibooker.book1D("chargedHadronEnergy", "chargedHadronEnergy", 100,0,500);
384  neutralHadronEnergy = ibooker.book1D("neutralHadronEnergy", "neutralHadronEnergy", 100,0,500);
385  chargedHadronEnergyFraction = ibooker.book1D("chargedHadronEnergyFraction", "chargedHadronEnergyFraction", 50,0,1);
386  neutralHadronEnergyFraction = ibooker.book1D("neutralHadronEnergyFraction", "neutralHadronEnergyFraction", 50,0,1);
387  chargedEmEnergyFraction = ibooker.book1D("chargedEmEnergyFraction", "chargedEmEnergyFraction", 50,0,1);
388  neutralEmEnergyFraction = ibooker.book1D("neutralEmEnergyFraction", "neutralEmEnergyFraction", 50,0,1);
389  photonEnergy = ibooker.book1D("photonEnergy", "photonEnergy", 50,0,500);
390  photonEnergyFraction = ibooker.book1D("photonEnergyFraction", "photonEnergyFraction", 50,0,1);
391  electronEnergy = ibooker.book1D("electronEnergy", "electronEnergy", 50,0,500);
392  electronEnergyFraction = ibooker.book1D("electronEnergyFraction", "electronEnergyFraction", 50,0,1);
393  muonEnergy = ibooker.book1D("muonEnergy", "muonEnergy", 50,0,500);
394  muonEnergyFraction = ibooker.book1D("muonEnergyFraction", "muonEnergyFraction", 50,0,1);
395  HFHadronEnergy = ibooker.book1D("HFHadronEnergy", "HFHadronEnergy", 50,0,500);
396  HFHadronEnergyFraction = ibooker.book1D("HFHadronEnergyFraction", "HFHadronEnergyFraction", 50,0,1);
397  HFEMEnergy = ibooker.book1D("HFEMEnergy", "HFEMEnergy", 50,0,500);
398  HFEMEnergyFraction = ibooker.book1D("HFEMEnergyFraction", "HFEMEnergyFraction", 50,0,1);
399  chargedHadronMultiplicity = ibooker.book1D("chargedHadronMultiplicity", "chargedHadronMultiplicity", 50,0,50);
400  neutralHadronMultiplicity = ibooker.book1D("neutralHadronMultiplicity", "neutralHadronMultiplicity", 50,0,50);
401  photonMultiplicity = ibooker.book1D("photonMultiplicity", "photonMultiplicity", 10,0,10);
402  electronMultiplicity = ibooker.book1D("electronMultiplicity", "electronMultiplicity", 10,0,10);
403  HFHadronMultiplicity = ibooker.book1D("HFHadronMultiplicity", "HFHadronMultiplicity", 50,0,50);
404  HFEMMultiplicity = ibooker.book1D("HFEMMultiplicity", "HFEMMultiplicity", 50,0,50);
405  chargedMuEnergy = ibooker.book1D("chargedMuEnergy", "chargedMuEnergy", 50,0,500);
406  chargedMuEnergyFraction = ibooker.book1D("chargedMuEnergyFraction", "chargedMuEnergyFraction", 50,0,1);
407  neutralMultiplicity = ibooker.book1D("neutralMultiplicity", "neutralMultiplicity", 50,0,50);
408  HOEnergy = ibooker.book1D("HOEnergy", "HOEnergy", 50,0,500);
409  HOEnergyFraction = ibooker.book1D("HOEnergyFraction", "HOEnergyFraction", 50,0,1);
410  }
411 
412  if (mOutputFile.empty ())
413  {
414  LogInfo("OutputInfo") << " Histograms will NOT be saved";
415  }
416  else
417  {
418  LogInfo("OutputInfo") << " Histograms will be saved to file:" << mOutputFile;
419  }
420 }
421 
422 
423 //------------------------------------------------------------------------------
424 // ~JetTester
425 //------------------------------------------------------------------------------
427 
428 
429 //------------------------------------------------------------------------------
430 // analyze
431 //------------------------------------------------------------------------------
432 void JetTester::analyze(const edm::Event& mEvent, const edm::EventSetup& mSetup)
433 {
434  // Get the primary vertices
435  //----------------------------------------------------------------------------
437  mEvent.getByToken(pvToken_, pvHandle);
438 
439  int nGoodVertices = 0;
440 
441  if (pvHandle.isValid())
442  {
443  for (unsigned i=0; i<pvHandle->size(); i++)
444  {
445  if ((*pvHandle)[i].ndof() > 4 &&
446  (fabs((*pvHandle)[i].z()) <= 24) &&
447  (fabs((*pvHandle)[i].position().rho()) <= 2))
448  nGoodVertices++;
449  }
450  }
451 
452  mNvtx->Fill(nGoodVertices);
453 
454 
455  // Get the CaloTower collection
456  //----------------------------------------------------------------------------
458  mEvent.getByToken(caloTowersToken_, caloTowers);
459 
460  if (caloTowers.isValid())
461  {
462  for (CaloTowerCollection::const_iterator cal=caloTowers->begin();
463  cal!=caloTowers->end(); ++cal)
464  {
465  mHadTiming->Fill(cal->hcalTime());
466  mEmTiming ->Fill(cal->ecalTime());
467  }
468  }
469 
470 
471 // // Get the jet rho
472 // //----------------------------------------------------------------------------
473 // edm::Handle<double> pRho;
474 // mEvent.getByToken(rhoTag, pRho);
475 //
476 // if (pRho.isValid())
477 // {
478 // double jetRho = *pRho;
479 //
480 // if (mRho) mRho->Fill(jetRho);
481 // }
482 
483 
484  // Get the Jet collection
485  //----------------------------------------------------------------------------
486  math::XYZTLorentzVector p4tmp[2];
487 
488  std::vector<Jet> recoJets;
489  recoJets.clear();
490 
493 // edm::Handle<JPTJetCollection> jptJets;
494 
495  if (isCaloJet) mEvent.getByToken(caloJetsToken_, caloJets);
496  if (isPFJet) mEvent.getByToken(pfJetsToken_, pfJets);
497 // if (isJPTJet) mEvent.getByToken(jptJetsToken_, jptJets);
498 
499  if (isCaloJet && !caloJets.isValid()) return;
500  if (isPFJet && !pfJets.isValid()) return;
501 // if (isJPTJet && !jptJets.isValid()) return;
502 
503 
504  if (isCaloJet)
505  {
506  for (unsigned ijet=0; ijet<caloJets->size(); ijet++)
507  recoJets.push_back((*caloJets)[ijet]);
508  }
509 
510 /* if (isJPTJet)
511  {
512  for (unsigned ijet=0; ijet<jptJets->size(); ijet++)
513  recoJets.push_back((*jptJets)[ijet]);
514  }*/
515 
516  if (isPFJet) {
517  for (unsigned ijet=0; ijet<pfJets->size(); ijet++)
518  recoJets.push_back((*pfJets)[ijet]);
519  }
520 
521  int nJet = 0;
522  int nJet_E_20_40 = 0;
523  int nJet_B_20_40 = 0;
524  int nJet_E_40 = 0;
525  int nJet_B_40 = 0;
526  int nJet_40 = 0;
527 
528  for (unsigned ijet=0; ijet<recoJets.size(); ijet++) {
529  if ( (recoJets[ijet].pt() > 20.) and (recoJets[ijet].pt() < mRecoJetPtThreshold)) {
530  if (fabs(recoJets[ijet].eta()) > 1.5)
531  nJet_E_20_40++;
532  else
533  nJet_B_20_40++;
534  }
535  if (recoJets[ijet].pt() > mRecoJetPtThreshold) {
536  //counting forward and barrel jets
537  if (fabs(recoJets[ijet].eta()) > 1.5)
538  nJet_E_40++;
539  else
540  nJet_B_40++;
541  nJet_40++;
542 
543  if (mEta) mEta->Fill(recoJets[ijet].eta());
544 
545  if (mJetArea) mJetArea ->Fill(recoJets[ijet].jetArea());
546  if (mPhi) mPhi ->Fill(recoJets[ijet].phi());
547  if (mEnergy) mEnergy ->Fill(recoJets[ijet].energy());
548  if (mP) mP ->Fill(recoJets[ijet].p());
549  if (mPt) mPt ->Fill(recoJets[ijet].pt());
550  if (mMass) mMass ->Fill(recoJets[ijet].mass());
551  if (mConstituents) mConstituents->Fill(recoJets[ijet].nConstituents());
552 
553  if (ijet == 0) {
554  if (mEtaFirst) mEtaFirst->Fill(recoJets[ijet].eta());
555  if (mPhiFirst) mPhiFirst->Fill(recoJets[ijet].phi());
556  if (mPtFirst) mPtFirst ->Fill(recoJets[ijet].pt());
557  }
558 
559  if (ijet == 0) {nJet++; p4tmp[0] = recoJets[ijet].p4();}
560  if (ijet == 1) {nJet++; p4tmp[1] = recoJets[ijet].p4();}
561 
562  // if (isPFJet || isCaloJet) {
563  // if (mHadEnergyInHF) mHadEnergyInHF ->Fill((*pfJets)[ijet].HFHadronEnergy());
564  // if (mEmEnergyInHF) mEmEnergyInHF ->Fill((*pfJets)[ijet].HFEMEnergy());
565  // if (mChargedEmEnergy) mChargedEmEnergy ->Fill((*pfJets)[ijet].chargedEmEnergy());
566  // if (mChargedHadronEnergy) mChargedHadronEnergy->Fill((*pfJets)[ijet].chargedHadronEnergy());
567  // if (mNeutralEmEnergy) mNeutralEmEnergy ->Fill((*pfJets)[ijet].neutralEmEnergy());
568  // if (mNeutralHadronEnergy) mNeutralHadronEnergy->Fill((*pfJets)[ijet].neutralHadronEnergy());
569  // }
570 
571 
572  // ---- Calo Jet specific information ----
573  if (isCaloJet) {
574  maxEInEmTowers ->Fill((*caloJets)[ijet].maxEInEmTowers());
575  maxEInHadTowers ->Fill((*caloJets)[ijet].maxEInHadTowers());
576  energyFractionHadronic ->Fill((*caloJets)[ijet].energyFractionHadronic());
577  emEnergyFraction ->Fill((*caloJets)[ijet].emEnergyFraction());
578  hadEnergyInHB ->Fill((*caloJets)[ijet].hadEnergyInHB());
579  hadEnergyInHO ->Fill((*caloJets)[ijet].hadEnergyInHO());
580  hadEnergyInHE ->Fill((*caloJets)[ijet].hadEnergyInHE());
581  hadEnergyInHF ->Fill((*caloJets)[ijet].hadEnergyInHF());
582  emEnergyInEB ->Fill((*caloJets)[ijet].emEnergyInEB());
583  emEnergyInEE ->Fill((*caloJets)[ijet].emEnergyInEE());
584  emEnergyInHF ->Fill((*caloJets)[ijet].emEnergyInHF());
585  towersArea ->Fill((*caloJets)[ijet].towersArea());
586  n90 ->Fill((*caloJets)[ijet].n90());
587  n60 ->Fill((*caloJets)[ijet].n60());
588  }
589  // ---- PF Jet specific information ----
590  if (isPFJet) {
591  muonMultiplicity ->Fill((*pfJets)[ijet].muonMultiplicity());
592  chargedMultiplicity ->Fill((*pfJets)[ijet].chargedMultiplicity());
593  chargedEmEnergy ->Fill((*pfJets)[ijet].chargedEmEnergy());
594  neutralEmEnergy ->Fill((*pfJets)[ijet].neutralEmEnergy());
595  chargedHadronEnergy ->Fill((*pfJets)[ijet].chargedHadronEnergy());
596  neutralHadronEnergy ->Fill((*pfJets)[ijet].neutralHadronEnergy());
601  photonEnergy ->Fill((*pfJets)[ijet].photonEnergy());
602  photonEnergyFraction ->Fill((*pfJets)[ijet].photonEnergyFraction());
603  electronEnergy ->Fill((*pfJets)[ijet].electronEnergy());
605  muonEnergy ->Fill((*pfJets)[ijet].muonEnergy());
606  muonEnergyFraction ->Fill((*pfJets)[ijet].muonEnergyFraction());
607  HFHadronEnergy ->Fill((*pfJets)[ijet].HFHadronEnergy());
609  HFEMEnergy ->Fill((*pfJets)[ijet].HFEMEnergy());
610  HFEMEnergyFraction ->Fill((*pfJets)[ijet].HFEMEnergyFraction());
613  photonMultiplicity ->Fill((*pfJets)[ijet].photonMultiplicity());
614  electronMultiplicity ->Fill((*pfJets)[ijet].electronMultiplicity());
615  HFHadronMultiplicity ->Fill((*pfJets)[ijet].HFHadronMultiplicity());
616  HFEMMultiplicity ->Fill((*pfJets)[ijet].HFEMMultiplicity());
617  chargedMuEnergy ->Fill((*pfJets)[ijet].chargedMuEnergy());
619  neutralMultiplicity ->Fill((*pfJets)[ijet].neutralMultiplicity());
620  HOEnergy ->Fill((*pfJets)[ijet].hoEnergy());
621  HOEnergyFraction ->Fill((*pfJets)[ijet].hoEnergyFraction());
622  }
623  // ---- JPT Jet specific information ----
624  /* if (isJPTJet) {
625  elecMultiplicity ->Fill((*jptJets)[ijet].elecMultiplicity());
626  muonMultiplicity ->Fill((*jptJets)[ijet].muonMultiplicity());
627  chargedMultiplicity ->Fill((*jptJets)[ijet].chargedMultiplicity());
628  chargedEmEnergy ->Fill((*jptJets)[ijet].chargedEmEnergy());
629  neutralEmEnergy ->Fill((*jptJets)[ijet].neutralEmEnergy());
630  chargedHadronEnergy ->Fill((*jptJets)[ijet].chargedHadronEnergy());
631  neutralHadronEnergy ->Fill((*jptJets)[ijet].neutralHadronEnergy());
632  chargedHadronEnergyFraction ->Fill((*jptJets)[ijet].chargedHadronEnergyFraction());
633  neutralHadronEnergyFraction ->Fill((*jptJets)[ijet].neutralHadronEnergyFraction());
634  chargedEmEnergyFraction ->Fill((*jptJets)[ijet].chargedEmEnergyFraction());
635  neutralEmEnergyFraction ->Fill((*jptJets)[ijet].neutralEmEnergyFraction());
636  }*/
637  }
638  }
639 
640  if (mNJetsEta_B_20_40) mNJetsEta_B_20_40->Fill(nJet_B_20_40);
641  if (mNJetsEta_E_20_40) mNJetsEta_E_20_40->Fill(nJet_E_20_40);
642  if (mNJetsEta_B_40) mNJetsEta_B_40->Fill(nJet_B_40);
643  if (mNJetsEta_E_40) mNJetsEta_E_40->Fill(nJet_E_40);
644  if (mNJets_40) mNJets_40->Fill(nJet_40);
645  if (nJet >= 2)
646  {
647  if (mMjj) mMjj->Fill((p4tmp[0]+p4tmp[1]).mass());
648  }
649 
650 
651  // Count jets above pt cut
652  //----------------------------------------------------------------------------
653  for (int istep=0; istep<100; ++istep)
654  {
655  int njets1 = 0;
656  int njets2 = 0;
657 
658  float ptStep1 = (istep * ( 200. / 100.));
659  float ptStep2 = (istep * (4000. / 100.));
660 
661  for (unsigned ijet=0; ijet<recoJets.size(); ijet++) {
662  if (recoJets[ijet].pt() > ptStep1) njets1++;
663  if (recoJets[ijet].pt() > ptStep2) njets2++;
664  }
665  mNJets1->Fill(ptStep1, njets1);
666  mNJets2->Fill(ptStep2, njets2);
667  }
668 
669 
670  // Corrected jets
671  //----------------------------------------------------------------------------
672  double scale = -999;
673 
674  if (!JetCorrectionService.empty())
675  {
677  for (unsigned ijet=0; ijet<recoJets.size(); ijet++) {
678  Jet correctedJet = recoJets[ijet];
679 
680  if (isCaloJet) scale = corrector->correction((*caloJets)[ijet], mEvent, mSetup);
681  if (isPFJet) scale = corrector->correction((*pfJets)[ijet], mEvent, mSetup);
682  //if (isJPTJet) scale = corrector->correction((*jptJets)[ijet], mEvent, mSetup);
683 
684  correctedJet.scaleEnergy(scale);
685 
686  if (correctedJet.pt() < 20) continue;
687 
688  mCorrJetEta->Fill(correctedJet.eta());
689  mCorrJetPhi->Fill(correctedJet.phi());
690  mCorrJetPt ->Fill(correctedJet.pt());
691  if (correctedJet.pt() >= 40) {
692  mCorrJetEta_Pt40->Fill(correctedJet.eta());
693  mCorrJetPhi_Pt40->Fill(correctedJet.phi());
694  }
695 
696  double ijetEta = recoJets[ijet].eta();
697  double ijetPt = recoJets[ijet].pt();
698  double ratio = correctedJet.pt() / ijetPt;
699 
700  if (fabs(ijetEta) < 1.5) mPtCorrOverReco_Pt_B->Fill(log10(ijetPt), ratio);
701  else if (fabs(ijetEta) < 3.0) mPtCorrOverReco_Pt_E->Fill(log10(ijetPt), ratio);
702  else if (fabs(ijetEta) < 6.0) mPtCorrOverReco_Pt_F->Fill(log10(ijetPt), ratio);
703 
704  if (ijetPt < 40) mPtCorrOverReco_Eta_20_40 ->Fill(ijetEta, ratio);
705  else if (ijetPt < 200) mPtCorrOverReco_Eta_40_200 ->Fill(ijetEta, ratio);
706  else if (ijetPt < 600) mPtCorrOverReco_Eta_200_600 ->Fill(ijetEta, ratio);
707  else if (ijetPt < 1500) mPtCorrOverReco_Eta_600_1500 ->Fill(ijetEta, ratio);
708  else if (ijetPt < 3500) mPtCorrOverReco_Eta_1500_3500->Fill(ijetEta, ratio);
709  }
710  }
711 
712 
713  //----------------------------------------------------------------------------
714  //
715  // Generation
716  //
717  //----------------------------------------------------------------------------
718  if (!mEvent.isRealData())
719  {
720  // Get ptHat
721  //------------------------------------------------------------------------
723  mEvent.getByToken(evtToken_, evt);
724 
725  if (evt.isValid()) {
726  HepMC::GenEvent* myGenEvent = new HepMC::GenEvent(*(evt->GetEvent()));
727  double ptHat = myGenEvent->event_scale();
728  if (mPtHat) mPtHat->Fill(ptHat);
729  delete myGenEvent;
730  }
731  // Gen jets
732  //------------------------------------------------------------------------
734  mEvent.getByToken(genJetsToken_, genJets);
735 
736  if (!genJets.isValid()) return;
737 
738  for (GenJetCollection::const_iterator gjet=genJets->begin(); gjet!=genJets->end(); gjet++) {
739  if (mGenEta) mGenEta->Fill(gjet->eta());
740  if (mGenPhi) mGenPhi->Fill(gjet->phi());
741  if (mGenPt) mGenPt ->Fill(gjet->pt());
742  if (gjet == genJets->begin()) {
743  if (mGenEtaFirst) mGenEtaFirst->Fill(gjet->eta());
744  if (mGenPhiFirst) mGenPhiFirst->Fill(gjet->phi());
745  }
746  }
747 
748  if (!(mInputGenCollection.label().empty())) {
749  for (GenJetCollection::const_iterator gjet=genJets->begin(); gjet!=genJets->end(); gjet++) {
750  if (fabs(gjet->eta()) > 6.) continue; // Out of the detector
751  if (gjet->pt() < mMatchGenPtThreshold) continue;
752  if (recoJets.size() <= 0) continue;
753  // pt response
754  //------------------------------------------------------------
755  if (!JetCorrectionService.empty()) {
756  int iMatch = -1;
757  double CorrdeltaRBest = 999;
758  double CorrJetPtBest = 0;
759  for (unsigned ijet=0; ijet<recoJets.size(); ++ijet) {
760  Jet correctedJet = recoJets[ijet];
761  correctedJet.scaleEnergy(scale);
762  double CorrJetPt = correctedJet.pt();
763  if (CorrJetPt > 10) {
764  double CorrdR = deltaR(gjet->eta(), gjet->phi(), correctedJet.eta(), correctedJet.phi());
765  if (CorrdR < CorrdeltaRBest) {
766  CorrdeltaRBest = CorrdR;
767  CorrJetPtBest = CorrJetPt;
768  iMatch = ijet;
769  }
770  }
771  }
772  if (iMatch<0) continue;
773  fillMatchHists(gjet->eta(), gjet->phi(), gjet->pt(), recoJets[iMatch].eta(), recoJets[iMatch].phi(), recoJets[iMatch].pt());
774 
775  if (CorrdeltaRBest < mRThreshold) {
776  double response = CorrJetPtBest / gjet->pt();
777 
778  if (fabs(gjet->eta()) < 1.5) mPtCorrOverGen_GenPt_B->Fill(log10(gjet->pt()), response);
779  else if (fabs(gjet->eta()) < 3.0) mPtCorrOverGen_GenPt_E->Fill(log10(gjet->pt()), response);
780  else if (fabs(gjet->eta()) < 6.0) mPtCorrOverGen_GenPt_F->Fill(log10(gjet->pt()), response);
781 
782  if (gjet->pt() > 20) {
783  if (gjet->pt() < 40) mPtCorrOverGen_GenEta_20_40 ->Fill(gjet->eta(), response);
784  else if (gjet->pt() < 200) mPtCorrOverGen_GenEta_40_200 ->Fill(gjet->eta(), response);
785  else if (gjet->pt() < 600) mPtCorrOverGen_GenEta_200_600 ->Fill(gjet->eta(), response);
786  else if (gjet->pt() < 1500) mPtCorrOverGen_GenEta_600_1500 ->Fill(gjet->eta(), response);
787  else if (gjet->pt() < 3500) mPtCorrOverGen_GenEta_1500_3500->Fill(gjet->eta(), response);
788  }
789  }
790  }
791  }
792  }
793  }
794 }
795 
796 
797 //------------------------------------------------------------------------------
798 // fillMatchHists
799 //------------------------------------------------------------------------------
800 void JetTester::fillMatchHists(const double GenEta,
801  const double GenPhi,
802  const double GenPt,
803  const double RecoEta,
804  const double RecoPhi,
805  const double RecoPt)
806 {
807  if (GenPt > mMatchGenPtThreshold) {
808  mDeltaEta->Fill(GenEta - RecoEta);
809  mDeltaPhi->Fill(GenPhi - RecoPhi);
810  mDeltaPt ->Fill((GenPt - RecoPt) / GenPt);
811  }
812 
813  if (fabs(GenEta) < 1.5)
814  {
815  mPtRecoOverGen_GenPt_B ->Fill(log10(GenPt), RecoPt / GenPt);
816  mPtRecoOverGen_GenPhi_B->Fill(GenPhi, RecoPt / GenPt);
817 
818  if (GenPt > 20 && GenPt < 40) mPtRecoOverGen_B_20_40 ->Fill(RecoPt / GenPt);
819  else if (GenPt < 200) mPtRecoOverGen_B_40_200 ->Fill(RecoPt / GenPt);
820  else if (GenPt < 600) mPtRecoOverGen_B_200_600 ->Fill(RecoPt / GenPt);
821  else if (GenPt < 1500) mPtRecoOverGen_B_600_1500 ->Fill(RecoPt / GenPt);
822  else if (GenPt < 3500) mPtRecoOverGen_B_1500_3500->Fill(RecoPt / GenPt);
823  }
824  else if (fabs(GenEta) < 3.0)
825  {
826  mPtRecoOverGen_GenPt_E ->Fill(log10(GenPt), RecoPt / GenPt);
827  mPtRecoOverGen_GenPhi_E->Fill(GenPhi, RecoPt / GenPt);
828 
829  if (GenPt > 20 && GenPt < 40) mPtRecoOverGen_E_20_40 ->Fill(RecoPt / GenPt);
830  else if (GenPt < 200) mPtRecoOverGen_E_40_200 ->Fill(RecoPt / GenPt);
831  else if (GenPt < 600) mPtRecoOverGen_E_200_600 ->Fill(RecoPt / GenPt);
832  else if (GenPt < 1500) mPtRecoOverGen_E_600_1500 ->Fill(RecoPt / GenPt);
833  else if (GenPt < 3500) mPtRecoOverGen_E_1500_3500->Fill(RecoPt / GenPt);
834  }
835  else if (fabs(GenEta) < 6.0)
836  {
837  mPtRecoOverGen_GenPt_F ->Fill (log10(GenPt), RecoPt / GenPt);
838  mPtRecoOverGen_GenPhi_F->Fill (GenPhi, RecoPt / GenPt);
839 
840  if (GenPt > 20 && GenPt < 40) mPtRecoOverGen_F_20_40 ->Fill(RecoPt / GenPt);
841  else if (GenPt < 200) mPtRecoOverGen_F_40_200 ->Fill(RecoPt / GenPt);
842  else if (GenPt < 600) mPtRecoOverGen_F_200_600 ->Fill(RecoPt / GenPt);
843  else if (GenPt < 1500) mPtRecoOverGen_F_600_1500 ->Fill(RecoPt / GenPt);
844  else if (GenPt < 3500) mPtRecoOverGen_F_1500_3500->Fill(RecoPt / GenPt);
845  }
846 
847  if (GenPt > 20 && GenPt < 40) mPtRecoOverGen_GenEta_20_40 ->Fill(GenEta, RecoPt / GenPt);
848  else if (GenPt < 200) mPtRecoOverGen_GenEta_40_200 ->Fill(GenEta, RecoPt / GenPt);
849  else if (GenPt < 600) mPtRecoOverGen_GenEta_200_600 ->Fill(GenEta, RecoPt / GenPt);
850  else if (GenPt < 1500) mPtRecoOverGen_GenEta_600_1500 ->Fill(GenEta, RecoPt / GenPt);
851  else if (GenPt < 3500) mPtRecoOverGen_GenEta_1500_3500->Fill(GenEta, RecoPt / GenPt);
852 }
MonitorElement * mNJetsEta_B_40
Definition: JetTester.h:156
MonitorElement * mPtRecoOverGen_E_20_40
Definition: JetTester.h:121
int i
Definition: DBlmapReader.cc:9
edm::EDGetTokenT< std::vector< reco::Vertex > > pvToken_
Definition: JetTester.h:62
MonitorElement * mPtCorrOverGen_GenEta_40_200
Definition: JetTester.h:104
MonitorElement * mPtCorrOverReco_Pt_E
Definition: JetTester.h:93
MonitorElement * hadEnergyInHE
Definition: JetTester.h:169
MonitorElement * mNvtx
Definition: JetTester.h:70
MonitorElement * HFHadronEnergyFraction
Definition: JetTester.h:198
MonitorElement * mPtRecoOverGen_B_20_40
Definition: JetTester.h:120
MonitorElement * mPtCorrOverGen_GenPt_F
Definition: JetTester.h:102
MonitorElement * mPtRecoOverGen_F_40_200
Definition: JetTester.h:125
edm::EDGetTokenT< reco::GenJetCollection > genJetsToken_
Definition: JetTester.h:66
MonitorElement * HOEnergy
Definition: JetTester.h:210
virtual void scaleEnergy(double fScale)
scale energy of the jet
MonitorElement * neutralHadronEnergy
Definition: JetTester.h:184
MonitorElement * electronEnergyFraction
Definition: JetTester.h:194
MonitorElement * mPtRecoOverGen_B_200_600
Definition: JetTester.h:126
virtual float pt() const
transverse momentum
virtual void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
Definition: JetTester.cc:241
MonitorElement * HFEMEnergyFraction
Definition: JetTester.h:200
bool isPFJet
Definition: JetTester.h:219
MonitorElement * mPtRecoOverGen_GenPt_F
Definition: JetTester.h:139
MonitorElement * mMjj
Definition: JetTester.h:153
edm::InputTag mInputGenCollection
Definition: JetTester.h:57
MonitorElement * mPtFirst
Definition: JetTester.h:152
MonitorElement * bookProfile(Args &&...args)
Definition: DQMStore.h:157
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:446
edm::EDGetTokenT< reco::CaloJetCollection > caloJetsToken_
Definition: JetTester.h:64
MonitorElement * photonEnergyFraction
Definition: JetTester.h:192
MonitorElement * neutralMultiplicity
Definition: JetTester.h:209
MonitorElement * mDeltaPhi
Definition: JetTester.h:117
virtual float phi() const
momentum azimuthal angle
Base class for all types of Jets.
Definition: Jet.h:20
bool isCaloJet
Definition: JetTester.h:218
Definition: DDAxes.h:10
MonitorElement * mPtRecoOverGen_GenPhi_E
Definition: JetTester.h:141
MonitorElement * mPtRecoOverGen_GenEta_20_40
Definition: JetTester.h:143
MonitorElement * hadEnergyInHB
Definition: JetTester.h:167
std::vector< CaloTower >::const_iterator const_iterator
MonitorElement * mPtCorrOverReco_Eta_40_200
Definition: JetTester.h:96
MonitorElement * photonMultiplicity
Definition: JetTester.h:203
MonitorElement * mCorrJetPhi
Definition: JetTester.h:88
MonitorElement * energyFractionHadronic
Definition: JetTester.h:165
double mMatchGenPtThreshold
Definition: JetTester.h:215
double correction(const LorentzVector &fJet) const
get correction using Jet information only
Definition: JetCorrector.h:47
MonitorElement * mPtRecoOverGen_E_40_200
Definition: JetTester.h:124
MonitorElement * mNJets2
Definition: JetTester.h:160
MonitorElement * mPtCorrOverReco_Eta_200_600
Definition: JetTester.h:97
MonitorElement * muonEnergyFraction
Definition: JetTester.h:196
MonitorElement * n90
Definition: JetTester.h:175
MonitorElement * mPtRecoOverGen_GenPhi_B
Definition: JetTester.h:140
T eta() const
MonitorElement * mEtaFirst
Definition: JetTester.h:150
bool isRealData() const
Definition: EventBase.h:60
float float float z
MonitorElement * emEnergyFraction
Definition: JetTester.h:166
std::string JetCorrectionService
Definition: JetTester.h:222
MonitorElement * mCorrJetEta
Definition: JetTester.h:87
MonitorElement * photonEnergy
Definition: JetTester.h:191
MonitorElement * towersArea
Definition: JetTester.h:174
void Fill(long long x)
MonitorElement * hadEnergyInHF
Definition: JetTester.h:170
MonitorElement * HFHadronMultiplicity
Definition: JetTester.h:205
MonitorElement * mGenPt
Definition: JetTester.h:112
XYZTLorentzVectorD XYZTLorentzVector
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:29
MonitorElement * muonEnergy
Definition: JetTester.h:195
MonitorElement * electronMultiplicity
Definition: JetTester.h:204
MonitorElement * mPtRecoOverGen_B_600_1500
Definition: JetTester.h:129
MonitorElement * mEnergy
Definition: JetTester.h:77
MonitorElement * mPtRecoOverGen_GenPt_E
Definition: JetTester.h:138
MonitorElement * mNJetsEta_E_40
Definition: JetTester.h:157
MonitorElement * mEta
Definition: JetTester.h:73
MonitorElement * mGenEtaFirst
Definition: JetTester.h:113
MonitorElement * mNJetsEta_B_20_40
Definition: JetTester.h:154
MonitorElement * chargedMuEnergy
Definition: JetTester.h:207
MonitorElement * mPtRecoOverGen_F_1500_3500
Definition: JetTester.h:134
MonitorElement * mDeltaEta
Definition: JetTester.h:116
MonitorElement * mNJets_40
Definition: JetTester.h:158
MonitorElement * HFHadronEnergy
Definition: JetTester.h:197
MonitorElement * mNJetsEta_E_20_40
Definition: JetTester.h:155
tuple corrector
Definition: mvaPFMET_cff.py:50
MonitorElement * mDeltaPt
Definition: JetTester.h:118
void Fill(HcalDetId &id, double val, std::vector< TH2F > &depth)
MonitorElement * mPtRecoOverGen_B_40_200
Definition: JetTester.h:123
MonitorElement * mPtRecoOverGen_B_1500_3500
Definition: JetTester.h:132
MonitorElement * mPtRecoOverGen_F_200_600
Definition: JetTester.h:128
MonitorElement * mPhiFirst
Definition: JetTester.h:151
virtual float eta() const
momentum pseudorapidity
MonitorElement * mP
Definition: JetTester.h:76
void fillMatchHists(const double GenEta, const double GenPhi, const double GenPt, const double RecoEta, const double RecoPhi, const double RecoPt)
Definition: JetTester.cc:800
MonitorElement * mEmTiming
Definition: JetTester.h:81
MonitorElement * mPtCorrOverGen_GenPt_B
Definition: JetTester.h:100
MonitorElement * mPtCorrOverReco_Eta_600_1500
Definition: JetTester.h:98
MonitorElement * n60
Definition: JetTester.h:176
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
MonitorElement * HOEnergyFraction
Definition: JetTester.h:211
MonitorElement * mGenEta
Definition: JetTester.h:110
MonitorElement * hadEnergyInHO
Definition: JetTester.h:168
MonitorElement * mPhi
Definition: JetTester.h:74
MonitorElement * mPtCorrOverGen_GenEta_200_600
Definition: JetTester.h:105
MonitorElement * mPt
Definition: JetTester.h:75
edm::InputTag mInputCollection
Definition: JetTester.h:56
MonitorElement * emEnergyInHF
Definition: JetTester.h:173
MonitorElement * mPtRecoOverGen_E_200_600
Definition: JetTester.h:127
JetTester(const edm::ParameterSet &)
Definition: JetTester.cc:12
MonitorElement * mPtRecoOverGen_GenPhi_F
Definition: JetTester.h:142
MonitorElement * chargedHadronEnergyFraction
Definition: JetTester.h:185
MonitorElement * mPtRecoOverGen_E_600_1500
Definition: JetTester.h:130
bool isValid() const
Definition: HandleBase.h:76
MonitorElement * mPtHat
Definition: JetTester.h:115
MonitorElement * chargedHadronEnergy
Definition: JetTester.h:183
MonitorElement * mPtCorrOverReco_Pt_B
Definition: JetTester.h:92
edm::EDGetTokenT< CaloTowerCollection > caloTowersToken_
Definition: JetTester.h:63
MonitorElement * mPtRecoOverGen_GenPt_B
Definition: JetTester.h:137
double deltaR(double eta1, double eta2, double phi1, double phi2)
Definition: TreeUtility.cc:17
MonitorElement * mPtCorrOverReco_Eta_1500_3500
Definition: JetTester.h:99
MonitorElement * mJetArea
Definition: JetTester.h:82
edm::EDGetTokenT< edm::HepMCProduct > evtToken_
Definition: JetTester.h:67
MonitorElement * mMass
Definition: JetTester.h:78
MonitorElement * HFEMMultiplicity
Definition: JetTester.h:206
MonitorElement * chargedEmEnergy
Definition: JetTester.h:181
MonitorElement * mPtRecoOverGen_GenEta_40_200
Definition: JetTester.h:144
MonitorElement * mPtRecoOverGen_E_1500_3500
Definition: JetTester.h:133
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:274
MonitorElement * mPtRecoOverGen_F_600_1500
Definition: JetTester.h:131
std::string mOutputFile
Definition: JetTester.h:58
MonitorElement * chargedMuEnergyFraction
Definition: JetTester.h:208
MonitorElement * electronEnergy
Definition: JetTester.h:193
MonitorElement * emEnergyInEE
Definition: JetTester.h:172
static const JetCorrector * getJetCorrector(const std::string &fName, const edm::EventSetup &fSetup)
retrieve corrector from the event setup. troughs exception if something is missing ...
Definition: JetCorrector.cc:50
tuple recoJets
Definition: RecoJets_cff.py:56
MonitorElement * mPtCorrOverGen_GenEta_20_40
Definition: JetTester.h:103
double mRecoJetPtThreshold
Definition: JetTester.h:214
MonitorElement * mPtCorrOverGen_GenEta_1500_3500
Definition: JetTester.h:107
MonitorElement * mGenPhi
Definition: JetTester.h:111
MonitorElement * maxEInHadTowers
Definition: JetTester.h:164
MonitorElement * mCorrJetEta_Pt40
Definition: JetTester.h:89
std::string const & label() const
Definition: InputTag.h:42
MonitorElement * emEnergyInEB
Definition: JetTester.h:171
edm::EDGetTokenT< reco::PFJetCollection > pfJetsToken_
Definition: JetTester.h:65
MonitorElement * mConstituents
Definition: JetTester.h:79
MonitorElement * maxEInEmTowers
Definition: JetTester.h:163
MonitorElement * mPtRecoOverGen_F_20_40
Definition: JetTester.h:122
MonitorElement * mGenPhiFirst
Definition: JetTester.h:114
MonitorElement * mCorrJetPt
Definition: JetTester.h:86
MonitorElement * mPtCorrOverGen_GenPt_E
Definition: JetTester.h:101
MonitorElement * mPtRecoOverGen_GenEta_600_1500
Definition: JetTester.h:146
static int position[264][3]
Definition: ReadPGInfo.cc:509
MonitorElement * mHadTiming
Definition: JetTester.h:80
MonitorElement * mPtRecoOverGen_GenEta_200_600
Definition: JetTester.h:145
MonitorElement * mPtCorrOverReco_Eta_20_40
Definition: JetTester.h:95
MonitorElement * chargedEmEnergyFraction
Definition: JetTester.h:187
MonitorElement * mPtCorrOverReco_Pt_F
Definition: JetTester.h:94
MonitorElement * muonMultiplicity
Definition: JetTester.h:179
MonitorElement * neutralHadronEnergyFraction
Definition: JetTester.h:186
double mRThreshold
Definition: JetTester.h:217
MonitorElement * neutralEmEnergy
Definition: JetTester.h:182
MonitorElement * chargedHadronMultiplicity
Definition: JetTester.h:201
std::string JetType
Definition: JetTester.h:59
MonitorElement * mPtRecoOverGen_GenEta_1500_3500
Definition: JetTester.h:147
MonitorElement * mNJets1
Definition: JetTester.h:159
MonitorElement * mPtCorrOverGen_GenEta_600_1500
Definition: JetTester.h:106
MonitorElement * chargedMultiplicity
Definition: JetTester.h:180
tuple pfJets
Definition: pfJets_cff.py:8
virtual void analyze(const edm::Event &, const edm::EventSetup &)
Definition: JetTester.cc:432
MonitorElement * HFEMEnergy
Definition: JetTester.h:199
MonitorElement * mCorrJetPhi_Pt40
Definition: JetTester.h:90
MonitorElement * neutralHadronMultiplicity
Definition: JetTester.h:202
Definition: Run.h:41
MonitorElement * neutralEmEnergyFraction
Definition: JetTester.h:188
Definition: DDAxes.h:10