CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
PFJetBenchmark.cc
Go to the documentation of this file.
1 #include "RecoParticleFlow/Benchmark/interface/PFJetBenchmark.h"
2 #include "DataFormats/TrackReco/interface/Track.h"
3 
4 // preprocessor macro for booking 1d histos with DQMStore -or- bare Root
5 #define BOOK1D(name,title,nbinsx,lowx,highx) \
6  h##name = dbe_ ? dbe_->book1D(#name,title,nbinsx,lowx,highx)->getTH1F() \
7  : new TH1F(#name,title,nbinsx,lowx,highx)
8 
9 // preprocessor macro for booking 2d histos with DQMStore -or- bare Root
10 #define BOOK2D(name,title,nbinsx,lowx,highx,nbinsy,lowy,highy) \
11  h##name = dbe_ ? dbe_->book2D(#name,title,nbinsx,lowx,highx,nbinsy,lowy,highy)->getTH2F() \
12  : new TH2F(#name,title,nbinsx,lowx,highx,nbinsy,lowy,highy)
13 
14 //macros for building barrel and endcap histos with one call
15 #define DBOOK1D(name,title,nbinsx,lowx,highx) \
16  BOOK1D(B##name,"Barrel "#title,nbinsx,lowx,highx); BOOK1D(E##name,"Endcap "#title,nbinsx,lowx,highx); BOOK1D(F##name,"Forward "#title,nbinsx,lowx,highx);
17 #define DBOOK2D(name,title,nbinsx,lowx,highx,nbinsy,lowy,highy) \
18  BOOK2D(B##name,"Barrel "#title,nbinsx,lowx,highx,nbinsy,lowy,highy); BOOK2D(E##name,"Endcap "#title,nbinsx,lowx,highx,nbinsy,lowy,highy); BOOK2D(F##name,"Forward "#title,nbinsx,lowx,highx,nbinsy,lowy,highy);
19 
20 // all versions OK
21 // preprocesor macro for setting axis titles
22 #define SETAXES(name,xtitle,ytitle) \
23  h##name->GetXaxis()->SetTitle(xtitle); h##name->GetYaxis()->SetTitle(ytitle)
24 
25 //macro for setting the titles for barrel and endcap together
26 #define DSETAXES(name,xtitle,ytitle) \
27  SETAXES(B##name,xtitle,ytitle);SETAXES(E##name,xtitle,ytitle);SETAXES(F##name,xtitle,ytitle);
28 /*#define SET2AXES(name,xtitle,ytitle) \
29  hE##name->GetXaxis()->SetTitle(xtitle); hE##name->GetYaxis()->SetTitle(ytitle); hB##name->GetXaxis()->SetTitle(xtitle); hB##name->GetYaxis()->SetTitle(ytitle)
30 */
31 
32 #define PT (plotAgainstReco_)?"reconstructed P_{T}" :"generated P_{T}"
33 #define P (plotAgainstReco_)?"generated P" :"generated P"
34 
35 using namespace reco;
36 using namespace std;
37 
38 class MonitorElement;
39 
40 PFJetBenchmark::PFJetBenchmark() : file_(0), entry_(0) {}
41 
42 PFJetBenchmark::~PFJetBenchmark() {
43  if(file_) file_->Close();
44 }
45 
46 void PFJetBenchmark::write() {
47  // Store the DAQ Histograms
48  if (outputFile_.size() != 0) {
49  if (dbe_)
50  dbe_->save(outputFile_.c_str());
51  // use bare Root if no DQM (FWLite applications)
52  else if (file_) {
53  file_->Write(outputFile_.c_str());
54  cout << "Benchmark output written to file " << outputFile_.c_str() << endl;
55  file_->Close();
56  }
57  }
58  else
59  cout << "No output file specified ("<<outputFile_<<"). Results will not be saved!" << endl;
60 
61 }
62 
63 void PFJetBenchmark::setup(
64  string Filename,
65  bool debug,
66  bool plotAgainstReco,
67  bool onlyTwoJets,
68  double deltaRMax,
69  string benchmarkLabel_,
70  double recPt,
71  double maxEta,
72  DQMStore * dbe_store) {
73  debug_ = debug;
74  plotAgainstReco_ = plotAgainstReco;
75  onlyTwoJets_ = onlyTwoJets;
76  deltaRMax_ = deltaRMax;
77  outputFile_=Filename;
78  recPt_cut = recPt;
79  maxEta_cut= maxEta;
80  file_ = NULL;
81  dbe_ = dbe_store;
82  // print parameters
83  cout<< "PFJetBenchmark Setup parameters =============================================="<<endl;
84  cout << "Filename to write histograms " << Filename<<endl;
85  cout << "PFJetBenchmark debug " << debug_<< endl;
86  cout << "plotAgainstReco " << plotAgainstReco_ << endl;
87  cout << "onlyTwoJets " << onlyTwoJets_ << endl;
88  cout << "deltaRMax " << deltaRMax << endl;
89  cout << "benchmarkLabel " << benchmarkLabel_ << endl;
90  cout << "recPt_cut " << recPt_cut << endl;
91  cout << "maxEta_cut " << maxEta_cut << endl;
92 
93  // Book histogram
94 
95  // Establish DQM Store
96  string path = "PFTask/Benchmarks/"+ benchmarkLabel_ + "/";
97  if (plotAgainstReco) path += "Reco"; else path += "Gen";
98  if (dbe_) {
99  dbe_->setCurrentFolder(path.c_str());
100  }
101  else {
102  file_ = new TFile(outputFile_.c_str(), "recreate");
103 // TTree * tr = new TTree("PFTast");
104 // tr->Branch("Benchmarks/ParticleFlow")
105  cout << "Info: DQM is not available to provide data storage service. Using TFile to save histograms. "<<endl;
106  }
107  // Jets inclusive distributions (Pt > 20 or specified recPt GeV)
108  char cutString[35];
109  sprintf(cutString,"Jet multiplicity P_{T}>%4.1f GeV", recPt_cut);
110  BOOK1D(Njets,cutString,50, 0, 50);
111 
112  BOOK1D(jetsPt,"Jets P_{T} Distribution",100, 0, 500);
113 
114  sprintf(cutString,"Jets #eta Distribution |#eta|<%4.1f", maxEta_cut);
115  BOOK1D(jetsEta,cutString,100, -5, 5);
116 
117  BOOK2D(RPtvsEta,"#DeltaP_{T}/P_{T} vs #eta",200, -5., 5., 200,-1,1);
118  BOOK2D(RNeutvsEta,"R_{Neutral} vs #eta",200, -5., 5., 200,-1,1);
119  BOOK2D(RNEUTvsEta,"R_{HCAL+ECAL} vs #eta",200, -5., 5., 200,-1,1);
120  BOOK2D(RNONLvsEta,"R_{HCAL+ECAL - Hcal Only} vs #eta",200, -5., 5., 200,-1,1);
121  BOOK2D(RHCALvsEta,"R_{HCAL} vs #eta",200, -5., 5., 200,-1,1);
122  BOOK2D(RHONLvsEta,"R_{HCAL only} vs #eta",200, -5., 5., 200,-1,1);
123  BOOK2D(RCHEvsEta,"R_{Charged} vs #eta",200, -5., 5., 200,-1,1);
124  BOOK2D(NCHvsEta,"N_{Charged} vs #eta",200, -5., 5., 200,0.,200.);
125  BOOK2D(NCH0vsEta,"N_{Charged} vs #eta, iter 0",200, -5., 5., 200,0.,200.);
126  BOOK2D(NCH1vsEta,"N_{Charged} vs #eta, iter 1",200, -5., 5., 200,0.,200.);
127  BOOK2D(NCH2vsEta,"N_{Charged} vs #eta, iter 2",200, -5., 5., 200,0.,200.);
128  BOOK2D(NCH3vsEta,"N_{Charged} vs #eta, iter 3",200, -5., 5., 200,0.,200.);
129  BOOK2D(NCH4vsEta,"N_{Charged} vs #eta, iter 4",200, -5., 5., 200,0.,200.);
130  BOOK2D(NCH5vsEta,"N_{Charged} vs #eta, iter 5",200, -5., 5., 200,0.,200.);
131  BOOK2D(NCH6vsEta,"N_{Charged} vs #eta, iter 6",200, -5., 5., 200,0.,200.);
132  // delta Pt or E quantities for Barrel
133  DBOOK1D(RPt,#DeltaP_{T}/P_{T},80,-1,1);
134  DBOOK1D(RCHE,#DeltaE/E (charged had),80,-2,2);
135  DBOOK1D(RNHE,#DeltaE/E (neutral had),80,-2,2);
136  DBOOK1D(RNEE,#DeltaE/E (neutral em),80,-2,2);
137  DBOOK1D(Rneut,#DeltaE/E (neutral),80,-2,2);
138  DBOOK1D(NCH, #N_{charged},200,0.,200.);
139  DBOOK2D(RPtvsPt,#DeltaP_{T}/P_{T} vs P_{T},250, 0, 500, 200,-1,1); //used to be 50 bin for each in x-direction
140  DBOOK2D(RCHEvsPt,#DeltaE/E (charged had) vs P_{T},250, 0, 500, 120,-1,2);
141  DBOOK2D(RNHEvsPt,#DeltaE/E (neutral had) vs P_{T},250, 0, 500, 120,-1,2);
142  DBOOK2D(RNEEvsPt,#DeltaE/E (neutral em) vs P_{T},250, 0, 500, 120,-1,2);
143  DBOOK2D(RneutvsPt,#DeltaE/E (neutral) vs P_{T},250, 0, 500, 120,-1,2);
144  DBOOK2D(NCHvsPt,N_{charged} vs P_{T},250,0,500,200,0.,200.);
145  DBOOK2D(NCH0vsPt, N_{charged} vs P_{T} iter 0,250,0,500,200,0.,200.);
146  DBOOK2D(NCH1vsPt, N_{charged} vs P_{T} iter 1,250,0,500,200,0.,200.);
147  DBOOK2D(NCH2vsPt, N_{charged} vs P_{T} iter 2,250,0,500,200,0.,200.);
148  DBOOK2D(NCH3vsPt, N_{charged} vs P_{T} iter 3,250,0,500,200,0.,200.);
149  DBOOK2D(NCH4vsPt, N_{charged} vs P_{T} iter 4,250,0,500,200,0.,200.);
150  DBOOK2D(NCH5vsPt, N_{charged} vs P_{T} iter 5,250,0,500,200,0.,200.);
151  DBOOK2D(NCH6vsPt, N_{charged} vs P_{T} iter 6,250,0,500,200,0.,200.);
152 
153 
154  DBOOK2D(RNEUTvsP,#DeltaE/E (ECAL+HCAL) vs P,250, 0, 1000, 150,-1.5,1.5);
155  DBOOK2D(RNONLvsP,#DeltaE/E (ECAL+HCAL-only) vs P,250, 0, 1000, 150,-1.5,1.5);
156  DBOOK2D(RHCALvsP,#DeltaE/E (HCAL) vs P,250, 0, 1000, 150,-1.5,1.5);
157  DBOOK2D(RHONLvsP,#DeltaE/E (HCAL only) vs P,250, 0, 1000, 150,-1.5,1.5);
158  DBOOK1D(RPt20_40,#DeltaP_{T}/P_{T},80,-1,1);
159  DBOOK1D(RPt40_60,#DeltaP_{T}/P_{T},80,-1,1);
160  DBOOK1D(RPt60_80,#DeltaP_{T}/P_{T},80,-1,1);
161  DBOOK1D(RPt80_100,#DeltaP_{T}/P_{T},80,-1,1);
162  DBOOK1D(RPt100_150,#DeltaP_{T}/P_{T},80,-1,1);
163  DBOOK1D(RPt150_200,#DeltaP_{T}/P_{T},80,-1,1);
164  DBOOK1D(RPt200_250,#DeltaP_{T}/P_{T},80,-1,1);
165  DBOOK1D(RPt250_300,#DeltaP_{T}/P_{T},80,-1,1);
166  DBOOK1D(RPt300_400,#DeltaP_{T}/P_{T},160,-1,1);
167  DBOOK1D(RPt400_500,#DeltaP_{T}/P_{T},160,-1,1);
168  DBOOK1D(RPt500_750,#DeltaP_{T}/P_{T},160,-1,1);
169  DBOOK1D(RPt750_1250,#DeltaP_{T}/P_{T},160,-1,1);
170  DBOOK1D(RPt1250_2000,#DeltaP_{T}/P_{T},160,-1,1);
171  DBOOK1D(RPt2000_5000,#DeltaP_{T}/P_{T},160,-1,1);
172 
173  DBOOK2D(DEtavsPt,#Delta#eta vs P_{T},1000,0,2000,500,-0.5,0.5);
174  DBOOK2D(DPhivsPt,#Delta#phi vs P_{T},1000,0,2000,500,-0.5,0.5);
175  BOOK2D(DEtavsEta,"#Delta#eta vs P_{T}",1000,-5.,+5.,500,-0.5,0.5);
176  BOOK2D(DPhivsEta,"#Delta#phi vs P_{T}",1000,-5.,+5.,500,-0.5,0.5);
177 
178  // Set Axis Titles
179 
180  // Jets inclusive distributions (Pt > 20 GeV)
181  SETAXES(Njets,"","Multiplicity");
182  SETAXES(jetsPt, PT, "Number of Events");
183  SETAXES(jetsEta, "#eta", "Number of Events");
184  SETAXES(RNeutvsEta, "#eta", "#DeltaE/E (Neutral)");
185  SETAXES(RNEUTvsEta, "#eta", "#DeltaE/E (ECAL+HCAL)");
186  SETAXES(RNONLvsEta, "#eta", "#DeltaE/E (ECAL+HCAL-only)");
187  SETAXES(RHCALvsEta, "#eta", "#DeltaE/E (HCAL)");
188  SETAXES(RHONLvsEta, "#eta", "#DeltaE/E (HCAL Only)");
189  SETAXES(RCHEvsEta, "#eta", "#DeltaE/E (Charged)");
190  SETAXES(RPtvsEta, "#eta", "#DeltaP_{T}/P_{T}");
191  SETAXES(DEtavsEta, "#eta", "#Delta#eta");
192  SETAXES(DPhivsEta,"#eta", "#Delta#phi");
193  // delta Pt or E quantities for Barrel and Endcap
194  DSETAXES(RPt, "#DeltaP_{T}/P_{T}", "Events");
195  DSETAXES(RPt20_40, "#DeltaP_{T}/P_{T}", "Events");
196  DSETAXES(RPt40_60, "#DeltaP_{T}/P_{T}", "Events");
197  DSETAXES(RPt60_80, "#DeltaP_{T}/P_{T}", "Events");
198  DSETAXES(RPt80_100, "#DeltaP_{T}/P_{T}", "Events");
199  DSETAXES(RPt100_150, "#DeltaP_{T}/P_{T}", "Events");
200  DSETAXES(RPt150_200, "#DeltaP_{T}/P_{T}", "Events");
201  DSETAXES(RPt200_250, "#DeltaP_{T}/P_{T}", "Events");
202  DSETAXES(RPt250_300, "#DeltaP_{T}/P_{T}", "Events");
203  DSETAXES(RPt300_400, "#DeltaP_{T}/P_{T}", "Events");
204  DSETAXES(RPt400_500, "#DeltaP_{T}/P_{T}", "Events");
205  DSETAXES(RPt500_750, "#DeltaP_{T}/P_{T}", "Events");
206  DSETAXES(RPt750_1250, "#DeltaP_{T}/P_{T}", "Events");
207  DSETAXES(RPt1250_2000, "#DeltaP_{T}/P_{T}", "Events");
208  DSETAXES(RPt2000_5000, "#DeltaP_{T}/P_{T}", "Events");
209  DSETAXES(RCHE, "#DeltaE/E(charged had)", "Events");
210  DSETAXES(RNHE, "#DeltaE/E(neutral had)", "Events");
211  DSETAXES(RNEE, "#DeltaE/E(neutral em)", "Events");
212  DSETAXES(Rneut, "#DeltaE/E(neutral)", "Events");
213  DSETAXES(RPtvsPt, PT, "#DeltaP_{T}/P_{T}");
214  DSETAXES(RCHEvsPt, PT, "#DeltaE/E(charged had)");
215  DSETAXES(RNHEvsPt, PT, "#DeltaE/E(neutral had)");
216  DSETAXES(RNEEvsPt, PT, "#DeltaE/E(neutral em)");
217  DSETAXES(RneutvsPt, PT, "#DeltaE/E(neutral)");
218  DSETAXES(RHCALvsP, P, "#DeltaE/E(HCAL)");
219  DSETAXES(RHONLvsP, P, "#DeltaE/E(HCAL-only)");
220  DSETAXES(RNEUTvsP, P, "#DeltaE/E(ECAL+HCAL)");
221  DSETAXES(RNONLvsP, P, "#DeltaE/E(ECAL+HCAL-only)");
222  DSETAXES(DEtavsPt, PT, "#Delta#eta");
223  DSETAXES(DPhivsPt, PT, "#Delta#phi");
224 
225 }
226 
227 
228 void PFJetBenchmark::process(const reco::PFJetCollection& pfJets, const reco::GenJetCollection& genJets) {
229  // loop over reco pf jets
230  resPtMax_ = 0.;
231  resChargedHadEnergyMax_ = 0.;
232  resNeutralHadEnergyMax_ = 0.;
233  resNeutralEmEnergyMax_ = 0.;
234  int NPFJets = 0;
235 
236  for(unsigned i=0; i<pfJets.size(); i++) {
237 
238  // Count the number of jets with a larger energy
239  unsigned highJets = 0;
240  for(unsigned j=0; j<pfJets.size(); j++) {
241  if ( j != i && pfJets[j].pt() > pfJets[i].pt() ) highJets++;
242  }
243  if ( onlyTwoJets_ && highJets > 1 ) continue;
244 
245 
246  const reco::PFJet& pfj = pfJets[i];
247  double rec_pt = pfj.pt();
248  double rec_eta = pfj.eta();
249  double rec_phi = pfj.phi();
250 
251  // skip PFjets with pt < recPt_cut GeV
252  if (rec_pt<recPt_cut and recPt_cut != -1.) continue;
253  // skip PFjets with eta > maxEta_cut
254  if (fabs(rec_eta)>maxEta_cut and maxEta_cut != -1.) continue;
255 
256  NPFJets++;
257 
258  // fill inclusive PFjet distribution pt > 20 GeV
259  hNjets->Fill(NPFJets);
260  hjetsPt->Fill(rec_pt);
261  hjetsEta->Fill(rec_eta);
262 
263  // separate Barrel PFJets from Endcap PFJets
264  bool Barrel = false;
265  bool Endcap = false;
266  bool Forward = false;
267  if (std::abs(rec_eta) < 1.4 ) Barrel = true;
268  if (std::abs (rec_eta) > 1.6 && std::abs (rec_eta) < 2.4 ) Endcap = true;
269  if (std::abs (rec_eta) > 2.5 && std::abs (rec_eta) < 2.9 ) Forward = true;
270  if (std::abs (rec_eta) > 3.1 && std::abs (rec_eta) < 4.7 ) Forward = true;
271 
272  // do only barrel for now
273  // if(!Barrel) continue;
274 
275  // look for the closets gen Jet : truth
276  const GenJet *truth = algo_->matchByDeltaR(&pfj,&genJets);
277  if(!truth) continue;
278  double deltaR = algo_->deltaR(&pfj, truth);
279  // check deltaR is small enough
280  if(deltaR < deltaRMax_ || (abs(rec_eta)>2.5 && deltaR < 0.2) || deltaRMax_ == -1.0 ) {//start case deltaR < deltaRMax
281 
282  // generate histograms comparing the reco and truth candidate (truth = closest in delta-R)
283  // get the quantities to place on the denominator and/or divide by
284  double pt_denom;
285  double true_E = truth->p();
286  double true_pt = truth->pt();
287  double true_eta = truth->eta();
288  double true_phi = truth->phi();
289 
290  if (plotAgainstReco_) {pt_denom = rec_pt;}
291  else {pt_denom = true_pt;}
292  // get true specific quantities
293  double true_ChargedHadEnergy;
294  double true_NeutralHadEnergy;
295  double true_NeutralEmEnergy;
296  gettrue (truth, true_ChargedHadEnergy, true_NeutralHadEnergy, true_NeutralEmEnergy);
297  double true_NeutralEnergy = true_NeutralHadEnergy + true_NeutralEmEnergy;
298  double rec_ChargedHadEnergy = pfj.chargedHadronEnergy();
299  double rec_NeutralHadEnergy = pfj.neutralHadronEnergy();
300  double rec_NeutralEmEnergy = pfj.neutralEmEnergy();
301  double rec_NeutralEnergy = rec_NeutralHadEnergy + rec_NeutralEmEnergy;
302  double rec_ChargedMultiplicity = pfj.chargedMultiplicity();
303  std::vector <PFCandidatePtr> constituents = pfj.getPFConstituents ();
304  std::vector <unsigned int> chMult(7, static_cast<unsigned int>(0));
305  for (unsigned ic = 0; ic < constituents.size (); ++ic) {
306  if ( constituents[ic]->particleId() > 3 ) continue;
307  reco::TrackRef trackRef = constituents[ic]->trackRef();
308  if ( trackRef.isNull() ) {
309  //std::cout << "Warning in entry " << entry_
310  // << " : a track with Id " << constituents[ic]->particleId()
311  // << " has no track ref.." << std::endl;
312  continue;
313  }
314  unsigned int iter = 0;
315  switch (trackRef->algo()) {
316  case TrackBase::ctf:
317  case TrackBase::iter0:
318  iter = 0;
319  break;
320  case TrackBase::iter1:
321  iter = 1;
322  break;
323  case TrackBase::iter2:
324  iter = 2;
325  break;
326  case TrackBase::iter3:
327  iter = 3;
328  break;
329  case TrackBase::iter4:
330  iter = 4;
331  break;
332  case TrackBase::iter5:
333  iter = 5;
334  break;
335  default:
336  iter = 6;
337  std::cout << "Warning in entry " << entry_ << " : iter = 6... " << std::endl;
338  break;
339  }
340  ++(chMult[iter]);
341  }
342 
343  bool plot1 = false;
344  bool plot2 = false;
345  bool plot3 = false;
346  bool plot4 = false;
347  bool plot5 = false;
348  bool plot6 = false;
349  bool plot7 = false;
350  double cut1 = 0.0001;
351  double cut2 = 0.0001;
352  double cut3 = 0.0001;
353  double cut4 = 0.0001;
354  double cut5 = 0.0001;
355  double cut6 = 0.0001;
356  double cut7 = 0.0001;
357  double resPt =0.;
358  double resChargedHadEnergy= 0.;
359  double resNeutralHadEnergy= 0.;
360  double resNeutralEmEnergy= 0.;
361  double resNeutralEnergy= 0.;
362 
363  double resHCALEnergy = 0.;
364  double resNEUTEnergy = 0.;
365  if ( rec_NeutralHadEnergy > cut6 && rec_ChargedHadEnergy < cut1 ) {
366  double true_NEUTEnergy = true_NeutralHadEnergy + true_NeutralEmEnergy;
367  double true_HCALEnergy = true_NEUTEnergy - rec_NeutralEmEnergy;
368  double rec_NEUTEnergy = rec_NeutralHadEnergy+rec_NeutralEmEnergy;
369  double rec_HCALEnergy = rec_NeutralHadEnergy;
370  resHCALEnergy = (rec_HCALEnergy-true_HCALEnergy)/rec_HCALEnergy;
371  resNEUTEnergy = (rec_NEUTEnergy-true_NEUTEnergy)/rec_NEUTEnergy;
372  if ( rec_NeutralEmEnergy > cut7 ) {
373  plot6 = true;
374  } else {
375  plot7 = true;
376  }
377  }
378 
379  // get relative delta quantities (protect against division by zero!)
380  if (true_pt > 0.0001){
381  resPt = (rec_pt -true_pt)/true_pt ;
382  plot1 = true;}
383  if (true_ChargedHadEnergy > cut1){
384  resChargedHadEnergy = (rec_ChargedHadEnergy- true_ChargedHadEnergy)/true_ChargedHadEnergy;
385  plot2 = true;}
386  if (true_NeutralHadEnergy > cut2){
387  resNeutralHadEnergy = (rec_NeutralHadEnergy- true_NeutralHadEnergy)/true_NeutralHadEnergy;
388  plot3 = true;}
389  else
390  if (rec_NeutralHadEnergy > cut3){
391  resNeutralHadEnergy = (rec_NeutralHadEnergy- true_NeutralHadEnergy)/rec_NeutralHadEnergy;
392  plot3 = true;}
393  if (true_NeutralEmEnergy > cut4){
394  resNeutralEmEnergy = (rec_NeutralEmEnergy- true_NeutralEmEnergy)/true_NeutralEmEnergy;
395  plot4 = true;}
396  if (true_NeutralEnergy > cut5){
397  resNeutralEnergy = (rec_NeutralEnergy- true_NeutralEnergy)/true_NeutralEnergy;
398  plot5 = true;}
399 
400  //double deltaEta = algo_->deltaEta(&pfj, truth);
401  //double deltaPhi = algo_->deltaPhi(&pfj, truth);
402 
403  // Print outliers for further debugging
404  if ( ( resPt > 0.2 && true_pt > 100. ) ||
405  ( resPt < -0.5 && true_pt > 100. ) ) {
406  //if ( ( true_pt > 50. &&
407  // ( ( truth->eta()>3.0 && rec_eta-truth->eta() < -0.1 ) ||
408  // ( truth->eta()<-3.0 && rec_eta-truth->eta() > 0.1 ) ))) {
409  std::cout << "Entry " << entry_
410  << " resPt = " << resPt
411  <<" resCharged " << resChargedHadEnergy
412  <<" resNeutralHad " << resNeutralHadEnergy
413  << " resNeutralEm " << resNeutralEmEnergy
414  << " pT (T/R) " << true_pt << "/" << rec_pt
415  << " Eta (T/R) " << truth->eta() << "/" << rec_eta
416  << " Phi (T/R) " << truth->phi() << "/" << rec_phi
417  << std::endl;
418 
419  // check overlapping PF jets
420  const reco::PFJet* pfoj = 0;
421  double dRo = 1E9;
422  for(unsigned j=0; j<pfJets.size(); j++) {
423  const reco::PFJet& pfo = pfJets[j];
424  if ( j != i && algo_->deltaR(&pfj,&pfo) < dRo && pfo.pt() > 0.25*pfj.pt()) {
425  dRo = algo_->deltaR(&pfj,&pfo);
426  pfoj = &pfo;
427  }
428  }
429 
430  // Check overlapping Gen Jet
431  math::XYZTLorentzVector overlappinGenJet(0.,0.,0.,0.);
432  const reco::GenJet* genoj = 0;
433  double dRgo = 1E9;
434  for(unsigned j=0; j<genJets.size(); j++) {
435  const reco::GenJet* gjo = &(genJets[j]);
436  if ( gjo != truth && algo_->deltaR(truth,gjo) < dRgo && gjo->pt() > 0.25*truth->pt() ) {
437  dRgo = algo_->deltaR(truth,gjo);
438  genoj = gjo;
439  }
440  }
441 
442  if ( dRo < 0.8 && dRgo < 0.8 && algo_->deltaR(genoj,pfoj) < 2.*deltaRMax_ )
443  std::cout << "Excess probably due to overlapping jets (DR = " << algo_->deltaR(genoj,pfoj) << "),"
444  << " at DeltaR(T/R) = " << dRgo << "/" << dRo
445  << " with pT(T/R) " << genoj->pt() << "/" << pfoj->pt()
446  << " and Eta (T/R) " << genoj->eta() << "/" << pfoj->eta()
447  << " and Phi (T/R) " << genoj->phi() << "/" << pfoj->phi()
448  << std::endl;
449  }
450 
451  if(std::abs(resPt) > std::abs(resPtMax_)) resPtMax_ = resPt;
452  if(std::abs(resChargedHadEnergy) > std::abs(resChargedHadEnergyMax_) ) resChargedHadEnergyMax_ = resChargedHadEnergy;
453  if(std::abs(resNeutralHadEnergy) > std::abs(resNeutralHadEnergyMax_) ) resNeutralHadEnergyMax_ = resNeutralHadEnergy;
454  if(std::abs(resNeutralEmEnergy) > std::abs(resNeutralEmEnergyMax_) ) resNeutralEmEnergyMax_ = resNeutralEmEnergy;
455  if (debug_) {
456  cout << i <<" =========PFJet Pt "<< rec_pt
457  << " eta " << rec_eta
458  << " phi " << rec_phi
459  << " Charged Had Energy " << rec_ChargedHadEnergy
460  << " Neutral Had Energy " << rec_NeutralHadEnergy
461  << " Neutral elm Energy " << rec_NeutralEmEnergy << endl;
462  cout << " matching Gen Jet Pt " << true_pt
463  << " eta " << truth->eta()
464  << " phi " << truth->phi()
465  << " Charged Had Energy " << true_ChargedHadEnergy
466  << " Neutral Had Energy " << true_NeutralHadEnergy
467  << " Neutral elm Energy " << true_NeutralEmEnergy << endl;
468  printPFJet(&pfj);
469  // cout<<pfj.print()<<endl;
470  printGenJet(truth);
471  //cout <<truth->print()<<endl;
472 
473  cout << "==============deltaR " << deltaR << " resPt " << resPt
474  << " resChargedHadEnergy " << resChargedHadEnergy
475  << " resNeutralHadEnergy " << resNeutralHadEnergy
476  << " resNeutralEmEnergy " << resNeutralEmEnergy
477  << endl;
478  }
479 
480 
481  if(plot1) {
482  if ( rec_eta > 0. )
483  hDEtavsEta->Fill(true_eta,rec_eta-true_eta);
484  else
485  hDEtavsEta->Fill(true_eta,-rec_eta+true_eta);
486  hDPhivsEta->Fill(true_eta,rec_phi-true_phi);
487 
488  hRPtvsEta->Fill(true_eta, resPt);
489  hNCHvsEta->Fill(true_eta, rec_ChargedMultiplicity);
490  hNCH0vsEta->Fill(true_eta,chMult[0]);
491  hNCH1vsEta->Fill(true_eta,chMult[1]);
492  hNCH2vsEta->Fill(true_eta,chMult[2]);
493  hNCH3vsEta->Fill(true_eta,chMult[3]);
494  hNCH4vsEta->Fill(true_eta,chMult[4]);
495  hNCH5vsEta->Fill(true_eta,chMult[5]);
496  hNCH6vsEta->Fill(true_eta,chMult[6]);
497  }
498  if(plot2)hRCHEvsEta->Fill(true_eta, resChargedHadEnergy);
499  if(plot5)hRNeutvsEta->Fill(true_eta, resNeutralEnergy);
500  if(plot6) {
501  hRHCALvsEta->Fill(true_eta, resHCALEnergy);
502  hRNEUTvsEta->Fill(true_eta, resNEUTEnergy);
503  }
504  if(plot7) {
505  hRHONLvsEta->Fill(true_eta, resHCALEnergy);
506  hRNONLvsEta->Fill(true_eta, resNEUTEnergy);
507  }
508 
509  // fill histograms for relative delta quantitites of matched jets
510  // delta Pt or E quantities for Barrel
511  if (Barrel){
512  if(plot1) {
513  hBRPt->Fill (resPt);
514  if ( pt_denom > 20. && pt_denom < 40. ) hBRPt20_40->Fill (resPt);
515  if ( pt_denom > 40. && pt_denom < 60. ) hBRPt40_60->Fill (resPt);
516  if ( pt_denom > 60. && pt_denom < 80. ) hBRPt60_80->Fill (resPt);
517  if ( pt_denom > 80. && pt_denom < 100. ) hBRPt80_100->Fill (resPt);
518  if ( pt_denom > 100. && pt_denom < 150. ) hBRPt100_150->Fill (resPt);
519  if ( pt_denom > 150. && pt_denom < 200. ) hBRPt150_200->Fill (resPt);
520  if ( pt_denom > 200. && pt_denom < 250. ) hBRPt200_250->Fill (resPt);
521  if ( pt_denom > 250. && pt_denom < 300. ) hBRPt250_300->Fill (resPt);
522  if ( pt_denom > 300. && pt_denom < 400. ) hBRPt300_400->Fill (resPt);
523  if ( pt_denom > 400. && pt_denom < 500. ) hBRPt400_500->Fill (resPt);
524  if ( pt_denom > 500. && pt_denom < 750. ) hBRPt500_750->Fill (resPt);
525  if ( pt_denom > 750. && pt_denom < 1250. ) hBRPt750_1250->Fill (resPt);
526  if ( pt_denom > 1250. && pt_denom < 2000. ) hBRPt1250_2000->Fill (resPt);
527  if ( pt_denom > 2000. && pt_denom < 5000. ) hBRPt2000_5000->Fill (resPt);
528  hBNCH->Fill(rec_ChargedMultiplicity);
529  hBNCH0vsPt->Fill(pt_denom,chMult[0]);
530  hBNCH1vsPt->Fill(pt_denom,chMult[1]);
531  hBNCH2vsPt->Fill(pt_denom,chMult[2]);
532  hBNCH3vsPt->Fill(pt_denom,chMult[3]);
533  hBNCH4vsPt->Fill(pt_denom,chMult[4]);
534  hBNCH5vsPt->Fill(pt_denom,chMult[5]);
535  hBNCH6vsPt->Fill(pt_denom,chMult[6]);
536  hBNCHvsPt->Fill(pt_denom,rec_ChargedMultiplicity);
537  if ( rec_eta > 0. )
538  hBDEtavsPt->Fill(pt_denom,rec_eta-true_eta);
539  else
540  hBDEtavsPt->Fill(pt_denom,-rec_eta+true_eta);
541  hBDPhivsPt->Fill(pt_denom,rec_phi-true_phi);
542  }
543  if(plot2)hBRCHE->Fill(resChargedHadEnergy);
544  if(plot3)hBRNHE->Fill(resNeutralHadEnergy);
545  if(plot4)hBRNEE->Fill(resNeutralEmEnergy);
546  if(plot5)hBRneut->Fill(resNeutralEnergy);
547  if(plot1)hBRPtvsPt->Fill(pt_denom, resPt);
548  if(plot2)hBRCHEvsPt->Fill(pt_denom, resChargedHadEnergy);
549  if(plot3)hBRNHEvsPt->Fill(pt_denom, resNeutralHadEnergy);
550  if(plot4)hBRNEEvsPt->Fill(pt_denom, resNeutralEmEnergy);
551  if(plot5)hBRneutvsPt->Fill(pt_denom, resNeutralEnergy);
552  if(plot6) {
553  hBRHCALvsP->Fill(true_E, resHCALEnergy);
554  hBRNEUTvsP->Fill(true_E, resNEUTEnergy);
555  }
556  if(plot7) {
557  hBRHONLvsP->Fill(true_E, resHCALEnergy);
558  hBRNONLvsP->Fill(true_E, resNEUTEnergy);
559  }
560 
561  }
562  // delta Pt or E quantities for Endcap
563  if (Endcap){
564  if(plot1) {
565  hERPt->Fill (resPt);
566  if ( pt_denom > 20. && pt_denom < 40. ) hERPt20_40->Fill (resPt);
567  if ( pt_denom > 40. && pt_denom < 60. ) hERPt40_60->Fill (resPt);
568  if ( pt_denom > 60. && pt_denom < 80. ) hERPt60_80->Fill (resPt);
569  if ( pt_denom > 80. && pt_denom < 100. ) hERPt80_100->Fill (resPt);
570  if ( pt_denom > 100. && pt_denom < 150. ) hERPt100_150->Fill (resPt);
571  if ( pt_denom > 150. && pt_denom < 200. ) hERPt150_200->Fill (resPt);
572  if ( pt_denom > 200. && pt_denom < 250. ) hERPt200_250->Fill (resPt);
573  if ( pt_denom > 250. && pt_denom < 300. ) hERPt250_300->Fill (resPt);
574  if ( pt_denom > 300. && pt_denom < 400. ) hERPt300_400->Fill (resPt);
575  if ( pt_denom > 400. && pt_denom < 500. ) hERPt400_500->Fill (resPt);
576  if ( pt_denom > 500. && pt_denom < 750. ) hERPt500_750->Fill (resPt);
577  if ( pt_denom > 750. && pt_denom < 1250. ) hERPt750_1250->Fill (resPt);
578  if ( pt_denom > 1250. && pt_denom < 2000. ) hERPt1250_2000->Fill (resPt);
579  if ( pt_denom > 2000. && pt_denom < 5000. ) hERPt2000_5000->Fill (resPt);
580  hENCH->Fill(rec_ChargedMultiplicity);
581  hENCHvsPt->Fill(pt_denom,rec_ChargedMultiplicity);
582  hENCH0vsPt->Fill(pt_denom,chMult[0]);
583  hENCH1vsPt->Fill(pt_denom,chMult[1]);
584  hENCH2vsPt->Fill(pt_denom,chMult[2]);
585  hENCH3vsPt->Fill(pt_denom,chMult[3]);
586  hENCH4vsPt->Fill(pt_denom,chMult[4]);
587  hENCH5vsPt->Fill(pt_denom,chMult[5]);
588  hENCH6vsPt->Fill(pt_denom,chMult[6]);
589  if ( rec_eta > 0. )
590  hEDEtavsPt->Fill(pt_denom,rec_eta-true_eta);
591  else
592  hEDEtavsPt->Fill(pt_denom,-rec_eta+true_eta);
593  hEDPhivsPt->Fill(pt_denom,rec_phi-true_phi);
594  }
595  if(plot2)hERCHE->Fill(resChargedHadEnergy);
596  if(plot3)hERNHE->Fill(resNeutralHadEnergy);
597  if(plot4)hERNEE->Fill(resNeutralEmEnergy);
598  if(plot5)hERneut->Fill(resNeutralEnergy);
599  if(plot1)hERPtvsPt->Fill(pt_denom, resPt);
600  if(plot2)hERCHEvsPt->Fill(pt_denom, resChargedHadEnergy);
601  if(plot3)hERNHEvsPt->Fill(pt_denom, resNeutralHadEnergy);
602  if(plot4)hERNEEvsPt->Fill(pt_denom, resNeutralEmEnergy);
603  if(plot5)hERneutvsPt->Fill(pt_denom, resNeutralEnergy);
604  if(plot6) {
605  hERHCALvsP->Fill(true_E, resHCALEnergy);
606  hERNEUTvsP->Fill(true_E, resNEUTEnergy);
607  }
608  if(plot7) {
609  hERHONLvsP->Fill(true_E, resHCALEnergy);
610  hERNONLvsP->Fill(true_E, resNEUTEnergy);
611  }
612  }
613  // delta Pt or E quantities for Forward
614  if (Forward){
615  if(plot1) {
616  hFRPt->Fill (resPt);
617  if ( pt_denom > 20. && pt_denom < 40. ) hFRPt20_40->Fill (resPt);
618  if ( pt_denom > 40. && pt_denom < 60. ) hFRPt40_60->Fill (resPt);
619  if ( pt_denom > 60. && pt_denom < 80. ) hFRPt60_80->Fill (resPt);
620  if ( pt_denom > 80. && pt_denom < 100. ) hFRPt80_100->Fill (resPt);
621  if ( pt_denom > 100. && pt_denom < 150. ) hFRPt100_150->Fill (resPt);
622  if ( pt_denom > 150. && pt_denom < 200. ) hFRPt150_200->Fill (resPt);
623  if ( pt_denom > 200. && pt_denom < 250. ) hFRPt200_250->Fill (resPt);
624  if ( pt_denom > 250. && pt_denom < 300. ) hFRPt250_300->Fill (resPt);
625  if ( pt_denom > 300. && pt_denom < 400. ) hFRPt300_400->Fill (resPt);
626  if ( pt_denom > 400. && pt_denom < 500. ) hFRPt400_500->Fill (resPt);
627  if ( pt_denom > 500. && pt_denom < 750. ) hFRPt500_750->Fill (resPt);
628  if ( pt_denom > 750. && pt_denom < 1250. ) hFRPt750_1250->Fill (resPt);
629  if ( pt_denom > 1250. && pt_denom < 2000. ) hFRPt1250_2000->Fill (resPt);
630  if ( pt_denom > 2000. && pt_denom < 5000. ) hFRPt2000_5000->Fill (resPt);
631  if ( rec_eta > 0. )
632  hFDEtavsPt->Fill(pt_denom,rec_eta-true_eta);
633  else
634  hFDEtavsPt->Fill(pt_denom,-rec_eta+true_eta);
635  hFDPhivsPt->Fill(pt_denom,rec_phi-true_phi);
636  }
637  if(plot2)hFRCHE->Fill(resChargedHadEnergy);
638  if(plot3)hFRNHE->Fill(resNeutralHadEnergy);
639  if(plot4)hFRNEE->Fill(resNeutralEmEnergy);
640  if(plot5)hFRneut->Fill(resNeutralEnergy);
641  if(plot1)hFRPtvsPt->Fill(pt_denom, resPt);
642  if(plot2)hFRCHEvsPt->Fill(pt_denom, resChargedHadEnergy);
643  if(plot3)hFRNHEvsPt->Fill(pt_denom, resNeutralHadEnergy);
644  if(plot4)hFRNEEvsPt->Fill(pt_denom, resNeutralEmEnergy);
645  if(plot5)hFRneutvsPt->Fill(pt_denom, resNeutralEnergy);
646  if(plot6) {
647  hFRHCALvsP->Fill(true_E, resHCALEnergy);
648  hFRNEUTvsP->Fill(true_E, resNEUTEnergy);
649  }
650  if(plot7) {
651  hFRHONLvsP->Fill(true_E, resHCALEnergy);
652  hFRNONLvsP->Fill(true_E, resNEUTEnergy);
653  }
654  }
655  } // end case deltaR < deltaRMax
656 
657  } // i loop on pf Jets
658 
659  // Increment counter
660  entry_++;
661 }
662 
663 void PFJetBenchmark::gettrue (const reco::GenJet* truth, double& true_ChargedHadEnergy,
664  double& true_NeutralHadEnergy, double& true_NeutralEmEnergy){
665  std::vector <const GenParticle*> mcparts = truth->getGenConstituents ();
666  true_NeutralEmEnergy = 0.;
667  true_ChargedHadEnergy = 0.;
668  true_NeutralHadEnergy = 0.;
669  // for each MC particle in turn
670  for (unsigned i = 0; i < mcparts.size (); i++) {
671  const GenParticle* mcpart = mcparts[i];
672  int PDG = std::abs( mcpart->pdgId());
673  double e = mcpart->energy();
674  switch(PDG){ // start PDG switch
675  case 22: // photon
676  true_NeutralEmEnergy += e;
677  break;
678  case 211: // pi
679  case 321: // K
680  case 2212: // p
681  case 11: //electrons (until recognised)
682  true_ChargedHadEnergy += e;
683  break;
684  case 310: // K_S0
685  case 130: // K_L0
686  case 3122: // Lambda0
687  case 2112: // n0
688  true_NeutralHadEnergy += e;
689  default:
690  break;
691  } // end PDG switch
692  } // end loop on constituents.
693 }
694 
695 void PFJetBenchmark::printPFJet(const reco::PFJet* pfj){
696  cout<<setiosflags(ios::right);
697  cout<<setiosflags(ios::fixed);
698  cout<<setprecision(3);
699 
700  cout << "PFJet p/px/py/pz/pt: " << pfj->p() << "/" << pfj->px ()
701  << "/" << pfj->py() << "/" << pfj->pz() << "/" << pfj->pt() << endl
702  << " eta/phi: " << pfj->eta () << "/" << pfj->phi () << endl
703  << " PFJet specific:" << std::endl
704  << " charged/neutral hadrons energy: " << pfj->chargedHadronEnergy () << '/' << pfj->neutralHadronEnergy () << endl
705  << " charged/neutral em energy: " << pfj->chargedEmEnergy () << '/' << pfj->neutralEmEnergy () << endl
706  << " charged muon energy: " << pfj->chargedMuEnergy () << '/' << endl
707  << " charged/neutral multiplicity: " << pfj->chargedMultiplicity () << '/' << pfj->neutralMultiplicity () << endl;
708 
709  // And print the constituents
710  std::cout << pfj->print() << std::endl;
711 
712  cout<<resetiosflags(ios::right|ios::fixed);
713 }
714 
715 
716 void PFJetBenchmark::printGenJet (const reco::GenJet* truth){
717  std::vector <const GenParticle*> mcparts = truth->getGenConstituents ();
718  cout << "GenJet p/px/py/pz/pt: " << truth->p() << '/' << truth->px ()
719  << '/' << truth->py() << '/' << truth->pz() << '/' << truth->pt() << endl
720  << " eta/phi: " << truth->eta () << '/' << truth->phi () << endl
721  << " # of constituents: " << mcparts.size() << endl;
722  cout << " constituents:" << endl;
723  for (unsigned i = 0; i < mcparts.size (); i++) {
724  const GenParticle* mcpart = mcparts[i];
725  cout << " #" << i << " PDG code:" << mcpart->pdgId()
726  << ", p/pt/eta/phi: " << mcpart->p() << '/' << mcpart->pt()
727  << '/' << mcpart->eta() << '/' << mcpart->phi() << endl;
728  }
729 }
730 
i
int i
Definition: DBlmapReader.cc:9
reco::LeafCandidate::pdgId
virtual int pdgId() const
PDG identifier.
Definition: LeafCandidate.h:194
reco::LeafCandidate::p
virtual double p() const
magnitude of momentum vector
Definition: LeafCandidate.h:117
BOOK1D
#define BOOK1D(name, title, nbinsx, lowx, highx)
Definition: PFJetBenchmark.cc:5
reco::PFJet::chargedEmEnergy
float chargedEmEnergy() const
chargedEmEnergy
Definition: PFJet.h:135
onlyTwoJets
bool onlyTwoJets
Definition: PFJetBenchmarkAnalyzer.cc:73
python.pfJets_cff.pfJets
tuple pfJets
Definition: pfJets_cff.py:8
PT
#define PT
Definition: PFJetBenchmark.cc:32
deltaRMax
double deltaRMax
Definition: PFJetBenchmarkAnalyzer.cc:74
DQMStore::save
void save(const std::string &filename, const std::string &path="", const std::string &pattern="", const std::string &rewrite="", SaveReferenceTag ref=SaveWithReference, int minStatus=dqm::qstatus::STATUS_OK, const std::string &fileupdate="RECREATE")
Definition: DQMStore.cc:1898
reco::GenJetCollection
std::vector< GenJet > GenJetCollection
collection of GenJet objects
Definition: GenJetCollection.h:15
SETAXES
#define SETAXES(name, xtitle, ytitle)
Definition: PFJetBenchmark.cc:22
abs
#define abs(x)
Definition: mlp_lapack.h:159
P
#define P
Definition: PFJetBenchmark.cc:33
NULL
#define NULL
Definition: scimark2.h:8
maxEta
double maxEta
Definition: PFJetBenchmarkAnalyzer.cc:77
eta
T eta() const
Definition: Basic3DVectorLD.h:168
dt_dqm_sourceclient_common_cff.reco
tuple reco
Definition: dt_dqm_sourceclient_common_cff.py:101
reco::PFJet::chargedMultiplicity
int chargedMultiplicity() const
chargedMultiplicity
Definition: PFJet.h:148
reco::PFJet
Jets made from PFObjects.
Definition: PFJet.h:22
reco::LeafCandidate::eta
virtual double eta() const
momentum pseudorapidity
Definition: LeafCandidate.h:143
reco::PFJet::neutralEmEnergy
float neutralEmEnergy() const
neutralEmEnergy
Definition: PFJet.h:143
PFJetBenchmark::entry_
unsigned int entry_
Definition: PFJetBenchmark.h:232
PFJetBenchmark::dbe_
DQMStore * dbe_
Definition: PFJetBenchmark.h:233
PFJetBenchmark::~PFJetBenchmark
virtual ~PFJetBenchmark()
Definition: PFJetBenchmark.cc:42
path
int path() const
Definition: HLTadd.h:3
PFJetBenchmark::gettrue
void gettrue(const reco::GenJet *truth, double &true_ChargedHadEnergy, double &true_NeutralHadEnergy, double &true_NeutralEmEnergy)
Definition: PFJetBenchmark.cc:663
math::XYZTLorentzVector
XYZTLorentzVectorD XYZTLorentzVector
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:30
reco::LeafCandidate::energy
virtual double energy() const
energy
Definition: LeafCandidate.h:119
PFJetBenchmark::setup
void setup(std::string Filename, bool debug, bool plotAgainstReco=0, bool onlyTwoJets=1, double deltaRMax=0.1, std::string benchmarkLabel_="ParticleFlow", double recPt=-1, double maxEta=-1, DQMStore *dbe_store=NULL)
Definition: PFJetBenchmark.cc:63
edm::Ref::isNull
bool isNull() const
Checks for null.
Definition: Ref.h:246
BOOK2D
#define BOOK2D(name, title, nbinsx, lowx, highx, nbinsy, lowy, highy)
Definition: PFJetBenchmark.cc:10
reco::PFJet::print
virtual std::string print() const
Print object in details.
Definition: PFJet.cc:84
PFBenchmarkAlgo::deltaR
static double deltaR(const T *, const U *)
Definition: PFBenchmarkAlgo.h:189
DBOOK2D
#define DBOOK2D(name, title, nbinsx, lowx, highx, nbinsy, lowy, highy)
Definition: PFJetBenchmark.cc:17
j
int j
Definition: DBlmapReader.cc:9
reco::GenJet
Jets made from MC generator particles.
Definition: GenJet.h:25
PFJetBenchmark::outputFile_
std::string outputFile_
Definition: PFJetBenchmark.h:218
benchmarkLabel_
string benchmarkLabel_
Definition: PFJetBenchmarkAnalyzer.cc:75
PFJetBenchmark::algo_
PFBenchmarkAlgo * algo_
Definition: PFJetBenchmark.h:221
reco::GenJet::getGenConstituents
virtual std::vector< const GenParticle * > getGenConstituents() const
get all constituents
Definition: GenJet.cc:59
reco::PFJet::neutralMultiplicity
int neutralMultiplicity() const
neutralMultiplicity
Definition: PFJet.h:150
PFJetBenchmark::process
void process(const reco::PFJetCollection &, const reco::GenJetCollection &)
Definition: PFJetBenchmark.cc:228
deltaR
double deltaR(double eta1, double eta2, double phi1, double phi2)
Definition: TreeUtility.cc:17
plotAgainstReco
bool plotAgainstReco
Definition: PFJetBenchmarkAnalyzer.cc:72
PFJetBenchmark::resChargedHadEnergyMax_
double resChargedHadEnergyMax_
Definition: PFJetBenchmark.h:227
PFBenchmarkAlgo::matchByDeltaR
static const Collection::value_type * matchByDeltaR(const T *, const Collection *)
Definition: PFBenchmarkAlgo.h:200
reco::LeafCandidate::px
virtual double px() const
x coordinate of momentum vector
Definition: LeafCandidate.h:131
reco::LeafCandidate::pt
virtual double pt() const
transverse momentum
Definition: LeafCandidate.cc:127
reco::LeafCandidate::pz
virtual double pz() const
z coordinate of momentum vector
Definition: LeafCandidate.h:135
reco::PFJetCollection
std::vector< PFJet > PFJetCollection
collection of PFJet objects
Definition: PFJetCollection.h:15
PFJetBenchmark::resNeutralHadEnergyMax_
double resNeutralHadEnergyMax_
Definition: PFJetBenchmark.h:228
PFJetBenchmark::printPFJet
void printPFJet(const reco::PFJet *)
Definition: PFJetBenchmark.cc:695
reco::PFJet::getPFConstituents
virtual std::vector< reco::PFCandidatePtr > getPFConstituents() const
get all constituents
Definition: PFJet.cc:53
reco::PFJet::neutralHadronEnergy
float neutralHadronEnergy() const
neutralHadronEnergy
Definition: PFJet.h:95
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:41
reco::PFJet::chargedMuEnergy
float chargedMuEnergy() const
chargedMuEnergy
Definition: PFJet.h:139
recPt
double recPt
Definition: PFJetBenchmarkAnalyzer.cc:76
PFJetBenchmark::resNeutralEmEnergyMax_
double resNeutralEmEnergyMax_
Definition: PFJetBenchmark.h:229
debug
#define debug
Definition: MEtoEDMFormat.h:34
DSETAXES
#define DSETAXES(name, xtitle, ytitle)
Definition: PFJetBenchmark.cc:26
T
long double T
Definition: Basic3DVectorLD.h:57
reco::LeafCandidate::phi
virtual double phi() const
momentum azimuthal angle
Definition: LeafCandidate.h:139
PFJetBenchmark::printGenJet
void printGenJet(const reco::GenJet *)
Definition: PFJetBenchmark.cc:716
DBOOK1D
#define DBOOK1D(name, title, nbinsx, lowx, highx)
Definition: PFJetBenchmark.cc:15
reco::PFJet::chargedHadronEnergy
float chargedHadronEnergy() const
chargedHadronEnergy
Definition: PFJet.h:91
reco::LeafCandidate::py
virtual double py() const
y coordinate of momentum vector
Definition: LeafCandidate.h:133
DQMStore::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:232
phi
Definition: DDAxes.h:10
Generated for CMSSW Reference Manual by doxygen 1.8.5