CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
MTVHistoProducerAlgoForTracker.cc
Go to the documentation of this file.
1 #include "Validation/RecoTrack/interface/MTVHistoProducerAlgoForTracker.h"
2 #include "FWCore/MessageLogger/interface/MessageLogger.h"
3 
4 #include "DataFormats/TrackReco/interface/DeDxData.h"
5 #include "DataFormats/Common/interface/ValueMap.h"
6 #include "DataFormats/Common/interface/Ref.h"
7 #include <DataFormats/TrackReco/interface/TrackFwd.h>
8 
9 #include "DQMServices/ClientConfig/interface/FitSlicesYTool.h"
10 
11 #include "TMath.h"
12 #include <TF1.h>
13 
14 using namespace std;
15 
16 MTVHistoProducerAlgoForTracker::MTVHistoProducerAlgoForTracker(const edm::ParameterSet& pset, edm::ConsumesCollector & iC): MTVHistoProducerAlgo(pset, iC){
17  //parameters for _vs_eta plots
18  minEta = pset.getParameter<double>("minEta");
19  maxEta = pset.getParameter<double>("maxEta");
20  nintEta = pset.getParameter<int>("nintEta");
21  useFabsEta = pset.getParameter<bool>("useFabsEta");
22 
23  //parameters for _vs_pt plots
24  minPt = pset.getParameter<double>("minPt");
25  maxPt = pset.getParameter<double>("maxPt");
26  nintPt = pset.getParameter<int>("nintPt");
27  useInvPt = pset.getParameter<bool>("useInvPt");
28  useLogPt = pset.getUntrackedParameter<bool>("useLogPt",false);
29 
30  //parameters for _vs_Hit plots
31  minHit = pset.getParameter<double>("minHit");
32  maxHit = pset.getParameter<double>("maxHit");
33  nintHit = pset.getParameter<int>("nintHit");
34 
35  //parameters for _vs_Layer plots
36  minLayers = pset.getParameter<double>("minLayers");
37  maxLayers = pset.getParameter<double>("maxLayers");
38  nintLayers = pset.getParameter<int>("nintLayers");
39 
40  //parameters for _vs_phi plots
41  minPhi = pset.getParameter<double>("minPhi");
42  maxPhi = pset.getParameter<double>("maxPhi");
43  nintPhi = pset.getParameter<int>("nintPhi");
44 
45  //parameters for _vs_Dxy plots
46  minDxy = pset.getParameter<double>("minDxy");
47  maxDxy = pset.getParameter<double>("maxDxy");
48  nintDxy = pset.getParameter<int>("nintDxy");
49 
50  //parameters for _vs_Dz plots
51  minDz = pset.getParameter<double>("minDz");
52  maxDz = pset.getParameter<double>("maxDz");
53  nintDz = pset.getParameter<int>("nintDz");
54 
55  //parameters for _vs_ProductionVertexTransvPosition plots
56  minVertpos = pset.getParameter<double>("minVertpos");
57  maxVertpos = pset.getParameter<double>("maxVertpos");
58  nintVertpos = pset.getParameter<int>("nintVertpos");
59 
60  //parameters for _vs_ProductionVertexZPosition plots
61  minZpos = pset.getParameter<double>("minZpos");
62  maxZpos = pset.getParameter<double>("maxZpos");
63  nintZpos = pset.getParameter<int>("nintZpos");
64 
65  //parameters for dE/dx plots
66  minDeDx = pset.getParameter<double>("minDeDx");
67  maxDeDx = pset.getParameter<double>("maxDeDx");
68  nintDeDx = pset.getParameter<int>("nintDeDx");
69 
70  //parameters for Pileup plots
71  minVertcount = pset.getParameter<double>("minVertcount");
72  maxVertcount = pset.getParameter<double>("maxVertcount");
73  nintVertcount = pset.getParameter<int>("nintVertcount");
74 
75  //parameters for resolution plots
76  ptRes_rangeMin = pset.getParameter<double>("ptRes_rangeMin");
77  ptRes_rangeMax = pset.getParameter<double>("ptRes_rangeMax");
78  ptRes_nbin = pset.getParameter<int>("ptRes_nbin");
79 
80  phiRes_rangeMin = pset.getParameter<double>("phiRes_rangeMin");
81  phiRes_rangeMax = pset.getParameter<double>("phiRes_rangeMax");
82  phiRes_nbin = pset.getParameter<int>("phiRes_nbin");
83 
84  cotThetaRes_rangeMin = pset.getParameter<double>("cotThetaRes_rangeMin");
85  cotThetaRes_rangeMax = pset.getParameter<double>("cotThetaRes_rangeMax");
86  cotThetaRes_nbin = pset.getParameter<int>("cotThetaRes_nbin");
87 
88  dxyRes_rangeMin = pset.getParameter<double>("dxyRes_rangeMin");
89  dxyRes_rangeMax = pset.getParameter<double>("dxyRes_rangeMax");
90  dxyRes_nbin = pset.getParameter<int>("dxyRes_nbin");
91 
92  dzRes_rangeMin = pset.getParameter<double>("dzRes_rangeMin");
93  dzRes_rangeMax = pset.getParameter<double>("dzRes_rangeMax");
94  dzRes_nbin = pset.getParameter<int>("dzRes_nbin");
95 
96 
97  //--- tracking particle selectors for efficiency measurements
98  using namespace edm;
99 
100  ParameterSet generalTpSelectorPSet = pset.getParameter<ParameterSet>("generalTpSelector");
101  ParameterSet TpSelectorForEfficiencyVsEtaPSet = pset.getParameter<ParameterSet>("TpSelectorForEfficiencyVsEta");
102  ParameterSet TpSelectorForEfficiencyVsPhiPSet = pset.getParameter<ParameterSet>("TpSelectorForEfficiencyVsPhi");
103  ParameterSet TpSelectorForEfficiencyVsPtPSet = pset.getParameter<ParameterSet>("TpSelectorForEfficiencyVsPt");
104  ParameterSet TpSelectorForEfficiencyVsVTXRPSet = pset.getParameter<ParameterSet>("TpSelectorForEfficiencyVsVTXR");
105  ParameterSet TpSelectorForEfficiencyVsVTXZPSet = pset.getParameter<ParameterSet>("TpSelectorForEfficiencyVsVTXZ");
106 
107  ParameterSet generalGpSelectorPSet = pset.getParameter<ParameterSet>("generalGpSelector");
108  ParameterSet GpSelectorForEfficiencyVsEtaPSet = pset.getParameter<ParameterSet>("GpSelectorForEfficiencyVsEta");
109  ParameterSet GpSelectorForEfficiencyVsPhiPSet = pset.getParameter<ParameterSet>("GpSelectorForEfficiencyVsPhi");
110  ParameterSet GpSelectorForEfficiencyVsPtPSet = pset.getParameter<ParameterSet>("GpSelectorForEfficiencyVsPt");
111  ParameterSet GpSelectorForEfficiencyVsVTXRPSet = pset.getParameter<ParameterSet>("GpSelectorForEfficiencyVsVTXR");
112  ParameterSet GpSelectorForEfficiencyVsVTXZPSet = pset.getParameter<ParameterSet>("GpSelectorForEfficiencyVsVTXZ");
113 
114  ParameterSet TpSelectorForEfficiencyVsConPSet = TpSelectorForEfficiencyVsEtaPSet;
115  Entry name("signalOnly",false,true);
116  TpSelectorForEfficiencyVsConPSet.insert(true,"signalOnly",name);
117 
118  using namespace reco::modules;
119  generalTpSelector = new TrackingParticleSelector(ParameterAdapter<TrackingParticleSelector>::make(generalTpSelectorPSet, iC));
120  TpSelectorForEfficiencyVsEta = new TrackingParticleSelector(ParameterAdapter<TrackingParticleSelector>::make(TpSelectorForEfficiencyVsEtaPSet, iC));
121  TpSelectorForEfficiencyVsCon = new TrackingParticleSelector(ParameterAdapter<TrackingParticleSelector>::make(TpSelectorForEfficiencyVsConPSet, iC));
122  TpSelectorForEfficiencyVsPhi = new TrackingParticleSelector(ParameterAdapter<TrackingParticleSelector>::make(TpSelectorForEfficiencyVsPhiPSet, iC));
123  TpSelectorForEfficiencyVsPt = new TrackingParticleSelector(ParameterAdapter<TrackingParticleSelector>::make(TpSelectorForEfficiencyVsPtPSet, iC));
124  TpSelectorForEfficiencyVsVTXR = new TrackingParticleSelector(ParameterAdapter<TrackingParticleSelector>::make(TpSelectorForEfficiencyVsVTXRPSet, iC));
125  TpSelectorForEfficiencyVsVTXZ = new TrackingParticleSelector(ParameterAdapter<TrackingParticleSelector>::make(TpSelectorForEfficiencyVsVTXZPSet, iC));
126 
127  generalGpSelector = new GenParticleCustomSelector(ParameterAdapter<GenParticleCustomSelector>::make(generalGpSelectorPSet, iC));
128  GpSelectorForEfficiencyVsEta = new GenParticleCustomSelector(ParameterAdapter<GenParticleCustomSelector>::make(GpSelectorForEfficiencyVsEtaPSet, iC));
129  GpSelectorForEfficiencyVsCon = new GenParticleCustomSelector(ParameterAdapter<GenParticleCustomSelector>::make(GpSelectorForEfficiencyVsEtaPSet, iC));
130  GpSelectorForEfficiencyVsPhi = new GenParticleCustomSelector(ParameterAdapter<GenParticleCustomSelector>::make(GpSelectorForEfficiencyVsPhiPSet, iC));
131  GpSelectorForEfficiencyVsPt = new GenParticleCustomSelector(ParameterAdapter<GenParticleCustomSelector>::make(GpSelectorForEfficiencyVsPtPSet, iC));
132  GpSelectorForEfficiencyVsVTXR = new GenParticleCustomSelector(ParameterAdapter<GenParticleCustomSelector>::make(GpSelectorForEfficiencyVsVTXRPSet, iC));
133  GpSelectorForEfficiencyVsVTXZ = new GenParticleCustomSelector(ParameterAdapter<GenParticleCustomSelector>::make(GpSelectorForEfficiencyVsVTXZPSet, iC));
134 
135  // fix for the LogScale by Ryan
136  if(useLogPt){
137  maxPt=log10(maxPt);
138  if(minPt > 0){
139  minPt=log10(minPt);
140  }
141  else{
142  edm::LogWarning("MultiTrackValidator")
143  << "minPt = "
144  << minPt << " <= 0 out of range while requesting log scale. Using minPt = 0.1.";
145  minPt=log10(0.1);
146  }
147  }
148 
149 }
150 
151 MTVHistoProducerAlgoForTracker::~MTVHistoProducerAlgoForTracker(){
152  delete generalTpSelector;
153  delete TpSelectorForEfficiencyVsEta;
154  delete TpSelectorForEfficiencyVsCon;
155  delete TpSelectorForEfficiencyVsPhi;
156  delete TpSelectorForEfficiencyVsPt;
157  delete TpSelectorForEfficiencyVsVTXR;
158  delete TpSelectorForEfficiencyVsVTXZ;
159 
160  delete generalGpSelector;
161  delete GpSelectorForEfficiencyVsEta;
162  delete GpSelectorForEfficiencyVsCon;
163  delete GpSelectorForEfficiencyVsPhi;
164  delete GpSelectorForEfficiencyVsPt;
165  delete GpSelectorForEfficiencyVsVTXR;
166  delete GpSelectorForEfficiencyVsVTXZ;
167 }
168 
169 
170 void MTVHistoProducerAlgoForTracker::setUpVectors(){
171  std::vector<double> etaintervalsv;
172  std::vector<double> phiintervalsv;
173  std::vector<double> pTintervalsv;
174  std::vector<double> dxyintervalsv;
175  std::vector<double> dzintervalsv;
176  std::vector<double> vertposintervalsv;
177  std::vector<double> zposintervalsv;
178  std::vector<double> vertcountintervalsv;
179 
180  std::vector<int> totSIMveta,totASSveta,totASS2veta,totloopveta,totmisidveta,totASS2vetaSig,totRECveta;
181  std::vector<int> totSIMvpT,totASSvpT,totASS2vpT,totRECvpT,totloopvpT,totmisidvpT;
182  std::vector<int> totSIMv_hit,totASSv_hit,totASS2v_hit,totRECv_hit,totloopv_hit,totmisidv_hit;
183  std::vector<int> totSIMv_phi,totASSv_phi,totASS2v_phi,totRECv_phi,totloopv_phi,totmisidv_phi;
184  std::vector<int> totSIMv_dxy,totASSv_dxy,totASS2v_dxy,totRECv_dxy,totloopv_dxy,totmisidv_dxy;
185  std::vector<int> totSIMv_dz,totASSv_dz,totASS2v_dz,totRECv_dz,totloopv_dz,totmisidv_dz;
186 
187  std::vector<int> totSIMv_vertpos,totASSv_vertpos,totSIMv_zpos,totASSv_zpos;
188  std::vector<int> totSIMv_vertcount,totASSv_vertcount,totRECv_vertcount,totASS2v_vertcount;
189  std::vector<int> totRECv_algo;
190 
191  double step=(maxEta-minEta)/nintEta;
192  //std::ostringstream title,name; ///BM, what is this?
193  etaintervalsv.push_back(minEta);
194  for (int k=1;k<nintEta+1;k++) {
195  double d=minEta+k*step;
196  etaintervalsv.push_back(d);
197  totSIMveta.push_back(0);
198  totASSveta.push_back(0);
199  totASS2veta.push_back(0);
200  totloopveta.push_back(0);
201  totmisidveta.push_back(0);
202  totASS2vetaSig.push_back(0);
203  totRECveta.push_back(0);
204  }
205  etaintervals.push_back(etaintervalsv);
206  totSIMeta.push_back(totSIMveta);
207  totCONeta.push_back(totASSveta);
208  totASSeta.push_back(totASSveta);
209  totASS2eta.push_back(totASS2veta);
210  totloopeta.push_back(totloopveta);
211  totmisideta.push_back(totmisidveta);
212  totASS2etaSig.push_back(totASS2vetaSig);
213  totRECeta.push_back(totRECveta);
214  totFOMT_eta.push_back(totASSveta);
215 
216  totASS2_itpu_eta_entire.push_back(totASS2veta);
217  totASS2_itpu_eta_entire_signal.push_back(totASS2vetaSig);
218  totASS2_ootpu_eta_entire.push_back(totASS2veta);
219 
220  for (size_t i = 0; i < 15; i++) {
221  totRECv_algo.push_back(0);
222  }
223  totREC_algo.push_back(totRECv_algo);
224 
225  double stepPt = (maxPt-minPt)/nintPt;
226  pTintervalsv.push_back(minPt);
227  for (int k=1;k<nintPt+1;k++) {
228  double d=0;
229  if(useLogPt)d=pow(10,minPt+k*stepPt);
230  else d=minPt+k*stepPt;
231  pTintervalsv.push_back(d);
232  totSIMvpT.push_back(0);
233  totASSvpT.push_back(0);
234  totASS2vpT.push_back(0);
235  totRECvpT.push_back(0);
236  totloopvpT.push_back(0);
237  totmisidvpT.push_back(0);
238  }
239  pTintervals.push_back(pTintervalsv);
240  totSIMpT.push_back(totSIMvpT);
241  totASSpT.push_back(totASSvpT);
242  totASS2pT.push_back(totASS2vpT);
243  totRECpT.push_back(totRECvpT);
244  totlooppT.push_back(totloopvpT);
245  totmisidpT.push_back(totmisidvpT);
246 
247  for (int k=1;k<nintHit+1;k++) {
248  totSIMv_hit.push_back(0);
249  totASSv_hit.push_back(0);
250  totASS2v_hit.push_back(0);
251  totRECv_hit.push_back(0);
252  totloopv_hit.push_back(0);
253  totmisidv_hit.push_back(0);
254  }
255  totSIM_hit.push_back(totSIMv_hit);
256  totASS_hit.push_back(totASSv_hit);
257  totASS2_hit.push_back(totASS2v_hit);
258  totREC_hit.push_back(totRECv_hit);
259  totloop_hit.push_back(totloopv_hit);
260  totmisid_hit.push_back(totmisidv_hit);
261 
262  double stepPhi = (maxPhi-minPhi)/nintPhi;
263  phiintervalsv.push_back(minPhi);
264  for (int k=1;k<nintPhi+1;k++) {
265  double d=minPhi+k*stepPhi;
266  phiintervalsv.push_back(d);
267  totSIMv_phi.push_back(0);
268  totASSv_phi.push_back(0);
269  totASS2v_phi.push_back(0);
270  totRECv_phi.push_back(0);
271  totloopv_phi.push_back(0);
272  totmisidv_phi.push_back(0);
273  }
274  phiintervals.push_back(phiintervalsv);
275  totSIM_phi.push_back(totSIMv_phi);
276  totASS_phi.push_back(totASSv_phi);
277  totASS2_phi.push_back(totASS2v_phi);
278  totREC_phi.push_back(totRECv_phi);
279  totloop_phi.push_back(totloopv_phi);
280  totmisid_phi.push_back(totmisidv_phi);
281 
282  double stepDxy = (maxDxy-minDxy)/nintDxy;
283  dxyintervalsv.push_back(minDxy);
284  for (int k=1;k<nintDxy+1;k++) {
285  double d=minDxy+k*stepDxy;
286  dxyintervalsv.push_back(d);
287  totSIMv_dxy.push_back(0);
288  totASSv_dxy.push_back(0);
289  totASS2v_dxy.push_back(0);
290  totRECv_dxy.push_back(0);
291  totloopv_dxy.push_back(0);
292  totmisidv_dxy.push_back(0);
293  }
294  dxyintervals.push_back(dxyintervalsv);
295  totSIM_dxy.push_back(totSIMv_dxy);
296  totASS_dxy.push_back(totASSv_dxy);
297  totASS2_dxy.push_back(totASS2v_dxy);
298  totREC_dxy.push_back(totRECv_dxy);
299  totloop_dxy.push_back(totloopv_dxy);
300  totmisid_dxy.push_back(totmisidv_dxy);
301 
302 
303  double stepDz = (maxDz-minDz)/nintDz;
304  dzintervalsv.push_back(minDz);
305  for (int k=1;k<nintDz+1;k++) {
306  double d=minDz+k*stepDz;
307  dzintervalsv.push_back(d);
308  totSIMv_dz.push_back(0);
309  totASSv_dz.push_back(0);
310  totASS2v_dz.push_back(0);
311  totRECv_dz.push_back(0);
312  totloopv_dz.push_back(0);
313  totmisidv_dz.push_back(0);
314  }
315  dzintervals.push_back(dzintervalsv);
316  totSIM_dz.push_back(totSIMv_dz);
317  totASS_dz.push_back(totASSv_dz);
318  totASS2_dz.push_back(totASS2v_dz);
319  totREC_dz.push_back(totRECv_dz);
320  totloop_dz.push_back(totloopv_dz);
321  totmisid_dz.push_back(totmisidv_dz);
322 
323  double stepVertpos = (maxVertpos-minVertpos)/nintVertpos;
324  vertposintervalsv.push_back(minVertpos);
325  for (int k=1;k<nintVertpos+1;k++) {
326  double d=minVertpos+k*stepVertpos;
327  vertposintervalsv.push_back(d);
328  totSIMv_vertpos.push_back(0);
329  totASSv_vertpos.push_back(0);
330  }
331  vertposintervals.push_back(vertposintervalsv);
332  totSIM_vertpos.push_back(totSIMv_vertpos);
333  totASS_vertpos.push_back(totASSv_vertpos);
334 
335  double stepZpos = (maxZpos-minZpos)/nintZpos;
336  zposintervalsv.push_back(minZpos);
337  for (int k=1;k<nintZpos+1;k++) {
338  double d=minZpos+k*stepZpos;
339  zposintervalsv.push_back(d);
340  totSIMv_zpos.push_back(0);
341  totASSv_zpos.push_back(0);
342  }
343  zposintervals.push_back(zposintervalsv);
344  totSIM_zpos.push_back(totSIMv_zpos);
345  totCONzpos.push_back(totSIMv_zpos);
346  totASS_zpos.push_back(totASSv_zpos);
347  totSIM_vertz_entire.push_back(totSIMv_zpos);
348  totASS_vertz_entire.push_back(totASSv_zpos);
349  totSIM_vertz_barrel.push_back(totSIMv_zpos);
350  totASS_vertz_barrel.push_back(totASSv_zpos);
351  totSIM_vertz_fwdpos.push_back(totSIMv_zpos);
352  totASS_vertz_fwdpos.push_back(totASSv_zpos);
353  totSIM_vertz_fwdneg.push_back(totSIMv_zpos);
354  totASS_vertz_fwdneg.push_back(totASSv_zpos);
355 
356  double stepVertcount=(maxVertcount-minVertcount)/nintVertcount;
357  vertcountintervalsv.push_back(minVertcount);
358  for (int k=1;k<nintVertcount+1;k++) {
359  double d=minVertcount+k*stepVertcount;
360  vertcountintervalsv.push_back(d);
361  totSIMv_vertcount.push_back(0);
362  totASSv_vertcount.push_back(0);
363  totASS2v_vertcount.push_back(0);
364  totRECv_vertcount.push_back(0);
365  }
366  vertcountintervals.push_back(vertcountintervalsv);
367  totSIM_vertcount_entire.push_back(totSIMv_vertcount);
368  totCONvertcount.push_back(totSIMv_vertcount);
369  totASS_vertcount_entire.push_back(totASSv_vertcount);
370  totASS2_vertcount_entire.push_back(totASS2v_vertcount);
371  totASS2_vertcount_entire_signal.push_back(totASS2v_vertcount);
372  totREC_vertcount_entire.push_back(totRECv_vertcount);
373  totSIM_vertcount_barrel.push_back(totSIMv_vertcount);
374  totASS_vertcount_barrel.push_back(totASSv_vertcount);
375  totASS2_vertcount_barrel.push_back(totASS2v_vertcount);
376  totREC_vertcount_barrel.push_back(totRECv_vertcount);
377  totSIM_vertcount_fwdpos.push_back(totSIMv_vertcount);
378  totASS_vertcount_fwdpos.push_back(totASSv_vertcount);
379  totASS2_vertcount_fwdpos.push_back(totASS2v_vertcount);
380  totREC_vertcount_fwdpos.push_back(totRECv_vertcount);
381  totSIM_vertcount_fwdneg.push_back(totSIMv_vertcount);
382  totASS_vertcount_fwdneg.push_back(totASSv_vertcount);
383  totASS2_vertcount_fwdneg.push_back(totASS2v_vertcount);
384  totREC_vertcount_fwdneg.push_back(totRECv_vertcount);
385  totFOMT_vertcount.push_back(totASSv_vertcount);
386 
387  totASS2_itpu_vertcount_entire.push_back(totASS2v_vertcount);
388  totASS2_itpu_vertcount_entire_signal.push_back(totASS2v_vertcount);
389 
390  totASS2_ootpu_entire.push_back(totASS2v_vertcount);
391  totREC_ootpu_entire.push_back(totRECv_vertcount);
392  totASS2_ootpu_barrel.push_back(totASS2v_vertcount);
393  totREC_ootpu_barrel.push_back(totRECv_vertcount);
394  totASS2_ootpu_fwdpos.push_back(totASS2v_vertcount);
395  totREC_ootpu_fwdpos.push_back(totRECv_vertcount);
396  totASS2_ootpu_fwdneg.push_back(totASS2v_vertcount);
397  totREC_ootpu_fwdneg.push_back(totRECv_vertcount);
398 
399 }
400 
401 void MTVHistoProducerAlgoForTracker::bookSimHistos(){
402  h_ptSIM.push_back( dbe_->book1D("ptSIM", "generated p_{t}", 5500, 0, 110 ) );
403  h_etaSIM.push_back( dbe_->book1D("etaSIM", "generated pseudorapidity", 500, -2.5, 2.5 ) );
404  h_tracksSIM.push_back( dbe_->book1D("tracksSIM","number of simulated tracks",200,-0.5,99.5) );
405  h_vertposSIM.push_back( dbe_->book1D("vertposSIM","Transverse position of sim vertices",100,0.,120.) );
406  h_bunchxSIM.push_back( dbe_->book1D("bunchxSIM", "bunch crossing", 22, -5, 5 ) );
407 }
408 
409 
410 void MTVHistoProducerAlgoForTracker::bookRecoHistos(){
411  h_tracks.push_back( dbe_->book1D("tracks","number of reconstructed tracks",401,-0.5,400.5) );
412  h_fakes.push_back( dbe_->book1D("fakes","number of fake reco tracks",101,-0.5,100.5) );
413  h_charge.push_back( dbe_->book1D("charge","charge",3,-1.5,1.5) );
414 
415  h_hits.push_back( dbe_->book1D("hits", "number of hits per track", nintHit,minHit,maxHit ) );
416  h_losthits.push_back( dbe_->book1D("losthits", "number of lost hits per track", nintHit,minHit,maxHit) );
417  h_nchi2.push_back( dbe_->book1D("chi2", "normalized #chi^{2}", 200, 0, 20 ) );
418  h_nchi2_prob.push_back( dbe_->book1D("chi2_prob", "normalized #chi^{2} probability",100,0,1));
419 
420  h_nmisslayers_inner.push_back( dbe_->book1D("missing_inner_layers", "number of missing inner layers", nintLayers,minLayers,maxLayers ) );
421  h_nmisslayers_outer.push_back( dbe_->book1D("missing_outer_layers", "number of missing outer layers", nintLayers,minLayers,maxLayers ) );
422 
423  h_algo.push_back( dbe_->book1D("h_algo","Tracks by algo",15,0.0,15.0) );
424 
426  h_recoeta.push_back( dbe_->book1D("num_reco_eta","N of reco track vs eta",nintEta,minEta,maxEta) );
427  h_assoceta.push_back( dbe_->book1D("num_assoc(simToReco)_eta","N of associated tracks (simToReco) vs eta",nintEta,minEta,maxEta) );
428  h_assoc2eta.push_back( dbe_->book1D("num_assoc(recoToSim)_eta","N of associated (recoToSim) tracks vs eta",nintEta,minEta,maxEta) );
429  h_simuleta.push_back( dbe_->book1D("num_simul_eta","N of simulated tracks vs eta",nintEta,minEta,maxEta) );
430  h_loopereta.push_back( dbe_->book1D("num_duplicate_eta","N of associated (recoToSim) duplicate tracks vs eta",nintEta,minEta,maxEta) );
431  h_misideta.push_back( dbe_->book1D("num_chargemisid_eta","N of associated (recoToSim) charge misIDed tracks vs eta",nintEta,minEta,maxEta) );
432  h_recopT.push_back( dbe_->book1D("num_reco_pT","N of reco track vs pT",nintPt,minPt,maxPt) );
433  h_assocpT.push_back( dbe_->book1D("num_assoc(simToReco)_pT","N of associated tracks (simToReco) vs pT",nintPt,minPt,maxPt) );
434  h_assoc2pT.push_back( dbe_->book1D("num_assoc(recoToSim)_pT","N of associated (recoToSim) tracks vs pT",nintPt,minPt,maxPt) );
435  h_simulpT.push_back( dbe_->book1D("num_simul_pT","N of simulated tracks vs pT",nintPt,minPt,maxPt) );
436  h_looperpT.push_back( dbe_->book1D("num_duplicate_pT","N of associated (recoToSim) duplicate tracks vs pT",nintPt,minPt,maxPt) );
437  h_misidpT.push_back( dbe_->book1D("num_chargemisid_pT","N of associated (recoToSim) charge misIDed tracks vs pT",nintPt,minPt,maxPt) );
438  //
439  h_recohit.push_back( dbe_->book1D("num_reco_hit","N of reco track vs hit",nintHit,minHit,maxHit) );
440  h_assochit.push_back( dbe_->book1D("num_assoc(simToReco)_hit","N of associated tracks (simToReco) vs hit",nintHit,minHit,maxHit) );
441  h_assoc2hit.push_back( dbe_->book1D("num_assoc(recoToSim)_hit","N of associated (recoToSim) tracks vs hit",nintHit,minHit,maxHit) );
442  h_simulhit.push_back( dbe_->book1D("num_simul_hit","N of simulated tracks vs hit",nintHit,minHit,maxHit) );
443  h_looperhit.push_back( dbe_->book1D("num_duplicate_hit","N of associated (recoToSim) duplicate tracks vs hit",nintHit,minHit,maxHit) );
444  h_misidhit.push_back( dbe_->book1D("num_chargemisid_hit","N of associated (recoToSim) charge misIDed tracks vs hit",nintHit,minHit,maxHit) );
445  //
446  h_recophi.push_back( dbe_->book1D("num_reco_phi","N of reco track vs phi",nintPhi,minPhi,maxPhi) );
447  h_assocphi.push_back( dbe_->book1D("num_assoc(simToReco)_phi","N of associated tracks (simToReco) vs phi",nintPhi,minPhi,maxPhi) );
448  h_assoc2phi.push_back( dbe_->book1D("num_assoc(recoToSim)_phi","N of associated (recoToSim) tracks vs phi",nintPhi,minPhi,maxPhi) );
449  h_simulphi.push_back( dbe_->book1D("num_simul_phi","N of simulated tracks vs phi",nintPhi,minPhi,maxPhi) );
450  h_looperphi.push_back( dbe_->book1D("num_duplicate_phi","N of associated (recoToSim) duplicate tracks vs phi",nintPhi,minPhi,maxPhi) );
451  h_misidphi.push_back( dbe_->book1D("num_chargemisid_phi","N of associated (recoToSim) charge misIDed tracks vs phi",nintPhi,minPhi,maxPhi) );
452 
453  h_recodxy.push_back( dbe_->book1D("num_reco_dxy","N of reco track vs dxy",nintDxy,minDxy,maxDxy) );
454  h_assocdxy.push_back( dbe_->book1D("num_assoc(simToReco)_dxy","N of associated tracks (simToReco) vs dxy",nintDxy,minDxy,maxDxy) );
455  h_assoc2dxy.push_back( dbe_->book1D("num_assoc(recoToSim)_dxy","N of associated (recoToSim) tracks vs dxy",nintDxy,minDxy,maxDxy) );
456  h_simuldxy.push_back( dbe_->book1D("num_simul_dxy","N of simulated tracks vs dxy",nintDxy,minDxy,maxDxy) );
457  h_looperdxy.push_back( dbe_->book1D("num_duplicate_dxy","N of associated (recoToSim) looper tracks vs dxy",nintDxy,minDxy,maxDxy) );
458  h_misiddxy.push_back( dbe_->book1D("num_chargemisid_dxy","N of associated (recoToSim) charge misIDed tracks vs dxy",nintDxy,minDxy,maxDxy) );
459 
460  h_recodz.push_back( dbe_->book1D("num_reco_dz","N of reco track vs dz",nintDz,minDz,maxDz) );
461  h_assocdz.push_back( dbe_->book1D("num_assoc(simToReco)_dz","N of associated tracks (simToReco) vs dz",nintDz,minDz,maxDz) );
462  h_assoc2dz.push_back( dbe_->book1D("num_assoc(recoToSim)_dz","N of associated (recoToSim) tracks vs dz",nintDz,minDz,maxDz) );
463  h_simuldz.push_back( dbe_->book1D("num_simul_dz","N of simulated tracks vs dz",nintDz,minDz,maxDz) );
464  h_looperdz.push_back( dbe_->book1D("num_duplicate_dz","N of associated (recoToSim) looper tracks vs dz",nintDz,minDz,maxDz) );
465  h_misiddz.push_back( dbe_->book1D("num_chargemisid_versus_dz","N of associated (recoToSim) charge misIDed tracks vs dz",nintDz,minDz,maxDz) );
466 
467  h_assocvertpos.push_back( dbe_->book1D("num_assoc(simToReco)_vertpos",
468  "N of associated tracks (simToReco) vs transverse vert position",
469  nintVertpos,minVertpos,maxVertpos) );
470  h_simulvertpos.push_back( dbe_->book1D("num_simul_vertpos","N of simulated tracks vs transverse vert position",
471  nintVertpos,minVertpos,maxVertpos) );
472 
473  h_assoczpos.push_back( dbe_->book1D("num_assoc(simToReco)_zpos","N of associated tracks (simToReco) vs z vert position",
474  nintZpos,minZpos,maxZpos) );
475  h_simulzpos.push_back( dbe_->book1D("num_simul_zpos","N of simulated tracks vs z vert position",nintZpos,minZpos,maxZpos) );
476 
477 
478  h_reco_vertcount_entire.push_back( dbe_->book1D("num_reco_vertcount_entire","N of reco tracks vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
479  h_assoc_vertcount_entire.push_back( dbe_->book1D("num_assoc(simToReco)_vertcount_entire","N of associated tracks (simToReco) vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
480  h_assoc2_vertcount_entire.push_back( dbe_->book1D("num_assoc(recoToSim)_vertcount_entire","N of associated (recoToSim) tracks vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
481  h_simul_vertcount_entire.push_back( dbe_->book1D("num_simul_vertcount_entire","N of simulated tracks vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
482 
483  h_reco_vertcount_barrel.push_back( dbe_->book1D("num_reco_vertcount_barrel","N of reco tracks in barrel vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
484  h_assoc_vertcount_barrel.push_back( dbe_->book1D("num_assoc(simToReco)_vertcount_barrel","N of associated tracks (simToReco) in barrel vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
485  h_assoc2_vertcount_barrel.push_back( dbe_->book1D("num_assoc(recoToSim)_vertcount_barrel","N of associated (recoToSim) tracks in barrel vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
486  h_simul_vertcount_barrel.push_back( dbe_->book1D("num_simul_vertcount_barrel","N of simulated tracks in barrel vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
487 
488  h_reco_vertcount_fwdpos.push_back( dbe_->book1D("num_reco_vertcount_fwdpos","N of reco tracks in endcap(+) vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
489  h_assoc_vertcount_fwdpos.push_back( dbe_->book1D("num_assoc(simToReco)_vertcount_fwdpos","N of associated tracks (simToReco) in endcap(+) vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
490  h_assoc2_vertcount_fwdpos.push_back( dbe_->book1D("num_assoc(recoToSim)_vertcount_fwdpos","N of associated (recoToSim) tracks in endcap(+) vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
491  h_simul_vertcount_fwdpos.push_back( dbe_->book1D("num_simul_vertcount_fwdpos","N of simulated tracks in endcap(+) vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
492 
493  h_reco_vertcount_fwdneg.push_back( dbe_->book1D("num_reco_vertcount_fwdneg","N of reco tracks in endcap(-) vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
494  h_assoc_vertcount_fwdneg.push_back( dbe_->book1D("num_assoc(simToReco)_vertcount_fwdneg","N of associated tracks (simToReco) in endcap(-) vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
495  h_assoc2_vertcount_fwdneg.push_back( dbe_->book1D("num_assoc(recoToSim)_vertcount_fwdneg","N of associated (recoToSim) tracks in endcap(-) vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
496  h_simul_vertcount_fwdneg.push_back( dbe_->book1D("num_simul_vertcount_fwdneg","N of simulated tracks in endcap(-) vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
497 
498  h_assoc_vertz_entire.push_back( dbe_->book1D("num_assoc(simToReco)_vertz_entire","N of associated tracks (simToReco) in entire vs z of primary intercation vertex",nintZpos,minZpos,maxZpos) );
499  h_simul_vertz_entire.push_back( dbe_->book1D("num_simul_vertz_entire","N of simulated tracks in entire vs N of pileup vertices",nintZpos,minZpos,maxZpos) );
500 
501  h_assoc_vertz_barrel.push_back( dbe_->book1D("num_assoc(simToReco)_vertz_barrel","N of associated tracks (simToReco) in barrel vs z of primary intercation vertex",nintZpos,minZpos,maxZpos) );
502  h_simul_vertz_barrel.push_back( dbe_->book1D("num_simul_vertz_barrel","N of simulated tracks in barrel vs N of pileup vertices",nintZpos,minZpos,maxZpos) );
503 
504  h_assoc_vertz_fwdpos.push_back( dbe_->book1D("num_assoc(simToReco)_vertz_fwdpos","N of associated tracks (simToReco) in endcap(+) vs z of primary interaction vertex",nintZpos,minZpos,maxZpos) );
505  h_simul_vertz_fwdpos.push_back( dbe_->book1D("num_simul_vertz_fwdpos","N of simulated tracks in endcap(+) vs z of primary interaction vertex",nintZpos,minZpos,maxZpos) );
506 
507  h_assoc_vertz_fwdneg.push_back( dbe_->book1D("num_assoc(simToReco)_vertz_fwdneg","N of associated tracks (simToReco) in endcap(-) vs N of pileup vertices",nintZpos,minZpos,maxZpos) );
508  h_simul_vertz_fwdneg.push_back( dbe_->book1D("num_simul_vertz_fwdneg","N of simulated tracks in endcap(-) vs z of primary interaction vertex",nintZpos,minZpos,maxZpos) );
509 /*
510  h_assoc2_itpu_eta.push_back( dbe_->book1D("num_assoc(recoToSim)_itpu_eta_entire","N of associated tracks (simToReco) from in time pileup vs eta",nintEta,minEta,maxEta) );
511  h_assoc2_itpu_sig_eta.push_back( dbe_->book1D("num_assoc(recoToSim)_itpu_eta_entire_signal","N of associated tracks (simToReco) from in time pileup vs eta",nintEta,minEta,maxEta) );
512  h_assoc2_itpu_vertcount.push_back( dbe_->book1D("num_assoc(recoToSim)_itpu_vertcount_entire","N of associated tracks (simToReco) from in time pileup vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
513  h_assoc2_itpu_sig_vertcount.push_back( dbe_->book1D("num_assoc(recoToSim)_itpu_vertcount_entire_signal","N of associated tracks (simToReco) from in time pileup vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );*/
514 
515  h_reco_ootpu_eta.push_back( dbe_->book1D("num_reco_ootpu_eta_entire","N of reco tracks vs eta",nintEta,minEta,maxEta) );
516  h_reco_ootpu_vertcount.push_back( dbe_->book1D("num_reco_ootpu_vertcount_entire","N of reco tracks vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
517 
518  h_assoc2_ootpu_entire.push_back( dbe_->book1D("num_assoc(recoToSim)_ootpu_eta_entire","N of associated tracks (simToReco) from out of time pileup vs eta",nintEta,minEta,maxEta) );
519  h_assoc2_ootpu_vertcount.push_back( dbe_->book1D("num_assoc(recoToSim)_ootpu_vertcount_entire","N of associated tracks (simToReco) from out of time pileup vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
520 
521  h_reco_ootpu_entire.push_back( dbe_->book1D("num_reco_ootpu_entire","N of reco tracks vs z of primary interaction vertex",nintVertcount,minVertcount,maxVertcount) );
522  h_assoc2_ootpu_barrel.push_back( dbe_->book1D("num_assoc(recoToSim)_ootpu_barrel","N of associated tracks (simToReco) from out of time pileup in barrel vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
523  h_reco_ootpu_barrel.push_back( dbe_->book1D("num_reco_ootpu_barrel","N of reco tracks in barrel vs z of primary interaction vertex",nintVertcount,minVertcount,maxVertcount) );
524  h_assoc2_ootpu_fwdpos.push_back( dbe_->book1D("num_assoc(recoToSim)_ootpu_fwdpos","N of associated tracks (simToReco) from out of time pileup in endcap(+) vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
525  h_reco_ootpu_fwdpos.push_back( dbe_->book1D("num_reco_ootpu_fwdpos","N of reco tracks in endcap(+) vs z of primary interaction vertex",nintVertcount,minVertcount,maxVertcount) );
526  h_assoc2_ootpu_fwdneg.push_back( dbe_->book1D("num_assoc(recoToSim)_ootpu_fwdneg","N of associated tracks (simToReco) from out of time pileup in endcap(-) vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
527  h_reco_ootpu_fwdneg.push_back( dbe_->book1D("num_reco_ootpu_fwdneg","N of reco tracks in endcap(-) vs z of primary interaction vertex",nintVertcount,minVertcount,maxVertcount) );
528 
529 
531 
532  h_eta.push_back( dbe_->book1D("eta", "pseudorapidity residue", 1000, -0.1, 0.1 ) );
533  h_pt.push_back( dbe_->book1D("pullPt", "pull of p_{t}", 100, -10, 10 ) );
534  h_pullTheta.push_back( dbe_->book1D("pullTheta","pull of #theta parameter",250,-25,25) );
535  h_pullPhi.push_back( dbe_->book1D("pullPhi","pull of #phi parameter",250,-25,25) );
536  h_pullDxy.push_back( dbe_->book1D("pullDxy","pull of dxy parameter",250,-25,25) );
537  h_pullDz.push_back( dbe_->book1D("pullDz","pull of dz parameter",250,-25,25) );
538  h_pullQoverp.push_back( dbe_->book1D("pullQoverp","pull of qoverp parameter",250,-25,25) );
539 
540  /* TO BE FIXED -----------
541  if (associators[ww]=="TrackAssociatorByChi2"){
542  h_assochi2.push_back( dbe_->book1D("assocChi2","track association #chi^{2}",1000000,0,100000) );
543  h_assochi2_prob.push_back(dbe_->book1D("assocChi2_prob","probability of association #chi^{2}",100,0,1));
544  } else if (associators[ww]=="quickTrackAssociatorByHits"){
545  h_assocFraction.push_back( dbe_->book1D("assocFraction","fraction of shared hits",200,0,2) );
546  h_assocSharedHit.push_back(dbe_->book1D("assocSharedHit","number of shared hits",20,0,20));
547  }
548  */
549  h_assocFraction.push_back( dbe_->book1D("assocFraction","fraction of shared hits",200,0,2) );
550  h_assocSharedHit.push_back(dbe_->book1D("assocSharedHit","number of shared hits",41,-0.5,40.5));
551  // ----------------------
552 
553  chi2_vs_nhits.push_back( dbe_->book2D("chi2_vs_nhits","#chi^{2} vs nhits",25,0,25,100,0,10) );
554 
555  etares_vs_eta.push_back( dbe_->book2D("etares_vs_eta","etaresidue vs eta",nintEta,minEta,maxEta,200,-0.1,0.1) );
556  nrec_vs_nsim.push_back( dbe_->book2D("nrec_vs_nsim","nrec vs nsim",401,-0.5,400.5,401,-0.5,400.5) );
557 
558  chi2_vs_eta.push_back( dbe_->book2D("chi2_vs_eta","chi2_vs_eta",nintEta,minEta,maxEta, 200, 0, 20 ));
559  chi2_vs_phi.push_back( dbe_->book2D("chi2_vs_phi","#chi^{2} vs #phi",nintPhi,minPhi,maxPhi, 200, 0, 20 ) );
560 
561  nhits_vs_eta.push_back( dbe_->book2D("nhits_vs_eta","nhits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
562  nPXBhits_vs_eta.push_back( dbe_->book2D("nPXBhits_vs_eta","# PXB its vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
563  nPXFhits_vs_eta.push_back( dbe_->book2D("nPXFhits_vs_eta","# PXF hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
564  nTIBhits_vs_eta.push_back( dbe_->book2D("nTIBhits_vs_eta","# TIB hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
565  nTIDhits_vs_eta.push_back( dbe_->book2D("nTIDhits_vs_eta","# TID hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
566  nTOBhits_vs_eta.push_back( dbe_->book2D("nTOBhits_vs_eta","# TOB hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
567  nTEChits_vs_eta.push_back( dbe_->book2D("nTEChits_vs_eta","# TEC hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
568 
569  nLayersWithMeas_vs_eta.push_back( dbe_->book2D("nLayersWithMeas_vs_eta","# Layers with measurement vs eta",
570  nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
571  nPXLlayersWithMeas_vs_eta.push_back( dbe_->book2D("nPXLlayersWithMeas_vs_eta","# PXL Layers with measurement vs eta",
572  nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
573  nSTRIPlayersWithMeas_vs_eta.push_back( dbe_->book2D("nSTRIPlayersWithMeas_vs_eta","# STRIP Layers with measurement vs eta",
574  nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
575  nSTRIPlayersWith1dMeas_vs_eta.push_back( dbe_->book2D("nSTRIPlayersWith1dMeas_vs_eta","# STRIP Layers with 1D measurement vs eta",
576  nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
577  nSTRIPlayersWith2dMeas_vs_eta.push_back( dbe_->book2D("nSTRIPlayersWith2dMeas_vs_eta","# STRIP Layers with 2D measurement vs eta",
578  nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
579 
580  nhits_vs_phi.push_back( dbe_->book2D("nhits_vs_phi","#hits vs #phi",nintPhi,minPhi,maxPhi,nintHit,minHit,maxHit) );
581 
582  nlosthits_vs_eta.push_back( dbe_->book2D("nlosthits_vs_eta","nlosthits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
583 
584  //resolution of track parameters
585  // dPt/Pt cotTheta Phi TIP LIP
586  // log10(pt)<0.5 100,0.1 240,0.08 100,0.015 100,0.1000 150,0.3000
587  // 0.5<log10(pt)<1.5 100,0.1 120,0.01 100,0.003 100,0.0100 150,0.0500
588  // >1.5 100,0.3 100,0.005 100,0.0008 100,0.0060 120,0.0300
589 
590  ptres_vs_eta.push_back(dbe_->book2D("ptres_vs_eta","ptres_vs_eta",
591  nintEta,minEta,maxEta, ptRes_nbin, ptRes_rangeMin, ptRes_rangeMax));
592 
593  ptres_vs_phi.push_back( dbe_->book2D("ptres_vs_phi","p_{t} res vs #phi",
594  nintPhi,minPhi,maxPhi, ptRes_nbin, ptRes_rangeMin, ptRes_rangeMax));
595 
596  ptres_vs_pt.push_back(dbe_->book2D("ptres_vs_pt","ptres_vs_pt",nintPt,minPt,maxPt, ptRes_nbin, ptRes_rangeMin, ptRes_rangeMax));
597 
598  cotThetares_vs_eta.push_back(dbe_->book2D("cotThetares_vs_eta","cotThetares_vs_eta",
599  nintEta,minEta,maxEta,cotThetaRes_nbin, cotThetaRes_rangeMin, cotThetaRes_rangeMax));
600 
601 
602  cotThetares_vs_pt.push_back(dbe_->book2D("cotThetares_vs_pt","cotThetares_vs_pt",
603  nintPt,minPt,maxPt, cotThetaRes_nbin, cotThetaRes_rangeMin, cotThetaRes_rangeMax));
604 
605 
606  phires_vs_eta.push_back(dbe_->book2D("phires_vs_eta","phires_vs_eta",
607  nintEta,minEta,maxEta, phiRes_nbin, phiRes_rangeMin, phiRes_rangeMax));
608 
609  phires_vs_pt.push_back(dbe_->book2D("phires_vs_pt","phires_vs_pt",
610  nintPt,minPt,maxPt, phiRes_nbin, phiRes_rangeMin, phiRes_rangeMax));
611 
612  phires_vs_phi.push_back(dbe_->book2D("phires_vs_phi","#phi res vs #phi",
613  nintPhi,minPhi,maxPhi,phiRes_nbin, phiRes_rangeMin, phiRes_rangeMax));
614 
615  dxyres_vs_eta.push_back(dbe_->book2D("dxyres_vs_eta","dxyres_vs_eta",
616  nintEta,minEta,maxEta,dxyRes_nbin, dxyRes_rangeMin, dxyRes_rangeMax));
617 
618  dxyres_vs_pt.push_back( dbe_->book2D("dxyres_vs_pt","dxyres_vs_pt",
619  nintPt,minPt,maxPt,dxyRes_nbin, dxyRes_rangeMin, dxyRes_rangeMax));
620 
621  dzres_vs_eta.push_back(dbe_->book2D("dzres_vs_eta","dzres_vs_eta",
622  nintEta,minEta,maxEta,dzRes_nbin, dzRes_rangeMin, dzRes_rangeMax));
623 
624  dzres_vs_pt.push_back(dbe_->book2D("dzres_vs_pt","dzres_vs_pt",nintPt,minPt,maxPt,dzRes_nbin, dzRes_rangeMin, dzRes_rangeMax));
625 
626  ptmean_vs_eta_phi.push_back(dbe_->bookProfile2D("ptmean_vs_eta_phi","mean p_{t} vs #eta and #phi",
627  nintPhi,minPhi,maxPhi,nintEta,minEta,maxEta,1000,0,1000));
628  phimean_vs_eta_phi.push_back(dbe_->bookProfile2D("phimean_vs_eta_phi","mean #phi vs #eta and #phi",
629  nintPhi,minPhi,maxPhi,nintEta,minEta,maxEta,nintPhi,minPhi,maxPhi));
630 
631  //pulls of track params vs eta: to be used with fitslicesytool
632  dxypull_vs_eta.push_back(dbe_->book2D("dxypull_vs_eta","dxypull_vs_eta",nintEta,minEta,maxEta,100,-10,10));
633  ptpull_vs_eta.push_back(dbe_->book2D("ptpull_vs_eta","ptpull_vs_eta",nintEta,minEta,maxEta,100,-10,10));
634  dzpull_vs_eta.push_back(dbe_->book2D("dzpull_vs_eta","dzpull_vs_eta",nintEta,minEta,maxEta,100,-10,10));
635  phipull_vs_eta.push_back(dbe_->book2D("phipull_vs_eta","phipull_vs_eta",nintEta,minEta,maxEta,100,-10,10));
636  thetapull_vs_eta.push_back(dbe_->book2D("thetapull_vs_eta","thetapull_vs_eta",nintEta,minEta,maxEta,100,-10,10));
637 
638  // h_ptshiftetamean.push_back( dbe_->book1D("h_ptshifteta_Mean","<#deltapT/pT>[%] vs #eta",nintEta,minEta,maxEta) );
639 
640 
641  //pulls of track params vs phi
642  ptpull_vs_phi.push_back(dbe_->book2D("ptpull_vs_phi","p_{t} pull vs #phi",nintPhi,minPhi,maxPhi,100,-10,10));
643  phipull_vs_phi.push_back(dbe_->book2D("phipull_vs_phi","#phi pull vs #phi",nintPhi,minPhi,maxPhi,100,-10,10));
644  thetapull_vs_phi.push_back(dbe_->book2D("thetapull_vs_phi","#theta pull vs #phi",nintPhi,minPhi,maxPhi,100,-10,10));
645 
646 
647  nrecHit_vs_nsimHit_sim2rec.push_back( dbe_->book2D("nrecHit_vs_nsimHit_sim2rec","nrecHit vs nsimHit (Sim2RecAssoc)",
648  nintHit,minHit,maxHit, nintHit,minHit,maxHit ));
649  nrecHit_vs_nsimHit_rec2sim.push_back( dbe_->book2D("nrecHit_vs_nsimHit_rec2sim","nrecHit vs nsimHit (Rec2simAssoc)",
650  nintHit,minHit,maxHit, nintHit,minHit,maxHit ));
651 
652  // dE/dx stuff
653  // FIXME: it would be nice to have an array
654  h_dedx_estim1.push_back( dbe_->book1D("h_dedx_estim1","dE/dx estimator 1",nintDeDx,minDeDx,maxDeDx) );
655  h_dedx_estim2.push_back( dbe_->book1D("h_dedx_estim2","dE/dx estimator 2",nintDeDx,minDeDx,maxDeDx) );
656  h_dedx_nom1.push_back( dbe_->book1D("h_dedx_nom1","dE/dx number of measurements",nintHit,minHit,maxHit) );
657  h_dedx_nom2.push_back( dbe_->book1D("h_dedx_nom2","dE/dx number of measurements",nintHit,minHit,maxHit) );
658  h_dedx_sat1.push_back( dbe_->book1D("h_dedx_sat1","dE/dx number of measurements with saturation",nintHit,minHit,maxHit) );
659  h_dedx_sat2.push_back( dbe_->book1D("h_dedx_sat2","dE/dx number of measurements with saturation",nintHit,minHit,maxHit) );
660 
661  // PU special stuff
662  h_con_eta.push_back( dbe_->book1D("num_con_eta","N of PU tracks vs eta",nintEta,minEta,maxEta) );
663  h_con_vertcount.push_back( dbe_->book1D("num_con_vertcount","N of PU tracks vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
664  h_con_zpos.push_back( dbe_->book1D("num_con_zpos","N of PU tracks vs z of primary interaction vertex",nintZpos,minZpos,maxZpos) );
665 
666 
667  if(useLogPt){
668  BinLogX(dzres_vs_pt.back()->getTH2F());
669  BinLogX(dxyres_vs_pt.back()->getTH2F());
670  BinLogX(phires_vs_pt.back()->getTH2F());
671  BinLogX(cotThetares_vs_pt.back()->getTH2F());
672  BinLogX(ptres_vs_pt.back()->getTH2F());
673  BinLogX(h_looperpT.back()->getTH1F());
674  BinLogX(h_misidpT.back()->getTH1F());
675  BinLogX(h_recopT.back()->getTH1F());
676  BinLogX(h_assocpT.back()->getTH1F());
677  BinLogX(h_assoc2pT.back()->getTH1F());
678  BinLogX(h_simulpT.back()->getTH1F());
679  }
680 }
681 
682 void MTVHistoProducerAlgoForTracker::bookRecoHistosForStandaloneRunning(){
683  h_effic.push_back( dbe_->book1D("effic","efficiency vs #eta",nintEta,minEta,maxEta) );
684  h_efficPt.push_back( dbe_->book1D("efficPt","efficiency vs pT",nintPt,minPt,maxPt) );
685  h_effic_vs_hit.push_back( dbe_->book1D("effic_vs_hit","effic vs hit",nintHit,minHit,maxHit) );
686  h_effic_vs_phi.push_back( dbe_->book1D("effic_vs_phi","effic vs phi",nintPhi,minPhi,maxPhi) );
687  h_effic_vs_dxy.push_back( dbe_->book1D("effic_vs_dxy","effic vs dxy",nintDxy,minDxy,maxDxy) );
688  h_effic_vs_dz.push_back( dbe_->book1D("effic_vs_dz","effic vs dz",nintDz,minDz,maxDz) );
689  h_effic_vs_vertpos.push_back( dbe_->book1D("effic_vs_vertpos","effic vs vertpos",nintVertpos,minVertpos,maxVertpos) );
690  h_effic_vs_zpos.push_back( dbe_->book1D("effic_vs_zpos","effic vs zpos",nintZpos,minZpos,maxZpos) );
691  h_effic_vertcount_entire.push_back( dbe_->book1D("effic_vertcount_entire","efficiency vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
692  h_effic_vertcount_barrel.push_back( dbe_->book1D("effic_vertcount_barrel","efficiency in barrel vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
693  h_effic_vertcount_fwdpos.push_back( dbe_->book1D("effic_vertcount_fwdpos","efficiency in endcap(+) vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
694  h_effic_vertcount_fwdneg.push_back( dbe_->book1D("effic_vertcount_fwdneg","efficiency in endcap(-) vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
695  h_effic_vertz_entire.push_back( dbe_->book1D("effic_vertz_entire","efficiency vs z of primary interaction vertex",nintZpos,minZpos,maxZpos) );
696  h_effic_vertz_barrel.push_back( dbe_->book1D("effic_vertz_barrel","efficiency in barrel vs z of primary interaction vertex",nintZpos,minZpos,maxZpos) );
697  h_effic_vertz_fwdpos.push_back( dbe_->book1D("effic_vertz_fwdpos","efficiency in endcap(+) vs z of primary interaction vertex",nintZpos,minZpos,maxZpos) );
698  h_effic_vertz_fwdneg.push_back( dbe_->book1D("effic_vertz_fwdneg","efficiency in endcap(-) vs z of primary interaction vertex",nintZpos,minZpos,maxZpos) );
699 
700  h_looprate.push_back( dbe_->book1D("duplicatesRate","loop rate vs #eta",nintEta,minEta,maxEta) );
701  h_misidrate.push_back( dbe_->book1D("chargeMisIdRate","misid rate vs #eta",nintEta,minEta,maxEta) );
702  h_fakerate.push_back( dbe_->book1D("fakerate","fake rate vs #eta",nintEta,minEta,maxEta) );
703  h_loopratepT.push_back( dbe_->book1D("duplicatesRate_Pt","loop rate vs pT",nintPt,minPt,maxPt) );
704  h_misidratepT.push_back( dbe_->book1D("chargeMisIdRate_Pt","misid rate vs pT",nintPt,minPt,maxPt) );
705  h_fakeratePt.push_back( dbe_->book1D("fakeratePt","fake rate vs pT",nintPt,minPt,maxPt) );
706  h_loopratehit.push_back( dbe_->book1D("duplicatesRate_hit","loop rate vs hit",nintHit,minHit,maxHit) );
707  h_misidratehit.push_back( dbe_->book1D("chargeMisIdRate_hit","misid rate vs hit",nintHit,minHit,maxHit) );
708  h_fake_vs_hit.push_back( dbe_->book1D("fakerate_vs_hit","fake rate vs hit",nintHit,minHit,maxHit) );
709  h_loopratephi.push_back( dbe_->book1D("duplicatesRate_phi","loop rate vs #phi",nintPhi,minPhi,maxPhi) );
710  h_misidratephi.push_back( dbe_->book1D("chargeMisIdRate_phi","misid rate vs #phi",nintPhi,minPhi,maxPhi) );
711  h_fake_vs_phi.push_back( dbe_->book1D("fakerate_vs_phi","fake vs #phi",nintPhi,minPhi,maxPhi) );
712  h_loopratedxy.push_back( dbe_->book1D("duplicatesRate_dxy","loop rate vs dxy",nintDxy,minDxy,maxDxy) );
713  h_misidratedxy.push_back( dbe_->book1D("chargeMisIdRate_dxy","misid rate vs dxy",nintDxy,minDxy,maxDxy) );
714  h_fake_vs_dxy.push_back( dbe_->book1D("fakerate_vs_dxy","fake rate vs dxy",nintDxy,minDxy,maxDxy) );
715  h_loopratedz.push_back( dbe_->book1D("duplicatesRate_dz","loop rate vs dz",nintDz,minDz,maxDz) );
716  h_misidratedz.push_back( dbe_->book1D("chargeMisIdRate_dz","misid rate vs dz",nintDz,minDz,maxDz) );
717  h_fake_vs_dz.push_back( dbe_->book1D("fakerate_vs_dz","fake vs dz",nintDz,minDz,maxDz) );
718  h_fakerate_vertcount_entire.push_back( dbe_->book1D("fakerate_vertcount_entire","fake rate vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
719  h_fakerate_vertcount_barrel.push_back( dbe_->book1D("fakerate_vertcount_barrel","fake rate in barrel vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
720  h_fakerate_vertcount_fwdpos.push_back( dbe_->book1D("fakerate_vertcount_fwdpos","fake rate in endcap(+) vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
721  h_fakerate_vertcount_fwdneg.push_back( dbe_->book1D("fakerate_vertcount_fwdneg","fake rate in endcap(-) vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
722  h_fakerate_ootpu_entire.push_back( dbe_->book1D("fakerate_ootpu_eta_entire","Out of time pileup fake rate vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
723  h_fakerate_ootpu_barrel.push_back( dbe_->book1D("fakerate_ootpu_barrel","Out of time pileup fake rate in barrel vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
724  h_fakerate_ootpu_fwdpos.push_back( dbe_->book1D("fakerate_ootpu_fwdpos","Out of time pileup fake rate in endcap(+) vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
725  h_fakerate_ootpu_fwdneg.push_back( dbe_->book1D("fakerate_ootpu_fwdneg","Out of time pileup fake rate in endcap(-) vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
726 
727  h_fomt_eta.push_back( dbe_->book1D("fomt","fraction of misreconstructed tracks vs #eta",nintEta,minEta,maxEta) );
728  h_fomt_sig_eta.push_back( dbe_->book1D("fomt_signal","fraction of misreconstructed tracks vs #eta",nintEta,minEta,maxEta) );
729  h_fomt_vertcount.push_back( dbe_->book1D("fomt_vertcount","fraction of misreconstructed tracks vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
730  h_fomt_sig_vertcount.push_back( dbe_->book1D("fomt_vertcount_signal","fraction of misreconstructed tracks vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
731  h_fomt_ootpu_eta.push_back( dbe_->book1D("fomt_ootpu_eta","Out of time pileup fraction of misreconstructed tracks vs #eta",nintEta,minEta,maxEta) );
732  h_fomt_ootpu_vertcount.push_back( dbe_->book1D("fomt_ootpu_vertcount","Out of time pileup fraction of misreconstructed tracks vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
733  h_fomt_itpu_eta.push_back( dbe_->book1D("fomt_itpu_eta","In time pileup fraction of misreconstructed tracks vs eta",nintEta,minEta,maxEta) );
734  h_fomt_itpu_vertcount.push_back( dbe_->book1D("fomt_itpu_vertcount","In time pileup fraction of misreconstructed tracks vs N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
735 
736  h_effic_PU_eta.push_back( dbe_->book1D("effic_PU_eta","PU efficiency vs #eta",nintEta,minEta,maxEta) );
737  h_effic_PU_vertcount.push_back( dbe_->book1D("effic_PU_vertcount","PU efficiency s N of pileup vertices",nintVertcount,minVertcount,maxVertcount) );
738  h_effic_PU_zpos.push_back( dbe_->book1D("effic_PU_zpos","PU efficiency vs z of primary interaction vertex",nintZpos,minZpos,maxZpos) );
739 
740  h_chi2meanhitsh.push_back( dbe_->bookProfile("chi2mean_vs_nhits","mean #chi^{2} vs nhits",25,0,25,100,0,10) );
741  h_chi2meanh.push_back( dbe_->bookProfile("chi2mean","mean #chi^{2} vs #eta",nintEta,minEta,maxEta, 200, 0, 20) );
742  h_chi2mean_vs_phi.push_back( dbe_->bookProfile("chi2mean_vs_phi","mean of #chi^{2} vs #phi",nintPhi,minPhi,maxPhi, 200, 0, 20) );
743 
744  h_hits_eta.push_back( dbe_->bookProfile("hits_eta","mean #hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
745  h_PXBhits_eta.push_back( dbe_->bookProfile("PXBhits_eta","mean # PXB hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
746  h_PXFhits_eta.push_back( dbe_->bookProfile("PXFhits_eta","mean # PXF hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
747  h_TIBhits_eta.push_back( dbe_->bookProfile("TIBhits_eta","mean # TIB hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
748  h_TIDhits_eta.push_back( dbe_->bookProfile("TIDhits_eta","mean # TID hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
749  h_TOBhits_eta.push_back( dbe_->bookProfile("TOBhits_eta","mean # TOB hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
750  h_TEChits_eta.push_back( dbe_->bookProfile("TEChits_eta","mean # TEC hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
751 
752  h_LayersWithMeas_eta.push_back(dbe_->bookProfile("LayersWithMeas_eta","mean # LayersWithMeas vs eta",
753  nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
754  h_PXLlayersWithMeas_eta.push_back(dbe_->bookProfile("PXLlayersWith2dMeas_eta","mean # PXLlayersWithMeas vs eta",
755  nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
756  h_STRIPlayersWithMeas_eta.push_back(dbe_->bookProfile("STRIPlayersWithMeas_eta","mean # STRIPlayersWithMeas vs eta",
757  nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
758  h_STRIPlayersWith1dMeas_eta.push_back(dbe_->bookProfile("STRIPlayersWith1dMeas_eta","mean # STRIPlayersWith1dMeas vs eta",
759  nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
760  h_STRIPlayersWith2dMeas_eta.push_back(dbe_->bookProfile("STRIPlayersWith2dMeas_eta","mean # STRIPlayersWith2dMeas vs eta",
761  nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
762  h_hits_phi.push_back( dbe_->bookProfile("hits_phi","mean #hits vs #phi",nintPhi,minPhi,maxPhi, nintHit,minHit,maxHit) );
763  h_losthits_eta.push_back( dbe_->bookProfile("losthits_eta","losthits_eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
764 
765  h_ptrmsh.push_back( dbe_->book1D("ptres_vs_eta_Sigma","#sigma(#deltap_{t}/p_{t}) vs #eta",nintEta,minEta,maxEta) );
766  h_ptmeanhPhi.push_back( dbe_->book1D("ptres_vs_phi_Mean","mean of p_{t} resolution vs #phi",nintPhi,minPhi,maxPhi));
767  h_ptrmshPhi.push_back( dbe_->book1D("ptres_vs_phi_Sigma","#sigma(#deltap_{t}/p_{t}) vs #phi",nintPhi,minPhi,maxPhi) );
768  h_ptmeanhPt.push_back( dbe_->book1D("ptres_vs_pt_Mean","mean of p_{t} resolution vs p_{t}",nintPt,minPt,maxPt));
769  h_ptrmshPt.push_back( dbe_->book1D("ptres_vs_pt_Sigma","#sigma(#deltap_{t}/p_{t}) vs pT",nintPt,minPt,maxPt) );
770  h_cotThetameanh.push_back( dbe_->book1D("cotThetares_vs_eta_Mean","#sigma(cot(#theta)) vs #eta Mean",nintEta,minEta,maxEta) );
771  h_cotThetarmsh.push_back( dbe_->book1D("cotThetares_vs_eta_Sigma","#sigma(cot(#theta)) vs #eta Sigma",nintEta,minEta,maxEta) );
772  h_cotThetameanhPt.push_back( dbe_->book1D("cotThetares_vs_pt_Mean","#sigma(cot(#theta)) vs pT Mean",nintPt,minPt,maxPt) );
773  h_cotThetarmshPt.push_back( dbe_->book1D("cotThetares_vs_pt_Sigma","#sigma(cot(#theta)) vs pT Sigma",nintPt,minPt,maxPt) );
774  h_phimeanh.push_back(dbe_->book1D("phires_vs_eta_Mean","mean of #phi res vs #eta",nintEta,minEta,maxEta));
775  h_phirmsh.push_back( dbe_->book1D("phires_vs_eta_Sigma","#sigma(#delta#phi) vs #eta",nintEta,minEta,maxEta) );
776  h_phimeanhPt.push_back(dbe_->book1D("phires_vs_pt_Mean","mean of #phi res vs pT",nintPt,minPt,maxPt));
777  h_phirmshPt.push_back( dbe_->book1D("phires_vs_pt_Sigma","#sigma(#delta#phi) vs pT",nintPt,minPt,maxPt) );
778  h_phimeanhPhi.push_back(dbe_->book1D("phires_vs_phi_Mean","mean of #phi res vs #phi",nintPhi,minPhi,maxPhi));
779  h_phirmshPhi.push_back( dbe_->book1D("phires_vs_phi_Sigma","#sigma(#delta#phi) vs #phi",nintPhi,minPhi,maxPhi) );
780  h_dxymeanh.push_back( dbe_->book1D("dxyres_vs_eta_Mean","mean of dxyres vs #eta",nintEta,minEta,maxEta) );
781  h_dxyrmsh.push_back( dbe_->book1D("dxyres_vs_eta_Sigma","#sigma(#deltadxy) vs #eta",nintEta,minEta,maxEta) );
782  h_dxymeanhPt.push_back( dbe_->book1D("dxyres_vs_pt_Mean","mean of dxyres vs pT",nintPt,minPt,maxPt) );
783  h_dxyrmshPt.push_back( dbe_->book1D("dxyres_vs_pt_Sigma","#sigmadxy vs pT",nintPt,minPt,maxPt) );
784  h_dzmeanh.push_back( dbe_->book1D("dzres_vs_eta_Mean","mean of dzres vs #eta",nintEta,minEta,maxEta) );
785  h_dzrmsh.push_back( dbe_->book1D("dzres_vs_eta_Sigma","#sigma(#deltadz) vs #eta",nintEta,minEta,maxEta) );
786  h_dzmeanhPt.push_back( dbe_->book1D("dzres_vs_pt_Mean","mean of dzres vs pT",nintPt,minPt,maxPt) );
787  h_dzrmshPt.push_back( dbe_->book1D("dzres_vs_pt_Sigma","#sigma(#deltadz vs pT",nintPt,minPt,maxPt) );
788  h_dxypulletamean.push_back( dbe_->book1D("h_dxypulleta_Mean","mean of dxy pull vs #eta",nintEta,minEta,maxEta) );
789  h_ptpulletamean.push_back( dbe_->book1D("h_ptpulleta_Mean","mean of p_{t} pull vs #eta",nintEta,minEta,maxEta) );
790  h_dzpulletamean.push_back( dbe_->book1D("h_dzpulleta_Mean","mean of dz pull vs #eta",nintEta,minEta,maxEta) );
791  h_phipulletamean.push_back( dbe_->book1D("h_phipulleta_Mean","mean of #phi pull vs #eta",nintEta,minEta,maxEta) );
792  h_thetapulletamean.push_back( dbe_->book1D("h_thetapulleta_Mean","mean of #theta pull vs #eta",nintEta,minEta,maxEta) );
793  h_dxypulleta.push_back( dbe_->book1D("h_dxypulleta_Sigma","#sigma of dxy pull vs #eta",nintEta,minEta,maxEta) );
794  h_ptpulleta.push_back( dbe_->book1D("h_ptpulleta_Sigma","#sigma of p_{t} pull vs #eta",nintEta,minEta,maxEta) );
795  h_dzpulleta.push_back( dbe_->book1D("h_dzpulleta_Sigma","#sigma of dz pull vs #eta",nintEta,minEta,maxEta) );
796  h_phipulleta.push_back( dbe_->book1D("h_phipulleta_Sigma","#sigma of #phi pull vs #eta",nintEta,minEta,maxEta) );
797  h_thetapulleta.push_back( dbe_->book1D("h_thetapulleta_Sigma","#sigma of #theta pull vs #eta",nintEta,minEta,maxEta) );
798  h_ptshifteta.push_back( dbe_->book1D("ptres_vs_eta_Mean","<#deltapT/pT>[%] vs #eta",nintEta,minEta,maxEta) );
799  h_ptpullphimean.push_back( dbe_->book1D("h_ptpullphi_Mean","mean of p_{t} pull vs #phi",nintPhi,minPhi,maxPhi) );
800  h_phipullphimean.push_back( dbe_->book1D("h_phipullphi_Mean","mean of #phi pull vs #phi",nintPhi,minPhi,maxPhi) );
801  h_thetapullphimean.push_back( dbe_->book1D("h_thetapullphi_Mean","mean of #theta pull vs #phi",nintPhi,minPhi,maxPhi) );
802  h_ptpullphi.push_back( dbe_->book1D("h_ptpullphi_Sigma","#sigma of p_{t} pull vs #phi",nintPhi,minPhi,maxPhi) );
803  h_phipullphi.push_back( dbe_->book1D("h_phipullphi_Sigma","#sigma of #phi pull vs #phi",nintPhi,minPhi,maxPhi) );
804  h_thetapullphi.push_back( dbe_->book1D("h_thetapullphi_Sigma","#sigma of #theta pull vs #phi",nintPhi,minPhi,maxPhi) );
805 
806  if(useLogPt){
807  BinLogX(h_dzmeanhPt.back()->getTH1F());
808  BinLogX(h_dzrmshPt.back()->getTH1F());
809  BinLogX(h_dxymeanhPt.back()->getTH1F());
810  BinLogX(h_dxyrmshPt.back()->getTH1F());
811  BinLogX(h_phimeanhPt.back()->getTH1F());
812  BinLogX(h_phirmshPt.back()->getTH1F());
813  BinLogX(h_cotThetameanhPt.back()->getTH1F());
814  BinLogX(h_cotThetarmshPt.back()->getTH1F());
815  BinLogX(h_ptmeanhPt.back()->getTH1F());
816  BinLogX(h_ptrmshPt.back()->getTH1F());
817  BinLogX(h_efficPt.back()->getTH1F());
818  BinLogX(h_fakeratePt.back()->getTH1F());
819  BinLogX(h_loopratepT.back()->getTH1F());
820  BinLogX(h_misidratepT.back()->getTH1F());
821  }
822 }
823 
824 void MTVHistoProducerAlgoForTracker::fill_generic_simTrack_histos(int count,
825  const TrackingParticle::Vector& momentumTP,
826  const TrackingParticle::Point& vertexTP,
827  int bx){
828  h_ptSIM[count]->Fill(sqrt(momentumTP.perp2()));
829  h_etaSIM[count]->Fill(momentumTP.eta());
830  h_vertposSIM[count]->Fill(sqrt(vertexTP.perp2()));
831  h_bunchxSIM[count]->Fill(bx);
832 }
833 
834 
835 
836 // TO BE FIXED USING PLAIN HISTOGRAMS INSTEAD OF RE-IMPLEMENTATION OF HISTOGRAMS (i.d. vectors<int/double>)
837 void MTVHistoProducerAlgoForTracker::fill_recoAssociated_simTrack_histos(int count,
838  const TrackingParticle& tp,
839  const TrackingParticle::Vector& momentumTP,
840  const TrackingParticle::Point& vertexTP,
841  double dxySim, double dzSim, int nSimHits,
842  const reco::Track* track,
843  int numVertices, double vertz){
844  bool isMatched = track;
845 
846  if((*TpSelectorForEfficiencyVsEta)(tp)){
847  //effic vs hits
848  int nSimHitsInBounds = std::min((int)nSimHits,int(maxHit-1));
849  totSIM_hit[count][nSimHitsInBounds]++;
850  if(isMatched) {
851  totASS_hit[count][nSimHitsInBounds]++;
852  nrecHit_vs_nsimHit_sim2rec[count]->Fill( track->numberOfValidHits(),nSimHits);
853  }
854 
855  //effic vs eta
856  for (unsigned int f=0; f<etaintervals[count].size()-1; f++){
857  if (getEta(momentumTP.eta())>etaintervals[count][f]&&
858  getEta(momentumTP.eta())<=etaintervals[count][f+1]) {
859  totSIMeta[count][f]++;
860  if (isMatched) {
861  totASSeta[count][f]++;
862  }
863  }
864 
865  } // END for (unsigned int f=0; f<etaintervals[w].size()-1; f++){
866 
867  //effic vs num pileup vertices
868  for (unsigned int f=0; f<vertcountintervals[count].size()-1; f++){
869  if (numVertices == vertcountintervals[count][f]) {
870  totSIM_vertcount_entire[count][f]++;
871  if (isMatched) {
872  totASS_vertcount_entire[count][f]++;
873  }
874  }
875  if (numVertices == vertcountintervals[count][f] && momentumTP.eta() <= 0.9 && momentumTP.eta() >= -0.9) {
876  totSIM_vertcount_barrel[count][f]++;
877  if (isMatched) {
878  totASS_vertcount_barrel[count][f]++;
879  }
880  }
881  if (numVertices == vertcountintervals[count][f] && momentumTP.eta() > 0.9) {
882  totSIM_vertcount_fwdpos[count][f]++;
883  if (isMatched) {
884  totASS_vertcount_fwdpos[count][f]++;
885  }
886  }
887  if (numVertices == vertcountintervals[count][f] && momentumTP.eta() < -0.9) {
888  totSIM_vertcount_fwdneg[count][f]++;
889  if (isMatched) {
890  totASS_vertcount_fwdneg[count][f]++;
891  }
892  }
893  }
894 
895  }
896 
897  if((*TpSelectorForEfficiencyVsPhi)(tp)){
898  for (unsigned int f=0; f<phiintervals[count].size()-1; f++){
899  if (momentumTP.phi() > phiintervals[count][f]&&
900  momentumTP.phi() <=phiintervals[count][f+1]) {
901  totSIM_phi[count][f]++;
902  if (isMatched) {
903  totASS_phi[count][f]++;
904  }
905  }
906  } // END for (unsigned int f=0; f<phiintervals[count].size()-1; f++){
907  }
908 
909  if((*TpSelectorForEfficiencyVsPt)(tp)){
910  for (unsigned int f=0; f<pTintervals[count].size()-1; f++){
911  if (getPt(sqrt(momentumTP.perp2()))>pTintervals[count][f]&&
912  getPt(sqrt(momentumTP.perp2()))<=pTintervals[count][f+1]) {
913  totSIMpT[count][f]++;
914  if (isMatched) {
915  totASSpT[count][f]++;
916  }
917  }
918  } // END for (unsigned int f=0; f<pTintervals[count].size()-1; f++){
919  }
920 
921  if((*TpSelectorForEfficiencyVsVTXR)(tp)){
922  for (unsigned int f=0; f<dxyintervals[count].size()-1; f++){
923  if (dxySim>dxyintervals[count][f]&&
924  dxySim<=dxyintervals[count][f+1]) {
925  totSIM_dxy[count][f]++;
926  if (isMatched) {
927  totASS_dxy[count][f]++;
928  }
929  }
930  } // END for (unsigned int f=0; f<dxyintervals[count].size()-1; f++){
931 
932  for (unsigned int f=0; f<vertposintervals[count].size()-1; f++){
933  if (sqrt(vertexTP.perp2())>vertposintervals[count][f]&&
934  sqrt(vertexTP.perp2())<=vertposintervals[count][f+1]) {
935  totSIM_vertpos[count][f]++;
936  if (isMatched) {
937  totASS_vertpos[count][f]++;
938  }
939  }
940  } // END for (unsigned int f=0; f<vertposintervals[count].size()-1; f++){
941  }
942 
943  if((*TpSelectorForEfficiencyVsVTXZ)(tp)){
944  for (unsigned int f=0; f<dzintervals[count].size()-1; f++){
945  if (dzSim>dzintervals[count][f]&&
946  dzSim<=dzintervals[count][f+1]) {
947  totSIM_dz[count][f]++;
948  if (isMatched) {
949  totASS_dz[count][f]++;
950  }
951  }
952  } // END for (unsigned int f=0; f<dzintervals[count].size()-1; f++){
953 
954 
955  for (unsigned int f=0; f<zposintervals[count].size()-1; f++){
956  if (vertexTP.z()>zposintervals[count][f]&&vertexTP.z()<=zposintervals[count][f+1]) {
957  totSIM_zpos[count][f]++;
958  if (isMatched) totASS_zpos[count][f]++;
959  }
960  if (vertz>zposintervals[count][f]&&vertz<=zposintervals[count][f+1]) {
961  totSIM_vertz_entire[count][f]++;
962  if (isMatched) totASS_vertz_entire[count][f]++;
963  }
964  if (vertz>zposintervals[count][f]&&vertz<=zposintervals[count][f+1] && fabs(momentumTP.eta())<0.9) {
965  totSIM_vertz_barrel[count][f]++;
966  if (isMatched) totASS_vertz_barrel[count][f]++;
967  }
968  if (vertz>zposintervals[count][f]&&vertz<=zposintervals[count][f+1] && momentumTP.eta()>0.9) {
969  totSIM_vertz_fwdpos[count][f]++;
970  if (isMatched) totASS_vertz_fwdpos[count][f]++;
971  }
972  if (vertz>zposintervals[count][f]&&vertz<=zposintervals[count][f+1] && momentumTP.eta()<-0.9) {
973  totSIM_vertz_fwdneg[count][f]++;
974  if (isMatched) totASS_vertz_fwdneg[count][f]++;
975  }
976  } // END for (unsigned int f=0; f<zposintervals[count].size()-1; f++){
977  }
978 
979  //Special investigations for PU
980  if(((*TpSelectorForEfficiencyVsCon)(tp)) && (!((*TpSelectorForEfficiencyVsEta)(tp)))){
981 
982  //efficPU vs eta
983  for (unsigned int f=0; f<etaintervals[count].size()-1; f++){
984  if (getEta(momentumTP.eta())>etaintervals[count][f]&&
985  getEta(momentumTP.eta())<=etaintervals[count][f+1]) {
986  totCONeta[count][f]++;
987  }
988  } // END for (unsigned int f=0; f<etaintervals[w].size()-1; f++){
989 
990  //efficPU vs num pileup vertices
991  for (unsigned int f=0; f<vertcountintervals[count].size()-1; f++){
992  if (numVertices == vertcountintervals[count][f]) {
993  totCONvertcount[count][f]++;
994  }
995  } // END for (unsigned int f=0; f<vertcountintervals[count].size()-1; f++){
996 
997  for (unsigned int f=0; f<zposintervals[count].size()-1; f++){
998  if (vertexTP.z()>zposintervals[count][f]&&vertexTP.z()<=zposintervals[count][f+1]) {
999  totCONzpos[count][f]++;
1000  }
1001  } // END for (unsigned int f=0; f<zposintervals[count].size()-1; f++){
1002 
1003  }
1004 
1005 }
1006 
1007 // dE/dx
1008 void MTVHistoProducerAlgoForTracker::fill_dedx_recoTrack_histos(int count, edm::RefToBase<reco::Track>& trackref, const std::vector< edm::ValueMap<reco::DeDxData> >& v_dEdx) {
1009 //void MTVHistoProducerAlgoForTracker::fill_dedx_recoTrack_histos(reco::TrackRef trackref, std::vector< edm::ValueMap<reco::DeDxData> > v_dEdx) {
1010  double dedx;
1011  int nom;
1012  int sat;
1013  edm::ValueMap<reco::DeDxData> dEdxTrack;
1014  for (unsigned int i=0; i<v_dEdx.size(); i++) {
1015  dEdxTrack = v_dEdx.at(i);
1016  dedx = dEdxTrack[trackref].dEdx();
1017  nom = dEdxTrack[trackref].numberOfMeasurements();
1018  sat = dEdxTrack[trackref].numberOfSaturatedMeasurements();
1019  if (i==0) {
1020  h_dedx_estim1[count]->Fill(dedx);
1021  h_dedx_nom1[count]->Fill(nom);
1022  h_dedx_sat1[count]->Fill(sat);
1023  } else if (i==1) {
1024  h_dedx_estim2[count]->Fill(dedx);
1025  h_dedx_nom2[count]->Fill(nom);
1026  h_dedx_sat2[count]->Fill(sat);
1027  }
1028  }
1029 }
1030 
1031 
1032 // TO BE FIXED USING PLAIN HISTOGRAMS INSTEAD OF RE-IMPLEMENTATION OF HISTOGRAMS (i.d. vectors<int/double>)
1033 void MTVHistoProducerAlgoForTracker::fill_generic_recoTrack_histos(int count,
1034  const reco::Track& track,
1035  const math::XYZPoint& bsPosition,
1036  bool isMatched,
1037  bool isSigMatched,
1038  bool isChargeMatched,
1039  int numAssocRecoTracks,
1040  int numVertices,
1041  int tpbunchcrossing, int nSimHits,
1042  double sharedFraction){
1043 
1044  //Fill track algo histogram
1045 
1046  if (track.algo()>=4 && track.algo()<=14) totREC_algo[count][track.algo()-4]++;
1047  int sharedHits = sharedFraction * track.numberOfValidHits();
1048 
1049  //Compute fake rate vs eta
1050  for (unsigned int f=0; f<etaintervals[count].size()-1; f++){
1051  if (getEta(track.momentum().eta())>etaintervals[count][f]&&
1052  getEta(track.momentum().eta())<=etaintervals[count][f+1]) {
1053  totRECeta[count][f]++;
1054  if (isMatched) {
1055  totASS2eta[count][f]++;
1056  if (!isChargeMatched) totmisideta[count][f]++;
1057  if (numAssocRecoTracks>1) totloopeta[count][f]++;
1058  if (tpbunchcrossing==0) totASS2_itpu_eta_entire[count][f]++;
1059  if (tpbunchcrossing!=0) totASS2_ootpu_eta_entire[count][f]++;
1060  nrecHit_vs_nsimHit_rec2sim[count]->Fill( track.numberOfValidHits(),nSimHits);
1061  h_assocFraction[count]->Fill( sharedFraction);
1062  h_assocSharedHit[count]->Fill( sharedHits);
1063  }
1064  if (isSigMatched) {
1065  totASS2etaSig[count][f]++;
1066  if (tpbunchcrossing==0) totASS2_itpu_eta_entire_signal[count][f]++;
1067  }
1068  }
1069  } // End for (unsigned int f=0; f<etaintervals[count].size()-1; f++){
1070 
1071  for (unsigned int f=0; f<phiintervals[count].size()-1; f++){
1072  if (track.momentum().phi()>phiintervals[count][f]&&
1073  track.momentum().phi()<=phiintervals[count][f+1]) {
1074  totREC_phi[count][f]++;
1075  if (isMatched) {
1076  totASS2_phi[count][f]++;
1077  if (!isChargeMatched) totmisid_phi[count][f]++;
1078  if (numAssocRecoTracks>1) totloop_phi[count][f]++;
1079  }
1080  }
1081  } // End for (unsigned int f=0; f<phiintervals[count].size()-1; f++){
1082 
1083 
1084  for (unsigned int f=0; f<pTintervals[count].size()-1; f++){
1085  if (getPt(sqrt(track.momentum().perp2()))>pTintervals[count][f]&&
1086  getPt(sqrt(track.momentum().perp2()))<=pTintervals[count][f+1]) {
1087  totRECpT[count][f]++;
1088  if (isMatched) {
1089  totASS2pT[count][f]++;
1090  if (!isChargeMatched) totmisidpT[count][f]++;
1091  if (numAssocRecoTracks>1) totlooppT[count][f]++;
1092  }
1093  }
1094  } // End for (unsigned int f=0; f<pTintervals[count].size()-1; f++){
1095 
1096  for (unsigned int f=0; f<dxyintervals[count].size()-1; f++){
1097  if (track.dxy(bsPosition)>dxyintervals[count][f]&&
1098  track.dxy(bsPosition)<=dxyintervals[count][f+1]) {
1099  totREC_dxy[count][f]++;
1100  if (isMatched) {
1101  totASS2_dxy[count][f]++;
1102  if (!isChargeMatched) totmisid_dxy[count][f]++;
1103  if (numAssocRecoTracks>1) totloop_dxy[count][f]++;
1104  }
1105  }
1106  } // End for (unsigned int f=0; f<dxyintervals[count].size()-1; f++){
1107 
1108  for (unsigned int f=0; f<dzintervals[count].size()-1; f++){
1109  if (track.dz(bsPosition)>dzintervals[count][f]&&
1110  track.dz(bsPosition)<=dzintervals[count][f+1]) {
1111  totREC_dz[count][f]++;
1112  if (isMatched) {
1113  totASS2_dz[count][f]++;
1114  if (!isChargeMatched) totmisid_dz[count][f]++;
1115  if (numAssocRecoTracks>1) totloop_dz[count][f]++;
1116  }
1117  }
1118  } // End for (unsigned int f=0; f<dzintervals[count].size()-1; f++){
1119 
1120  int tmp = std::min((int)track.found(),int(maxHit-1));
1121  totREC_hit[count][tmp]++;
1122  if (isMatched) {
1123  totASS2_hit[count][tmp]++;
1124  if (!isChargeMatched) totmisid_hit[count][tmp]++;
1125  if (numAssocRecoTracks>1) totloop_hit[count][tmp]++;
1126  }
1127 
1128  for (unsigned int f=0; f<vertcountintervals[count].size()-1; f++){
1129  if (numVertices == vertcountintervals[count][f]) {
1130  totREC_vertcount_entire[count][f]++;
1131  totREC_ootpu_entire[count][f]++;
1132  if (isMatched) {
1133  totASS2_vertcount_entire[count][f]++;
1134  if (tpbunchcrossing==0) totASS2_itpu_vertcount_entire[count][f]++;
1135  if (tpbunchcrossing!=0) totASS2_ootpu_entire[count][f]++;
1136  }
1137  if (isSigMatched) {
1138  totASS2_vertcount_entire_signal[count][f]++;
1139  if (tpbunchcrossing==0) totASS2_itpu_vertcount_entire_signal[count][f]++;
1140  }
1141  }
1142  if (numVertices == vertcountintervals[count][f] && track.eta() <= 0.9 && track.eta() >= -0.9) {
1143  totREC_vertcount_barrel[count][f]++;
1144  totREC_ootpu_barrel[count][f]++;
1145  if (isMatched) {
1146  totASS2_vertcount_barrel[count][f]++;
1147  if (isMatched && tpbunchcrossing!=0) totASS2_ootpu_barrel[count][f]++;
1148  }
1149  }
1150  if (numVertices == vertcountintervals[count][f] && track.eta() > 0.9) {
1151  totREC_vertcount_fwdpos[count][f]++;
1152  totREC_ootpu_fwdpos[count][f]++;
1153  if (isMatched) {
1154  totASS2_vertcount_fwdpos[count][f]++;
1155  if (isMatched && tpbunchcrossing!=0) totASS2_ootpu_fwdpos[count][f]++;
1156  }
1157  }
1158  if (numVertices == vertcountintervals[count][f] && track.eta() < -0.9) {
1159  totREC_vertcount_fwdneg[count][f]++;
1160  totREC_ootpu_fwdneg[count][f]++;
1161  if (isMatched) {
1162  totASS2_vertcount_fwdneg[count][f]++;
1163  if (isMatched && tpbunchcrossing!=0) totASS2_ootpu_fwdneg[count][f]++;
1164  }
1165  }
1166 
1167  }
1168 
1169 }
1170 
1171 
1172 void MTVHistoProducerAlgoForTracker::fill_simAssociated_recoTrack_histos(int count,
1173  const reco::Track& track){
1174  //nchi2 and hits global distributions
1175  h_nchi2[count]->Fill(track.normalizedChi2());
1176  h_nchi2_prob[count]->Fill(TMath::Prob(track.chi2(),(int)track.ndof()));
1177  h_hits[count]->Fill(track.numberOfValidHits());
1178  h_losthits[count]->Fill(track.numberOfLostHits());
1179  chi2_vs_nhits[count]->Fill(track.numberOfValidHits(),track.normalizedChi2());
1180  h_charge[count]->Fill( track.charge() );
1181  h_nmisslayers_inner[count]->Fill(track.trackerExpectedHitsInner().numberOfHits());
1182  h_nmisslayers_outer[count]->Fill(track.trackerExpectedHitsOuter().numberOfHits());
1183 
1184  //chi2 and #hit vs eta: fill 2D histos
1185  chi2_vs_eta[count]->Fill(getEta(track.eta()),track.normalizedChi2());
1186  nhits_vs_eta[count]->Fill(getEta(track.eta()),track.numberOfValidHits());
1187  nPXBhits_vs_eta[count]->Fill(getEta(track.eta()),track.hitPattern().numberOfValidPixelBarrelHits());
1188  nPXFhits_vs_eta[count]->Fill(getEta(track.eta()),track.hitPattern().numberOfValidPixelEndcapHits());
1189  nTIBhits_vs_eta[count]->Fill(getEta(track.eta()),track.hitPattern().numberOfValidStripTIBHits());
1190  nTIDhits_vs_eta[count]->Fill(getEta(track.eta()),track.hitPattern().numberOfValidStripTIDHits());
1191  nTOBhits_vs_eta[count]->Fill(getEta(track.eta()),track.hitPattern().numberOfValidStripTOBHits());
1192  nTEChits_vs_eta[count]->Fill(getEta(track.eta()),track.hitPattern().numberOfValidStripTECHits());
1193  nLayersWithMeas_vs_eta[count]->Fill(getEta(track.eta()),track.hitPattern().trackerLayersWithMeasurement());
1194  nPXLlayersWithMeas_vs_eta[count]->Fill(getEta(track.eta()),track.hitPattern().pixelLayersWithMeasurement());
1195  int LayersAll = track.hitPattern().stripLayersWithMeasurement();
1196  int Layers2D = track.hitPattern().numberOfValidStripLayersWithMonoAndStereo();
1197  int Layers1D = LayersAll - Layers2D;
1198  nSTRIPlayersWithMeas_vs_eta[count]->Fill(getEta(track.eta()),LayersAll);
1199  nSTRIPlayersWith1dMeas_vs_eta[count]->Fill(getEta(track.eta()),Layers1D);
1200  nSTRIPlayersWith2dMeas_vs_eta[count]->Fill(getEta(track.eta()),Layers2D);
1201 
1202  nlosthits_vs_eta[count]->Fill(getEta(track.eta()),track.numberOfLostHits());
1203 }
1204 
1205 
1206 void MTVHistoProducerAlgoForTracker::fill_trackBased_histos(int count, int assTracks, int numRecoTracks, int numSimTracks){
1207 
1208  h_tracks[count]->Fill(assTracks);
1209  h_fakes[count]->Fill(numRecoTracks-assTracks);
1210  nrec_vs_nsim[count]->Fill(numRecoTracks,numSimTracks);
1211 
1212 }
1213 
1214 
1215 
1216 void MTVHistoProducerAlgoForTracker::fill_ResoAndPull_recoTrack_histos(int count,
1217  const TrackingParticle::Vector& momentumTP,
1218  const TrackingParticle::Point& vertexTP,
1219  int chargeTP,
1220  const reco::Track& track,
1221  const math::XYZPoint& bsPosition){
1222 
1223  // evaluation of TP parameters
1224  double qoverpSim = chargeTP/sqrt(momentumTP.x()*momentumTP.x()+momentumTP.y()*momentumTP.y()+momentumTP.z()*momentumTP.z());
1225  double lambdaSim = M_PI/2-momentumTP.theta();
1226  double phiSim = momentumTP.phi();
1227  double dxySim = (-vertexTP.x()*sin(momentumTP.phi())+vertexTP.y()*cos(momentumTP.phi()));
1228  double dzSim = vertexTP.z() - (vertexTP.x()*momentumTP.x()+vertexTP.y()*momentumTP.y())/sqrt(momentumTP.perp2())
1229  * momentumTP.z()/sqrt(momentumTP.perp2());
1230 
1231 
1232  // reco::Track::ParameterVector rParameters = track.parameters(); // UNUSED
1233 
1234  double qoverpRec(0);
1235  double qoverpErrorRec(0);
1236  double ptRec(0);
1237  double ptErrorRec(0);
1238  double lambdaRec(0);
1239  double lambdaErrorRec(0);
1240  double phiRec(0);
1241  double phiErrorRec(0);
1242 
1243  /* TO BE FIXED LATER -----------
1244  //loop to decide whether to take gsfTrack (utilisation of mode-function) or common track
1245  const GsfTrack* gsfTrack(0);
1246  if(useGsf){
1247  gsfTrack = dynamic_cast<const GsfTrack*>(&(*track));
1248  if (gsfTrack==0) edm::LogInfo("TrackValidator") << "Trying to access mode for a non-GsfTrack";
1249  }
1250 
1251  if (gsfTrack) {
1252  // get values from mode
1253  getRecoMomentum(*gsfTrack, ptRec, ptErrorRec, qoverpRec, qoverpErrorRec,
1254  lambdaRec,lambdaErrorRec, phiRec, phiErrorRec);
1255  }
1256 
1257  else {
1258  // get values from track (without mode)
1259  getRecoMomentum(*track, ptRec, ptErrorRec, qoverpRec, qoverpErrorRec,
1260  lambdaRec,lambdaErrorRec, phiRec, phiErrorRec);
1261  }
1262  */
1263  getRecoMomentum(track, ptRec, ptErrorRec, qoverpRec, qoverpErrorRec,
1264  lambdaRec,lambdaErrorRec, phiRec, phiErrorRec);
1265  // -------------
1266 
1267  double ptError = ptErrorRec;
1268  double ptres=ptRec-sqrt(momentumTP.perp2());
1269  double etares=track.eta()-momentumTP.Eta();
1270 
1271 
1272  double dxyRec = track.dxy(bsPosition);
1273  double dzRec = track.dz(bsPosition);
1274 
1275  // eta residue; pt, k, theta, phi, dxy, dz pulls
1276  double qoverpPull=(qoverpRec-qoverpSim)/qoverpErrorRec;
1277  double thetaPull=(lambdaRec-lambdaSim)/lambdaErrorRec;
1278  double phiPull=(phiRec-phiSim)/phiErrorRec;
1279  double dxyPull=(dxyRec-dxySim)/track.dxyError();
1280  double dzPull=(dzRec-dzSim)/track.dzError();
1281 
1282  double contrib_Qoverp = ((qoverpRec-qoverpSim)/qoverpErrorRec)*
1283  ((qoverpRec-qoverpSim)/qoverpErrorRec)/5;
1284  double contrib_dxy = ((dxyRec-dxySim)/track.dxyError())*((dxyRec-dxySim)/track.dxyError())/5;
1285  double contrib_dz = ((dzRec-dzSim)/track.dzError())*((dzRec-dzSim)/track.dzError())/5;
1286  double contrib_theta = ((lambdaRec-lambdaSim)/lambdaErrorRec)*
1287  ((lambdaRec-lambdaSim)/lambdaErrorRec)/5;
1288  double contrib_phi = ((phiRec-phiSim)/phiErrorRec)*
1289  ((phiRec-phiSim)/phiErrorRec)/5;
1290 
1291  LogTrace("TrackValidatorTEST")
1292  //<< "assocChi2=" << tp.begin()->second << "\n"
1293  << "" << "\n"
1294  << "ptREC=" << ptRec << "\n" << "etaREC=" << track.eta() << "\n" << "qoverpREC=" << qoverpRec << "\n"
1295  << "dxyREC=" << dxyRec << "\n" << "dzREC=" << dzRec << "\n"
1296  << "thetaREC=" << track.theta() << "\n" << "phiREC=" << phiRec << "\n"
1297  << "" << "\n"
1298  << "qoverpError()=" << qoverpErrorRec << "\n" << "dxyError()=" << track.dxyError() << "\n"<< "dzError()="
1299  << track.dzError() << "\n"
1300  << "thetaError()=" << lambdaErrorRec << "\n" << "phiError()=" << phiErrorRec << "\n"
1301  << "" << "\n"
1302  << "ptSIM=" << sqrt(momentumTP.perp2()) << "\n"<< "etaSIM=" << momentumTP.Eta() << "\n"<< "qoverpSIM=" << qoverpSim << "\n"
1303  << "dxySIM=" << dxySim << "\n"<< "dzSIM=" << dzSim << "\n" << "thetaSIM=" << M_PI/2-lambdaSim << "\n"
1304  << "phiSIM=" << phiSim << "\n"
1305  << "" << "\n"
1306  << "contrib_Qoverp=" << contrib_Qoverp << "\n"<< "contrib_dxy=" << contrib_dxy << "\n"<< "contrib_dz=" << contrib_dz << "\n"
1307  << "contrib_theta=" << contrib_theta << "\n"<< "contrib_phi=" << contrib_phi << "\n"
1308  << "" << "\n"
1309  <<"chi2PULL="<<contrib_Qoverp+contrib_dxy+contrib_dz+contrib_theta+contrib_phi<<"\n";
1310 
1311  h_pullQoverp[count]->Fill(qoverpPull);
1312  h_pullTheta[count]->Fill(thetaPull);
1313  h_pullPhi[count]->Fill(phiPull);
1314  h_pullDxy[count]->Fill(dxyPull);
1315  h_pullDz[count]->Fill(dzPull);
1316 
1317 
1318  h_pt[count]->Fill(ptres/ptError);
1319  h_eta[count]->Fill(etares);
1320  //etares_vs_eta[count]->Fill(getEta(track.eta()),etares);
1321  etares_vs_eta[count]->Fill(getEta(momentumTP.eta()),etares);
1322 
1323 
1324  /*
1325  //resolution of track params: fill 2D histos
1326  dxyres_vs_eta[count]->Fill(getEta(track.eta()),dxyRec-dxySim);
1327  ptres_vs_eta[count]->Fill(getEta(track.eta()),(ptRec-sqrt(momentumTP.perp2()))/ptRec);
1328  dzres_vs_eta[count]->Fill(getEta(track.eta()),dzRec-dzSim);
1329  phires_vs_eta[count]->Fill(getEta(track.eta()),phiRec-phiSim);
1330  cotThetares_vs_eta[count]->Fill(getEta(track.eta()),1/tan(M_PI*0.5-lambdaRec)-1/tan(M_PI*0.5-lambdaSim));
1331 
1332  //same as before but vs pT
1333  dxyres_vs_pt[count]->Fill(getPt(ptRec),dxyRec-dxySim);
1334  ptres_vs_pt[count]->Fill(getPt(ptRec),(ptRec-sqrt(momentumTP.perp2()))/ptRec);
1335  dzres_vs_pt[count]->Fill(getPt(ptRec),dzRec-dzSim);
1336  phires_vs_pt[count]->Fill(getPt(ptRec),phiRec-phiSim);
1337  cotThetares_vs_pt[count]->Fill(getPt(ptRec),1/tan(M_PI*0.5-lambdaRec)-1/tan(M_PI*0.5-lambdaSim));
1338 
1339  //pulls of track params vs eta: fill 2D histos
1340  dxypull_vs_eta[count]->Fill(getEta(track.eta()),dxyPull);
1341  ptpull_vs_eta[count]->Fill(getEta(track.eta()),ptres/ptError);
1342  dzpull_vs_eta[count]->Fill(getEta(track.eta()),dzPull);
1343  phipull_vs_eta[count]->Fill(getEta(track.eta()),phiPull);
1344  thetapull_vs_eta[count]->Fill(getEta(track.eta()),thetaPull);
1345 
1346  //plots vs phi
1347  nhits_vs_phi[count]->Fill(phiRec,track.numberOfValidHits());
1348  chi2_vs_phi[count]->Fill(phiRec,track.normalizedChi2());
1349  ptmean_vs_eta_phi[count]->Fill(phiRec,getEta(track.eta()),ptRec);
1350  phimean_vs_eta_phi[count]->Fill(phiRec,getEta(track.eta()),phiRec);
1351  ptres_vs_phi[count]->Fill(phiRec,(ptRec-sqrt(momentumTP.perp2()))/ptRec);
1352  phires_vs_phi[count]->Fill(phiRec,phiRec-phiSim);
1353  ptpull_vs_phi[count]->Fill(phiRec,ptres/ptError);
1354  phipull_vs_phi[count]->Fill(phiRec,phiPull);
1355  thetapull_vs_phi[count]->Fill(phiRec,thetaPull);
1356  */
1357 
1358  //resolution of track params: fill 2D histos
1359  dxyres_vs_eta[count]->Fill(getEta(momentumTP.eta()),dxyRec-dxySim);
1360  ptres_vs_eta[count]->Fill(getEta(momentumTP.eta()),(ptRec-sqrt(momentumTP.perp2()))/ptRec);
1361  dzres_vs_eta[count]->Fill(getEta(momentumTP.eta()),dzRec-dzSim);
1362  phires_vs_eta[count]->Fill(getEta(momentumTP.eta()),phiRec-phiSim);
1363  cotThetares_vs_eta[count]->Fill(getEta(momentumTP.eta()),1/tan(M_PI*0.5-lambdaRec)-1/tan(M_PI*0.5-lambdaSim));
1364 
1365  //same as before but vs pT
1366  dxyres_vs_pt[count]->Fill(getPt(sqrt(momentumTP.perp2())),dxyRec-dxySim);
1367  ptres_vs_pt[count]->Fill(getPt(sqrt(momentumTP.perp2())),(ptRec-sqrt(momentumTP.perp2()))/ptRec);
1368  dzres_vs_pt[count]->Fill(getPt(sqrt(momentumTP.perp2())),dzRec-dzSim);
1369  phires_vs_pt[count]->Fill(getPt(sqrt(momentumTP.perp2())),phiRec-phiSim);
1370  cotThetares_vs_pt[count]->Fill(getPt(sqrt(momentumTP.perp2())),1/tan(M_PI*0.5-lambdaRec)-1/tan(M_PI*0.5-lambdaSim));
1371 
1372  //pulls of track params vs eta: fill 2D histos
1373  dxypull_vs_eta[count]->Fill(getEta(momentumTP.eta()),dxyPull);
1374  ptpull_vs_eta[count]->Fill(getEta(momentumTP.eta()),ptres/ptError);
1375  dzpull_vs_eta[count]->Fill(getEta(momentumTP.eta()),dzPull);
1376  phipull_vs_eta[count]->Fill(getEta(momentumTP.eta()),phiPull);
1377  thetapull_vs_eta[count]->Fill(getEta(momentumTP.eta()),thetaPull);
1378 
1379  //plots vs phi
1380  nhits_vs_phi[count]->Fill(phiRec,track.numberOfValidHits());
1381  chi2_vs_phi[count]->Fill(phiRec,track.normalizedChi2());
1382  ptmean_vs_eta_phi[count]->Fill(phiRec,getEta(track.eta()),ptRec);
1383  phimean_vs_eta_phi[count]->Fill(phiRec,getEta(track.eta()),phiRec);
1384 
1385  ptres_vs_phi[count]->Fill(momentumTP.phi(),(ptRec-sqrt(momentumTP.perp2()))/ptRec);
1386  phires_vs_phi[count]->Fill(momentumTP.phi(),phiRec-phiSim);
1387  ptpull_vs_phi[count]->Fill(momentumTP.phi(),ptres/ptError);
1388  phipull_vs_phi[count]->Fill(momentumTP.phi(),phiPull);
1389  thetapull_vs_phi[count]->Fill(momentumTP.phi(),thetaPull);
1390 
1391 
1392 }
1393 
1394 
1395 
1396 void
1397 MTVHistoProducerAlgoForTracker::getRecoMomentum (const reco::Track& track, double& pt, double& ptError,
1398  double& qoverp, double& qoverpError, double& lambda,double& lambdaError,
1399  double& phi, double& phiError ) const {
1400  pt = track.pt();
1401  ptError = track.ptError();
1402  qoverp = track.qoverp();
1403  qoverpError = track.qoverpError();
1404  lambda = track.lambda();
1405  lambdaError = track.lambdaError();
1406  phi = track.phi();
1407  phiError = track.phiError();
1408  // cout <<"test1" << endl;
1409 
1410 
1411 
1412 }
1413 
1414 void
1415 MTVHistoProducerAlgoForTracker::getRecoMomentum (const reco::GsfTrack& gsfTrack, double& pt, double& ptError,
1416  double& qoverp, double& qoverpError, double& lambda,double& lambdaError,
1417  double& phi, double& phiError ) const {
1418 
1419  pt = gsfTrack.ptMode();
1420  ptError = gsfTrack.ptModeError();
1421  qoverp = gsfTrack.qoverpMode();
1422  qoverpError = gsfTrack.qoverpModeError();
1423  lambda = gsfTrack.lambdaMode();
1424  lambdaError = gsfTrack.lambdaModeError();
1425  phi = gsfTrack.phiMode();
1426  phiError = gsfTrack.phiModeError();
1427  // cout <<"test2" << endl;
1428 
1429 }
1430 
1431 double
1432 MTVHistoProducerAlgoForTracker::getEta(double eta) {
1433  if (useFabsEta) return fabs(eta);
1434  else return eta;
1435 }
1436 
1437 double
1438 MTVHistoProducerAlgoForTracker::getPt(double pt) {
1439  if (useInvPt && pt!=0) return 1/pt;
1440  else return pt;
1441 }
1442 
1443 
1444 void MTVHistoProducerAlgoForTracker::finalHistoFits(int counter){
1445  //resolution of track params: get sigma from 2D histos
1446  FitSlicesYTool fsyt_dxy(dxyres_vs_eta[counter]);
1447  fsyt_dxy.getFittedSigmaWithError(h_dxyrmsh[counter]);
1448  fsyt_dxy.getFittedMeanWithError(h_dxymeanh[counter]);
1449  FitSlicesYTool fsyt_dxyPt(dxyres_vs_pt[counter]);
1450  fsyt_dxyPt.getFittedSigmaWithError(h_dxyrmshPt[counter]);
1451  fsyt_dxyPt.getFittedMeanWithError(h_dxymeanhPt[counter]);
1452  FitSlicesYTool fsyt_pt(ptres_vs_eta[counter]);
1453  fsyt_pt.getFittedSigmaWithError(h_ptrmsh[counter]);
1454  fsyt_pt.getFittedMeanWithError(h_ptshifteta[counter]);
1455  FitSlicesYTool fsyt_ptPt(ptres_vs_pt[counter]);
1456  fsyt_ptPt.getFittedSigmaWithError(h_ptrmshPt[counter]);
1457  fsyt_ptPt.getFittedMeanWithError(h_ptmeanhPt[counter]);
1458  FitSlicesYTool fsyt_ptPhi(ptres_vs_phi[counter]);
1459  fsyt_ptPhi.getFittedSigmaWithError(h_ptrmshPhi[counter]);
1460  fsyt_ptPhi.getFittedMeanWithError(h_ptmeanhPhi[counter]);
1461  FitSlicesYTool fsyt_dz(dzres_vs_eta[counter]);
1462  fsyt_dz.getFittedSigmaWithError(h_dzrmsh[counter]);
1463  fsyt_dz.getFittedMeanWithError(h_dzmeanh[counter]);
1464  FitSlicesYTool fsyt_dzPt(dzres_vs_pt[counter]);
1465  fsyt_dzPt.getFittedSigmaWithError(h_dzrmshPt[counter]);
1466  fsyt_dzPt.getFittedMeanWithError(h_dzmeanhPt[counter]);
1467  FitSlicesYTool fsyt_phi(phires_vs_eta[counter]);
1468  fsyt_phi.getFittedSigmaWithError(h_phirmsh[counter]);
1469  fsyt_phi.getFittedMeanWithError(h_phimeanh[counter]);
1470  FitSlicesYTool fsyt_phiPt(phires_vs_pt[counter]);
1471  fsyt_phiPt.getFittedSigmaWithError(h_phirmshPt[counter]);
1472  fsyt_phiPt.getFittedMeanWithError(h_phimeanhPt[counter]);
1473  FitSlicesYTool fsyt_phiPhi(phires_vs_phi[counter]);
1474  fsyt_phiPhi.getFittedSigmaWithError(h_phirmshPhi[counter]);
1475  fsyt_phiPhi.getFittedMeanWithError(h_phimeanhPhi[counter]);
1476  FitSlicesYTool fsyt_cotTheta(cotThetares_vs_eta[counter]);
1477  fsyt_cotTheta.getFittedSigmaWithError(h_cotThetarmsh[counter]);
1478  fsyt_cotTheta.getFittedMeanWithError(h_cotThetameanh[counter]);
1479  FitSlicesYTool fsyt_cotThetaPt(cotThetares_vs_pt[counter]);
1480  fsyt_cotThetaPt.getFittedSigmaWithError(h_cotThetarmshPt[counter]);
1481  fsyt_cotThetaPt.getFittedMeanWithError(h_cotThetameanhPt[counter]);
1482 
1483  //pulls of track params vs eta: get sigma from 2D histos
1484  FitSlicesYTool fsyt_dxyp(dxypull_vs_eta[counter]);
1485  fsyt_dxyp.getFittedSigmaWithError(h_dxypulleta[counter]);
1486  fsyt_dxyp.getFittedMeanWithError(h_dxypulletamean[counter]);
1487  FitSlicesYTool fsyt_ptp(ptpull_vs_eta[counter]);
1488  fsyt_ptp.getFittedSigmaWithError(h_ptpulleta[counter]);
1489  fsyt_ptp.getFittedMeanWithError(h_ptpulletamean[counter]);
1490  FitSlicesYTool fsyt_dzp(dzpull_vs_eta[counter]);
1491  fsyt_dzp.getFittedSigmaWithError(h_dzpulleta[counter]);
1492  fsyt_dzp.getFittedMeanWithError(h_dzpulletamean[counter]);
1493  FitSlicesYTool fsyt_phip(phipull_vs_eta[counter]);
1494  fsyt_phip.getFittedSigmaWithError(h_phipulleta[counter]);
1495  fsyt_phip.getFittedMeanWithError(h_phipulletamean[counter]);
1496  FitSlicesYTool fsyt_thetap(thetapull_vs_eta[counter]);
1497  fsyt_thetap.getFittedSigmaWithError(h_thetapulleta[counter]);
1498  fsyt_thetap.getFittedMeanWithError(h_thetapulletamean[counter]);
1499  //vs phi
1500  FitSlicesYTool fsyt_ptpPhi(ptpull_vs_phi[counter]);
1501  fsyt_ptpPhi.getFittedSigmaWithError(h_ptpullphi[counter]);
1502  fsyt_ptpPhi.getFittedMeanWithError(h_ptpullphimean[counter]);
1503  FitSlicesYTool fsyt_phipPhi(phipull_vs_phi[counter]);
1504  fsyt_phipPhi.getFittedSigmaWithError(h_phipullphi[counter]);
1505  fsyt_phipPhi.getFittedMeanWithError(h_phipullphimean[counter]);
1506  FitSlicesYTool fsyt_thetapPhi(thetapull_vs_phi[counter]);
1507  fsyt_thetapPhi.getFittedSigmaWithError(h_thetapullphi[counter]);
1508  fsyt_thetapPhi.getFittedMeanWithError(h_thetapullphimean[counter]);
1509 
1510  //effic&fake;
1511  for (unsigned int ite = 0;ite<totASSeta[counter].size();ite++) totFOMT_eta[counter][ite]=totASS2eta[counter][ite]-totASS2etaSig[counter][ite];
1512  for (unsigned int ite = 0;ite<totASS2_vertcount_entire[counter].size();ite++)
1513  totFOMT_vertcount[counter][ite]=totASS2_vertcount_entire[counter][ite]-totASS2_vertcount_entire_signal[counter][ite];
1514  for (unsigned int ite = 0;ite<totASS2_itpu_eta_entire[counter].size();ite++) totASS2_itpu_eta_entire[counter][ite]-=totASS2_itpu_eta_entire_signal[counter][ite];
1515  for (unsigned int ite = 0;ite<totASS2_itpu_vertcount_entire[counter].size();ite++) totASS2_itpu_vertcount_entire[counter][ite]-=totASS2_itpu_vertcount_entire_signal[counter][ite];
1516 
1517  fillPlotFromVectors(h_effic[counter],totASSeta[counter],totSIMeta[counter],"effic");
1518  fillPlotFromVectors(h_fakerate[counter],totASS2eta[counter],totRECeta[counter],"fakerate");
1519  fillPlotFromVectors(h_looprate[counter],totloopeta[counter],totRECeta[counter],"effic");
1520  fillPlotFromVectors(h_misidrate[counter],totmisideta[counter],totRECeta[counter],"effic");
1521  fillPlotFromVectors(h_efficPt[counter],totASSpT[counter],totSIMpT[counter],"effic");
1522  fillPlotFromVectors(h_fakeratePt[counter],totASS2pT[counter],totRECpT[counter],"fakerate");
1523  fillPlotFromVectors(h_loopratepT[counter],totlooppT[counter],totRECpT[counter],"effic");
1524  fillPlotFromVectors(h_misidratepT[counter],totmisidpT[counter],totRECpT[counter],"effic");
1525  fillPlotFromVectors(h_effic_vs_hit[counter],totASS_hit[counter],totSIM_hit[counter],"effic");
1526  fillPlotFromVectors(h_fake_vs_hit[counter],totASS2_hit[counter],totREC_hit[counter],"fakerate");
1527  fillPlotFromVectors(h_loopratehit[counter],totloop_hit[counter],totREC_hit[counter],"effic");
1528  fillPlotFromVectors(h_misidratehit[counter],totmisid_hit[counter],totREC_hit[counter],"effic");
1529  fillPlotFromVectors(h_effic_vs_phi[counter],totASS_phi[counter],totSIM_phi[counter],"effic");
1530  fillPlotFromVectors(h_fake_vs_phi[counter],totASS2_phi[counter],totREC_phi[counter],"fakerate");
1531  fillPlotFromVectors(h_loopratephi[counter],totloop_phi[counter],totREC_phi[counter],"effic");
1532  fillPlotFromVectors(h_misidratephi[counter],totmisid_phi[counter],totREC_phi[counter],"effic");
1533  fillPlotFromVectors(h_effic_vs_dxy[counter],totASS_dxy[counter],totSIM_dxy[counter],"effic");
1534  fillPlotFromVectors(h_fake_vs_dxy[counter],totASS2_dxy[counter],totREC_dxy[counter],"fakerate");
1535  fillPlotFromVectors(h_loopratedxy[counter],totloop_dxy[counter],totREC_dxy[counter],"effic");
1536  fillPlotFromVectors(h_misidratedxy[counter],totmisid_dxy[counter],totREC_dxy[counter],"effic");
1537  fillPlotFromVectors(h_effic_vs_dz[counter],totASS_dz[counter],totSIM_dz[counter],"effic");
1538  fillPlotFromVectors(h_fake_vs_dz[counter],totASS2_dz[counter],totREC_dz[counter],"fakerate");
1539  fillPlotFromVectors(h_loopratedz[counter],totloop_dz[counter],totREC_dz[counter],"effic");
1540  fillPlotFromVectors(h_misidratedz[counter],totmisid_dz[counter],totREC_dz[counter],"effic");
1541  fillPlotFromVectors(h_effic_vs_vertpos[counter],totASS_vertpos[counter],totSIM_vertpos[counter],"effic");
1542  fillPlotFromVectors(h_effic_vs_zpos[counter],totASS_zpos[counter],totSIM_zpos[counter],"effic");
1543  fillPlotFromVectors(h_effic_vertcount_entire[counter],totASS_vertcount_entire[counter],totSIM_vertcount_entire[counter],"effic");
1544  fillPlotFromVectors(h_effic_vertcount_barrel[counter],totASS_vertcount_barrel[counter],totSIM_vertcount_barrel[counter],"effic");
1545  fillPlotFromVectors(h_effic_vertcount_fwdpos[counter],totASS_vertcount_fwdpos[counter],totSIM_vertcount_fwdpos[counter],"effic");
1546  fillPlotFromVectors(h_effic_vertcount_fwdneg[counter],totASS_vertcount_fwdneg[counter],totSIM_vertcount_fwdneg[counter],"effic");
1547  fillPlotFromVectors(h_fakerate_vertcount_entire[counter],totASS2_vertcount_entire[counter],totREC_vertcount_entire[counter],"fakerate");
1548  fillPlotFromVectors(h_fakerate_vertcount_barrel[counter],totASS2_vertcount_barrel[counter],totREC_vertcount_barrel[counter],"fakerate");
1549  fillPlotFromVectors(h_fakerate_vertcount_fwdpos[counter],totASS2_vertcount_fwdpos[counter],totREC_vertcount_fwdpos[counter],"fakerate");
1550  fillPlotFromVectors(h_fakerate_vertcount_fwdneg[counter],totASS2_vertcount_fwdneg[counter],totREC_vertcount_fwdneg[counter],"fakerate");
1551  fillPlotFromVectors(h_effic_vertz_entire[counter],totASS_vertz_entire[counter],totSIM_vertz_entire[counter],"effic");
1552  fillPlotFromVectors(h_effic_vertz_barrel[counter],totASS_vertz_barrel[counter],totSIM_vertz_barrel[counter],"effic");
1553  fillPlotFromVectors(h_effic_vertz_fwdpos[counter],totASS_vertz_fwdpos[counter],totSIM_vertz_fwdpos[counter],"effic");
1554  fillPlotFromVectors(h_effic_vertz_fwdneg[counter],totASS_vertz_fwdneg[counter],totSIM_vertz_fwdneg[counter],"effic");
1555  fillPlotFromVectors(h_fakerate_ootpu_entire[counter],totASS2_ootpu_entire[counter],totREC_ootpu_entire[counter],"effic");
1556  fillPlotFromVectors(h_fakerate_ootpu_barrel[counter],totASS2_ootpu_barrel[counter],totREC_ootpu_barrel[counter],"effic");
1557  fillPlotFromVectors(h_fakerate_ootpu_fwdpos[counter],totASS2_ootpu_fwdpos[counter],totREC_ootpu_fwdpos[counter],"effic");
1558  fillPlotFromVectors(h_fakerate_ootpu_fwdneg[counter],totASS2_ootpu_fwdneg[counter],totREC_ootpu_fwdneg[counter],"effic");
1559 
1560  fillPlotFromVectors(h_fomt_eta[counter],totFOMT_eta[counter],totASS2etaSig[counter],"pileup");
1561  fillPlotFromVectors(h_fomt_vertcount[counter],totFOMT_vertcount[counter],totASS2_vertcount_entire_signal[counter],"pileup");
1562  fillPlotFromVectors(h_fomt_sig_eta[counter],totASS2etaSig[counter],totRECeta[counter],"fakerate");
1563  fillPlotFromVectors(h_fomt_sig_vertcount[counter],totASS2_vertcount_entire_signal[counter],totREC_vertcount_entire[counter],"fakerate");
1564  fillPlotFromVectors(h_fomt_itpu_eta[counter],totASS2_itpu_eta_entire[counter],totRECeta[counter],"effic");
1565  fillPlotFromVectors(h_fomt_itpu_vertcount[counter],totASS2_itpu_vertcount_entire[counter],totREC_vertcount_entire[counter],"effic");
1566  fillPlotFromVectors(h_fomt_ootpu_eta[counter],totASS2_ootpu_eta_entire[counter],totRECeta[counter],"effic");
1567  fillPlotFromVectors(h_fomt_ootpu_vertcount[counter],totASS2_ootpu_entire[counter],totREC_ootpu_entire[counter],"effic");
1568 
1569  fillPlotFromVectors(h_effic_PU_eta[counter],totASSeta[counter],totCONeta[counter],"pileup");
1570  fillPlotFromVectors(h_effic_PU_vertcount[counter],totASS_vertcount_entire[counter],totCONvertcount[counter],"pileup");
1571  fillPlotFromVectors(h_effic_PU_zpos[counter],totASS_zpos[counter],totCONzpos[counter],"pileup");
1572 
1573 }
1574 
1575 void MTVHistoProducerAlgoForTracker::fillProfileHistosFromVectors(int counter){
1576  //chi2 and #hit vs eta: get mean from 2D histos
1577  doProfileX(chi2_vs_eta[counter],h_chi2meanh[counter]);
1578  doProfileX(nhits_vs_eta[counter],h_hits_eta[counter]);
1579  doProfileX(nPXBhits_vs_eta[counter],h_PXBhits_eta[counter]);
1580  doProfileX(nPXFhits_vs_eta[counter],h_PXFhits_eta[counter]);
1581  doProfileX(nTIBhits_vs_eta[counter],h_TIBhits_eta[counter]);
1582  doProfileX(nTIDhits_vs_eta[counter],h_TIDhits_eta[counter]);
1583  doProfileX(nTOBhits_vs_eta[counter],h_TOBhits_eta[counter]);
1584  doProfileX(nTEChits_vs_eta[counter],h_TEChits_eta[counter]);
1585 
1586  doProfileX(nLayersWithMeas_vs_eta[counter],h_LayersWithMeas_eta[counter]);
1587  doProfileX(nPXLlayersWithMeas_vs_eta[counter],h_PXLlayersWithMeas_eta[counter]);
1588  doProfileX(nSTRIPlayersWithMeas_vs_eta[counter],h_STRIPlayersWithMeas_eta[counter]);
1589  doProfileX(nSTRIPlayersWith1dMeas_vs_eta[counter],h_STRIPlayersWith1dMeas_eta[counter]);
1590  doProfileX(nSTRIPlayersWith2dMeas_vs_eta[counter],h_STRIPlayersWith2dMeas_eta[counter]);
1591 
1592 
1593 
1594  doProfileX(nlosthits_vs_eta[counter],h_losthits_eta[counter]);
1595  //vs phi
1596  doProfileX(chi2_vs_nhits[counter],h_chi2meanhitsh[counter]);
1597  // doProfileX(ptres_vs_eta[counter],h_ptresmean_vs_eta[counter]);
1598  // doProfileX(phires_vs_eta[counter],h_phiresmean_vs_eta[counter]);
1599  doProfileX(chi2_vs_phi[counter],h_chi2mean_vs_phi[counter]);
1600  doProfileX(nhits_vs_phi[counter],h_hits_phi[counter]);
1601  // doProfileX(ptres_vs_phi[counter],h_ptresmean_vs_phi[counter]);
1602  // doProfileX(phires_vs_phi[counter],h_phiresmean_vs_phi[counter]);
1603 }
1604 
1605 void MTVHistoProducerAlgoForTracker::fillHistosFromVectors(int counter){
1606  fillPlotFromVector(h_algo[counter],totREC_algo[counter]);
1607 
1608  fillPlotFromVector(h_recoeta[counter],totRECeta[counter]);
1609  fillPlotFromVector(h_simuleta[counter],totSIMeta[counter]);
1610  fillPlotFromVector(h_assoceta[counter],totASSeta[counter]);
1611  fillPlotFromVector(h_assoc2eta[counter],totASS2eta[counter]);
1612  fillPlotFromVector(h_loopereta[counter],totloopeta[counter]);
1613  fillPlotFromVector(h_misideta[counter],totmisideta[counter]);
1614 
1615  fillPlotFromVector(h_recopT[counter],totRECpT[counter]);
1616  fillPlotFromVector(h_simulpT[counter],totSIMpT[counter]);
1617  fillPlotFromVector(h_assocpT[counter],totASSpT[counter]);
1618  fillPlotFromVector(h_assoc2pT[counter],totASS2pT[counter]);
1619  fillPlotFromVector(h_looperpT[counter],totlooppT[counter]);
1620  fillPlotFromVector(h_misidpT[counter],totmisidpT[counter]);
1621 
1622  fillPlotFromVector(h_recohit[counter],totREC_hit[counter]);
1623  fillPlotFromVector(h_simulhit[counter],totSIM_hit[counter]);
1624  fillPlotFromVector(h_assochit[counter],totASS_hit[counter]);
1625  fillPlotFromVector(h_assoc2hit[counter],totASS2_hit[counter]);
1626  fillPlotFromVector(h_looperhit[counter],totloop_hit[counter]);
1627  fillPlotFromVector(h_misidhit[counter],totmisid_hit[counter]);
1628 
1629  fillPlotFromVector(h_recophi[counter],totREC_phi[counter]);
1630  fillPlotFromVector(h_simulphi[counter],totSIM_phi[counter]);
1631  fillPlotFromVector(h_assocphi[counter],totASS_phi[counter]);
1632  fillPlotFromVector(h_assoc2phi[counter],totASS2_phi[counter]);
1633  fillPlotFromVector(h_looperphi[counter],totloop_phi[counter]);
1634  fillPlotFromVector(h_misidphi[counter],totmisid_phi[counter]);
1635 
1636  fillPlotFromVector(h_recodxy[counter],totREC_dxy[counter]);
1637  fillPlotFromVector(h_simuldxy[counter],totSIM_dxy[counter]);
1638  fillPlotFromVector(h_assocdxy[counter],totASS_dxy[counter]);
1639  fillPlotFromVector(h_assoc2dxy[counter],totASS2_dxy[counter]);
1640  fillPlotFromVector(h_looperdxy[counter],totloop_dxy[counter]);
1641  fillPlotFromVector(h_misiddxy[counter],totmisid_dxy[counter]);
1642 
1643  fillPlotFromVector(h_recodz[counter],totREC_dz[counter]);
1644  fillPlotFromVector(h_simuldz[counter],totSIM_dz[counter]);
1645  fillPlotFromVector(h_assocdz[counter],totASS_dz[counter]);
1646  fillPlotFromVector(h_assoc2dz[counter],totASS2_dz[counter]);
1647  fillPlotFromVector(h_looperdz[counter],totloop_dz[counter]);
1648  fillPlotFromVector(h_misiddz[counter],totmisid_dz[counter]);
1649 
1650  fillPlotFromVector(h_simulvertpos[counter],totSIM_vertpos[counter]);
1651  fillPlotFromVector(h_assocvertpos[counter],totASS_vertpos[counter]);
1652 
1653  fillPlotFromVector(h_simulzpos[counter],totSIM_zpos[counter]);
1654  fillPlotFromVector(h_assoczpos[counter],totASS_zpos[counter]);
1655 
1656  fillPlotFromVector(h_reco_vertcount_entire[counter],totREC_vertcount_entire[counter]);
1657  fillPlotFromVector(h_simul_vertcount_entire[counter],totSIM_vertcount_entire[counter]);
1658  fillPlotFromVector(h_assoc_vertcount_entire[counter],totASS_vertcount_entire[counter]);
1659  fillPlotFromVector(h_assoc2_vertcount_entire[counter],totASS2_vertcount_entire[counter]);
1660 
1661  fillPlotFromVector(h_reco_vertcount_barrel[counter],totREC_vertcount_barrel[counter]);
1662  fillPlotFromVector(h_simul_vertcount_barrel[counter],totSIM_vertcount_barrel[counter]);
1663  fillPlotFromVector(h_assoc_vertcount_barrel[counter],totASS_vertcount_barrel[counter]);
1664  fillPlotFromVector(h_assoc2_vertcount_barrel[counter],totASS2_vertcount_barrel[counter]);
1665 
1666  fillPlotFromVector(h_reco_vertcount_fwdpos[counter],totREC_vertcount_fwdpos[counter]);
1667  fillPlotFromVector(h_simul_vertcount_fwdpos[counter],totSIM_vertcount_fwdpos[counter]);
1668  fillPlotFromVector(h_assoc_vertcount_fwdpos[counter],totASS_vertcount_fwdpos[counter]);
1669  fillPlotFromVector(h_assoc2_vertcount_fwdpos[counter],totASS2_vertcount_fwdpos[counter]);
1670 
1671  fillPlotFromVector(h_reco_vertcount_fwdneg[counter],totREC_vertcount_fwdneg[counter]);
1672  fillPlotFromVector(h_simul_vertcount_fwdneg[counter],totSIM_vertcount_fwdneg[counter]);
1673  fillPlotFromVector(h_assoc_vertcount_fwdneg[counter],totASS_vertcount_fwdneg[counter]);
1674  fillPlotFromVector(h_assoc2_vertcount_fwdneg[counter],totASS2_vertcount_fwdneg[counter]);
1675 
1676  fillPlotFromVector(h_simul_vertz_entire[counter],totSIM_vertz_entire[counter]);
1677  fillPlotFromVector(h_assoc_vertz_entire[counter],totASS_vertz_entire[counter]);
1678 
1679  fillPlotFromVector(h_simul_vertz_barrel[counter],totSIM_vertz_barrel[counter]);
1680  fillPlotFromVector(h_assoc_vertz_barrel[counter],totASS_vertz_barrel[counter]);
1681 
1682  fillPlotFromVector(h_simul_vertz_fwdpos[counter],totSIM_vertz_fwdpos[counter]);
1683  fillPlotFromVector(h_assoc_vertz_fwdpos[counter],totASS_vertz_fwdpos[counter]);
1684 
1685  fillPlotFromVector(h_simul_vertz_fwdneg[counter],totSIM_vertz_fwdneg[counter]);
1686  fillPlotFromVector(h_assoc_vertz_fwdneg[counter],totASS_vertz_fwdneg[counter]);
1687 
1688  fillPlotFromVector(h_reco_ootpu_entire[counter],totREC_ootpu_entire[counter]);
1689  fillPlotFromVector(h_assoc2_ootpu_entire[counter],totASS2_ootpu_entire[counter]);
1690 
1691  fillPlotFromVector(h_reco_ootpu_barrel[counter],totREC_ootpu_barrel[counter]);
1692  fillPlotFromVector(h_assoc2_ootpu_barrel[counter],totASS2_ootpu_barrel[counter]);
1693 
1694  fillPlotFromVector(h_reco_ootpu_fwdpos[counter],totREC_ootpu_fwdpos[counter]);
1695  fillPlotFromVector(h_assoc2_ootpu_fwdpos[counter],totASS2_ootpu_fwdpos[counter]);
1696 
1697  fillPlotFromVector(h_reco_ootpu_fwdneg[counter],totREC_ootpu_fwdneg[counter]);
1698  fillPlotFromVector(h_assoc2_ootpu_fwdneg[counter],totASS2_ootpu_fwdneg[counter]);
1699 
1700  fillPlotFromVector(h_con_eta[counter],totCONeta[counter]);
1701  fillPlotFromVector(h_con_vertcount[counter],totCONvertcount[counter]);
1702  fillPlotFromVector(h_con_zpos[counter],totCONzpos[counter]);
1703 
1704 }
1705 
1706 
1707 
1708 
1709 
1710 
1711 void MTVHistoProducerAlgoForTracker::fill_recoAssociated_simTrack_histos(int count,
1712  const reco::GenParticle& tp,
1713  const TrackingParticle::Vector& momentumTP,
1714  const TrackingParticle::Point& vertexTP,
1715  double dxySim, double dzSim, int nSimHits,
1716  const reco::Track* track,
1717  int numVertices, double vertz){
1718  bool isMatched = track;
1719 
1720  if((*GpSelectorForEfficiencyVsEta)(tp)){
1721  //effic vs hits
1722  int nSimHitsInBounds = std::min((int)nSimHits,int(maxHit-1));
1723  totSIM_hit[count][nSimHitsInBounds]++;
1724  if(isMatched) {
1725  totASS_hit[count][nSimHitsInBounds]++;
1726  nrecHit_vs_nsimHit_sim2rec[count]->Fill( track->numberOfValidHits(),nSimHits);
1727  }
1728 
1729  //effic vs eta
1730  for (unsigned int f=0; f<etaintervals[count].size()-1; f++){
1731  if (getEta(momentumTP.eta())>etaintervals[count][f]&&
1732  getEta(momentumTP.eta())<=etaintervals[count][f+1]) {
1733  totSIMeta[count][f]++;
1734  if (isMatched) {
1735  totASSeta[count][f]++;
1736  }
1737  }
1738 
1739  } // END for (unsigned int f=0; f<etaintervals[w].size()-1; f++){
1740 
1741  //effic vs num pileup vertices
1742  for (unsigned int f=0; f<vertcountintervals[count].size()-1; f++){
1743  if (numVertices == vertcountintervals[count][f]) {
1744  totSIM_vertcount_entire[count][f]++;
1745  if (isMatched) {
1746  totASS_vertcount_entire[count][f]++;
1747  }
1748  }
1749  if (numVertices == vertcountintervals[count][f] && momentumTP.eta() <= 0.9 && momentumTP.eta() >= -0.9) {
1750  totSIM_vertcount_barrel[count][f]++;
1751  if (isMatched) {
1752  totASS_vertcount_barrel[count][f]++;
1753  }
1754  }
1755  if (numVertices == vertcountintervals[count][f] && momentumTP.eta() > 0.9) {
1756  totSIM_vertcount_fwdpos[count][f]++;
1757  if (isMatched) {
1758  totASS_vertcount_fwdpos[count][f]++;
1759  }
1760  }
1761  if (numVertices == vertcountintervals[count][f] && momentumTP.eta() < -0.9) {
1762  totSIM_vertcount_fwdneg[count][f]++;
1763  if (isMatched) {
1764  totASS_vertcount_fwdneg[count][f]++;
1765  }
1766  }
1767  }
1768 
1769  }
1770 
1771  if((*GpSelectorForEfficiencyVsPhi)(tp)){
1772  for (unsigned int f=0; f<phiintervals[count].size()-1; f++){
1773  if (momentumTP.phi() > phiintervals[count][f]&&
1774  momentumTP.phi() <=phiintervals[count][f+1]) {
1775  totSIM_phi[count][f]++;
1776  if (isMatched) {
1777  totASS_phi[count][f]++;
1778  }
1779  }
1780  } // END for (unsigned int f=0; f<phiintervals[count].size()-1; f++){
1781  }
1782 
1783  if((*GpSelectorForEfficiencyVsPt)(tp)){
1784  for (unsigned int f=0; f<pTintervals[count].size()-1; f++){
1785  if (getPt(sqrt(momentumTP.perp2()))>pTintervals[count][f]&&
1786  getPt(sqrt(momentumTP.perp2()))<=pTintervals[count][f+1]) {
1787  totSIMpT[count][f]++;
1788  if (isMatched) {
1789  totASSpT[count][f]++;
1790  }
1791  }
1792  } // END for (unsigned int f=0; f<pTintervals[count].size()-1; f++){
1793  }
1794 
1795  if((*GpSelectorForEfficiencyVsVTXR)(tp)){
1796  for (unsigned int f=0; f<dxyintervals[count].size()-1; f++){
1797  if (dxySim>dxyintervals[count][f]&&
1798  dxySim<=dxyintervals[count][f+1]) {
1799  totSIM_dxy[count][f]++;
1800  if (isMatched) {
1801  totASS_dxy[count][f]++;
1802  }
1803  }
1804  } // END for (unsigned int f=0; f<dxyintervals[count].size()-1; f++){
1805 
1806  for (unsigned int f=0; f<vertposintervals[count].size()-1; f++){
1807  if (sqrt(vertexTP.perp2())>vertposintervals[count][f]&&
1808  sqrt(vertexTP.perp2())<=vertposintervals[count][f+1]) {
1809  totSIM_vertpos[count][f]++;
1810  if (isMatched) {
1811  totASS_vertpos[count][f]++;
1812  }
1813  }
1814  } // END for (unsigned int f=0; f<vertposintervals[count].size()-1; f++){
1815  }
1816 
1817  if((*GpSelectorForEfficiencyVsVTXZ)(tp)){
1818  for (unsigned int f=0; f<dzintervals[count].size()-1; f++){
1819  if (dzSim>dzintervals[count][f]&&
1820  dzSim<=dzintervals[count][f+1]) {
1821  totSIM_dz[count][f]++;
1822  if (isMatched) {
1823  totASS_dz[count][f]++;
1824  }
1825  }
1826  } // END for (unsigned int f=0; f<dzintervals[count].size()-1; f++){
1827 
1828 
1829  for (unsigned int f=0; f<zposintervals[count].size()-1; f++){
1830  if (vertexTP.z()>zposintervals[count][f]&&vertexTP.z()<=zposintervals[count][f+1]) {
1831  totSIM_zpos[count][f]++;
1832  if (isMatched) totASS_zpos[count][f]++;
1833  }
1834  if (vertz>zposintervals[count][f]&&vertz<=zposintervals[count][f+1]) {
1835  totSIM_vertz_entire[count][f]++;
1836  if (isMatched) totASS_vertz_entire[count][f]++;
1837  }
1838  if (vertz>zposintervals[count][f]&&vertz<=zposintervals[count][f+1] && fabs(momentumTP.eta())<0.9) {
1839  totSIM_vertz_barrel[count][f]++;
1840  if (isMatched) totASS_vertz_barrel[count][f]++;
1841  }
1842  if (vertz>zposintervals[count][f]&&vertz<=zposintervals[count][f+1] && momentumTP.eta()>0.9) {
1843  totSIM_vertz_fwdpos[count][f]++;
1844  if (isMatched) totASS_vertz_fwdpos[count][f]++;
1845  }
1846  if (vertz>zposintervals[count][f]&&vertz<=zposintervals[count][f+1] && momentumTP.eta()<-0.9) {
1847  totSIM_vertz_fwdneg[count][f]++;
1848  if (isMatched) totASS_vertz_fwdneg[count][f]++;
1849  }
1850  } // END for (unsigned int f=0; f<zposintervals[count].size()-1; f++){
1851  }
1852 
1853  //Special investigations for PU
1854  if(((*GpSelectorForEfficiencyVsCon)(tp)) && (!((*GpSelectorForEfficiencyVsEta)(tp)))){
1855 
1856  //efficPU vs eta
1857  for (unsigned int f=0; f<etaintervals[count].size()-1; f++){
1858  if (getEta(momentumTP.eta())>etaintervals[count][f]&&
1859  getEta(momentumTP.eta())<=etaintervals[count][f+1]) {
1860  totCONeta[count][f]++;
1861  }
1862  } // END for (unsigned int f=0; f<etaintervals[w].size()-1; f++){
1863 
1864  //efficPU vs num pileup vertices
1865  for (unsigned int f=0; f<vertcountintervals[count].size()-1; f++){
1866  if (numVertices == vertcountintervals[count][f]) {
1867  totCONvertcount[count][f]++;
1868  }
1869  } // END for (unsigned int f=0; f<vertcountintervals[count].size()-1; f++){
1870 
1871  for (unsigned int f=0; f<zposintervals[count].size()-1; f++){
1872  if (vertexTP.z()>zposintervals[count][f]&&vertexTP.z()<=zposintervals[count][f+1]) {
1873  totCONzpos[count][f]++;
1874  }
1875  } // END for (unsigned int f=0; f<zposintervals[count].size()-1; f++){
1876 
1877  }
1878 
1879 }
MTVHistoProducerAlgoForTracker::h_assoc_vertz_fwdpos
std::vector< MonitorElement * > h_assoc_vertz_fwdpos
Definition: MTVHistoProducerAlgoForTracker.h:173
MTVHistoProducerAlgoForTracker::totFOMT_vertcount
std::vector< std::vector< int > > totFOMT_vertcount
Definition: MTVHistoProducerAlgoForTracker.h:255
reco::TrackBase::qoverp
double qoverp() const
q/p
Definition: TrackBase.h:113
MTVHistoProducerAlgoForTracker::h_fakerate_ootpu_entire
std::vector< MonitorElement * > h_fakerate_ootpu_entire
Definition: MTVHistoProducerAlgoForTracker.h:176
MTVHistoProducerAlgoForTracker::vertcountintervals
std::vector< std::vector< double > > vertcountintervals
Definition: MTVHistoProducerAlgoForTracker.h:231
reco::GsfTrack::phiModeError
double phiModeError() const
error on phi from mode
Definition: GsfTrack.h:93
MTVHistoProducerAlgoForTracker::h_simul_vertz_entire
std::vector< MonitorElement * > h_simul_vertz_entire
Definition: MTVHistoProducerAlgoForTracker.h:171
MTVHistoProducerAlgoForTracker::h_looperhit
std::vector< MonitorElement * > h_looperhit
Definition: MTVHistoProducerAlgoForTracker.h:160
MTVHistoProducerAlgoForTracker::h_loopratephi
std::vector< MonitorElement * > h_loopratephi
Definition: MTVHistoProducerAlgoForTracker.h:161
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
MTVHistoProducerAlgoForTracker::h_fakerate_vertcount_fwdpos
std::vector< MonitorElement * > h_fakerate_vertcount_fwdpos
Definition: MTVHistoProducerAlgoForTracker.h:169
MTVHistoProducerAlgoForTracker::h_assoc2hit
std::vector< MonitorElement * > h_assoc2hit
Definition: MTVHistoProducerAlgoForTracker.h:160
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
MTVHistoProducerAlgoForTracker::h_dedx_estim2
std::vector< MonitorElement * > h_dedx_estim2
Definition: MTVHistoProducerAlgoForTracker.h:194
i
int i
Definition: DBlmapReader.cc:9
MTVHistoProducerAlgoForTracker::h_dzpulletamean
std::vector< MonitorElement * > h_dzpulletamean
Definition: MTVHistoProducerAlgoForTracker.h:299
MTVHistoProducerAlgoForTracker::h_recodxy
std::vector< MonitorElement * > h_recodxy
Definition: MTVHistoProducerAlgoForTracker.h:162
MTVHistoProducerAlgoForTracker::totASS_vertcount_fwdpos
std::vector< std::vector< int > > totASS_vertcount_fwdpos
Definition: MTVHistoProducerAlgoForTracker.h:242
MTVHistoProducerAlgoForTracker::h_fomt_itpu_eta
std::vector< MonitorElement * > h_fomt_itpu_eta
Definition: MTVHistoProducerAlgoForTracker.h:181
MTVHistoProducerAlgoForTracker::h_assochit
std::vector< MonitorElement * > h_assochit
Definition: MTVHistoProducerAlgoForTracker.h:160
MTVHistoProducerAlgoForTracker::h_efficPt
std::vector< MonitorElement * > h_efficPt
Definition: MTVHistoProducerAlgoForTracker.h:159
MTVHistoProducerAlgoForTracker::h_fakes
std::vector< MonitorElement * > h_fakes
Definition: MTVHistoProducerAlgoForTracker.h:157
MTVHistoProducerAlgoForTracker::zposintervals
std::vector< std::vector< double > > zposintervals
Definition: MTVHistoProducerAlgoForTracker.h:230
MTVHistoProducerAlgoForTracker::h_loopratedxy
std::vector< MonitorElement * > h_loopratedxy
Definition: MTVHistoProducerAlgoForTracker.h:162
MTVHistoProducerAlgoForTracker::h_PXFhits_eta
std::vector< MonitorElement * > h_PXFhits_eta
Definition: MTVHistoProducerAlgoForTracker.h:217
MTVHistoProducerAlgoForTracker::totASS2_ootpu_fwdpos
std::vector< std::vector< int > > totASS2_ootpu_fwdpos
Definition: MTVHistoProducerAlgoForTracker.h:251
MTVHistoProducerAlgoForTracker::h_nchi2_prob
std::vector< MonitorElement * > h_nchi2_prob
Definition: MTVHistoProducerAlgoForTracker.h:262
MTVHistoProducerAlgoForTracker::fill_dedx_recoTrack_histos
void fill_dedx_recoTrack_histos(int count, edm::RefToBase< reco::Track > &trackref, const std::vector< edm::ValueMap< reco::DeDxData > > &v_dEdx)
Definition: MTVHistoProducerAlgoForTracker.cc:1008
MTVHistoProducerAlgoForTracker::h_looperpT
std::vector< MonitorElement * > h_looperpT
Definition: MTVHistoProducerAlgoForTracker.h:159
MTVHistoProducerAlgoForTracker::h_pullDz
std::vector< MonitorElement * > h_pullDz
Definition: MTVHistoProducerAlgoForTracker.h:166
FitSlicesYTool::getFittedSigmaWithError
void getFittedSigmaWithError(MonitorElement *)
Fill the ME with the sigma value (with error) of the gaussian fit in each slice.
Definition: FitSlicesYTool.cc:71
MTVHistoProducerAlgoForTracker::TpSelectorForEfficiencyVsPhi
TrackingParticleSelector * TpSelectorForEfficiencyVsPhi
Definition: MTVHistoProducerAlgoForTracker.h:120
MTVHistoProducerAlgo::fillPlotFromVectors
void fillPlotFromVectors(MonitorElement *h, std::vector< int > &numerator, std::vector< int > &denominator, std::string type)
Definition: MTVHistoProducerAlgo.cc:20
MTVHistoProducerAlgoForTracker::ptpull_vs_phi
std::vector< MonitorElement * > ptpull_vs_phi
Definition: MTVHistoProducerAlgoForTracker.h:296
MTVHistoProducerAlgoForTracker::h_assoczpos
std::vector< MonitorElement * > h_assoczpos
Definition: MTVHistoProducerAlgoForTracker.h:165
MTVHistoProducerAlgoForTracker::totASS_phi
std::vector< std::vector< int > > totASS_phi
Definition: MTVHistoProducerAlgoForTracker.h:235
MTVHistoProducerAlgoForTracker::nPXFhits_vs_eta
std::vector< MonitorElement * > nPXFhits_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:209
MTVHistoProducerAlgoForTracker::totSIM_vertz_fwdpos
std::vector< std::vector< int > > totSIM_vertz_fwdpos
Definition: MTVHistoProducerAlgoForTracker.h:246
reco::TrackBase::momentum
const Vector & momentum() const
track momentum vector
Definition: TrackBase.h:148
MTVHistoProducerAlgoForTracker::h_fake_vs_hit
std::vector< MonitorElement * > h_fake_vs_hit
Definition: MTVHistoProducerAlgoForTracker.h:160
MTVHistoProducerAlgoForTracker::h_dzmeanh
std::vector< MonitorElement * > h_dzmeanh
Definition: MTVHistoProducerAlgoForTracker.h:290
MTVHistoProducerAlgoForTracker::h_assoc2_ootpu_vertcount
std::vector< MonitorElement * > h_assoc2_ootpu_vertcount
Definition: MTVHistoProducerAlgoForTracker.h:185
MTVHistoProducerAlgoForTracker::totRECeta
std::vector< std::vector< int > > totRECeta
Definition: MTVHistoProducerAlgoForTracker.h:232
MTVHistoProducerAlgoForTracker::h_misidratephi
std::vector< MonitorElement * > h_misidratephi
Definition: MTVHistoProducerAlgoForTracker.h:161
MTVHistoProducerAlgo::doProfileX
void doProfileX(TH2 *th2, MonitorElement *me)
Definition: MTVHistoProducerAlgo.cc:3
MTVHistoProducerAlgoForTracker::h_simulzpos
std::vector< MonitorElement * > h_simulzpos
Definition: MTVHistoProducerAlgoForTracker.h:165
MTVHistoProducerAlgoForTracker::totASSeta
std::vector< std::vector< int > > totASSeta
Definition: MTVHistoProducerAlgoForTracker.h:232
MTVHistoProducerAlgoForTracker::nrecHit_vs_nsimHit_rec2sim
std::vector< MonitorElement * > nrecHit_vs_nsimHit_rec2sim
Definition: MTVHistoProducerAlgoForTracker.h:203
MTVHistoProducerAlgoForTracker::vertposintervals
std::vector< std::vector< double > > vertposintervals
Definition: MTVHistoProducerAlgoForTracker.h:229
MTVHistoProducerAlgoForTracker::totASS2_itpu_eta_entire
std::vector< std::vector< int > > totASS2_itpu_eta_entire
Definition: MTVHistoProducerAlgoForTracker.h:254
MTVHistoProducerAlgoForTracker::totCONeta
std::vector< std::vector< int > > totCONeta
Definition: MTVHistoProducerAlgoForTracker.h:256
MTVHistoProducerAlgoForTracker::h_effic_vertz_fwdpos
std::vector< MonitorElement * > h_effic_vertz_fwdpos
Definition: MTVHistoProducerAlgoForTracker.h:173
MTVHistoProducerAlgoForTracker::h_assoc2pT
std::vector< MonitorElement * > h_assoc2pT
Definition: MTVHistoProducerAlgoForTracker.h:159
DQMStore::book1D
MonitorElement * book1D(const char *name, const char *title, int nchX, double lowX, double highX)
Book 1D histogram.
Definition: DQMStore.cc:872
MTVHistoProducerAlgoForTracker::h_nmisslayers_inner
std::vector< MonitorElement * > h_nmisslayers_inner
Definition: MTVHistoProducerAlgoForTracker.h:262
reco::GsfTrack::lambdaMode
double lambdaMode() const
Lambda angle from mode.
Definition: GsfTrack.h:44
MTVHistoProducerAlgoForTracker::h_simulpT
std::vector< MonitorElement * > h_simulpT
Definition: MTVHistoProducerAlgoForTracker.h:159
MTVHistoProducerAlgoForTracker::h_effic_vertz_barrel
std::vector< MonitorElement * > h_effic_vertz_barrel
Definition: MTVHistoProducerAlgoForTracker.h:172
MTVHistoProducerAlgo::fillPlotFromVector
void fillPlotFromVector(MonitorElement *h, std::vector< int > &vec)
Definition: MTVHistoProducerAlgo.cc:14
MTVHistoProducerAlgoForTracker::h_ptshifteta
std::vector< MonitorElement * > h_ptshifteta
Definition: MTVHistoProducerAlgoForTracker.h:266
reco::TrackBase::normalizedChi2
double normalizedChi2() const
chi-squared divided by n.d.o.f. (or chi-squared * 1e6 if n.d.o.f. is zero)
Definition: TrackBase.h:109
MTVHistoProducerAlgoForTracker::getRecoMomentum
void getRecoMomentum(const reco::Track &track, double &pt, double &ptError, double &qoverp, double &qoverpError, double &lambda, double &lambdaError, double &phi, double &phiError) const
retrieval of reconstructed momentum components from reco::Track (== mean values for GSF) ...
Definition: MTVHistoProducerAlgoForTracker.cc:1397
MTVHistoProducerAlgoForTracker::GpSelectorForEfficiencyVsPhi
GenParticleCustomSelector * GpSelectorForEfficiencyVsPhi
Definition: MTVHistoProducerAlgoForTracker.h:128
MTVHistoProducerAlgoForTracker::nTEChits_vs_eta
std::vector< MonitorElement * > nTEChits_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:209
MTVHistoProducerAlgoForTracker::h_reco_ootpu_entire
std::vector< MonitorElement * > h_reco_ootpu_entire
Definition: MTVHistoProducerAlgoForTracker.h:176
MTVHistoProducerAlgoForTracker::h_fakerate_vertcount_barrel
std::vector< MonitorElement * > h_fakerate_vertcount_barrel
Definition: MTVHistoProducerAlgoForTracker.h:168
MTVHistoProducerAlgoForTracker::totSIM_vertz_entire
std::vector< std::vector< int > > totSIM_vertz_entire
Definition: MTVHistoProducerAlgoForTracker.h:244
MTVHistoProducerAlgoForTracker::h_fake_vs_dz
std::vector< MonitorElement * > h_fake_vs_dz
Definition: MTVHistoProducerAlgoForTracker.h:163
MTVHistoProducerAlgoForTracker::h_hits
std::vector< MonitorElement * > h_hits
Definition: MTVHistoProducerAlgoForTracker.h:157
MTVHistoProducerAlgoForTracker::h_assoc_vertcount_fwdneg
std::vector< MonitorElement * > h_assoc_vertcount_fwdneg
Definition: MTVHistoProducerAlgoForTracker.h:170
MTVHistoProducerAlgoForTracker::h_effic_vs_vertpos
std::vector< MonitorElement * > h_effic_vs_vertpos
Definition: MTVHistoProducerAlgoForTracker.h:165
MTVHistoProducerAlgoForTracker::dxyintervals
std::vector< std::vector< double > > dxyintervals
Definition: MTVHistoProducerAlgoForTracker.h:227
reco::TrackBase::theta
double theta() const
polar angle
Definition: TrackBase.h:115
reco::TrackBase::dxyError
double dxyError() const
error on dxy
Definition: TrackBase.h:207
MTVHistoProducerAlgoForTracker::nLayersWithMeas_vs_eta
std::vector< MonitorElement * > nLayersWithMeas_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:209
MTVHistoProducerAlgoForTracker::h_pullPhi
std::vector< MonitorElement * > h_pullPhi
Definition: MTVHistoProducerAlgoForTracker.h:166
MTVHistoProducerAlgoForTracker::h_fomt_vertcount
std::vector< MonitorElement * > h_fomt_vertcount
Definition: MTVHistoProducerAlgoForTracker.h:180
MTVHistoProducerAlgoForTracker::totASS_vertcount_barrel
std::vector< std::vector< int > > totASS_vertcount_barrel
Definition: MTVHistoProducerAlgoForTracker.h:241
MTVHistoProducerAlgoForTracker::h_fake_vs_dxy
std::vector< MonitorElement * > h_fake_vs_dxy
Definition: MTVHistoProducerAlgoForTracker.h:162
MTVHistoProducerAlgoForTracker::phipull_vs_phi
std::vector< MonitorElement * > phipull_vs_phi
Definition: MTVHistoProducerAlgoForTracker.h:296
MTVHistoProducerAlgoForTracker::h_dedx_sat1
std::vector< MonitorElement * > h_dedx_sat1
Definition: MTVHistoProducerAlgoForTracker.h:197
MTVHistoProducerAlgoForTracker::h_hits_eta
std::vector< MonitorElement * > h_hits_eta
Definition: MTVHistoProducerAlgoForTracker.h:217
MTVHistoProducerAlgoForTracker::h_effic_vertcount_fwdpos
std::vector< MonitorElement * > h_effic_vertcount_fwdpos
Definition: MTVHistoProducerAlgoForTracker.h:169
MTVHistoProducerAlgoForTracker::h_thetapullphi
std::vector< MonitorElement * > h_thetapullphi
Definition: MTVHistoProducerAlgoForTracker.h:298
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
MTVHistoProducerAlgoForTracker::nrec_vs_nsim
std::vector< MonitorElement * > nrec_vs_nsim
Definition: MTVHistoProducerAlgoForTracker.h:201
MTVHistoProducerAlgoForTracker::h_ptrmshPt
std::vector< MonitorElement * > h_ptrmshPt
Definition: MTVHistoProducerAlgoForTracker.h:286
MTVHistoProducerAlgoForTracker::fill_generic_recoTrack_histos
void fill_generic_recoTrack_histos(int count, const reco::Track &track, const math::XYZPoint &bsPosition, bool isMatched, bool isSigMatched, bool isChargeMatched, int numAssocRecoTracks, int numVertices, int tpbunchcrossing, int nSimHits, double sharedFraction)
Definition: MTVHistoProducerAlgoForTracker.cc:1033
MTVHistoProducerAlgoForTracker::h_fakerate_ootpu_barrel
std::vector< MonitorElement * > h_fakerate_ootpu_barrel
Definition: MTVHistoProducerAlgoForTracker.h:177
MTVHistoProducerAlgoForTracker::h_algo
std::vector< MonitorElement * > h_algo
Definition: MTVHistoProducerAlgoForTracker.h:175
MTVHistoProducerAlgoForTracker::h_assocdz
std::vector< MonitorElement * > h_assocdz
Definition: MTVHistoProducerAlgoForTracker.h:163
MTVHistoProducerAlgoForTracker::totREC_dz
std::vector< std::vector< int > > totREC_dz
Definition: MTVHistoProducerAlgoForTracker.h:237
MTVHistoProducerAlgoForTracker::totASS2_phi
std::vector< std::vector< int > > totASS2_phi
Definition: MTVHistoProducerAlgoForTracker.h:235
reco::HitPattern::pixelLayersWithMeasurement
int pixelLayersWithMeasurement() const
Definition: HitPattern.h:745
MTVHistoProducerAlgoForTracker::h_assoc_vertcount_fwdpos
std::vector< MonitorElement * > h_assoc_vertcount_fwdpos
Definition: MTVHistoProducerAlgoForTracker.h:169
MTVHistoProducerAlgoForTracker::nTIDhits_vs_eta
std::vector< MonitorElement * > nTIDhits_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:209
MTVHistoProducerAlgoForTracker::totREC_vertcount_entire
std::vector< std::vector< int > > totREC_vertcount_entire
Definition: MTVHistoProducerAlgoForTracker.h:240
MTVHistoProducerAlgoForTracker::h_ptSIM
std::vector< MonitorElement * > h_ptSIM
Definition: MTVHistoProducerAlgoForTracker.h:154
MTVHistoProducerAlgoForTracker::h_dxypulletamean
std::vector< MonitorElement * > h_dxypulletamean
Definition: MTVHistoProducerAlgoForTracker.h:299
MTVHistoProducerAlgoForTracker::totASS2_vertcount_entire
std::vector< std::vector< int > > totASS2_vertcount_entire
Definition: MTVHistoProducerAlgoForTracker.h:240
MTVHistoProducerAlgoForTracker::totREC_algo
std::vector< std::vector< int > > totREC_algo
Definition: MTVHistoProducerAlgoForTracker.h:248
MTVHistoProducerAlgoForTracker::phires_vs_eta
std::vector< MonitorElement * > phires_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:282
MTVHistoProducerAlgoForTracker::h_pullDxy
std::vector< MonitorElement * > h_pullDxy
Definition: MTVHistoProducerAlgoForTracker.h:166
MTVHistoProducerAlgoForTracker::h_assoc2phi
std::vector< MonitorElement * > h_assoc2phi
Definition: MTVHistoProducerAlgoForTracker.h:161
MTVHistoProducerAlgoForTracker::totASS_dxy
std::vector< std::vector< int > > totASS_dxy
Definition: MTVHistoProducerAlgoForTracker.h:236
MTVHistoProducerAlgoForTracker::h_phipullphi
std::vector< MonitorElement * > h_phipullphi
Definition: MTVHistoProducerAlgoForTracker.h:298
MTVHistoProducerAlgoForTracker::h_nchi2
std::vector< MonitorElement * > h_nchi2
Definition: MTVHistoProducerAlgoForTracker.h:262
MTVHistoProducerAlgoForTracker::h_fakeratePt
std::vector< MonitorElement * > h_fakeratePt
Definition: MTVHistoProducerAlgoForTracker.h:159
reco::TrackBase::phi
double phi() const
azimuthal angle of momentum vector
Definition: TrackBase.h:137
reco::TrackBase::numberOfLostHits
unsigned short numberOfLostHits() const
number of cases where track crossed a layer without getting a hit.
Definition: TrackBase.h:232
MTVHistoProducerAlgoForTracker::totSIM_vertcount_entire
std::vector< std::vector< int > > totSIM_vertcount_entire
Definition: MTVHistoProducerAlgoForTracker.h:240
MTVHistoProducerAlgoForTracker::TpSelectorForEfficiencyVsVTXZ
TrackingParticleSelector * TpSelectorForEfficiencyVsVTXZ
Definition: MTVHistoProducerAlgoForTracker.h:123
MTVHistoProducerAlgoForTracker::h_dxyrmsh
std::vector< MonitorElement * > h_dxyrmsh
Definition: MTVHistoProducerAlgoForTracker.h:285
MTVHistoProducerAlgoForTracker::h_simul_vertcount_fwdpos
std::vector< MonitorElement * > h_simul_vertcount_fwdpos
Definition: MTVHistoProducerAlgoForTracker.h:169
MTVHistoProducerAlgoForTracker::totmisid_dxy
std::vector< std::vector< int > > totmisid_dxy
Definition: MTVHistoProducerAlgoForTracker.h:236
MTVHistoProducerAlgoForTracker::h_dzrmshPt
std::vector< MonitorElement * > h_dzrmshPt
Definition: MTVHistoProducerAlgoForTracker.h:286
MTVHistoProducerAlgoForTracker::h_vertposSIM
std::vector< MonitorElement * > h_vertposSIM
Definition: MTVHistoProducerAlgoForTracker.h:154
MTVHistoProducerAlgoForTracker::h_looperdxy
std::vector< MonitorElement * > h_looperdxy
Definition: MTVHistoProducerAlgoForTracker.h:162
MTVHistoProducerAlgoForTracker::h_simuleta
std::vector< MonitorElement * > h_simuleta
Definition: MTVHistoProducerAlgoForTracker.h:158
MTVHistoProducerAlgoForTracker::h_misidratepT
std::vector< MonitorElement * > h_misidratepT
Definition: MTVHistoProducerAlgoForTracker.h:159
MTVHistoProducerAlgoForTracker::totSIM_dz
std::vector< std::vector< int > > totSIM_dz
Definition: MTVHistoProducerAlgoForTracker.h:237
MTVHistoProducerAlgoForTracker::fill_recoAssociated_simTrack_histos
void fill_recoAssociated_simTrack_histos(int count, const TrackingParticle &tp, const TrackingParticle::Vector &momentumTP, const TrackingParticle::Point &vertexTP, double dxy, double dz, int nSimHits, const reco::Track *track, int numVertices, double vertz)
Definition: MTVHistoProducerAlgoForTracker.cc:837
MTVHistoProducerAlgoForTracker::h_ptpulleta
std::vector< MonitorElement * > h_ptpulleta
Definition: MTVHistoProducerAlgoForTracker.h:297
MTVHistoProducerAlgoForTracker::h_effic_PU_eta
std::vector< MonitorElement * > h_effic_PU_eta
Definition: MTVHistoProducerAlgoForTracker.h:187
MTVHistoProducerAlgoForTracker::h_assoc2_ootpu_fwdneg
std::vector< MonitorElement * > h_assoc2_ootpu_fwdneg
Definition: MTVHistoProducerAlgoForTracker.h:179
MTVHistoProducerAlgoForTracker::h_assoc2_vertcount_fwdneg
std::vector< MonitorElement * > h_assoc2_vertcount_fwdneg
Definition: MTVHistoProducerAlgoForTracker.h:170
MTVHistoProducerAlgoForTracker::h_fomt_sig_vertcount
std::vector< MonitorElement * > h_fomt_sig_vertcount
Definition: MTVHistoProducerAlgoForTracker.h:180
eta
T eta() const
Definition: Basic3DVectorLD.h:179
MTVHistoProducerAlgoForTracker::h_assoc_vertz_fwdneg
std::vector< MonitorElement * > h_assoc_vertz_fwdneg
Definition: MTVHistoProducerAlgoForTracker.h:174
MTVHistoProducerAlgoForTracker::h_TIBhits_eta
std::vector< MonitorElement * > h_TIBhits_eta
Definition: MTVHistoProducerAlgoForTracker.h:217
MTVHistoProducerAlgoForTracker::h_thetapullphimean
std::vector< MonitorElement * > h_thetapullphimean
Definition: MTVHistoProducerAlgoForTracker.h:300
MTVHistoProducerAlgoForTracker::h_fomt_ootpu_eta
std::vector< MonitorElement * > h_fomt_ootpu_eta
Definition: MTVHistoProducerAlgoForTracker.h:182
MTVHistoProducerAlgoForTracker::h_cotThetameanhPt
std::vector< MonitorElement * > h_cotThetameanhPt
Definition: MTVHistoProducerAlgoForTracker.h:291
MTVHistoProducerAlgoForTracker::totFOMT_eta
std::vector< std::vector< int > > totFOMT_eta
Definition: MTVHistoProducerAlgoForTracker.h:255
MTVHistoProducerAlgoForTracker::h_phimeanhPhi
std::vector< MonitorElement * > h_phimeanhPhi
Definition: MTVHistoProducerAlgoForTracker.h:292
MTVHistoProducerAlgoForTracker::fill_trackBased_histos
void fill_trackBased_histos(int count, int assTracks, int numRecoTracks, int numSimTracks)
Definition: MTVHistoProducerAlgoForTracker.cc:1206
MTVHistoProducerAlgoForTracker::h_misidratedz
std::vector< MonitorElement * > h_misidratedz
Definition: MTVHistoProducerAlgoForTracker.h:163
MTVHistoProducerAlgoForTracker::h_assoc2dz
std::vector< MonitorElement * > h_assoc2dz
Definition: MTVHistoProducerAlgoForTracker.h:163
MTVHistoProducerAlgoForTracker::chi2_vs_phi
std::vector< MonitorElement * > chi2_vs_phi
Definition: MTVHistoProducerAlgoForTracker.h:267
MTVHistoProducerAlgoForTracker::h_fomt_eta
std::vector< MonitorElement * > h_fomt_eta
Definition: MTVHistoProducerAlgoForTracker.h:180
MTVHistoProducerAlgoForTracker::h_LayersWithMeas_eta
std::vector< MonitorElement * > h_LayersWithMeas_eta
Definition: MTVHistoProducerAlgoForTracker.h:217
reco::HitPattern::numberOfValidStripTOBHits
int numberOfValidStripTOBHits() const
Definition: HitPattern.h:625
MTVHistoProducerAlgoForTracker::totASS_zpos
std::vector< std::vector< int > > totASS_zpos
Definition: MTVHistoProducerAlgoForTracker.h:239
MTVHistoProducerAlgoForTracker::totloop_dxy
std::vector< std::vector< int > > totloop_dxy
Definition: MTVHistoProducerAlgoForTracker.h:236
MTVHistoProducerAlgoForTracker::totASS2etaSig
std::vector< std::vector< int > > totASS2etaSig
Definition: MTVHistoProducerAlgoForTracker.h:232
MTVHistoProducerAlgoForTracker::totASS2_vertcount_barrel
std::vector< std::vector< int > > totASS2_vertcount_barrel
Definition: MTVHistoProducerAlgoForTracker.h:241
MTVHistoProducerAlgoForTracker::h_chi2mean_vs_phi
std::vector< MonitorElement * > h_chi2mean_vs_phi
Definition: MTVHistoProducerAlgoForTracker.h:279
MTVHistoProducerAlgoForTracker::h_assocphi
std::vector< MonitorElement * > h_assocphi
Definition: MTVHistoProducerAlgoForTracker.h:161
EgAmbiguityTools::sharedHits
int sharedHits(const reco::GsfTrackRef &, const reco::GsfTrackRef &)
Definition: EgAmbiguityTools.cc:66
MTVHistoProducerAlgoForTracker::h_cotThetarmsh
std::vector< MonitorElement * > h_cotThetarmsh
Definition: MTVHistoProducerAlgoForTracker.h:285
MTVHistoProducerAlgoForTracker::phires_vs_phi
std::vector< MonitorElement * > phires_vs_phi
Definition: MTVHistoProducerAlgoForTracker.h:267
MTVHistoProducerAlgoForTracker::MTVHistoProducerAlgoForTracker
MTVHistoProducerAlgoForTracker(const edm::ParameterSet &pset, edm::ConsumesCollector &&iC)
Definition: MTVHistoProducerAlgoForTracker.h:27
MTVHistoProducerAlgoForTracker::dzres_vs_eta
std::vector< MonitorElement * > dzres_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:282
MTVHistoProducerAlgoForTracker::h_losthits_eta
std::vector< MonitorElement * > h_losthits_eta
Definition: MTVHistoProducerAlgoForTracker.h:277
reco::GsfTrack::qoverpMode
double qoverpMode() const
q/p from mode
Definition: GsfTrack.h:40
MTVHistoProducerAlgoForTracker::h_ptmeanhPhi
std::vector< MonitorElement * > h_ptmeanhPhi
Definition: MTVHistoProducerAlgoForTracker.h:292
MTVHistoProducerAlgoForTracker::totSIM_hit
std::vector< std::vector< int > > totSIM_hit
Definition: MTVHistoProducerAlgoForTracker.h:234
MTVHistoProducerAlgoForTracker::h_misideta
std::vector< MonitorElement * > h_misideta
Definition: MTVHistoProducerAlgoForTracker.h:158
MTVHistoProducerAlgoForTracker::nlosthits_vs_eta
std::vector< MonitorElement * > nlosthits_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:276
MTVHistoProducerAlgoForTracker::GpSelectorForEfficiencyVsVTXZ
GenParticleCustomSelector * GpSelectorForEfficiencyVsVTXZ
Definition: MTVHistoProducerAlgoForTracker.h:131
MTVHistoProducerAlgoForTracker::nSTRIPlayersWith1dMeas_vs_eta
std::vector< MonitorElement * > nSTRIPlayersWith1dMeas_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:209
MTVHistoProducerAlgoForTracker::h_phimeanh
std::vector< MonitorElement * > h_phimeanh
Definition: MTVHistoProducerAlgoForTracker.h:290
reco::GsfTrack::ptModeError
double ptModeError() const
error on Pt (set to 1000 TeV if charge==0 for safety) from mode
Definition: GsfTrack.h:80
MTVHistoProducerAlgoForTracker::h_recohit
std::vector< MonitorElement * > h_recohit
Definition: MTVHistoProducerAlgoForTracker.h:160
reco::TrackBase::algo
TrackAlgorithm algo() const
Definition: TrackBase.h:330
MTVHistoProducerAlgoForTracker::h_reco_vertcount_entire
std::vector< MonitorElement * > h_reco_vertcount_entire
Definition: MTVHistoProducerAlgoForTracker.h:167
MTVHistoProducerAlgoForTracker::h_thetapulleta
std::vector< MonitorElement * > h_thetapulleta
Definition: MTVHistoProducerAlgoForTracker.h:297
TrackingParticle::Point
math::XYZPointD Point
point in the space
Definition: TrackingParticle.h:36
MTVHistoProducerAlgoForTracker::h_fakerate_vertcount_entire
std::vector< MonitorElement * > h_fakerate_vertcount_entire
Definition: MTVHistoProducerAlgoForTracker.h:167
MTVHistoProducerAlgoForTracker::totSIM_zpos
std::vector< std::vector< int > > totSIM_zpos
Definition: MTVHistoProducerAlgoForTracker.h:239
MTVHistoProducerAlgoForTracker::totASSpT
std::vector< std::vector< int > > totASSpT
Definition: MTVHistoProducerAlgoForTracker.h:233
MTVHistoProducerAlgoForTracker::totSIM_vertz_fwdneg
std::vector< std::vector< int > > totSIM_vertz_fwdneg
Definition: MTVHistoProducerAlgoForTracker.h:247
MTVHistoProducerAlgoForTracker::totASS2_vertcount_fwdneg
std::vector< std::vector< int > > totASS2_vertcount_fwdneg
Definition: MTVHistoProducerAlgoForTracker.h:243
MTVHistoProducerAlgoForTracker::h_phipullphimean
std::vector< MonitorElement * > h_phipullphimean
Definition: MTVHistoProducerAlgoForTracker.h:300
MTVHistoProducerAlgoForTracker::h_dedx_estim1
std::vector< MonitorElement * > h_dedx_estim1
Definition: MTVHistoProducerAlgoForTracker.h:193
MTVHistoProducerAlgoForTracker::h_hits_phi
std::vector< MonitorElement * > h_hits_phi
Definition: MTVHistoProducerAlgoForTracker.h:278
MTVHistoProducerAlgoForTracker::totASS2_ootpu_fwdneg
std::vector< std::vector< int > > totASS2_ootpu_fwdneg
Definition: MTVHistoProducerAlgoForTracker.h:252
MTVHistoProducerAlgoForTracker::phires_vs_pt
std::vector< MonitorElement * > phires_vs_pt
Definition: MTVHistoProducerAlgoForTracker.h:283
MTVHistoProducerAlgoForTracker::h_reco_ootpu_fwdneg
std::vector< MonitorElement * > h_reco_ootpu_fwdneg
Definition: MTVHistoProducerAlgoForTracker.h:179
reco::modules::TrackingParticleSelector
SingleObjectSelector< TrackingParticleCollection,::TrackingParticleSelector > TrackingParticleSelector
Definition: TrackingParticleSelector.cc:18
MTVHistoProducerAlgoForTracker::totlooppT
std::vector< std::vector< int > > totlooppT
Definition: MTVHistoProducerAlgoForTracker.h:233
MTVHistoProducerAlgoForTracker::totloop_hit
std::vector< std::vector< int > > totloop_hit
Definition: MTVHistoProducerAlgoForTracker.h:234
MTVHistoProducerAlgoForTracker::fill_ResoAndPull_recoTrack_histos
void fill_ResoAndPull_recoTrack_histos(int count, const TrackingParticle::Vector &momentumTP, const TrackingParticle::Point &vertexTP, int chargeTP, const reco::Track &track, const math::XYZPoint &bsPosition)
Definition: MTVHistoProducerAlgoForTracker.cc:1216
MTVHistoProducerAlgoForTracker::h_STRIPlayersWithMeas_eta
std::vector< MonitorElement * > h_STRIPlayersWithMeas_eta
Definition: MTVHistoProducerAlgoForTracker.h:217
MTVHistoProducerAlgoForTracker::totASS2eta
std::vector< std::vector< int > > totASS2eta
Definition: MTVHistoProducerAlgoForTracker.h:232
MTVHistoProducerAlgoForTracker::h_assoc2_ootpu_fwdpos
std::vector< MonitorElement * > h_assoc2_ootpu_fwdpos
Definition: MTVHistoProducerAlgoForTracker.h:178
reco::TrackBase::trackerExpectedHitsOuter
const HitPattern & trackerExpectedHitsOuter() const
Access the hit pattern counting (in the Tracker) the number of expected crossed layers after the last...
Definition: TrackBase.h:225
MTVHistoProducerAlgoForTracker::nPXBhits_vs_eta
std::vector< MonitorElement * > nPXBhits_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:209
reco::TrackBase::eta
double eta() const
pseudorapidity of momentum vector
Definition: TrackBase.h:139
MTVHistoProducerAlgoForTracker::totASS_hit
std::vector< std::vector< int > > totASS_hit
Definition: MTVHistoProducerAlgoForTracker.h:234
MTVHistoProducerAlgoForTracker::totASS2_vertcount_entire_signal
std::vector< std::vector< int > > totASS2_vertcount_entire_signal
Definition: MTVHistoProducerAlgoForTracker.h:240
MTVHistoProducerAlgoForTracker::totASS2_itpu_vertcount_entire
std::vector< std::vector< int > > totASS2_itpu_vertcount_entire
Definition: MTVHistoProducerAlgoForTracker.h:254
MTVHistoProducerAlgoForTracker::h_assoc2dxy
std::vector< MonitorElement * > h_assoc2dxy
Definition: MTVHistoProducerAlgoForTracker.h:162
MTVHistoProducerAlgoForTracker::h_dxyrmshPt
std::vector< MonitorElement * > h_dxyrmshPt
Definition: MTVHistoProducerAlgoForTracker.h:286
MTVHistoProducerAlgoForTracker::h_STRIPlayersWith1dMeas_eta
std::vector< MonitorElement * > h_STRIPlayersWith1dMeas_eta
Definition: MTVHistoProducerAlgoForTracker.h:217
MTVHistoProducerAlgoForTracker::h_pullQoverp
std::vector< MonitorElement * > h_pullQoverp
Definition: MTVHistoProducerAlgoForTracker.h:166
reco::HitPattern::numberOfValidPixelBarrelHits
int numberOfValidPixelBarrelHits() const
Definition: HitPattern.h:605
MTVHistoProducerAlgoForTracker::totSIM_phi
std::vector< std::vector< int > > totSIM_phi
Definition: MTVHistoProducerAlgoForTracker.h:235
MTVHistoProducerAlgoForTracker::totASS2pT
std::vector< std::vector< int > > totASS2pT
Definition: MTVHistoProducerAlgoForTracker.h:233
MTVHistoProducerAlgoForTracker::h_fake_vs_phi
std::vector< MonitorElement * > h_fake_vs_phi
Definition: MTVHistoProducerAlgoForTracker.h:161
MTVHistoProducerAlgoForTracker::h_ptpulletamean
std::vector< MonitorElement * > h_ptpulletamean
Definition: MTVHistoProducerAlgoForTracker.h:299
reco::TrackBase::chi2
double chi2() const
chi-squared of the fit
Definition: TrackBase.h:105
MTVHistoProducerAlgoForTracker::h_misidhit
std::vector< MonitorElement * > h_misidhit
Definition: MTVHistoProducerAlgoForTracker.h:160
MTVHistoProducerAlgoForTracker::nSTRIPlayersWithMeas_vs_eta
std::vector< MonitorElement * > nSTRIPlayersWithMeas_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:209
MTVHistoProducerAlgoForTracker::nTOBhits_vs_eta
std::vector< MonitorElement * > nTOBhits_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:209
MTVHistoProducerAlgoForTracker::totASS_dz
std::vector< std::vector< int > > totASS_dz
Definition: MTVHistoProducerAlgoForTracker.h:237
reco::TrackBase::ndof
double ndof() const
number of degrees of freedom of the fit
Definition: TrackBase.h:107
reco::HitPattern::trackerLayersWithMeasurement
int trackerLayersWithMeasurement() const
Definition: HitPattern.h:740
MTVHistoProducerAlgoForTracker::totASS_vertz_barrel
std::vector< std::vector< int > > totASS_vertz_barrel
Definition: MTVHistoProducerAlgoForTracker.h:245
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:48
MTVHistoProducerAlgoForTracker::ptpull_vs_eta
std::vector< MonitorElement * > ptpull_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:295
MTVHistoProducerAlgoForTracker::etares_vs_eta
std::vector< MonitorElement * > etares_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:265
MTVHistoProducerAlgoForTracker::h_fakerate_ootpu_fwdneg
std::vector< MonitorElement * > h_fakerate_ootpu_fwdneg
Definition: MTVHistoProducerAlgoForTracker.h:179
reco::TrackBase::pt
double pt() const
track transverse momentum
Definition: TrackBase.h:129
MTVHistoProducerAlgoForTracker::h_recophi
std::vector< MonitorElement * > h_recophi
Definition: MTVHistoProducerAlgoForTracker.h:161
MTVHistoProducerAlgoForTracker::h_misidratehit
std::vector< MonitorElement * > h_misidratehit
Definition: MTVHistoProducerAlgoForTracker.h:160
MTVHistoProducerAlgoForTracker::h_assocpT
std::vector< MonitorElement * > h_assocpT
Definition: MTVHistoProducerAlgoForTracker.h:159
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
MTVHistoProducerAlgoForTracker::h_ptpullphimean
std::vector< MonitorElement * > h_ptpullphimean
Definition: MTVHistoProducerAlgoForTracker.h:300
reco::TrackBase::ptError
double ptError() const
error on Pt (set to 1000 TeV if charge==0 for safety)
Definition: TrackBase.h:192
MTVHistoProducerAlgoForTracker::h_simul_vertz_barrel
std::vector< MonitorElement * > h_simul_vertz_barrel
Definition: MTVHistoProducerAlgoForTracker.h:172
MTVHistoProducerAlgoForTracker::totASS_vertcount_entire
std::vector< std::vector< int > > totASS_vertcount_entire
Definition: MTVHistoProducerAlgoForTracker.h:240
MTVHistoProducerAlgoForTracker::nSTRIPlayersWith2dMeas_vs_eta
std::vector< MonitorElement * > nSTRIPlayersWith2dMeas_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:209
MTVHistoProducerAlgoForTracker::h_tracks
std::vector< MonitorElement * > h_tracks
Definition: MTVHistoProducerAlgoForTracker.h:157
MTVHistoProducerAlgoForTracker::h_chi2meanh
std::vector< MonitorElement * > h_chi2meanh
Definition: MTVHistoProducerAlgoForTracker.h:277
reco::TrackBase::phiError
double phiError() const
error on phi
Definition: TrackBase.h:205
MTVHistoProducerAlgoForTracker::h_TIDhits_eta
std::vector< MonitorElement * > h_TIDhits_eta
Definition: MTVHistoProducerAlgoForTracker.h:217
MTVHistoProducerAlgoForTracker::h_tracksSIM
std::vector< MonitorElement * > h_tracksSIM
Definition: MTVHistoProducerAlgoForTracker.h:154
MTVHistoProducerAlgoForTracker::h_effic_vertcount_entire
std::vector< MonitorElement * > h_effic_vertcount_entire
Definition: MTVHistoProducerAlgoForTracker.h:167
MTVHistoProducerAlgoForTracker::h_effic
std::vector< MonitorElement * > h_effic
Definition: MTVHistoProducerAlgoForTracker.h:158
funct::tan
Tan< T >::type tan(const T &t)
Definition: Tan.h:22
MTVHistoProducerAlgoForTracker::nhits_vs_phi
std::vector< MonitorElement * > nhits_vs_phi
Definition: MTVHistoProducerAlgoForTracker.h:267
MTVHistoProducerAlgoForTracker::totloopeta
std::vector< std::vector< int > > totloopeta
Definition: MTVHistoProducerAlgoForTracker.h:232
reco::HitPattern::numberOfHits
int numberOfHits() const
Definition: HitPattern.cc:211
MTVHistoProducerAlgoForTracker::totASS2_dz
std::vector< std::vector< int > > totASS2_dz
Definition: MTVHistoProducerAlgoForTracker.h:237
reco::HitPattern::numberOfValidStripTIDHits
int numberOfValidStripTIDHits() const
Definition: HitPattern.h:621
reco::TrackBase::lambda
double lambda() const
Lambda angle.
Definition: TrackBase.h:117
MTVHistoProducerAlgoForTracker::totSIM_vertpos
std::vector< std::vector< int > > totSIM_vertpos
Definition: MTVHistoProducerAlgoForTracker.h:239
MTVHistoProducerAlgoForTracker::h_simul_vertcount_barrel
std::vector< MonitorElement * > h_simul_vertcount_barrel
Definition: MTVHistoProducerAlgoForTracker.h:168
MTVHistoProducerAlgoForTracker::totREC_ootpu_entire
std::vector< std::vector< int > > totREC_ootpu_entire
Definition: MTVHistoProducerAlgoForTracker.h:249
MTVHistoProducerAlgoForTracker::h_ptmeanhPt
std::vector< MonitorElement * > h_ptmeanhPt
Definition: MTVHistoProducerAlgoForTracker.h:291
MTVHistoProducerAlgoForTracker::h_phirmsh
std::vector< MonitorElement * > h_phirmsh
Definition: MTVHistoProducerAlgoForTracker.h:285
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
MTVHistoProducerAlgoForTracker::nrecHit_vs_nsimHit_sim2rec
std::vector< MonitorElement * > nrecHit_vs_nsimHit_sim2rec
Definition: MTVHistoProducerAlgoForTracker.h:202
trackerHitRTTI::isMatched
bool isMatched(TrackingRecHit const &hit)
Definition: BaseTrackerRecHit.h:17
MTVHistoProducerAlgoForTracker::totRECpT
std::vector< std::vector< int > > totRECpT
Definition: MTVHistoProducerAlgoForTracker.h:233
MTVHistoProducerAlgoForTracker::totmisid_phi
std::vector< std::vector< int > > totmisid_phi
Definition: MTVHistoProducerAlgoForTracker.h:235
reco::TrackBase::trackerExpectedHitsInner
const HitPattern & trackerExpectedHitsInner() const
Access the hit pattern counting (in the Tracker) the number of expected crossed layers before the fir...
Definition: TrackBase.h:223
MTVHistoProducerAlgoForTracker::totREC_vertcount_fwdneg
std::vector< std::vector< int > > totREC_vertcount_fwdneg
Definition: MTVHistoProducerAlgoForTracker.h:243
reco::TrackBase::numberOfValidHits
unsigned short numberOfValidHits() const
number of valid hits found
Definition: TrackBase.h:230
MTVHistoProducerAlgoForTracker::fill_simAssociated_recoTrack_histos
void fill_simAssociated_recoTrack_histos(int count, const reco::Track &track)
Definition: MTVHistoProducerAlgoForTracker.cc:1172
reco::HitPattern::numberOfValidStripTECHits
int numberOfValidStripTECHits() const
Definition: HitPattern.h:629
MTVHistoProducerAlgoForTracker::totmisidpT
std::vector< std::vector< int > > totmisidpT
Definition: MTVHistoProducerAlgoForTracker.h:233
DQMStore::bookProfile
MonitorElement * bookProfile(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, const char *option="s")
Definition: DQMStore.cc:1186
MTVHistoProducerAlgoForTracker::h_reco_ootpu_barrel
std::vector< MonitorElement * > h_reco_ootpu_barrel
Definition: MTVHistoProducerAlgoForTracker.h:177
MTVHistoProducerAlgoForTracker::h_assoc_vertz_barrel
std::vector< MonitorElement * > h_assoc_vertz_barrel
Definition: MTVHistoProducerAlgoForTracker.h:172
MTVHistoProducerAlgoForTracker::h_effic_PU_zpos
std::vector< MonitorElement * > h_effic_PU_zpos
Definition: MTVHistoProducerAlgoForTracker.h:187
MTVHistoProducerAlgoForTracker::h_phirmshPt
std::vector< MonitorElement * > h_phirmshPt
Definition: MTVHistoProducerAlgoForTracker.h:286
MTVHistoProducerAlgoForTracker::totloop_dz
std::vector< std::vector< int > > totloop_dz
Definition: MTVHistoProducerAlgoForTracker.h:237
MTVHistoProducerAlgoForTracker::phimean_vs_eta_phi
std::vector< MonitorElement * > phimean_vs_eta_phi
Definition: MTVHistoProducerAlgoForTracker.h:270
MTVHistoProducerAlgoForTracker::h_charge
std::vector< MonitorElement * > h_charge
Definition: MTVHistoProducerAlgoForTracker.h:157
reco::TrackBase::hitPattern
const HitPattern & hitPattern() const
Access the hit pattern, indicating in which Tracker layers the track has hits.
Definition: TrackBase.h:221
MTVHistoProducerAlgoForTracker::totASS2_itpu_vertcount_entire_signal
std::vector< std::vector< int > > totASS2_itpu_vertcount_entire_signal
Definition: MTVHistoProducerAlgoForTracker.h:254
MTVHistoProducerAlgoForTracker::h_reco_ootpu_eta
std::vector< MonitorElement * > h_reco_ootpu_eta
Definition: MTVHistoProducerAlgoForTracker.h:186
MTVHistoProducerAlgoForTracker::totASS2_hit
std::vector< std::vector< int > > totASS2_hit
Definition: MTVHistoProducerAlgoForTracker.h:234
MTVHistoProducerAlgoForTracker::h_loopratehit
std::vector< MonitorElement * > h_loopratehit
Definition: MTVHistoProducerAlgoForTracker.h:160
MTVHistoProducerAlgoForTracker::h_loopereta
std::vector< MonitorElement * > h_loopereta
Definition: MTVHistoProducerAlgoForTracker.h:158
MTVHistoProducerAlgoForTracker::h_effic_vertcount_fwdneg
std::vector< MonitorElement * > h_effic_vertcount_fwdneg
Definition: MTVHistoProducerAlgoForTracker.h:170
MTVHistoProducerAlgoForTracker::h_misiddz
std::vector< MonitorElement * > h_misiddz
Definition: MTVHistoProducerAlgoForTracker.h:163
MTVHistoProducerAlgoForTracker::totREC_dxy
std::vector< std::vector< int > > totREC_dxy
Definition: MTVHistoProducerAlgoForTracker.h:236
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:502
MTVHistoProducerAlgoForTracker::phiintervals
std::vector< std::vector< double > > phiintervals
Definition: MTVHistoProducerAlgoForTracker.h:226
MTVHistoProducerAlgoForTracker::h_assoc_vertcount_entire
std::vector< MonitorElement * > h_assoc_vertcount_entire
Definition: MTVHistoProducerAlgoForTracker.h:167
MTVHistoProducerAlgoForTracker::chi2_vs_nhits
std::vector< MonitorElement * > chi2_vs_nhits
Definition: MTVHistoProducerAlgoForTracker.h:265
MTVHistoProducerAlgoForTracker::totSIM_vertcount_fwdpos
std::vector< std::vector< int > > totSIM_vertcount_fwdpos
Definition: MTVHistoProducerAlgoForTracker.h:242
MTVHistoProducerAlgoForTracker::totSIM_vertz_barrel
std::vector< std::vector< int > > totSIM_vertz_barrel
Definition: MTVHistoProducerAlgoForTracker.h:245
MTVHistoProducerAlgoForTracker::totASS2_itpu_eta_entire_signal
std::vector< std::vector< int > > totASS2_itpu_eta_entire_signal
Definition: MTVHistoProducerAlgoForTracker.h:254
MTVHistoProducerAlgoForTracker::dzpull_vs_eta
std::vector< MonitorElement * > dzpull_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:295
MTVHistoProducerAlgoForTracker::totREC_vertcount_barrel
std::vector< std::vector< int > > totREC_vertcount_barrel
Definition: MTVHistoProducerAlgoForTracker.h:241
MTVHistoProducerAlgoForTracker::h_simuldz
std::vector< MonitorElement * > h_simuldz
Definition: MTVHistoProducerAlgoForTracker.h:163
MTVHistoProducerAlgoForTracker::h_misiddxy
std::vector< MonitorElement * > h_misiddxy
Definition: MTVHistoProducerAlgoForTracker.h:162
MTVHistoProducerAlgoForTracker::totASS_vertz_fwdpos
std::vector< std::vector< int > > totASS_vertz_fwdpos
Definition: MTVHistoProducerAlgoForTracker.h:246
MTVHistoProducerAlgoForTracker::h_bunchxSIM
std::vector< MonitorElement * > h_bunchxSIM
Definition: MTVHistoProducerAlgoForTracker.h:154
gen::k
int k[5][pyjets_maxn]
Definition: Cascade2Hadronizer.cc:81
MTVHistoProducerAlgoForTracker::h_fakerate
std::vector< MonitorElement * > h_fakerate
Definition: MTVHistoProducerAlgoForTracker.h:158
reco::TrackBase::qoverpError
double qoverpError() const
error on signed transverse curvature
Definition: TrackBase.h:190
reco::TrackBase::dz
double dz() const
dz parameter (= dsz/cos(lambda)). This is the track z0 w.r.t (0,0,0) only if the refPoint is close to...
Definition: TrackBase.h:125
reco::TrackBase::dzError
double dzError() const
error on dz
Definition: TrackBase.h:213
MTVHistoProducerAlgoForTracker::totmisid_hit
std::vector< std::vector< int > > totmisid_hit
Definition: MTVHistoProducerAlgoForTracker.h:234
MTVHistoProducerAlgoForTracker::h_ptpullphi
std::vector< MonitorElement * > h_ptpullphi
Definition: MTVHistoProducerAlgoForTracker.h:298
MTVHistoProducerAlgoForTracker::totCONzpos
std::vector< std::vector< int > > totCONzpos
Definition: MTVHistoProducerAlgoForTracker.h:256
MTVHistoProducerAlgoForTracker::thetapull_vs_phi
std::vector< MonitorElement * > thetapull_vs_phi
Definition: MTVHistoProducerAlgoForTracker.h:296
MTVHistoProducerAlgoForTracker::h_assoc2_ootpu_barrel
std::vector< MonitorElement * > h_assoc2_ootpu_barrel
Definition: MTVHistoProducerAlgoForTracker.h:177
MTVHistoProducerAlgoForTracker::TpSelectorForEfficiencyVsPt
TrackingParticleSelector * TpSelectorForEfficiencyVsPt
Definition: MTVHistoProducerAlgoForTracker.h:121
MTVHistoProducerAlgoForTracker::totREC_ootpu_barrel
std::vector< std::vector< int > > totREC_ootpu_barrel
Definition: MTVHistoProducerAlgoForTracker.h:250
MTVHistoProducerAlgoForTracker::h_simulvertpos
std::vector< MonitorElement * > h_simulvertpos
Definition: MTVHistoProducerAlgoForTracker.h:165
MTVHistoProducerAlgoForTracker::h_STRIPlayersWith2dMeas_eta
std::vector< MonitorElement * > h_STRIPlayersWith2dMeas_eta
Definition: MTVHistoProducerAlgoForTracker.h:217
MTVHistoProducerAlgoForTracker::dxyres_vs_eta
std::vector< MonitorElement * > dxyres_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:282
MTVHistoProducerAlgoForTracker::h_effic_vs_phi
std::vector< MonitorElement * > h_effic_vs_phi
Definition: MTVHistoProducerAlgoForTracker.h:161
MTVHistoProducerAlgoForTracker::totREC_vertcount_fwdpos
std::vector< std::vector< int > > totREC_vertcount_fwdpos
Definition: MTVHistoProducerAlgoForTracker.h:242
MTVHistoProducerAlgoForTracker::h_ptrmsh
std::vector< MonitorElement * > h_ptrmsh
Definition: MTVHistoProducerAlgoForTracker.h:285
MTVHistoProducerAlgoForTracker::totASS_vertpos
std::vector< std::vector< int > > totASS_vertpos
Definition: MTVHistoProducerAlgoForTracker.h:239
MTVHistoProducerAlgoForTracker::h_chi2meanhitsh
std::vector< MonitorElement * > h_chi2meanhitsh
Definition: MTVHistoProducerAlgoForTracker.h:279
MTVHistoProducerAlgoForTracker::h_fomt_ootpu_vertcount
std::vector< MonitorElement * > h_fomt_ootpu_vertcount
Definition: MTVHistoProducerAlgoForTracker.h:182
MTVHistoProducerAlgoForTracker::h_dxymeanhPt
std::vector< MonitorElement * > h_dxymeanhPt
Definition: MTVHistoProducerAlgoForTracker.h:291
MTVHistoProducerAlgoForTracker::h_dzpulleta
std::vector< MonitorElement * > h_dzpulleta
Definition: MTVHistoProducerAlgoForTracker.h:297
M_PI
#define M_PI
Definition: BFit3D.cc:3
MTVHistoProducerAlgoForTracker::h_misidpT
std::vector< MonitorElement * > h_misidpT
Definition: MTVHistoProducerAlgoForTracker.h:159
MTVHistoProducerAlgoForTracker::h_nmisslayers_outer
std::vector< MonitorElement * > h_nmisslayers_outer
Definition: MTVHistoProducerAlgoForTracker.h:262
MTVHistoProducerAlgoForTracker::nPXLlayersWithMeas_vs_eta
std::vector< MonitorElement * > nPXLlayersWithMeas_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:209
MTVHistoProducerAlgoForTracker::totSIMpT
std::vector< std::vector< int > > totSIMpT
Definition: MTVHistoProducerAlgoForTracker.h:233
MTVHistoProducerAlgoForTracker::totASS_vertz_entire
std::vector< std::vector< int > > totASS_vertz_entire
Definition: MTVHistoProducerAlgoForTracker.h:244
MTVHistoProducerAlgoForTracker::totASS_vertcount_fwdneg
std::vector< std::vector< int > > totASS_vertcount_fwdneg
Definition: MTVHistoProducerAlgoForTracker.h:243
MTVHistoProducerAlgoForTracker::nTIBhits_vs_eta
std::vector< MonitorElement * > nTIBhits_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:209
MTVHistoProducerAlgoForTracker::h_fakerate_ootpu_fwdpos
std::vector< MonitorElement * > h_fakerate_ootpu_fwdpos
Definition: MTVHistoProducerAlgoForTracker.h:178
MTVHistoProducerAlgoForTracker::h_dxypulleta
std::vector< MonitorElement * > h_dxypulleta
Definition: MTVHistoProducerAlgoForTracker.h:297
MTVHistoProducerAlgoForTracker::etaintervals
std::vector< std::vector< double > > etaintervals
Definition: MTVHistoProducerAlgoForTracker.h:224
MTVHistoProducerAlgoForTracker::GpSelectorForEfficiencyVsCon
GenParticleCustomSelector * GpSelectorForEfficiencyVsCon
Definition: MTVHistoProducerAlgoForTracker.h:127
MTVHistoProducerAlgoForTracker::h_effic_vs_dz
std::vector< MonitorElement * > h_effic_vs_dz
Definition: MTVHistoProducerAlgoForTracker.h:163
math::XYZPoint
XYZPointD XYZPoint
point in space with cartesian internal representation
Definition: Point3D.h:12
MTVHistoProducerAlgoForTracker::h_phirmshPhi
std::vector< MonitorElement * > h_phirmshPhi
Definition: MTVHistoProducerAlgoForTracker.h:287
MTVHistoProducerAlgoForTracker::totREC_ootpu_fwdpos
std::vector< std::vector< int > > totREC_ootpu_fwdpos
Definition: MTVHistoProducerAlgoForTracker.h:251
reco::GsfTrack::qoverpModeError
double qoverpModeError() const
error on signed transverse curvature from mode
Definition: GsfTrack.h:78
reco::HitPattern::stripLayersWithMeasurement
int stripLayersWithMeasurement() const
Definition: HitPattern.h:750
MTVHistoProducerAlgoForTracker::totASS2_ootpu_entire
std::vector< std::vector< int > > totASS2_ootpu_entire
Definition: MTVHistoProducerAlgoForTracker.h:249
MTVHistoProducerAlgoForTracker::h_eta
std::vector< MonitorElement * > h_eta
Definition: MTVHistoProducerAlgoForTracker.h:166
FitSlicesYTool::getFittedMeanWithError
void getFittedMeanWithError(MonitorElement *)
Fill the ME with the mean value (with error) of the gaussian fit in each slice.
Definition: FitSlicesYTool.cc:59
MTVHistoProducerAlgoForTracker::h_effic_PU_vertcount
std::vector< MonitorElement * > h_effic_PU_vertcount
Definition: MTVHistoProducerAlgoForTracker.h:187
MTVHistoProducerAlgoForTracker::h_pt
std::vector< MonitorElement * > h_pt
Definition: MTVHistoProducerAlgoForTracker.h:166
MTVHistoProducerAlgoForTracker::h_PXBhits_eta
std::vector< MonitorElement * > h_PXBhits_eta
Definition: MTVHistoProducerAlgoForTracker.h:217
MTVHistoProducerAlgoForTracker::totASS2_ootpu_eta_entire
std::vector< std::vector< int > > totASS2_ootpu_eta_entire
Definition: MTVHistoProducerAlgoForTracker.h:253
MTVHistoProducerAlgoForTracker::h_phimeanhPt
std::vector< MonitorElement * > h_phimeanhPt
Definition: MTVHistoProducerAlgoForTracker.h:291
MTVHistoProducerAlgoForTracker::h_dedx_nom2
std::vector< MonitorElement * > h_dedx_nom2
Definition: MTVHistoProducerAlgoForTracker.h:196
MTVHistoProducerAlgoForTracker::cotThetares_vs_pt
std::vector< MonitorElement * > cotThetares_vs_pt
Definition: MTVHistoProducerAlgoForTracker.h:283
MTVHistoProducerAlgoForTracker::h_effic_vs_zpos
std::vector< MonitorElement * > h_effic_vs_zpos
Definition: MTVHistoProducerAlgoForTracker.h:165
MTVHistoProducerAlgoForTracker::h_etaSIM
std::vector< MonitorElement * > h_etaSIM
Definition: MTVHistoProducerAlgoForTracker.h:154
reco::HitPattern::numberOfValidStripTIBHits
int numberOfValidStripTIBHits() const
Definition: HitPattern.h:617
MTVHistoProducerAlgoForTracker::h_simulphi
std::vector< MonitorElement * > h_simulphi
Definition: MTVHistoProducerAlgoForTracker.h:161
MTVHistoProducerAlgoForTracker::h_reco_vertcount_fwdpos
std::vector< MonitorElement * > h_reco_vertcount_fwdpos
Definition: MTVHistoProducerAlgoForTracker.h:169
reco::HitPattern::numberOfValidPixelEndcapHits
int numberOfValidPixelEndcapHits() const
Definition: HitPattern.h:609
MTVHistoProducerAlgoForTracker::h_pullTheta
std::vector< MonitorElement * > h_pullTheta
Definition: MTVHistoProducerAlgoForTracker.h:166
relval_parameters_module.step
string step
Definition: relval_parameters_module.py:36
MTVHistoProducerAlgoForTracker::totREC_hit
std::vector< std::vector< int > > totREC_hit
Definition: MTVHistoProducerAlgoForTracker.h:234
MTVHistoProducerAlgoForTracker::ptmean_vs_eta_phi
std::vector< MonitorElement * > ptmean_vs_eta_phi
Definition: MTVHistoProducerAlgoForTracker.h:270
MTVHistoProducerAlgoForTracker::h_looperphi
std::vector< MonitorElement * > h_looperphi
Definition: MTVHistoProducerAlgoForTracker.h:161
tmp
std::vector< std::vector< double > > tmp
Definition: MVATrainer.cc:100
reco::TrackBase::lambdaError
double lambdaError() const
error on lambda
Definition: TrackBase.h:201
MTVHistoProducerAlgoForTracker::totSIMeta
std::vector< std::vector< int > > totSIMeta
Definition: MTVHistoProducerAlgoForTracker.h:232
MTVHistoProducerAlgoForTracker::h_reco_vertcount_fwdneg
std::vector< MonitorElement * > h_reco_vertcount_fwdneg
Definition: MTVHistoProducerAlgoForTracker.h:170
MTVHistoProducerAlgoForTracker::totREC_ootpu_fwdneg
std::vector< std::vector< int > > totREC_ootpu_fwdneg
Definition: MTVHistoProducerAlgoForTracker.h:252
MTVHistoProducerAlgoForTracker::totSIM_vertcount_barrel
std::vector< std::vector< int > > totSIM_vertcount_barrel
Definition: MTVHistoProducerAlgoForTracker.h:241
MTVHistoProducerAlgoForTracker::dxypull_vs_eta
std::vector< MonitorElement * > dxypull_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:295
MTVHistoProducerAlgoForTracker::h_fomt_itpu_vertcount
std::vector< MonitorElement * > h_fomt_itpu_vertcount
Definition: MTVHistoProducerAlgoForTracker.h:181
MTVHistoProducerAlgoForTracker::ptres_vs_eta
std::vector< MonitorElement * > ptres_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:282
MTVHistoProducerAlgoForTracker::h_cotThetameanh
std::vector< MonitorElement * > h_cotThetameanh
Definition: MTVHistoProducerAlgoForTracker.h:290
MTVHistoProducerAlgoForTracker::h_assoc_vertz_entire
std::vector< MonitorElement * > h_assoc_vertz_entire
Definition: MTVHistoProducerAlgoForTracker.h:171
MTVHistoProducerAlgoForTracker::h_assoc2_vertcount_fwdpos
std::vector< MonitorElement * > h_assoc2_vertcount_fwdpos
Definition: MTVHistoProducerAlgoForTracker.h:169
MTVHistoProducerAlgoForTracker::h_dzrmsh
std::vector< MonitorElement * > h_dzrmsh
Definition: MTVHistoProducerAlgoForTracker.h:285
counter
static std::atomic< unsigned int > counter
Definition: SharedResourceNames.cc:14
MTVHistoProducerAlgoForTracker::h_con_vertcount
std::vector< MonitorElement * > h_con_vertcount
Definition: MTVHistoProducerAlgoForTracker.h:188
MTVHistoProducerAlgoForTracker::generalGpSelector
GenParticleCustomSelector * generalGpSelector
Definition: MTVHistoProducerAlgoForTracker.h:125
MTVHistoProducerAlgoForTracker::h_effic_vs_dxy
std::vector< MonitorElement * > h_effic_vs_dxy
Definition: MTVHistoProducerAlgoForTracker.h:162
MTVHistoProducerAlgoForTracker::phipull_vs_eta
std::vector< MonitorElement * > phipull_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:295
reco::Track::found
unsigned short found() const
Number of valid hits on track.
Definition: Track.h:99
MTVHistoProducerAlgoForTracker::h_TOBhits_eta
std::vector< MonitorElement * > h_TOBhits_eta
Definition: MTVHistoProducerAlgoForTracker.h:217
MTVHistoProducerAlgoForTracker::GpSelectorForEfficiencyVsPt
GenParticleCustomSelector * GpSelectorForEfficiencyVsPt
Definition: MTVHistoProducerAlgoForTracker.h:129
MTVHistoProducerAlgoForTracker::h_misidrate
std::vector< MonitorElement * > h_misidrate
Definition: MTVHistoProducerAlgoForTracker.h:158
MTVHistoProducerAlgoForTracker::h_TEChits_eta
std::vector< MonitorElement * > h_TEChits_eta
Definition: MTVHistoProducerAlgoForTracker.h:217
MTVHistoProducerAlgoForTracker::h_reco_vertcount_barrel
std::vector< MonitorElement * > h_reco_vertcount_barrel
Definition: MTVHistoProducerAlgoForTracker.h:168
MTVHistoProducerAlgoForTracker::h_simulhit
std::vector< MonitorElement * > h_simulhit
Definition: MTVHistoProducerAlgoForTracker.h:160
MTVHistoProducerAlgoForTracker::h_effic_vertz_entire
std::vector< MonitorElement * > h_effic_vertz_entire
Definition: MTVHistoProducerAlgoForTracker.h:171
MTVHistoProducerAlgoForTracker::GpSelectorForEfficiencyVsVTXR
GenParticleCustomSelector * GpSelectorForEfficiencyVsVTXR
Definition: MTVHistoProducerAlgoForTracker.h:130
MTVHistoProducerAlgoForTracker::h_con_zpos
std::vector< MonitorElement * > h_con_zpos
Definition: MTVHistoProducerAlgoForTracker.h:188
MTVHistoProducerAlgoForTracker::h_dzmeanhPt
std::vector< MonitorElement * > h_dzmeanhPt
Definition: MTVHistoProducerAlgoForTracker.h:291
MTVHistoProducerAlgoForTracker::totASS_vertz_fwdneg
std::vector< std::vector< int > > totASS_vertz_fwdneg
Definition: MTVHistoProducerAlgoForTracker.h:247
MTVHistoProducerAlgoForTracker::h_recopT
std::vector< MonitorElement * > h_recopT
Definition: MTVHistoProducerAlgoForTracker.h:159
MTVHistoProducerAlgoForTracker::h_looperdz
std::vector< MonitorElement * > h_looperdz
Definition: MTVHistoProducerAlgoForTracker.h:163
MTVHistoProducerAlgoForTracker::h_simul_vertcount_fwdneg
std::vector< MonitorElement * > h_simul_vertcount_fwdneg
Definition: MTVHistoProducerAlgoForTracker.h:170
MTVHistoProducerAlgoForTracker::pTintervals
std::vector< std::vector< double > > pTintervals
Definition: MTVHistoProducerAlgoForTracker.h:225
MTVHistoProducerAlgoForTracker::h_assocdxy
std::vector< MonitorElement * > h_assocdxy
Definition: MTVHistoProducerAlgoForTracker.h:162
reco::GsfTrack::phiMode
double phiMode() const
azimuthal angle of momentum vector from mode
Definition: GsfTrack.h:56
TrackingParticle
Monte Carlo truth information used for tracking validation.
Definition: TrackingParticle.h:29
reco::TrackBase::charge
int charge() const
track electric charge
Definition: TrackBase.h:111
MTVHistoProducerAlgoForTracker::cotThetares_vs_eta
std::vector< MonitorElement * > cotThetares_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:282
MTVHistoProducerAlgoForTracker::h_assocFraction
std::vector< MonitorElement * > h_assocFraction
Definition: MTVHistoProducerAlgoForTracker.h:206
MTVHistoProducerAlgoForTracker::fill_generic_simTrack_histos
void fill_generic_simTrack_histos(int counter, const TrackingParticle::Vector &, const TrackingParticle::Point &vertex, int bx)
Definition: MTVHistoProducerAlgoForTracker.cc:824
MTVHistoProducerAlgoForTracker::h_loopratedz
std::vector< MonitorElement * > h_loopratedz
Definition: MTVHistoProducerAlgoForTracker.h:163
MTVHistoProducerAlgoForTracker::h_fomt_sig_eta
std::vector< MonitorElement * > h_fomt_sig_eta
Definition: MTVHistoProducerAlgoForTracker.h:180
MTVHistoProducerAlgoForTracker::h_cotThetarmshPt
std::vector< MonitorElement * > h_cotThetarmshPt
Definition: MTVHistoProducerAlgoForTracker.h:286
MTVHistoProducerAlgoForTracker::totSIM_vertcount_fwdneg
std::vector< std::vector< int > > totSIM_vertcount_fwdneg
Definition: MTVHistoProducerAlgoForTracker.h:243
MTVHistoProducerAlgoForTracker::totREC_phi
std::vector< std::vector< int > > totREC_phi
Definition: MTVHistoProducerAlgoForTracker.h:235
MTVHistoProducerAlgoForTracker::GpSelectorForEfficiencyVsEta
GenParticleCustomSelector * GpSelectorForEfficiencyVsEta
Definition: MTVHistoProducerAlgoForTracker.h:126
reco::GsfTrack::lambdaModeError
double lambdaModeError() const
error on lambda from mode
Definition: GsfTrack.h:89
MTVHistoProducerAlgoForTracker::totASS2_ootpu_barrel
std::vector< std::vector< int > > totASS2_ootpu_barrel
Definition: MTVHistoProducerAlgoForTracker.h:250
MTVHistoProducerAlgoForTracker::h_assoc_vertcount_barrel
std::vector< MonitorElement * > h_assoc_vertcount_barrel
Definition: MTVHistoProducerAlgoForTracker.h:168
MTVHistoProducerAlgoForTracker::h_simul_vertz_fwdpos
std::vector< MonitorElement * > h_simul_vertz_fwdpos
Definition: MTVHistoProducerAlgoForTracker.h:173
MTVHistoProducerAlgoForTracker::h_recodz
std::vector< MonitorElement * > h_recodz
Definition: MTVHistoProducerAlgoForTracker.h:163
MTVHistoProducerAlgoForTracker::ptres_vs_pt
std::vector< MonitorElement * > ptres_vs_pt
Definition: MTVHistoProducerAlgoForTracker.h:283
reco::modules::GenParticleCustomSelector
SingleObjectSelector< GenParticleCollection,::GenParticleCustomSelector > GenParticleCustomSelector
Definition: GenParticleCustomSelector.cc:16
MTVHistoProducerAlgoForTracker::h_reco_ootpu_fwdpos
std::vector< MonitorElement * > h_reco_ootpu_fwdpos
Definition: MTVHistoProducerAlgoForTracker.h:178
MTVHistoProducerAlgoForTracker::h_dedx_sat2
std::vector< MonitorElement * > h_dedx_sat2
Definition: MTVHistoProducerAlgoForTracker.h:198
TrackingParticle::Vector
math::XYZVectorD Vector
point in the space
Definition: TrackingParticle.h:37
MTVHistoProducerAlgoForTracker::h_reco_ootpu_vertcount
std::vector< MonitorElement * > h_reco_ootpu_vertcount
Definition: MTVHistoProducerAlgoForTracker.h:186
MTVHistoProducerAlgoForTracker::totloop_phi
std::vector< std::vector< int > > totloop_phi
Definition: MTVHistoProducerAlgoForTracker.h:235
DQMStore::book2D
MonitorElement * book2D(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY)
Book 2D histogram.
Definition: DQMStore.cc:1000
MTVHistoProducerAlgoForTracker::h_assoc2_ootpu_entire
std::vector< MonitorElement * > h_assoc2_ootpu_entire
Definition: MTVHistoProducerAlgoForTracker.h:176
MTVHistoProducerAlgoForTracker::h_phipulleta
std::vector< MonitorElement * > h_phipulleta
Definition: MTVHistoProducerAlgoForTracker.h:297
reco::TrackBase::dxy
double dxy() const
dxy parameter. (This is the transverse impact parameter w.r.t. to (0,0,0) ONLY if refPoint is close t...
Definition: TrackBase.h:119
MTVHistoProducerAlgoForTracker::h_simul_vertcount_entire
std::vector< MonitorElement * > h_simul_vertcount_entire
Definition: MTVHistoProducerAlgoForTracker.h:167
MTVHistoProducerAlgoForTracker::totCONvertcount
std::vector< std::vector< int > > totCONvertcount
Definition: MTVHistoProducerAlgoForTracker.h:256
MTVHistoProducerAlgoForTracker::h_assoceta
std::vector< MonitorElement * > h_assoceta
Definition: MTVHistoProducerAlgoForTracker.h:158
MTVHistoProducerAlgoForTracker::h_effic_vertcount_barrel
std::vector< MonitorElement * > h_effic_vertcount_barrel
Definition: MTVHistoProducerAlgoForTracker.h:168
MTVHistoProducerAlgoForTracker::h_looprate
std::vector< MonitorElement * > h_looprate
Definition: MTVHistoProducerAlgoForTracker.h:158
MTVHistoProducerAlgoForTracker::ptres_vs_phi
std::vector< MonitorElement * > ptres_vs_phi
Definition: MTVHistoProducerAlgoForTracker.h:267
MTVHistoProducerAlgoForTracker::TpSelectorForEfficiencyVsVTXR
TrackingParticleSelector * TpSelectorForEfficiencyVsVTXR
Definition: MTVHistoProducerAlgoForTracker.h:122
MTVHistoProducerAlgoForTracker::h_con_eta
std::vector< MonitorElement * > h_con_eta
Definition: MTVHistoProducerAlgoForTracker.h:188
MTVHistoProducerAlgoForTracker::h_assocSharedHit
std::vector< MonitorElement * > h_assocSharedHit
Definition: MTVHistoProducerAlgoForTracker.h:206
MTVHistoProducerAlgoForTracker::h_dxymeanh
std::vector< MonitorElement * > h_dxymeanh
Definition: MTVHistoProducerAlgoForTracker.h:290
MTVHistoProducerAlgoForTracker::nhits_vs_eta
std::vector< MonitorElement * > nhits_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:209
reco::HitPattern::numberOfValidStripLayersWithMonoAndStereo
int numberOfValidStripLayersWithMonoAndStereo(uint32_t stripdet, uint32_t layer) const
Definition: HitPattern.cc:221
MTVHistoProducerAlgoForTracker::h_ptrmshPhi
std::vector< MonitorElement * > h_ptrmshPhi
Definition: MTVHistoProducerAlgoForTracker.h:287
reco::GsfTrack::ptMode
double ptMode() const
track transverse momentum from mode
Definition: GsfTrack.h:48
MTVHistoProducerAlgoForTracker::h_assoc2_vertcount_barrel
std::vector< MonitorElement * > h_assoc2_vertcount_barrel
Definition: MTVHistoProducerAlgoForTracker.h:168
MTVHistoProducerAlgoForTracker::h_effic_vs_hit
std::vector< MonitorElement * > h_effic_vs_hit
Definition: MTVHistoProducerAlgoForTracker.h:160
MTVHistoProducerAlgoForTracker::h_simuldxy
std::vector< MonitorElement * > h_simuldxy
Definition: MTVHistoProducerAlgoForTracker.h:162
MTVHistoProducerAlgoForTracker::totmisideta
std::vector< std::vector< int > > totmisideta
Definition: MTVHistoProducerAlgoForTracker.h:232
MTVHistoProducerAlgoForTracker::h_assocvertpos
std::vector< MonitorElement * > h_assocvertpos
Definition: MTVHistoProducerAlgoForTracker.h:165
MTVHistoProducerAlgoForTracker::h_loopratepT
std::vector< MonitorElement * > h_loopratepT
Definition: MTVHistoProducerAlgoForTracker.h:159
MTVHistoProducerAlgoForTracker::h_effic_vertz_fwdneg
std::vector< MonitorElement * > h_effic_vertz_fwdneg
Definition: MTVHistoProducerAlgoForTracker.h:174
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:40
MTVHistoProducerAlgoForTracker::totASS2_vertcount_fwdpos
std::vector< std::vector< int > > totASS2_vertcount_fwdpos
Definition: MTVHistoProducerAlgoForTracker.h:242
MTVHistoProducerAlgoForTracker::h_assoc2_vertcount_entire
std::vector< MonitorElement * > h_assoc2_vertcount_entire
Definition: MTVHistoProducerAlgoForTracker.h:167
MTVHistoProducerAlgoForTracker::h_simul_vertz_fwdneg
std::vector< MonitorElement * > h_simul_vertz_fwdneg
Definition: MTVHistoProducerAlgoForTracker.h:174
MTVHistoProducerAlgoForTracker::h_recoeta
std::vector< MonitorElement * > h_recoeta
Definition: MTVHistoProducerAlgoForTracker.h:158
MTVHistoProducerAlgoForTracker::thetapull_vs_eta
std::vector< MonitorElement * > thetapull_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:295
MTVHistoProducerAlgoForTracker::totSIM_dxy
std::vector< std::vector< int > > totSIM_dxy
Definition: MTVHistoProducerAlgoForTracker.h:236
MTVHistoProducerAlgoForTracker::chi2_vs_eta
std::vector< MonitorElement * > chi2_vs_eta
Definition: MTVHistoProducerAlgoForTracker.h:276
MTVHistoProducerAlgoForTracker::h_phipulletamean
std::vector< MonitorElement * > h_phipulletamean
Definition: MTVHistoProducerAlgoForTracker.h:299
MTVHistoProducerAlgoForTracker::h_PXLlayersWithMeas_eta
std::vector< MonitorElement * > h_PXLlayersWithMeas_eta
Definition: MTVHistoProducerAlgoForTracker.h:217
MTVHistoProducerAlgoForTracker::dzintervals
std::vector< std::vector< double > > dzintervals
Definition: MTVHistoProducerAlgoForTracker.h:228
MTVHistoProducerAlgoForTracker::dxyres_vs_pt
std::vector< MonitorElement * > dxyres_vs_pt
Definition: MTVHistoProducerAlgoForTracker.h:283
MTVHistoProducerAlgoForTracker::TpSelectorForEfficiencyVsCon
TrackingParticleSelector * TpSelectorForEfficiencyVsCon
Definition: MTVHistoProducerAlgoForTracker.h:119
MTVHistoProducerAlgoForTracker::h_misidratedxy
std::vector< MonitorElement * > h_misidratedxy
Definition: MTVHistoProducerAlgoForTracker.h:162
MTVHistoProducerAlgoForTracker::h_dedx_nom1
std::vector< MonitorElement * > h_dedx_nom1
Definition: MTVHistoProducerAlgoForTracker.h:195
MTVHistoProducerAlgoForTracker::totASS2_dxy
std::vector< std::vector< int > > totASS2_dxy
Definition: MTVHistoProducerAlgoForTracker.h:236
MTVHistoProducerAlgoForTracker::h_losthits
std::vector< MonitorElement * > h_losthits
Definition: MTVHistoProducerAlgoForTracker.h:262
MTVHistoProducerAlgoForTracker::TpSelectorForEfficiencyVsEta
TrackingParticleSelector * TpSelectorForEfficiencyVsEta
Definition: MTVHistoProducerAlgoForTracker.h:118
MTVHistoProducerAlgoForTracker::h_assoc2eta
std::vector< MonitorElement * > h_assoc2eta
Definition: MTVHistoProducerAlgoForTracker.h:158
MTVHistoProducerAlgoForTracker::totmisid_dz
std::vector< std::vector< int > > totmisid_dz
Definition: MTVHistoProducerAlgoForTracker.h:237
MTVHistoProducerAlgoForTracker::h_thetapulletamean
std::vector< MonitorElement * > h_thetapulletamean
Definition: MTVHistoProducerAlgoForTracker.h:299
MTVHistoProducerAlgoForTracker::h_misidphi
std::vector< MonitorElement * > h_misidphi
Definition: MTVHistoProducerAlgoForTracker.h:161
MTVHistoProducerAlgoForTracker::h_fakerate_vertcount_fwdneg
std::vector< MonitorElement * > h_fakerate_vertcount_fwdneg
Definition: MTVHistoProducerAlgoForTracker.h:170
phi
Definition: DDAxes.h:10
DQMStore::bookProfile2D
MonitorElement * bookProfile2D(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, int nchZ, double lowZ, double highZ, const char *option="s")
Definition: DQMStore.cc:1330
MTVHistoProducerAlgoForTracker::dzres_vs_pt
std::vector< MonitorElement * > dzres_vs_pt
Definition: MTVHistoProducerAlgoForTracker.h:283
Generated for CMSSW Reference Manual by doxygen 1.8.5