CMS 3D CMS Logo

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
MuonTrackValidatorBase.h
Go to the documentation of this file.
1 #ifndef MuonTrackValidatorBase_h
2 #define MuonTrackValidatorBase_h
3 
9 #include <memory>
10 
15 
18 
22 
23 
26 
30 
31 #include <iostream>
32 #include <sstream>
33 #include <string>
34 #include <TH1F.h>
35 #include <TH2F.h>
36 
37 class DQMStore;
39  public:
42  {
46  for (unsigned int www=0;www<label.size();www++){
48  }
49  }
50 
52  label(pset.getParameter< std::vector<edm::InputTag> >("label")),
53  usetracker(pset.getParameter<bool>("usetracker")),
54  usemuon(pset.getParameter<bool>("usemuon")),
55  bsSrc(pset.getParameter< edm::InputTag >("beamSpot")),
56  label_tp_effic(pset.getParameter< edm::InputTag >("label_tp_effic")),
57  label_tp_fake(pset.getParameter< edm::InputTag >("label_tp_fake")),
58  associators(pset.getParameter< std::vector<std::string> >("associators")),
59  out(pset.getParameter<std::string>("outputFile")),
60  parametersDefiner(pset.getParameter<std::string>("parametersDefiner")),
61  min(pset.getParameter<double>("min")),
62  max(pset.getParameter<double>("max")),
63  nint(pset.getParameter<int>("nint")),
64  useFabs(pset.getParameter<bool>("useFabsEta")),
65  minpT(pset.getParameter<double>("minpT")),
66  maxpT(pset.getParameter<double>("maxpT")),
67  nintpT(pset.getParameter<int>("nintpT")),
68  minHit(pset.getParameter<double>("minHit")),
69  maxHit(pset.getParameter<double>("maxHit")),
70  nintHit(pset.getParameter<int>("nintHit")),
71  minPhi(pset.getParameter<double>("minPhi")),
72  maxPhi(pset.getParameter<double>("maxPhi")),
73  nintPhi(pset.getParameter<int>("nintPhi")),
74  minDxy(pset.getParameter<double>("minDxy")),
75  maxDxy(pset.getParameter<double>("maxDxy")),
76  nintDxy(pset.getParameter<int>("nintDxy")),
77  minDz(pset.getParameter<double>("minDz")),
78  maxDz(pset.getParameter<double>("maxDz")),
79  nintDz(pset.getParameter<int>("nintDz")),
80  minVertpos(pset.getParameter<double>("minVertpos")),
81  maxVertpos(pset.getParameter<double>("maxVertpos")),
82  nintVertpos(pset.getParameter<int>("nintVertpos")),
83  minZpos(pset.getParameter<double>("minZpos")),
84  maxZpos(pset.getParameter<double>("maxZpos")),
85  nintZpos(pset.getParameter<int>("nintZpos")),
86  useInvPt(pset.getParameter<bool>("useInvPt")),
87  //
88  ptRes_rangeMin(pset.getParameter<double>("ptRes_rangeMin")),
89  ptRes_rangeMax(pset.getParameter<double>("ptRes_rangeMax")),
90  phiRes_rangeMin(pset.getParameter<double>("phiRes_rangeMin")),
91  phiRes_rangeMax(pset.getParameter<double>("phiRes_rangeMax")),
92  cotThetaRes_rangeMin(pset.getParameter<double>("cotThetaRes_rangeMin")),
93  cotThetaRes_rangeMax(pset.getParameter<double>("cotThetaRes_rangeMax")),
94  dxyRes_rangeMin(pset.getParameter<double>("dxyRes_rangeMin")),
95  dxyRes_rangeMax(pset.getParameter<double>("dxyRes_rangeMax")),
96  dzRes_rangeMin(pset.getParameter<double>("dzRes_rangeMin")),
97  dzRes_rangeMax(pset.getParameter<double>("dzRes_rangeMax")),
98  ptRes_nbin(pset.getParameter<int>("ptRes_nbin")),
99  cotThetaRes_nbin(pset.getParameter<int>("cotThetaRes_nbin")),
100  phiRes_nbin(pset.getParameter<int>("phiRes_nbin")),
101  dxyRes_nbin(pset.getParameter<int>("dxyRes_nbin")),
102  dzRes_nbin(pset.getParameter<int>("dzRes_nbin")),
103  ignoremissingtkcollection_(pset.getUntrackedParameter<bool>("ignoremissingtrackcollection",false)),
104  useLogPt(pset.getUntrackedParameter<bool>("useLogPt",false))
105  //
106  {
108  if(useLogPt){
109  maxpT=log10(maxpT);
110  minpT=log10(minpT);
111  }
112  }
113 
116 
117  virtual void doProfileX(TH2 * th2, MonitorElement* me){
118  if (th2->GetNbinsX()==me->getNbinsX()){
119  TProfile * p1 = (TProfile*) th2->ProfileX();
120  p1->Copy(*me->getTProfile());
121  delete p1;
122  } else {
123  throw cms::Exception("MuonTrackValidator") << "Different number of bins!";
124  }
125  }
126 
127  virtual void doProfileX(MonitorElement * th2m, MonitorElement* me) {
128  doProfileX(th2m->getTH2F(), me);
129  }
130 
131  virtual double getEta(double eta) {
132  if (useFabs) return fabs(eta);
133  else return eta;
134  }
135 
136  virtual double getPt(double pt) {
137  if (useInvPt && pt!=0) return 1/pt;
138  else return pt;
139  }
140 
141  void fillPlotFromVector(MonitorElement* h, std::vector<int>& vec) {
142  for (unsigned int j=0; j<vec.size(); j++){
143  h->setBinContent(j+1, vec[j]);
144  }
145  }
146 
147  void fillPlotFromVectors(MonitorElement* h, std::vector<int>& numerator, std::vector<int>& denominator,std::string type){
148  double value,err;
149  for (unsigned int j=0; j<numerator.size(); j++){
150  if (denominator[j]!=0){
151 if (type=="effic")
152 value = ((double) numerator[j])/((double) denominator[j]);
153 else if (type=="fakerate")
154 value = 1-((double) numerator[j])/((double) denominator[j]);
155 else return;
156 err = sqrt( value*(1-value)/(double) denominator[j] );
157 h->setBinContent(j+1, value);
158 h->setBinError(j+1,err);
159  }
160  else {
161 h->setBinContent(j+1, 0);
162  }
163  }
164  }
165 
166  void BinLogX(TH1*h)
167  {
168 
169  TAxis *axis = h->GetXaxis();
170  int bins = axis->GetNbins();
171 
172  float from = axis->GetXmin();
173  float to = axis->GetXmax();
174  float width = (to - from) / bins;
175  float *new_bins = new float[bins + 1];
176 
177  for (int i = 0; i <= bins; i++) {
178  new_bins[i] = TMath::Power(10, from + i * width);
179 
180  }
181  axis->Set(bins, new_bins);
182  delete[] new_bins;
183  }
184 
185  void setUpVectors() {
186  std::vector<double> etaintervalsv;
187  std::vector<double> phiintervalsv;
188  std::vector<double> pTintervalsv;
189  std::vector<double> dxyintervalsv;
190  std::vector<double> dzintervalsv;
191  std::vector<double> vertposintervalsv;
192  std::vector<double> zposintervalsv;
193  std::vector<int> totSIMveta,totASSveta,totASS2veta,totRECveta;
194  std::vector<int> totSIMvpT,totASSvpT,totASS2vpT,totRECvpT;
195  std::vector<int> totSIMv_hit,totASSv_hit,totASS2v_hit,totRECv_hit;
196  std::vector<int> totSIMv_phi,totASSv_phi,totASS2v_phi,totRECv_phi;
197  std::vector<int> totSIMv_dxy,totASSv_dxy,totASS2v_dxy,totRECv_dxy;
198  std::vector<int> totSIMv_dz,totASSv_dz,totASS2v_dz,totRECv_dz;
199  std::vector<int> totSIMv_vertpos,totASSv_vertpos,totSIMv_zpos,totASSv_zpos;
200 
201  // for muon Validation
202  std::vector<int> totASSveta_Quality05, totASSveta_Quality075;
203  std::vector<int> totASSvpT_Quality05, totASSvpT_Quality075;
204  std::vector<int> totASSv_phi_Quality05, totASSv_phi_Quality075;
205 
206  double step=(max-min)/nint;
207  std::ostringstream title,name;
208  etaintervalsv.push_back(min);
209  for (int k=1;k<nint+1;k++) {
210  double d=min+k*step;
211  etaintervalsv.push_back(d);
212  totSIMveta.push_back(0);
213  totASSveta.push_back(0);
214  totASS2veta.push_back(0);
215  totRECveta.push_back(0);
216  //
217  totASSveta_Quality05.push_back(0);
218  totASSveta_Quality075.push_back(0);
219  }
220  etaintervals.push_back(etaintervalsv);
221  totSIMeta.push_back(totSIMveta);
222  totASSeta.push_back(totASSveta);
223  totASS2eta.push_back(totASS2veta);
224  totRECeta.push_back(totRECveta);
225  //
226  totASSeta_Quality05.push_back(totASSveta_Quality05);
227  totASSeta_Quality075.push_back(totASSveta_Quality075);
228 
229  double steppT = (maxpT-minpT)/nintpT;
230  pTintervalsv.push_back(minpT);
231  for (int k=1;k<nintpT+1;k++) {
232  double d=0;
233  if(useLogPt)d=pow(10,minpT+k*steppT);
234  else d=minpT+k*steppT;
235  pTintervalsv.push_back(d);
236  totSIMvpT.push_back(0);
237  totASSvpT.push_back(0);
238  totASS2vpT.push_back(0);
239  totRECvpT.push_back(0);
240  //
241  totASSvpT_Quality05.push_back(0);
242  totASSvpT_Quality075.push_back(0);
243  }
244  pTintervals.push_back(pTintervalsv);
245  totSIMpT.push_back(totSIMvpT);
246  totASSpT.push_back(totASSvpT);
247  totASS2pT.push_back(totASS2vpT);
248  totRECpT.push_back(totRECvpT);
249  //
250  totASSpT_Quality05.push_back(totASSvpT_Quality05);
251  totASSpT_Quality075.push_back(totASSvpT_Quality075);
252 
253  for (int k=1;k<nintHit+1;k++) {
254  totSIMv_hit.push_back(0);
255  totASSv_hit.push_back(0);
256  totASS2v_hit.push_back(0);
257  totRECv_hit.push_back(0);
258  }
259  totSIM_hit.push_back(totSIMv_hit);
260  totASS_hit.push_back(totASSv_hit);
261  totASS2_hit.push_back(totASS2v_hit);
262  totREC_hit.push_back(totRECv_hit);
263 
264  double stepPhi = (maxPhi-minPhi)/nintPhi;
265  phiintervalsv.push_back(minPhi);
266  for (int k=1;k<nintPhi+1;k++) {
267  double d=minPhi+k*stepPhi;
268  phiintervalsv.push_back(d);
269  totSIMv_phi.push_back(0);
270  totASSv_phi.push_back(0);
271  totASS2v_phi.push_back(0);
272  totRECv_phi.push_back(0);
273  //
274  totASSv_phi_Quality05.push_back(0);
275  totASSv_phi_Quality075.push_back(0);
276  }
277  phiintervals.push_back(phiintervalsv);
278  totSIM_phi.push_back(totSIMv_phi);
279  totASS_phi.push_back(totASSv_phi);
280  totASS2_phi.push_back(totASS2v_phi);
281  totREC_phi.push_back(totRECv_phi);
282  //
283  totASS_phi_Quality05.push_back(totASSv_phi_Quality05);
284  totASS_phi_Quality075.push_back(totASSv_phi_Quality075);
285 
286  double stepDxy = (maxDxy-minDxy)/nintDxy;
287  dxyintervalsv.push_back(minDxy);
288  for (int k=1;k<nintDxy+1;k++) {
289  double d=minDxy+k*stepDxy;
290  dxyintervalsv.push_back(d);
291  totSIMv_dxy.push_back(0);
292  totASSv_dxy.push_back(0);
293  totASS2v_dxy.push_back(0);
294  totRECv_dxy.push_back(0);
295  }
296  dxyintervals.push_back(dxyintervalsv);
297  totSIM_dxy.push_back(totSIMv_dxy);
298  totASS_dxy.push_back(totASSv_dxy);
299  totASS2_dxy.push_back(totASS2v_dxy);
300  totREC_dxy.push_back(totRECv_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  }
313  dzintervals.push_back(dzintervalsv);
314  totSIM_dz.push_back(totSIMv_dz);
315  totASS_dz.push_back(totASSv_dz);
316  totASS2_dz.push_back(totASS2v_dz);
317  totREC_dz.push_back(totRECv_dz);
318 
319  double stepVertpos = (maxVertpos-minVertpos)/nintVertpos;
320  vertposintervalsv.push_back(minVertpos);
321  for (int k=1;k<nintVertpos+1;k++) {
322  double d=minVertpos+k*stepVertpos;
323  vertposintervalsv.push_back(d);
324  totSIMv_vertpos.push_back(0);
325  totASSv_vertpos.push_back(0);
326  }
327  vertposintervals.push_back(vertposintervalsv);
328  totSIM_vertpos.push_back(totSIMv_vertpos);
329  totASS_vertpos.push_back(totASSv_vertpos);
330 
331  double stepZpos = (maxZpos-minZpos)/nintZpos;
332  zposintervalsv.push_back(minZpos);
333  for (int k=1;k<nintZpos+1;k++) {
334  double d=minZpos+k*stepZpos;
335  zposintervalsv.push_back(d);
336  totSIMv_zpos.push_back(0);
337  totASSv_zpos.push_back(0);
338  }
339  zposintervals.push_back(zposintervalsv);
340  totSIM_zpos.push_back(totSIMv_zpos);
341  totASS_zpos.push_back(totASSv_zpos);
342 
343  }
344 
345  protected:
346 
348 
349  std::vector<edm::InputTag> label;
351  bool usemuon;
355  std::vector<std::string> associators;
358  std::vector<edm::EDGetTokenT<edm::View<reco::Track> > > track_Collection_Token;
362 
363  double min, max;
364  int nint;
365  bool useFabs;
366  double minpT, maxpT;
367  int nintpT;
368  double minHit, maxHit;
369  int nintHit;
370  double minPhi, maxPhi;
371  int nintPhi;
372  double minDxy, maxDxy;
373  int nintDxy;
374  double minDz, maxDz;
375  int nintDz;
378  double minZpos, maxZpos;
379  int nintZpos;
380  bool useInvPt;
381  //
387  bool useLogPt;
388 
390 
391  //sim
392  std::vector<MonitorElement*> h_ptSIM, h_etaSIM, h_tracksSIM, h_vertposSIM;
393 
394  //1D
395  std::vector<MonitorElement*> h_tracks, h_fakes, h_hits, h_charge;
396  std::vector<MonitorElement*> h_recoeta, h_assoceta, h_assoc2eta, h_simuleta;
397  std::vector<MonitorElement*> h_recopT, h_assocpT, h_assoc2pT, h_simulpT;
398  std::vector<MonitorElement*> h_recohit, h_assochit, h_assoc2hit, h_simulhit;
399  std::vector<MonitorElement*> h_recophi, h_assocphi, h_assoc2phi, h_simulphi;
400  std::vector<MonitorElement*> h_recodxy, h_assocdxy, h_assoc2dxy, h_simuldxy;
401  std::vector<MonitorElement*> h_recodz, h_assocdz, h_assoc2dz, h_simuldz;
402  std::vector<MonitorElement*> h_assocvertpos, h_simulvertpos, h_assoczpos, h_simulzpos;
404 
405  std::vector<MonitorElement*> h_assoceta_Quality05, h_assoceta_Quality075;
406  std::vector<MonitorElement*> h_assocpT_Quality05, h_assocpT_Quality075;
407  std::vector<MonitorElement*> h_assocphi_Quality05, h_assocphi_Quality075;
408 
409 
410  //2D
411  std::vector<MonitorElement*> nrec_vs_nsim;
412  std::vector<MonitorElement*> nrecHit_vs_nsimHit_sim2rec;
413  std::vector<MonitorElement*> nrecHit_vs_nsimHit_rec2sim;
414 
415  //assoc hits
416  std::vector<MonitorElement*> h_assocFraction, h_assocSharedHit;
417 
418  //#hit vs eta: to be used with doProfileX
419  std::vector<MonitorElement*> nhits_vs_eta,
421 
422  std::vector<MonitorElement*> h_hits_eta,
424 
425 
426  std::vector< std::vector<double> > etaintervals;
427  std::vector< std::vector<double> > pTintervals;
428  std::vector< std::vector<double> > phiintervals;
429  std::vector< std::vector<double> > dxyintervals;
430  std::vector< std::vector<double> > dzintervals;
431  std::vector< std::vector<double> > vertposintervals;
432  std::vector< std::vector<double> > zposintervals;
433  std::vector< std::vector<int> > totSIMeta,totRECeta,totASSeta,totASS2eta;
434  std::vector< std::vector<int> > totSIMpT,totRECpT,totASSpT,totASS2pT;
435  std::vector< std::vector<int> > totSIM_hit,totREC_hit,totASS_hit,totASS2_hit;
436  std::vector< std::vector<int> > totSIM_phi,totREC_phi,totASS_phi,totASS2_phi;
437  std::vector< std::vector<int> > totSIM_dxy,totREC_dxy,totASS_dxy,totASS2_dxy;
438  std::vector< std::vector<int> > totSIM_dz,totREC_dz,totASS_dz,totASS2_dz;
439  std::vector< std::vector<int> > totSIM_vertpos,totASS_vertpos,totSIM_zpos,totASS_zpos;
440 
441  // for muon Validation (SimToReco distributions for Quality > 0.5, 0.75)
442  std::vector<MonitorElement*> h_PurityVsQuality;
443  std::vector< std::vector<int> > totASSeta_Quality05,totASSeta_Quality075;
444  std::vector< std::vector<int> > totASSpT_Quality05, totASSpT_Quality075;
445  std::vector< std::vector<int> > totASS_phi_Quality05, totASS_phi_Quality075;
446 
447 };
448 
449 
450 #endif
std::vector< MonitorElement * > h_assoc2phi
std::vector< MonitorElement * > h_recoeta
EDGetTokenT< ProductType > consumes(edm::InputTag const &tag)
type
Definition: HCALResponse.h:21
std::vector< MonitorElement * > nrecHit_vs_nsimHit_sim2rec
std::vector< MonitorElement * > h_DThits_eta
std::vector< MonitorElement * > h_assoc2hit
std::vector< std::vector< int > > totASS_zpos
int i
Definition: DBlmapReader.cc:9
std::vector< MonitorElement * > h_PurityVsQuality
std::vector< std::vector< int > > totASSeta_Quality05
std::vector< MonitorElement * > h_recopT
edm::ESHandle< MagneticField > theMF
void setBinContent(int binx, double content)
set content of bin (1-D)
std::vector< std::vector< int > > totREC_phi
std::vector< MonitorElement * > h_assoc2dxy
list numerator
Definition: cuy.py:483
std::vector< MonitorElement * > nrecHit_vs_nsimHit_rec2sim
std::vector< std::vector< int > > totASS2_hit
std::vector< edm::EDGetTokenT< edm::View< reco::Track > > > track_Collection_Token
void fillPlotFromVectors(MonitorElement *h, std::vector< int > &numerator, std::vector< int > &denominator, std::string type)
std::vector< MonitorElement * > h_assocpT_Quality075
std::vector< std::vector< int > > totRECpT
std::vector< TrackingParticle > TrackingParticleCollection
std::vector< std::vector< int > > totREC_dz
std::vector< MonitorElement * > nrec_vs_nsim
std::vector< MonitorElement * > h_pullDz
std::vector< MonitorElement * > h_recohit
std::vector< MonitorElement * > h_etaSIM
std::vector< MonitorElement * > h_assocvertpos
std::vector< MonitorElement * > h_fakes
virtual double getEta(double eta)
std::vector< MonitorElement * > h_eta
std::vector< std::vector< int > > totASS_dz
std::vector< std::vector< double > > etaintervals
std::vector< MonitorElement * > h_pt
std::vector< MonitorElement * > h_pullQoverp
std::vector< std::vector< int > > totSIM_zpos
std::vector< MonitorElement * > h_CSChits_eta
std::vector< std::vector< int > > totASS2_dz
std::vector< std::vector< int > > totASS_phi_Quality05
T eta() const
std::vector< MonitorElement * > h_assoceta
std::vector< MonitorElement * > h_tracks
std::vector< std::vector< double > > dxyintervals
std::vector< MonitorElement * > h_assoceta_Quality075
std::vector< MonitorElement * > nDThits_vs_eta
std::vector< std::vector< int > > totASS_phi
std::vector< std::vector< int > > totASS_dxy
std::vector< MonitorElement * > h_simuldxy
std::vector< std::vector< int > > totSIM_dxy
std::vector< MonitorElement * > h_simuldz
std::vector< std::vector< int > > totASSeta_Quality075
std::vector< MonitorElement * > nhits_vs_eta
virtual double getPt(double pt)
std::vector< MonitorElement * > h_assoczpos
std::vector< MonitorElement * > h_simulphi
list denominator
Definition: cuy.py:484
std::vector< std::vector< int > > totASS2pT
std::vector< MonitorElement * > h_vertposSIM
edm::EDGetTokenT< TrackingParticleCollection > tp_fake_Token
virtual void doProfileX(TH2 *th2, MonitorElement *me)
std::vector< edm::InputTag > label
std::vector< MonitorElement * > h_assocSharedHit
std::vector< std::vector< double > > pTintervals
virtual ~MuonTrackValidatorBase()
Destructor.
std::vector< std::vector< int > > totASS2eta
T sqrt(T t)
Definition: SSEVec.h:48
std::vector< std::vector< int > > totSIMpT
std::vector< std::vector< int > > totREC_dxy
std::vector< MonitorElement * > h_assoc2dz
MuonTrackValidatorBase(const edm::ParameterSet &pset, edm::ConsumesCollector iC)
Constructor.
std::vector< MonitorElement * > h_pullPhi
std::vector< std::vector< int > > totSIM_hit
std::vector< MonitorElement * > h_recophi
std::vector< std::vector< int > > totASSpT
int j
Definition: DBlmapReader.cc:9
std::vector< std::vector< int > > totASS_phi_Quality075
The Signals That Services Can Subscribe To This is based on ActivityRegistry h
Helper function to determine trigger accepts.
Definition: Activities.doc:4
std::vector< MonitorElement * > h_pullTheta
std::vector< std::vector< int > > totSIM_vertpos
std::vector< std::vector< int > > totASSpT_Quality05
void setBinError(int binx, double error)
set uncertainty on content of bin (1-D)
std::vector< std::vector< int > > totREC_hit
std::vector< MonitorElement * > h_simulhit
std::vector< std::vector< int > > totSIMeta
std::vector< std::vector< int > > totASS2_dxy
std::vector< MonitorElement * > h_charge
std::vector< MonitorElement * > h_assocphi
virtual void doProfileX(MonitorElement *th2m, MonitorElement *me)
std::vector< std::vector< int > > totASS2_phi
std::vector< std::vector< double > > phiintervals
std::vector< std::vector< int > > totASSpT_Quality075
std::vector< MonitorElement * > h_assocpT
std::vector< MonitorElement * > h_pullDxy
std::vector< MonitorElement * > h_simulpT
std::vector< MonitorElement * > h_tracksSIM
std::vector< MonitorElement * > h_assocphi_Quality05
std::vector< MonitorElement * > h_simulzpos
std::vector< MonitorElement * > h_recodz
std::vector< MonitorElement * > h_assocphi_Quality075
std::vector< std::vector< int > > totSIM_phi
void fillPlotFromVector(MonitorElement *h, std::vector< int > &vec)
std::vector< MonitorElement * > h_hits_eta
std::vector< MonitorElement * > h_hits
double p1[4]
Definition: TauolaWrapper.h:89
std::vector< std::vector< int > > totASSeta
std::vector< MonitorElement * > h_simulvertpos
MuonTrackValidatorBase(const edm::ParameterSet &pset)
TProfile * getTProfile(void) const
std::vector< std::vector< int > > totRECeta
std::vector< std::vector< double > > vertposintervals
std::vector< std::vector< double > > dzintervals
std::vector< MonitorElement * > h_recodxy
std::vector< MonitorElement * > h_ptSIM
int getNbinsX(void) const
get # of bins in X-axis
std::vector< MonitorElement * > h_assocdz
std::vector< std::vector< double > > zposintervals
std::vector< MonitorElement * > h_assocpT_Quality05
std::vector< MonitorElement * > h_RPChits_eta
std::vector< MonitorElement * > h_assoc2pT
std::vector< MonitorElement * > h_assocFraction
volatile std::atomic< bool > shutdown_flag false
TH2F * getTH2F(void) const
std::vector< std::vector< int > > totSIM_dz
std::vector< std::string > associators
std::vector< MonitorElement * > h_assoceta_Quality05
std::vector< MonitorElement * > h_assocdxy
edm::EDGetTokenT< TrackingParticleCollection > tp_effic_Token
std::vector< MonitorElement * > nRPChits_vs_eta
std::vector< std::vector< int > > totASS_vertpos
std::vector< MonitorElement * > h_assochit
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:40
std::vector< std::vector< int > > totASS_hit
std::vector< MonitorElement * > nCSChits_vs_eta
std::vector< MonitorElement * > h_simuleta
std::vector< MonitorElement * > h_assoc2eta
edm::EDGetTokenT< reco::BeamSpot > bsSrc_Token