CMS 3D CMS Logo

TrackAnalyzer.cc
Go to the documentation of this file.
1 /*
2  * See header file for a description of this class.
3  *
4  * \author Suchandra Dutta , Giorgia Mila
5  */
6 
15 
20 #include <string>
21 #include "TMath.h"
23 
24 using namespace dqm;
25 
26 namespace {
27  template <typename T, size_t N>
28  std::array<T, N+1> makeLogBins(const double min, const double max) {
29  const double minLog10 = std::log10(min);
30  const double maxLog10 = std::log10(max);
31  const double width = (maxLog10-minLog10)/N;
32  std::array<T, N+1> ret;
33  ret[0] = std::pow(10,minLog10);
34  const double mult = std::pow(10, width);
35  for(size_t i=1; i<= N; ++i) {
36  ret[i] = ret[i-1]*mult;
37  }
38  return ret;
39  }
40 }
41 
43  : conf_( nullptr )
44  , stateName_ (iConfig.getParameter<std::string>("MeasurementState") )
45  , doTrackerSpecific_ ( iConfig.getParameter<bool>("doTrackerSpecific") )
46  , doAllPlots_ ( iConfig.getParameter<bool>("doAllPlots") )
47  , doBSPlots_ ( iConfig.getParameter<bool>("doBeamSpotPlots") )
48  , doPVPlots_ ( iConfig.getParameter<bool>("doPrimaryVertexPlots") )
49  , doDCAPlots_ ( iConfig.getParameter<bool>("doDCAPlots") )
50  , doGeneralPropertiesPlots_ ( iConfig.getParameter<bool>("doGeneralPropertiesPlots") )
51  , doMeasurementStatePlots_ ( iConfig.getParameter<bool>("doMeasurementStatePlots") )
52  , doHitPropertiesPlots_ ( iConfig.getParameter<bool>("doHitPropertiesPlots") )
53  , doRecHitVsPhiVsEtaPerTrack_ ( iConfig.getParameter<bool>("doRecHitVsPhiVsEtaPerTrack") )
54  , doRecHitVsPtVsEtaPerTrack_ ( iConfig.getParameter<bool>("doRecHitVsPtVsEtaPerTrack") )
55  , doLayersVsPhiVsEtaPerTrack_ ( iConfig.getParameter<bool>("doLayersVsPhiVsEtaPerTrack") )
56  , doRecHitsPerTrackProfile_ ( iConfig.getParameter<bool>("doRecHitsPerTrackProfile") )
57  , doThetaPlots_ ( iConfig.getParameter<bool>("doThetaPlots") )
58  , doTrackPxPyPlots_ ( iConfig.getParameter<bool>("doTrackPxPyPlots") )
59  , doDCAwrtPVPlots_ ( iConfig.getParameter<bool>("doDCAwrtPVPlots") )
60  , doDCAwrt000Plots_ ( iConfig.getParameter<bool>("doDCAwrt000Plots") )
61  , doLumiAnalysis_ ( iConfig.getParameter<bool>("doLumiAnalysis") )
62  , doTestPlots_ ( iConfig.getParameter<bool>("doTestPlots") )
63  , doHIPlots_ ( iConfig.getParameter<bool>("doHIPlots") )
64  , doSIPPlots_ ( iConfig.getParameter<bool>("doSIPPlots") )
65  , doEffFromHitPatternVsPU_ ( iConfig.getParameter<bool>("doEffFromHitPatternVsPU") )
66  , doEffFromHitPatternVsBX_ ( iConfig.getParameter<bool>("doEffFromHitPatternVsBX") )
67  , doEffFromHitPatternVsLUMI_ ( iConfig.getParameter<bool>("doEffFromHitPatternVsLUMI") )
68  , pvNDOF_ ( iConfig.getParameter<int> ("pvNDOF") )
69  , useBPixLayer1_ ( iConfig.getParameter<bool>("useBPixLayer1") )
70  , minNumberOfPixelsPerCluster_ ( iConfig.getParameter<int>("minNumberOfPixelsPerCluster") )
71  , minPixelClusterCharge_ ( iConfig.getParameter<double>("minPixelClusterCharge") )
72  , qualityString_ ( iConfig.getParameter<std::string>("qualityString"))
73  , good_vertices_(0)
74  , bx_(0)
75  , pixel_lumi_(0.)
76  , scal_lumi_(0.)
77 {
78  initHistos();
79  TopFolder_ = iConfig.getParameter<std::string>("FolderName");
80 }
81 
83  : TrackAnalyzer(iConfig)
84 {
85  edm::InputTag bsSrc = iConfig.getParameter<edm::InputTag>("beamSpot");
86  edm::InputTag primaryVertexInputTag = iConfig.getParameter<edm::InputTag>("primaryVertex");
87  edm::InputTag pixelClusterInputTag = iConfig.getParameter<edm::InputTag>("pixelCluster4lumi");
88  edm::InputTag scalInputTag = iConfig.getParameter<edm::InputTag>("scal");
90  pvToken_ = iC.consumes<reco::VertexCollection>(primaryVertexInputTag);
93 
94  if(useBPixLayer1_)
96  else
98 
99 
100 }
101 
103 {
104  Chi2 = nullptr;
105  Chi2Prob = nullptr;
106  Chi2ProbVsPhi = nullptr;
107  Chi2ProbVsEta = nullptr;
108  Chi2oNDF = nullptr;
109  Chi2oNDFVsEta = nullptr;
110  Chi2oNDFVsPhi = nullptr;
111  Chi2oNDFVsTheta = nullptr;
112 
113  NumberOfRecHitsPerTrack = nullptr;
115  NumberOfLostRecHitsPerTrack = nullptr;
116 
120 
122 
125 
126  DistanceOfClosestApproach = nullptr;
130  DeltaZToPV = nullptr;
136  xPointOfClosestApproach = nullptr;
139  yPointOfClosestApproach = nullptr;
142  zPointOfClosestApproach = nullptr;
144  algorithm = nullptr;
145  oriAlgo = nullptr;
146  stoppingSource = nullptr;
147  stoppingSourceVSeta = nullptr;
148  stoppingSourceVSphi = nullptr;
149  // TESTING
152 
153 // by Mia in order to deal w/ LS transitions
154  Chi2oNDF_lumiFlag = nullptr;
156 
158  //special Plots for HI DQM //SHOULD I ADD THE BOOL HERE??
160  LongDCASig = nullptr;
161  TransDCASig = nullptr;
162  dNdPhi_HighPurity = nullptr;
163  dNdEta_HighPurity = nullptr;
164  dNdPt_HighPurity = nullptr;
165  NhitVsEta_HighPurity = nullptr;
166  NhitVsPhi_HighPurity = nullptr;
167 
168  // IP significance
169  sipDxyToBS = nullptr;
170  sipDzToBS = nullptr;
171  sip3dToPV = nullptr;
172  sip2dToPV = nullptr;
173  sipDxyToPV = nullptr;
174  sipDzToPV = nullptr;
175 
176 }
177 
179 {
180 }
181 
182 void TrackAnalyzer::initHisto(DQMStore::IBooker & ibooker, const edm::EventSetup & iSetup, const edm::ParameterSet& iConfig)
183 {
184  conf_ = &iConfig;
186  bookHistosForBeamSpot(ibooker);
190  if (doEffFromHitPatternVsLUMI_ || doAllPlots_) bookHistosForEfficiencyFromHitPatter(ibooker, iSetup, "VsSCALLUMI");
191  // if (doEffFromHitPatternVsLUMI_ || doAllPlots_) bookHistosForEfficiencyFromHitPatter(ibooker, iSetup, "VsPIXELLUMI");
192 
193  // book tracker specific related histograms
194  // ---------------------------------------------------------------------------------//
196 
197  // book state related histograms
198  // ---------------------------------------------------------------------------------//
200 
201 
202  if (stateName_ == "All") {
203  bookHistosForState("OuterSurface", ibooker);
204  bookHistosForState("InnerSurface", ibooker);
205  bookHistosForState("ImpactPoint" , ibooker);
206  } else if (
207  stateName_ != "OuterSurface" &&
208  stateName_ != "InnerSurface" &&
209  stateName_ != "ImpactPoint" &&
210  stateName_ != "default"
211  ) {
212  bookHistosForState("default", ibooker);
213 
214  } else {
215  bookHistosForState(stateName_, ibooker);
216  }
217  conf_ = nullptr;
218  }
219 }
220 
222  const edm::EventSetup & iSetup,
223  const std::string suffix)
224 {
225 
226  ibooker.setCurrentFolder(TopFolder_ + "/HitEffFromHitPattern" + suffix);
227 
228  constexpr int LUMIBin = 300; // conf_->getParameter<int>("LUMIBin");
229  float LUMIMin = conf_->getParameter<double>("LUMIMin");
230  float LUMIMax = conf_->getParameter<double>("LUMIMax");
231 
232 
233  int NBINS[] = { 60, int(GetLumi::lastBunchCrossing), LUMIBin, LUMIBin};
234  float MIN[] = { 0.5, 0.5, LUMIMin, LUMIMin };
235  float MAX[] = { 60.5, float(GetLumi::lastBunchCrossing)+0.5, LUMIMax, LUMIMax };
236  std::string NAME[] = { "", "VsBX", "VsLUMI", "VsLUMI" };
237 
238  auto logBins = makeLogBins<float,LUMIBin>(LUMIMin,LUMIMax);
239 
240  int mon = -1;
241  int nbins = -1;
242  float min = -1.;
243  float max = -1.;
244  bool logQ = false;
245  std::string name = "";
246  for (int i=0; i<monQuantity::END; i++) {
247  if (monName[i] == suffix) {
248  logQ = (i>1);
249  mon = i;
250  nbins = NBINS[i];
251  min = MIN[i];
252  max = MAX[i];
253  name = NAME[i];
254  }
255  }
256 
257  edm::ESHandle<TrackerGeometry> trackerGeometry;
258  iSetup.get<TrackerDigiGeometryRecord>().get(trackerGeometry);
259 
260  // Values are not ordered randomly, but the order is taken from
261  // http://cmslxr.fnal.gov/dxr/CMSSW/source/Geometry/CommonDetUnit/interface/GeomDetEnumerators.h#15
262  const char * dets[] = { "None", "PXB", "PXF", "TIB", "TID", "TOB", "TEC"};
263 
264  // Also in this case, ordering is not random but extracted from
265  // http://cmslxr.fnal.gov/dxr/CMSSW/source/DataFormats/TrackReco/interface/HitPattern.h
266  // The category "total" is an addition to ease the computation of
267  // the efficiencies and is not part of the original HitPattern.
268  const char * hit_category[] = { "valid", "missing", "inactive", "bad", "total"};
269 
270  // We set sub_det to be a 1-based index since to it is the sub-sub-structure in the HitPattern
271  char title[50];
272  for (unsigned int det = 1; det < sizeof(dets)/sizeof(char*); ++det ) {
273  for (unsigned int sub_det = 1;
274  sub_det <= trackerGeometry->numberOfLayers(det); ++sub_det) {
275  for (unsigned int cat = 0;
276  cat < sizeof(hit_category)/sizeof(char *); ++cat) {
277  memset(title, 0, sizeof(title));
278  snprintf(title, sizeof(title), "Hits%s_%s_%s_Subdet%d", name.c_str(), hit_category[cat], dets[det], sub_det);
279  switch(cat) {
280  case 0:
281  hits_valid_.insert(std::make_pair(
282  Key(det, sub_det, mon), logQ?
283  ibooker.book1D(title, title, nbins, &logBins[0]) :
284  ibooker.book1D(title, title, nbins, min, max)));
285  break;
286  case 4:
287  hits_total_.insert(std::make_pair(
288  Key(det, sub_det, mon), logQ?
289  ibooker.book1D(title, title, nbins, &logBins[0]) :
290  ibooker.book1D(title, title, nbins, min, max)));
291  break;
292  default:
293  LogDebug("TrackAnalyzer") << "Invalid hit category used " << cat << " ignored\n";
294  }
295  }
296  }
297  }
298 }
299 
302 
303  // parameters from the configuration
304  std::string QualName = conf_->getParameter<std::string>("Quality");
305  std::string AlgoName = conf_->getParameter<std::string>("AlgoName");
306  std::string MEBSFolderName = conf_->getParameter<std::string>("BSFolderName");
307 
308  // use the AlgoName and Quality Name
309  std::string CategoryName = QualName != "" ? AlgoName + "_" + QualName : AlgoName;
310 
311  // get binning from the configuration
312  int TKHitBin = conf_->getParameter<int>( "RecHitBin");
313  double TKHitMin = conf_->getParameter<double>("RecHitMin");
314  double TKHitMax = conf_->getParameter<double>("RecHitMax");
315 
316  int TKLostBin = conf_->getParameter<int>( "RecLostBin");
317  double TKLostMin = conf_->getParameter<double>("RecLostMin");
318  double TKLostMax = conf_->getParameter<double>("RecLostMax");
319 
320  int TKLayBin = conf_->getParameter<int>( "RecLayBin");
321  double TKLayMin = conf_->getParameter<double>("RecLayMin");
322  double TKLayMax = conf_->getParameter<double>("RecLayMax");
323 
324  int PhiBin = conf_->getParameter<int>( "PhiBin");
325  double PhiMin = conf_->getParameter<double>("PhiMin");
326  double PhiMax = conf_->getParameter<double>("PhiMax");
327 
328  int EtaBin = conf_->getParameter<int>( "EtaBin");
329  double EtaMin = conf_->getParameter<double>("EtaMin");
330  double EtaMax = conf_->getParameter<double>("EtaMax");
331 
332  int PtBin = conf_->getParameter<int>( "TrackPtBin");
333  double PtMin = conf_->getParameter<double>("TrackPtMin");
334  double PtMax = conf_->getParameter<double>("TrackPtMax");
335 
336  int VXBin = conf_->getParameter<int>( "VXBin");
337  double VXMin = conf_->getParameter<double>("VXMin");
338  double VXMax = conf_->getParameter<double>("VXMax");
339 
340  int VYBin = conf_->getParameter<int>( "VYBin");
341  double VYMin = conf_->getParameter<double>("VYMin");
342  double VYMax = conf_->getParameter<double>("VYMax");
343 
344  int VZBin = conf_->getParameter<int>( "VZBin");
345  double VZMin = conf_->getParameter<double>("VZMin");
346  double VZMax = conf_->getParameter<double>("VZMax");
347 
348  ibooker.setCurrentFolder(TopFolder_);
349 
350  // book the Hit Property histograms
351  // ---------------------------------------------------------------------------------//
352 
353  TkParameterMEs tkmes;
355 
356  ibooker.setCurrentFolder(TopFolder_+"/HitProperties");
357 
358  histname = "NumberOfRecHitsPerTrack_";
359  NumberOfRecHitsPerTrack = ibooker.book1D(histname+CategoryName, histname+CategoryName, TKHitBin, TKHitMin, TKHitMax);
360  NumberOfRecHitsPerTrack->setAxisTitle("Number of all RecHits of each Track");
361  NumberOfRecHitsPerTrack->setAxisTitle("Number of Tracks", 2);
362 
363  histname = "NumberOfValidRecHitsPerTrack_";
364  NumberOfValidRecHitsPerTrack = ibooker.book1D(histname+CategoryName, histname+CategoryName, TKHitBin, TKHitMin, TKHitMax);
365  NumberOfValidRecHitsPerTrack->setAxisTitle("Number of valid RecHits for each Track");
366 
367  NumberOfValidRecHitsPerTrack->setAxisTitle("Number of Tracks", 2);
368 
369  histname = "NumberOfLostRecHitsPerTrack_";
370  NumberOfLostRecHitsPerTrack = ibooker.book1D(histname+CategoryName, histname+CategoryName, TKLostBin, TKLostMin, TKLostMax);
371  NumberOfLostRecHitsPerTrack->setAxisTitle("Number of lost RecHits for each Track");
372  NumberOfLostRecHitsPerTrack->setAxisTitle("Number of Tracks", 2);
373 
374  histname = "NumberOfMissingInnerRecHitsPerTrack_";
375  NumberOfMIRecHitsPerTrack = ibooker.book1D(histname+CategoryName, histname+CategoryName, 10, -0.5, 9.5);
376  NumberOfMIRecHitsPerTrack->setAxisTitle("Number of missing-inner RecHits for each Track");
377  NumberOfMIRecHitsPerTrack->setAxisTitle("Number of Tracks", 2);
378 
379  histname = "NumberOfMissingOuterRecHitsPerTrack_";
380  NumberOfMORecHitsPerTrack = ibooker.book1D(histname+CategoryName, histname+CategoryName, 10, -0.5, 9.5);
381  NumberOfMORecHitsPerTrack->setAxisTitle("Number of missing-outer RecHits for each Track");
382  NumberOfMORecHitsPerTrack->setAxisTitle("Number of Tracks", 2);
383 
384  histname = "ValidFractionPerTrack_";
385  ValidFractionPerTrack = ibooker.book1D(histname+CategoryName, histname+CategoryName, 101, 0., 1.01);
386  ValidFractionPerTrack->setAxisTitle("ValidFraction of RecHits for each Track");
387  ValidFractionPerTrack->setAxisTitle("Number of Tracks", 2);
388 
389 
390 
392 
393  histname = "NumberOfValidRecHitVsPhiVsEtaPerTrack_";
394  NumberOfValidRecHitVsPhiVsEtaPerTrack = ibooker.bookProfile2D(histname+CategoryName, histname+CategoryName,
395  EtaBin, EtaMin, EtaMax, PhiBin, PhiMin, PhiMax, 0, 40., "");
398 
399  histname = "NumberOfLostRecHitVsPhiVsEtaPerTrack_";
400  NumberOfLostRecHitVsPhiVsEtaPerTrack = ibooker.bookProfile2D(histname+CategoryName, histname+CategoryName,
401  EtaBin, EtaMin, EtaMax, PhiBin, PhiMin, PhiMax, 0, 5., "");
404 
405 
406  histname = "NumberMIRecHitVsPhiVsEtaPerTrack_";
407  NumberOfMIRecHitVsPhiVsEtaPerTrack = ibooker.bookProfile2D(histname+CategoryName, histname+CategoryName,
408  EtaBin, EtaMin, EtaMax, PhiBin, PhiMin, PhiMax, 0, 15., "");
411 
412  histname = "NumberMORecHitVsPhiVsEtaPerTrack_";
413  NumberOfMORecHitVsPhiVsEtaPerTrack = ibooker.bookProfile2D(histname+CategoryName, histname+CategoryName,
414  EtaBin, EtaMin, EtaMax, PhiBin, PhiMin, PhiMax, 0, 15., "");
417 
418  histname = "ValidFractionVsPhiVsEtaPerTrack_";
419  ValidFractionVsPhiVsEtaPerTrack = ibooker.bookProfile2D(histname+CategoryName, histname+CategoryName,
420  EtaBin, EtaMin, EtaMax, PhiBin, PhiMin, PhiMax, 0, 2., "");
423 
424  }
425 
427 
428  histname = "NumberOfValidRecHitVsPtVsEtaPerTrack_";
429  NumberOfValidRecHitVsPtVsEtaPerTrack = ibooker.bookProfile2D(histname+CategoryName, histname+CategoryName,
430  EtaBin, EtaMin, EtaMax, PtBin, PtMin, PtMax, 0, 40., "");
432  NumberOfValidRecHitVsPtVsEtaPerTrack->setAxisTitle("Track p_{T} [GeV] ", 2);
433 
434  histname = "NumberOfLostRecHitVsPtVsEtaPerTrack_";
435  NumberOfLostRecHitVsPtVsEtaPerTrack = ibooker.bookProfile2D(histname+CategoryName, histname+CategoryName,
436  EtaBin, EtaMin, EtaMax, PtBin, PtMin, PtMax, 0, 5., "");
438  NumberOfLostRecHitVsPtVsEtaPerTrack->setAxisTitle("Track p_{T} [GeV] ", 2);
439 
440 
441  histname = "NumberMIRecHitVsPtVsEtaPerTrack_";
442  NumberOfMIRecHitVsPtVsEtaPerTrack = ibooker.bookProfile2D(histname+CategoryName, histname+CategoryName,
443  EtaBin, EtaMin, EtaMax, PtBin, PtMin, PtMax, 0, 15., "");
445  NumberOfMIRecHitVsPtVsEtaPerTrack->setAxisTitle("Track p_{T} [GeV] ", 2);
446 
447  histname = "NumberMORecHitVsPtVsEtaPerTrack_";
448  NumberOfMORecHitVsPtVsEtaPerTrack = ibooker.bookProfile2D(histname+CategoryName, histname+CategoryName,
449  EtaBin, EtaMin, EtaMax, PtBin, PtMin, PtMax, 0, 15., "");
451  NumberOfMORecHitVsPtVsEtaPerTrack->setAxisTitle("Track p_{T} [GeV] ", 2);
452 
453  }
454 
455  histname = "NumberOfValidRecHitsPerTrackVsPt_";
456  NumberOfValidRecHitsPerTrackVsPt = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, PtBin, PtMin, PtMax, TKHitMin, TKHitMax,"");
457  NumberOfValidRecHitsPerTrackVsPt->setAxisTitle("Track p_{T} [GeV]",1);
458  NumberOfValidRecHitsPerTrackVsPt->setAxisTitle("Number of valid RecHits in each Track",2);
459 
460  histname = "NumberOfLostRecHitsPerTrackVsPt_";
461  NumberOfLostRecHitsPerTrackVsPt = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, PtBin, PtMin, PtMax,TKHitMin, TKHitMax,"");
462  NumberOfLostRecHitsPerTrackVsPt->setAxisTitle("Track p_{T} [GeV]", 1);
463  NumberOfLostRecHitsPerTrackVsPt->setAxisTitle("Average Number of Lost RecHits per Track", 2);
464 
465 
466  histname = "NumberMIRecHitsPerTrackVsPt_";
467  NumberOfMIRecHitsPerTrackVsPt = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, PtBin, PtMin, PtMax,TKHitMin, TKHitMax,"");
468  NumberOfMIRecHitsPerTrackVsPt->setAxisTitle("Track p_{T} [GeV]", 1);
469  NumberOfMIRecHitsPerTrackVsPt->setAxisTitle("Average Number of Lost RecHits per Track", 2);
470 
471  histname = "NumberMORecHitsPerTrackVsPt_";
472  NumberOfMORecHitsPerTrackVsPt = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, PtBin, PtMin, PtMax,TKHitMin, TKHitMax,"");
473  NumberOfMORecHitsPerTrackVsPt->setAxisTitle("Track p_{T} [GeV]", 1);
474  NumberOfMORecHitsPerTrackVsPt->setAxisTitle("Average Number of Lost RecHits per Track", 2);
475 
476  std::string layerTypeName[4] = {"","Off","3D","Missing"};
477  for (int i=0; i<4; ++i) {
478  histname = "NumberOf"+ layerTypeName[i] + "LayersPerTrack_";
479  NumberOfLayersPerTrack[i] = ibooker.book1D(histname+CategoryName, histname+CategoryName, TKLayBin, TKLayMin, TKLayMax);
480  NumberOfLayersPerTrack[i]->setAxisTitle("Number of " + layerTypeName[i] + " Layers of each Track", 1);
481  NumberOfLayersPerTrack[i]->setAxisTitle("Number of Tracks", 2);
482  }
484  for (int i=0; i<4; ++i) {
485  histname = "NumberOf"+ layerTypeName[i] + "LayersVsPhiVsEtaPerTrack_";
486  NumberOfLayersVsPhiVsEtaPerTrack[i] = ibooker.bookProfile2D(histname+CategoryName, histname+CategoryName,
487  EtaBin, EtaMin, EtaMax, PhiBin, PhiMin, PhiMax, 0, 40., "");
488  NumberOfLayersVsPhiVsEtaPerTrack[i]->setAxisTitle("Track #eta ", 1);
489  NumberOfLayersVsPhiVsEtaPerTrack[i]->setAxisTitle("Track #phi ", 2);
490  }
491  }
492 
493  // book the General Property histograms
494  // ---------------------------------------------------------------------------------//
495 
497 
498  int Chi2Bin = conf_->getParameter<int>( "Chi2Bin");
499  double Chi2Min = conf_->getParameter<double>("Chi2Min");
500  double Chi2Max = conf_->getParameter<double>("Chi2Max");
501 
502  int Chi2NDFBin = conf_->getParameter<int>( "Chi2NDFBin");
503  double Chi2NDFMin = conf_->getParameter<double>("Chi2NDFMin");
504  double Chi2NDFMax = conf_->getParameter<double>("Chi2NDFMax");
505 
506  int Chi2ProbBin = conf_->getParameter<int>( "Chi2ProbBin");
507  double Chi2ProbMin = conf_->getParameter<double>("Chi2ProbMin");
508  double Chi2ProbMax = conf_->getParameter<double>("Chi2ProbMax");
509 
510 
511  //HI PLOTS////
512  int TransDCABins = conf_->getParameter<int>("TransDCABins");
513  double TransDCAMin = conf_->getParameter<double>("TransDCAMin");
514  double TransDCAMax = conf_->getParameter<double>("TransDCAMax");
515 
516  int LongDCABins = conf_->getParameter<int>("LongDCABins");
517  double LongDCAMin = conf_->getParameter<double>("LongDCAMin");
518  double LongDCAMax = conf_->getParameter<double>("LongDCAMax");
520 
521 
522  ibooker.setCurrentFolder(TopFolder_+"/GeneralProperties");
523 
524  histname = "Chi2_";
525  Chi2 = ibooker.book1D(histname+CategoryName, histname+CategoryName, Chi2Bin, Chi2Min, Chi2Max);
526  Chi2->setAxisTitle("Track #chi^{2}" ,1);
527  Chi2->setAxisTitle("Number of Tracks",2);
528 
529  histname = "Chi2Prob_";
530  Chi2Prob = ibooker.book1D(histname+CategoryName, histname+CategoryName, Chi2ProbBin, Chi2ProbMin, Chi2ProbMax);
531  Chi2Prob->setAxisTitle("Track #chi^{2} probability",1);
532  Chi2Prob->setAxisTitle("Number of Tracks" ,2);
533 
534  histname = "Chi2oNDF_";
535  Chi2oNDF = ibooker.book1D(histname+CategoryName, histname+CategoryName, Chi2NDFBin, Chi2NDFMin, Chi2NDFMax);
536  Chi2oNDF->setAxisTitle("Track #chi^{2}/ndf",1);
537  Chi2oNDF->setAxisTitle("Number of Tracks" ,2);
538 
539 
541  //HI PLOTS///
543  if (doHIPlots_)
544  {
545  histname = "LongDCASig_";
546  LongDCASig = ibooker.book1D(histname+CategoryName, histname+CategoryName,LongDCABins,LongDCAMin,LongDCAMax);
547  LongDCASig->setAxisTitle("dz/#sigma_{dz}",1);
548 
549  histname = "TransDCASig_";
550  TransDCASig = ibooker.book1D(histname+CategoryName,histname+CategoryName,TransDCABins,TransDCAMin,TransDCAMax);
551  TransDCASig->setAxisTitle("dxy/#sigma_{dxy}",1);
552 
553  histname = "dNdPhi_HighPurity_";
554  dNdPhi_HighPurity = ibooker.book1D(histname+CategoryName,histname+CategoryName,PhiBin,PhiMin,PhiMax);
555  dNdPhi_HighPurity->setAxisTitle("#phi",1);
556 
557  histname = "dNdEta_HighPurity_";
558  dNdEta_HighPurity = ibooker.book1D(histname+CategoryName,histname+CategoryName,EtaBin,EtaMin,EtaMax);
559  dNdEta_HighPurity->setAxisTitle("#eta",1);
560 
561  histname = "dNdPt_HighPurity_";
562  dNdPt_HighPurity = ibooker.book1D(histname+CategoryName,histname+CategoryName,150,0,0.3);
563  dNdPt_HighPurity->setAxisTitle("#sigma_{p_{T}}/p_{T}",1);
564 
565  histname = "NhitVsEta_HighPurity_";
566  NhitVsEta_HighPurity = ibooker.bookProfile(histname+CategoryName,histname+CategoryName,EtaBin,EtaMin,EtaMax,-0.5,39.5,"");
567  NhitVsEta_HighPurity->setAxisTitle("Track #eta",1);
568  NhitVsEta_HighPurity->setAxisTitle("Number of Valid RecHits in each Track",2);
569 
570  histname = "NhitVsPhi_HighPurity_";
571  NhitVsPhi_HighPurity = ibooker.bookProfile(histname+CategoryName,histname+CategoryName,PhiBin,PhiMin,PhiMax,-0.5,39.5,"");
572  NhitVsPhi_HighPurity->setAxisTitle("Track #phi",1);
573  NhitVsPhi_HighPurity->setAxisTitle("Number of Valid RecHits in each Track",2);
574 
575  histname = "Ptdist_HighPurity_";
576  Ptdist_HighPurity = ibooker.book1D(histname+CategoryName,histname+CategoryName,150,0,50.);
577  Ptdist_HighPurity->setAxisTitle("p_{T} (GeV/c)",1);
578  Ptdist_HighPurity->setAxisTitle("Number of Tracks",2);
579 
580  histname = "dNhitdPt_HighPurity_";
581  dNhitdPt_HighPurity = ibooker.bookProfile(histname+CategoryName,histname+CategoryName,150,0,25.,-0.5,39.5,"");
582  dNhitdPt_HighPurity->setAxisTitle("p_{T} (GeV/c)",1);
583  dNhitdPt_HighPurity->setAxisTitle("N_{hit}",2);
584 
585  }
586 
587 
588 
590  histname = "xPointOfClosestApproach_";
591  xPointOfClosestApproach = ibooker.book1D(histname+CategoryName, histname+CategoryName, VXBin, VXMin, VXMax);
592  xPointOfClosestApproach->setAxisTitle("x component of Track PCA to beam line (cm)",1);
593  xPointOfClosestApproach->setAxisTitle("Number of Tracks",2);
594 
595  histname = "yPointOfClosestApproach_";
596  yPointOfClosestApproach = ibooker.book1D(histname+CategoryName, histname+CategoryName, VYBin, VYMin, VYMax);
597  yPointOfClosestApproach->setAxisTitle("y component of Track PCA to beam line (cm)",1);
598  yPointOfClosestApproach->setAxisTitle("Number of Tracks",2);
599 
600  histname = "zPointOfClosestApproach_";
601  zPointOfClosestApproach = ibooker.book1D(histname+CategoryName, histname+CategoryName, VZBin, VZMin, VZMax);
602  zPointOfClosestApproach->setAxisTitle("z component of Track PCA to beam line (cm)",1);
603  zPointOfClosestApproach->setAxisTitle("Number of Tracks",2);
604 
605  histname = "xPointOfClosestApproachToPV_";
606  xPointOfClosestApproachToPV = ibooker.book1D(histname+CategoryName, histname+CategoryName, VXBin, VXMin, VXMax);
607  xPointOfClosestApproachToPV->setAxisTitle("x component of Track PCA to pv (cm)",1);
608  xPointOfClosestApproachToPV->setAxisTitle("Number of Tracks",2);
609 
610  histname = "yPointOfClosestApproachToPV_";
611  yPointOfClosestApproachToPV = ibooker.book1D(histname+CategoryName, histname+CategoryName, VYBin, VYMin, VYMax);
612  yPointOfClosestApproachToPV->setAxisTitle("y component of Track PCA to pv line (cm)",1);
613  yPointOfClosestApproachToPV->setAxisTitle("Number of Tracks",2);
614 
615  histname = "zPointOfClosestApproachToPV_";
616  zPointOfClosestApproachToPV = ibooker.book1D(histname+CategoryName, histname+CategoryName, VZBin, VZMin, VZMax);
617  zPointOfClosestApproachToPV->setAxisTitle("z component of Track PCA to pv line (cm)",1);
618  zPointOfClosestApproachToPV->setAxisTitle("Number of Tracks",2);
619  }
620 
621  // See DataFormats/TrackReco/interface/TrackBase.h for track algorithm enum definition
622  // http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/CMSSW/DataFormats/TrackReco/interface/TrackBase.h?view=log
623  histname = "algorithm_";
624  algorithm = ibooker.book1D(histname+CategoryName, histname+CategoryName, reco::TrackBase::algoSize, 0., double(reco::TrackBase::algoSize));
625  algorithm->setAxisTitle("Tracking algorithm",1);
626  algorithm->setAxisTitle("Number of Tracks",2);
627 
628  histname = "originalAlgorithm_";
629  oriAlgo = ibooker.book1D(histname+CategoryName, histname+CategoryName, reco::TrackBase::algoSize, 0., double(reco::TrackBase::algoSize));
630  oriAlgo->setAxisTitle("Tracking algorithm",1);
631  oriAlgo->setAxisTitle("Number of Tracks",2);
632 
633  for (size_t ibin=0; ibin<reco::TrackBase::algoSize-1; ibin++) {
636  }
637 
638  size_t StopReasonNameSize = sizeof(StopReasonName::StopReasonName)/sizeof(std::string);
639  if(StopReasonNameSize != static_cast<unsigned int>(StopReason::SIZE)) {
640  throw cms::Exception("Assert") << "StopReason::SIZE is " << static_cast<unsigned int>(StopReason::SIZE)
641  << " but StopReasonName's only for "
642  << StopReasonNameSize
643  << ". Please update DataFormats/TrackReco/interface/TrajectoryStopReasons.h.";
644  }
645 
646  histname = "stoppingSource_";
647  stoppingSource = ibooker.book1D(histname+CategoryName, histname+CategoryName, StopReasonNameSize, 0., double(StopReasonNameSize));
648  stoppingSource->setAxisTitle("stopping reason",1);
649  stoppingSource->setAxisTitle("Number of Tracks",2);
650 
651  histname = "stoppingSourceVSeta_";
652  stoppingSourceVSeta = ibooker.bookProfile(histname+CategoryName, histname+CategoryName,
653  EtaBin, EtaMin, EtaMax, 2, 0., 2.);
654  stoppingSourceVSeta->setAxisTitle("track #eta",1);
655  stoppingSourceVSeta->setAxisTitle("stopped fraction",2);
656 
657  histname = "stoppingSourceVSphi_";
658  stoppingSourceVSphi = ibooker.bookProfile(histname+CategoryName, histname+CategoryName,
659  PhiBin, PhiMin, PhiMax, 2, 0., 2.);
660  stoppingSourceVSphi->setAxisTitle("track #phi",1);
661  stoppingSourceVSphi->setAxisTitle("stopped fraction",2);
662 
663  for (size_t ibin=0; ibin<StopReasonNameSize; ibin++) {
665  }
666 
667  }
668 
669 }
670 
672 
673  // parameters from the configuration
674  std::string QualName = conf_->getParameter<std::string>("Quality");
675  std::string AlgoName = conf_->getParameter<std::string>("AlgoName");
676 
677  // use the AlgoName and Quality Name
678  std::string CategoryName = QualName != "" ? AlgoName + "_" + QualName : AlgoName;
679 
680 
681  // book LS analysis related histograms
682  // -----------------------------------
683  if ( doLumiAnalysis_ ) {
684 
685  // get binning from the configuration
686  int TKHitBin = conf_->getParameter<int>( "RecHitBin");
687  double TKHitMin = conf_->getParameter<double>("RecHitMin");
688  double TKHitMax = conf_->getParameter<double>("RecHitMax");
689 
690  int Chi2NDFBin = conf_->getParameter<int>( "Chi2NDFBin");
691  double Chi2NDFMin = conf_->getParameter<double>("Chi2NDFMin");
692  double Chi2NDFMax = conf_->getParameter<double>("Chi2NDFMax");
693 
694  // add by Mia in order to deal w/ LS transitions
695  ibooker.setCurrentFolder(TopFolder_+"/LSanalysis");
696 
697  histname = "NumberOfRecHitsPerTrack_lumiFlag_";
698  NumberOfRecHitsPerTrack_lumiFlag = ibooker.book1D(histname+CategoryName, histname+CategoryName, TKHitBin, TKHitMin, TKHitMax);
699  NumberOfRecHitsPerTrack_lumiFlag->setAxisTitle("Number of all RecHits of each Track");
700  NumberOfRecHitsPerTrack_lumiFlag->setAxisTitle("Number of Tracks", 2);
701 
702  histname = "Chi2oNDF_lumiFlag_";
703  Chi2oNDF_lumiFlag = ibooker.book1D(histname+CategoryName, histname+CategoryName, Chi2NDFBin, Chi2NDFMin, Chi2NDFMax);
704  Chi2oNDF_lumiFlag->setAxisTitle("Track #chi^{2}/ndf",1);
705  Chi2oNDF_lumiFlag->setAxisTitle("Number of Tracks" ,2);
706 
707  }
708 }
709 
711 
712  // parameters from the configuration
713  std::string QualName = conf_->getParameter<std::string>("Quality");
714  std::string AlgoName = conf_->getParameter<std::string>("AlgoName");
715 
716  // use the AlgoName and Quality Name
717  std::string CategoryName = QualName != "" ? AlgoName + "_" + QualName : AlgoName;
718 
719  // book the Beam Spot related histograms
720  // ---------------------------------------------------------------------------------//
721 
723 
724  int DxyBin = conf_->getParameter<int>( "DxyBin");
725  double DxyMin = conf_->getParameter<double>("DxyMin");
726  double DxyMax = conf_->getParameter<double>("DxyMax");
727 
728  int AbsDxyBin = conf_->getParameter<int>( "AbsDxyBin");
729  double AbsDxyMin = conf_->getParameter<double>("AbsDxyMin");
730  double AbsDxyMax = conf_->getParameter<double>("AbsDxyMax");
731 
732  int PhiBin = conf_->getParameter<int>( "PhiBin");
733  double PhiMin = conf_->getParameter<double>("PhiMin");
734  double PhiMax = conf_->getParameter<double>("PhiMax");
735 
736  int X0Bin = conf_->getParameter<int>( "X0Bin");
737  double X0Min = conf_->getParameter<double>("X0Min");
738  double X0Max = conf_->getParameter<double>("X0Max");
739 
740  int Y0Bin = conf_->getParameter<int>( "Y0Bin");
741  double Y0Min = conf_->getParameter<double>("Y0Min");
742  double Y0Max = conf_->getParameter<double>("Y0Max");
743 
744  int Z0Bin = conf_->getParameter<int>( "Z0Bin");
745  double Z0Min = conf_->getParameter<double>("Z0Min");
746  double Z0Max = conf_->getParameter<double>("Z0Max");
747 
748  int VZBinProf = conf_->getParameter<int>( "VZBinProf");
749  double VZMinProf = conf_->getParameter<double>("VZMinProf");
750  double VZMaxProf = conf_->getParameter<double>("VZMaxProf");
751 
752 
753  ibooker.setCurrentFolder(TopFolder_+"/GeneralProperties");
754 
755  histname = "DistanceOfClosestApproachToBS_";
756  DistanceOfClosestApproachToBS = ibooker.book1D(histname+CategoryName,histname+CategoryName,DxyBin,DxyMin,DxyMax);
757  DistanceOfClosestApproachToBS->setAxisTitle("Track d_{xy} wrt beam spot (cm)",1);
758  DistanceOfClosestApproachToBS->setAxisTitle("Number of Tracks",2);
759 
760  histname = "AbsDistanceOfClosestApproachToBS_";
761  AbsDistanceOfClosestApproachToBS = ibooker.book1D(histname+CategoryName,histname+CategoryName,AbsDxyBin,AbsDxyMin,AbsDxyMax);
762  AbsDistanceOfClosestApproachToBS->setAxisTitle("Track |d_{xy}| wrt beam spot (cm)",1);
763  AbsDistanceOfClosestApproachToBS->setAxisTitle("Number of Tracks",2);
764 
765  histname = "DistanceOfClosestApproachToBSVsPhi_";
766  DistanceOfClosestApproachToBSVsPhi = ibooker.bookProfile(histname+CategoryName,histname+CategoryName, PhiBin, PhiMin, PhiMax, DxyBin, DxyMin, DxyMax,"");
767  DistanceOfClosestApproachToBSVsPhi->getTH1()->SetCanExtend(TH1::kAllAxes);
769  DistanceOfClosestApproachToBSVsPhi->setAxisTitle("Track d_{xy} wrt beam spot (cm)",2);
770 
771  histname = "xPointOfClosestApproachVsZ0wrt000_";
772  xPointOfClosestApproachVsZ0wrt000 = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, Z0Bin, Z0Min, Z0Max, X0Bin, X0Min, X0Max,"");
774  xPointOfClosestApproachVsZ0wrt000->setAxisTitle("x component of Track PCA to beam line (cm)",2);
775 
776  histname = "yPointOfClosestApproachVsZ0wrt000_";
777  yPointOfClosestApproachVsZ0wrt000 = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, Z0Bin, Z0Min, Z0Max, Y0Bin, Y0Min, Y0Max,"");
779  yPointOfClosestApproachVsZ0wrt000->setAxisTitle("y component of Track PCA to beam line (cm)",2);
780 
781  histname = "xPointOfClosestApproachVsZ0wrtBS_";
782  xPointOfClosestApproachVsZ0wrtBS = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, Z0Bin, Z0Min, Z0Max, X0Bin, X0Min, X0Max,"");
783  xPointOfClosestApproachVsZ0wrtBS->setAxisTitle("d_{z} w.r.t. Beam Spot (cm)",1);
784  xPointOfClosestApproachVsZ0wrtBS->setAxisTitle("x component of Track PCA to BS (cm)",2);
785 
786  histname = "yPointOfClosestApproachVsZ0wrtBS_";
787  yPointOfClosestApproachVsZ0wrtBS = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, Z0Bin, Z0Min, Z0Max, Y0Bin, Y0Min, Y0Max,"");
788  yPointOfClosestApproachVsZ0wrtBS->setAxisTitle("d_{z} w.r.t. Beam Spot (cm)",1);
789  yPointOfClosestApproachVsZ0wrtBS->setAxisTitle("y component of Track PCA to BS (cm)",2);
790 
791  histname = "zPointOfClosestApproachVsPhi_";
792  zPointOfClosestApproachVsPhi = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, PhiBin, PhiMin, PhiMax, VZBinProf, VZMinProf, VZMaxProf, "");
794  zPointOfClosestApproachVsPhi->setAxisTitle("z component of Track PCA to beam line (cm)",2);
795  }
796 
798 
799  int DxyBin = conf_->getParameter<int>( "DxyBin");
800  double DxyMin = conf_->getParameter<double>("DxyMin");
801  double DxyMax = conf_->getParameter<double>("DxyMax");
802 
803  int PhiBin = conf_->getParameter<int>( "PhiBin");
804  double PhiMin = conf_->getParameter<double>("PhiMin");
805  double PhiMax = conf_->getParameter<double>("PhiMax");
806 
807  int X0Bin = conf_->getParameter<int>( "X0Bin");
808  double X0Min = conf_->getParameter<double>("X0Min");
809  double X0Max = conf_->getParameter<double>("X0Max");
810 
811  int Y0Bin = conf_->getParameter<int>( "Y0Bin");
812  double Y0Min = conf_->getParameter<double>("Y0Min");
813  double Y0Max = conf_->getParameter<double>("Y0Max");
814 
815  int Z0Bin = conf_->getParameter<int>( "Z0Bin");
816  double Z0Min = conf_->getParameter<double>("Z0Min");
817  double Z0Max = conf_->getParameter<double>("Z0Max");
818 
819  ibooker.setCurrentFolder(TopFolder_+"/GeneralProperties");
820 
821  histname = "DistanceOfClosestApproachToPV_";
822  DistanceOfClosestApproachToPV = ibooker.book1D(histname+CategoryName,histname+CategoryName,DxyBin,DxyMin,DxyMax);
823  DistanceOfClosestApproachToPV->setAxisTitle("Track d_{xy} w.r.t. PV (cm)",1);
824  DistanceOfClosestApproachToPV->setAxisTitle("Number of Tracks",2);
825 
826  histname = "DeltaZToPV_";
827  DeltaZToPV = ibooker.book1D(histname+CategoryName,histname+CategoryName,Z0Bin,Z0Min,Z0Max);
828  DeltaZToPV->setAxisTitle("Track d_{z} w.r.t. PV (cm)",1);
829  DeltaZToPV->setAxisTitle("Number of Tracks",2);
830 
831  histname = "DistanceOfClosestApproachToPVVsPhi_";
832  DistanceOfClosestApproachToPVVsPhi = ibooker.bookProfile(histname+CategoryName,histname+CategoryName, PhiBin, PhiMin, PhiMax, DxyBin, DxyMin, DxyMax,"");
833  DistanceOfClosestApproachToPVVsPhi->getTH1()->SetCanExtend(TH1::kAllAxes);
835  DistanceOfClosestApproachToPVVsPhi->setAxisTitle("Track d_{xy} w.r.t. PV (cm)",2);
836 
837  histname = "xPointOfClosestApproachVsZ0wrtPV_";
838  xPointOfClosestApproachVsZ0wrtPV = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, Z0Bin, Z0Min, Z0Max, X0Bin, X0Min, X0Max,"");
839  xPointOfClosestApproachVsZ0wrtPV->setAxisTitle("d_{z} w.r.t. PV (cm)",1);
840  xPointOfClosestApproachVsZ0wrtPV->setAxisTitle("x component of Track PCA to PV (cm)",2);
841 
842  histname = "yPointOfClosestApproachVsZ0wrtPV_";
843  yPointOfClosestApproachVsZ0wrtPV = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, Z0Bin, Z0Min, Z0Max, Y0Bin, Y0Min, Y0Max,"");
844  yPointOfClosestApproachVsZ0wrtPV->setAxisTitle("d_{z} w.r.t. PV (cm)",1);
845  yPointOfClosestApproachVsZ0wrtPV->setAxisTitle("y component of Track PCA to PV (cm)",2);
846 
847  }
848 
849  if (doBSPlots_ || doAllPlots_) {
850  if (doTestPlots_) {
851 
852  int DxyBin = conf_->getParameter<int>( "DxyBin");
853  double DxyMin = conf_->getParameter<double>("DxyMin");
854  double DxyMax = conf_->getParameter<double>("DxyMax");
855 
856  int PhiBin = conf_->getParameter<int>( "PhiBin");
857  double PhiMin = conf_->getParameter<double>("PhiMin");
858  double PhiMax = conf_->getParameter<double>("PhiMax");
859 
860  histname = "TESTDistanceOfClosestApproachToBS_";
861  TESTDistanceOfClosestApproachToBS = ibooker.book1D(histname+CategoryName,histname+CategoryName,DxyBin,DxyMin,DxyMax);
862  TESTDistanceOfClosestApproachToBS->setAxisTitle("Track d_{xy} wrt beam spot (cm)",1);
863  TESTDistanceOfClosestApproachToBS->setAxisTitle("Number of Tracks",2);
864 
865  histname = "TESTDistanceOfClosestApproachToBSVsPhi_";
866  TESTDistanceOfClosestApproachToBSVsPhi = ibooker.bookProfile(histname+CategoryName,histname+CategoryName, PhiBin, PhiMin, PhiMax, DxyBin, DxyMin, DxyMax,"");
867  TESTDistanceOfClosestApproachToBSVsPhi->getTH1()->SetCanExtend(TH1::kAllAxes);
869  TESTDistanceOfClosestApproachToBSVsPhi->setAxisTitle("Track d_{xy} wrt beam spot (cm)",2);
870 
871  }
872 
873  }
874 
875  // book the Profile plots for DCA related histograms
876  // ---------------------------------------------------------------------------------//
877  if(doDCAPlots_ || doAllPlots_) {
878 
879  if (doDCAwrt000Plots_) {
880 
881  int EtaBin = conf_->getParameter<int>( "EtaBin");
882  double EtaMin = conf_->getParameter<double>("EtaMin");
883  double EtaMax = conf_->getParameter<double>("EtaMax");
884 
885  int PhiBin = conf_->getParameter<int>( "PhiBin");
886  double PhiMin = conf_->getParameter<double>("PhiMin");
887  double PhiMax = conf_->getParameter<double>("PhiMax");
888 
889  int DxyBin = conf_->getParameter<int>( "DxyBin");
890  double DxyMin = conf_->getParameter<double>("DxyMin");
891  double DxyMax = conf_->getParameter<double>("DxyMax");
892 
893  if (doThetaPlots_) {
894  int ThetaBin = conf_->getParameter<int>( "ThetaBin");
895  double ThetaMin = conf_->getParameter<double>("ThetaMin");
896  double ThetaMax = conf_->getParameter<double>("ThetaMax");
897 
898  ibooker.setCurrentFolder(TopFolder_+"/GeneralProperties");
899  histname = "DistanceOfClosestApproachVsTheta_";
900  DistanceOfClosestApproachVsTheta = ibooker.bookProfile(histname+CategoryName,histname+CategoryName, ThetaBin, ThetaMin, ThetaMax, DxyMin,DxyMax,"");
902  DistanceOfClosestApproachVsTheta->setAxisTitle("Track d_{xy} wrt (0,0,0) (cm)",2);
903  }
904 
905  histname = "DistanceOfClosestApproachVsEta_";
906  DistanceOfClosestApproachVsEta = ibooker.bookProfile(histname+CategoryName,histname+CategoryName, EtaBin, EtaMin, EtaMax, DxyMin, DxyMax,"");
908  DistanceOfClosestApproachVsEta->setAxisTitle("Track d_{xy} wrt (0,0,0) (cm)",2);
909  // temporary patch in order to put back those MEs in Muon Workspace
910 
911  histname = "DistanceOfClosestApproach_";
912  DistanceOfClosestApproach = ibooker.book1D(histname+CategoryName,histname+CategoryName,DxyBin,DxyMin,DxyMax);
913  DistanceOfClosestApproach->setAxisTitle("Track d_{xy} wrt (0,0,0) (cm)",1);
914  DistanceOfClosestApproach->setAxisTitle("Number of Tracks",2);
915 
916  histname = "DistanceOfClosestApproachVsPhi_";
917  DistanceOfClosestApproachVsPhi = ibooker.bookProfile(histname+CategoryName,histname+CategoryName, PhiBin, PhiMin, PhiMax, DxyMin,DxyMax,"");
918  DistanceOfClosestApproachVsPhi->getTH1()->SetCanExtend(TH1::kAllAxes);
920  DistanceOfClosestApproachVsPhi->setAxisTitle("Track d_{xy} wrt (0,0,0) (cm)",2);
921  }
922  }
923 
924 
925  if (doSIPPlots_ || doAllPlots_) {
926  const double sipBins = 200;
927  const double sipMin = -20;
928  const double sipMax = 20;
929 
930  ibooker.setCurrentFolder(TopFolder_+"/GeneralProperties");
931 
932  // SIP wrt. beamspot
933  histname = "SIPDxyToBS_";
934  sipDxyToBS = ibooker.book1D(histname+CategoryName, histname+CategoryName, sipBins, sipMin, sipMax);
935  sipDxyToBS->setAxisTitle("Track dxy significance wrt beam spot",1);
936  sipDxyToBS->setAxisTitle("Number of Tracks",2);
937 
938  histname = "SIPDzToBS_";
939  sipDzToBS = ibooker.book1D(histname+CategoryName, histname+CategoryName, sipBins, sipMin, sipMax);
940  sipDzToBS->setAxisTitle("Track dz significance wrt beam spot",1);
941  sipDzToBS->setAxisTitle("Number of Tracks",2);
942 
943  // SIP wrt. vertex
944  histname = "SIP3DToPV_";
945  sip3dToPV = ibooker.book1D(histname+CategoryName, histname+CategoryName, sipBins, sipMin, sipMax);
946  sip3dToPV->setAxisTitle("3D IP significance wrt primary vertex",1);
947  sip3dToPV->setAxisTitle("Number of Tracks",2);
948 
949  histname = "SIP2DToPV_";
950  sip2dToPV = ibooker.book1D(histname+CategoryName, histname+CategoryName, sipBins, sipMin, sipMax);
951  sip2dToPV->setAxisTitle("2D IP significance wrt primary vertex",1);
952  sip2dToPV->setAxisTitle("Number of Tracks",2);
953 
954  histname = "SIPDxyToPV_";
955  sipDxyToPV = ibooker.book1D(histname+CategoryName, histname+CategoryName, sipBins, sipMin, sipMax);
956  sipDxyToPV->setAxisTitle("Track dxy significance wrt primary vertex",1);
957  sipDxyToPV->setAxisTitle("Number of Tracks",2);
958 
959  histname = "SIPDzToPV_";
960  sipDzToPV = ibooker.book1D(histname+CategoryName, histname+CategoryName, sipBins, sipMin, sipMax);
961  sipDzToPV->setAxisTitle("Track dz significance wrt primary vertex",1);
962  sipDzToPV->setAxisTitle("Number of Tracks",2);
963  }
964 }
965 
966 // -- Analyse
967 // ---------------------------------------------------------------------------------//
969 
970  good_vertices_ = 0;
971 
972  edm::Handle<reco::VertexCollection> recoPrimaryVerticesHandle;
973  iEvent.getByToken(pvToken_, recoPrimaryVerticesHandle);
974  if (recoPrimaryVerticesHandle.isValid())
975  if (!recoPrimaryVerticesHandle->empty())
976  for (auto v : *recoPrimaryVerticesHandle)
977  if (v.ndof() >= pvNDOF_ && !v.isFake())
978  ++good_vertices_;
979 }
980 
982  bx_ = iEvent.bunchCrossing();
983 }
984 
987  // as done by pixelLumi http://cmslxr.fnal.gov/source/DQM/PixelLumi/plugins/PixelLumiDQM.cc
988 
990  iEvent.getByToken(lumiscalersToken_, lumiScalers);
991  if ( lumiScalers.isValid() && !lumiScalers->empty() ) {
992  LumiScalersCollection::const_iterator scalit = lumiScalers->begin();
993  scal_lumi_ = scalit->instantLumi();
994  } else
995  scal_lumi_ = -1;
996 
998  iEvent.getByToken(pixelClustersToken_, pixelClusters);
999  if ( pixelClusters.isValid() ) {
1000 
1001  edm::ESHandle<TrackerTopology> tTopoHandle;
1002  iSetup.get<TrackerTopologyRcd>().get(tTopoHandle);
1003  const TrackerTopology* const tTopo = tTopoHandle.product();
1004 
1005  // Count the number of clusters with at least a minimum
1006  // number of pixels per cluster and at least a minimum charge.
1007  size_t numClusters = 0;
1008  size_t tot = 0;
1009 
1010  edmNew::DetSetVector<SiPixelCluster>::const_iterator pixCluDet = pixelClusters->begin();
1011  for ( ; pixCluDet!=pixelClusters->end(); ++pixCluDet) {
1012 
1013  DetId detid = pixCluDet->detId();
1014  size_t subdetid = detid.subdetId();
1015  // std::cout << tTopo->print(detid) << std::endl;
1016  if ( subdetid == (int) PixelSubdetector::PixelBarrel )
1017  if ( tTopo->layer(detid)==1 )
1018  continue;
1019 
1021  for ( ; pixClu != pixCluDet->end(); ++pixClu ) {
1022  ++tot;
1023  if ( (pixClu->size() >= minNumberOfPixelsPerCluster_) &&
1024  (pixClu->charge() >= minPixelClusterCharge_ ) ) {
1025  ++numClusters;
1026  }
1027  }
1028  }
1029  pixel_lumi_ = lumi_factor_per_bx_ * numClusters / GetLumi::CM2_TO_NANOBARN ; // ?!?!
1030  } else
1031  pixel_lumi_ = -1.;
1032 
1033 }
1034 
1036 {
1037  auto pt = track.pt();
1038  auto phi = track.phi();
1039  // double eta = track.eta();
1040  auto phiIn = track.innerPosition().phi();
1041  auto etaIn = track.innerPosition().eta();
1042  auto phiOut = track.outerPosition().phi();
1043  auto etaOut = track.outerPosition().eta();
1044 
1045  int nRecHits = track.hitPattern().numberOfHits(reco::HitPattern::TRACK_HITS);
1046  int nValidRecHits = track.numberOfValidHits();
1047  int nLostRecHits = track.numberOfLostHits();
1050 
1051  auto chi2 = track.chi2();
1052  auto chi2prob = TMath::Prob(track.chi2(),(int)track.ndof());
1053  auto chi2oNDF = track.normalizedChi2();
1054 
1056  // rec hits
1057  NumberOfRecHitsPerTrack -> Fill(nRecHits);
1058  NumberOfValidRecHitsPerTrack-> Fill(nValidRecHits);
1059  NumberOfLostRecHitsPerTrack -> Fill(nLostRecHits);
1060  NumberOfMIRecHitsPerTrack -> Fill(nLostIn);
1061  NumberOfMORecHitsPerTrack -> Fill(nLostOut);
1063 
1064 
1065  // 2D plots
1067  NumberOfValidRecHitVsPhiVsEtaPerTrack->Fill(etaIn,phiIn,nValidRecHits);
1068  NumberOfLostRecHitVsPhiVsEtaPerTrack->Fill(etaIn,phiIn,nLostRecHits);
1069  NumberOfMIRecHitVsPhiVsEtaPerTrack->Fill(etaIn,phiIn,nLostIn);
1070  NumberOfMORecHitVsPhiVsEtaPerTrack->Fill(etaOut,phiOut,nLostOut);
1071  ValidFractionVsPhiVsEtaPerTrack -> Fill(etaIn,phiIn,track.validFraction());
1072  }
1074  NumberOfValidRecHitVsPtVsEtaPerTrack->Fill(etaIn,pt,nValidRecHits);
1075  NumberOfLostRecHitVsPtVsEtaPerTrack->Fill(etaIn,pt,nLostRecHits);
1076  NumberOfMIRecHitVsPtVsEtaPerTrack->Fill(etaIn,pt,nLostIn);
1077  NumberOfMORecHitVsPtVsEtaPerTrack->Fill(etaOut,pt,nLostOut);
1078  }
1079  NumberOfValidRecHitsPerTrackVsPt->Fill(pt,nValidRecHits);
1080  NumberOfLostRecHitsPerTrackVsPt->Fill(pt,nLostRecHits);
1083 
1084  int nLayers[4] = { track.hitPattern().trackerLayersWithMeasurement(),
1088  };
1089 
1090  // layers
1091  for (int i=0;i<4;++i) NumberOfLayersPerTrack[i]->Fill(nLayers[i]);
1092 
1093  // 2D plots
1095  for (int i=0;i<4;++i) NumberOfLayersVsPhiVsEtaPerTrack[i]->Fill(etaIn,phiIn,nLayers[i]);
1096 
1097  }
1098 
1102  // if (doEffFromHitPatternVsLUMI_ || doAllPlots_) fillHistosForEfficiencyFromHitPatter(track,"VsPIXELLUMI", pixel_lumi_ );
1103 
1104 
1106  // fitting
1107  Chi2 -> Fill(chi2);
1108  Chi2Prob -> Fill(chi2prob);
1109  Chi2oNDF -> Fill(chi2oNDF);
1110 
1111  // DCA
1112  // temporary patch in order to put back those MEs in Muon Workspace
1113  if (doDCAPlots_) {
1114  if (doDCAwrt000Plots_) {
1116  DistanceOfClosestApproachVsPhi->Fill(phi, track.dxy());
1117  }
1118 
1119  // PCA
1123  }
1124 
1125  // algorithm
1126  algorithm->Fill(static_cast<double>(track.algo()));
1127  oriAlgo->Fill(static_cast<double>(track.originalAlgo()));
1128 
1129  // stopping source
1130  int max = stoppingSource->getNbinsX();
1131  double stop = track.stopReason() > max ? double(max-1) : static_cast<double>(track.stopReason());
1132  double stopped = int(StopReason::NOT_STOPPED)==track.stopReason() ? 0. : 1.;
1133  stoppingSource->Fill(stop);
1134  stoppingSourceVSeta->Fill(track.eta(),stopped);
1135  stoppingSourceVSphi->Fill(track.phi(),stopped);
1136  }
1137 
1138  if ( doLumiAnalysis_ ) {
1140  Chi2oNDF_lumiFlag -> Fill(chi2oNDF);
1141  }
1142 
1144 
1145  edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
1146  iEvent.getByToken(beamSpotToken_,recoBeamSpotHandle);
1147  const reco::BeamSpot& bs = *recoBeamSpotHandle;
1148 
1151  DistanceOfClosestApproachToBSVsPhi -> Fill(track.phi(), track.dxy(bs.position()));
1152  zPointOfClosestApproachVsPhi -> Fill(track.phi(), track.vz());
1153  xPointOfClosestApproachVsZ0wrt000 -> Fill(track.dz(), track.vx());
1154  yPointOfClosestApproachVsZ0wrt000 -> Fill(track.dz(), track.vy());
1155  xPointOfClosestApproachVsZ0wrtBS -> Fill(track.dz(bs.position()),(track.vx()-bs.position(track.vz()).x()));
1156  yPointOfClosestApproachVsZ0wrtBS -> Fill(track.dz(bs.position()),(track.vy()-bs.position(track.vz()).y()));
1157  if (doTestPlots_) {
1158  TESTDistanceOfClosestApproachToBS -> Fill(track.dxy(bs.position(track.vz())));
1159  TESTDistanceOfClosestApproachToBSVsPhi -> Fill(track.phi(), track.dxy(bs.position(track.vz())));
1160  }
1161 
1162  if(doSIPPlots_) {
1163  sipDxyToBS->Fill(track.dxy(bs.position())/track.dxyError());
1164  sipDzToBS->Fill(track.dz(bs.position())/track.dzError());
1165  }
1166  }
1167 
1169  edm::Handle<reco::VertexCollection> recoPrimaryVerticesHandle;
1170  iEvent.getByToken(pvToken_,recoPrimaryVerticesHandle);
1171  if (recoPrimaryVerticesHandle.isValid() && !recoPrimaryVerticesHandle->empty()) {
1172  const reco::Vertex& pv = (*recoPrimaryVerticesHandle)[0];
1173 
1174 
1176  //HI PLOTS///////
1178 
1179  if(doHIPlots_)
1180  {
1181  double longDCAsig = 0, transDCAsig = 0;
1182  double zerr2 = track.dzError()*track.dzError()+pv.zError()*pv.zError();
1183  double xyerr2 = track.d0Error()*track.d0Error()+pv.xError()*pv.yError();
1184  if(zerr2 > 0) longDCAsig = track.dz(pv.position())/zerr2;
1185  if(xyerr2 > 0) transDCAsig = track.dxy(pv.position())/xyerr2;
1186  LongDCASig->Fill(longDCAsig);
1187  TransDCASig->Fill(transDCAsig);
1188 
1189 
1190 
1191 
1193  {
1194  dNdEta_HighPurity->Fill(track.eta());
1195  dNdPhi_HighPurity->Fill(track.phi());
1196  dNdPt_HighPurity->Fill(track.ptError()/track.pt());
1197  NhitVsEta_HighPurity->Fill(track.eta(),track.numberOfValidHits());
1198  NhitVsPhi_HighPurity->Fill(track.phi(),track.numberOfValidHits());
1199  dNhitdPt_HighPurity->Fill(track.pt(),track.numberOfValidHits());
1200  Ptdist_HighPurity->Fill(track.pt());
1201  }//end of high quality tracks requirement
1202  }
1203 
1204 
1205  xPointOfClosestApproachToPV->Fill(track.vx()-pv.position().x());
1206  yPointOfClosestApproachToPV->Fill(track.vy()-pv.position().y());
1209  DeltaZToPV -> Fill(track.dz (pv.position()));
1210  DistanceOfClosestApproachToPVVsPhi -> Fill(track.phi(), track.dxy(pv.position()));
1211  xPointOfClosestApproachVsZ0wrtPV -> Fill(track.dz(pv.position()),(track.vx()-pv.position().x()));
1212  yPointOfClosestApproachVsZ0wrtPV -> Fill(track.dz(pv.position()),(track.vy()-pv.position().y()));
1213 
1214 
1215  if(doSIPPlots_) {
1217  iSetup.get<TransientTrackRecord>().get("TransientTrackBuilder",theB);
1218  reco::TransientTrack transTrack = theB->build(track);
1219 
1220  GlobalVector dir(track.px(), track.py(), track.pz());
1221  std::pair<bool, Measurement1D> ip3d = IPTools::signedImpactParameter3D(transTrack, dir, pv);
1222  std::pair<bool, Measurement1D> ip2d = IPTools::signedTransverseImpactParameter(transTrack, dir, pv);
1223  if(ip3d.first) sip3dToPV->Fill(ip3d.second.value() / ip3d.second.error());
1224  if(ip2d.first) sip2dToPV->Fill(ip2d.second.value() / ip2d.second.error());
1225  sipDxyToPV->Fill(track.dxy(pv.position())/track.dxyError());
1226  sipDzToPV->Fill(track.dz(pv.position())/track.dzError());
1227  }
1228  }
1229  }
1230 
1231  if(doDCAPlots_ || doAllPlots_) {
1232  if (doDCAwrt000Plots_) {
1233  if (doThetaPlots_) {
1234  DistanceOfClosestApproachVsTheta->Fill(track.theta(), track.d0());
1235  }
1236  DistanceOfClosestApproachVsEta->Fill(track.eta(), track.d0());
1237  }
1238 
1239  }
1240 
1241  //Tracker Specific Histograms
1244  }
1245 
1247 
1248  if (stateName_ == "All") {
1249  fillHistosForState(iSetup, track, std::string("OuterSurface"));
1250  fillHistosForState(iSetup, track, std::string("InnerSurface"));
1251  fillHistosForState(iSetup, track, std::string("ImpactPoint"));
1252  } else if (
1253  stateName_ != "OuterSurface" &&
1254  stateName_ != "InnerSurface" &&
1255  stateName_ != "ImpactPoint" &&
1256  stateName_ != "default"
1257  ) {
1258  fillHistosForState(iSetup, track, std::string("default"));
1259  } else {
1260  fillHistosForState(iSetup, track, stateName_);
1261  }
1262  }
1263 
1264  if ( doAllPlots_ ) {
1265  }
1266 
1267 }
1268 
1270 
1271  int mon = -1;
1272  for (int i=0; i<monQuantity::END; i++) {
1273  if (monName[i] == suffix) mon = i;
1274  }
1275 
1276  // if (track.pt() > 1.0 && track.dxy() < 0.1 and monitoring > 0) {
1277  if (track.pt() > 1.0 && track.dxy() < 0.1 and monitoring > -9.) {
1278  auto hp = track.hitPattern();
1279  // Here hit_category is meant to iterate over
1280  // reco::HitPattern::HitCategory, defined here:
1281  // http://cmslxr.fnal.gov/dxr/CMSSW/source/DataFormats/TrackReco/interface/HitPattern.h
1282  for (unsigned int category = 0; category < 3; ++category) {
1283  for (int hit = 0; hit < hp.numberOfHits((reco::HitPattern::HitCategory)(category)); ++hit) {
1284  auto pattern = hp.getHitPattern((reco::HitPattern::HitCategory)(category), hit);
1285  // Boolean bad is missing simply because it is inferred and the only missing case.
1286  bool valid = hp.validHitFilter(pattern);
1287  bool missing = hp.missingHitFilter(pattern);
1288  bool inactive = hp.inactiveHitFilter(pattern);
1289  int hit_type = -1;
1290  hit_type = valid ? 0 :
1291  ( missing ? 1 :
1292  ( inactive ? 2 : 3));
1293  if (hits_valid_.find(Key(hp.getSubStructure(pattern), hp.getSubSubStructure(pattern), mon)) == hits_valid_.end()) {
1294  LogDebug("TrackAnalyzer") << "Invalid combination of detector and subdetector: ("
1295  << hp.getSubStructure(pattern) << ", "
1296  << hp.getSubSubStructure(pattern) << ", "
1297  << mon
1298  << "): ignoring it.\n";
1299  continue;
1300  }
1301  switch (hit_type) {
1302  case 0:
1303  hits_valid_[Key(hp.getSubStructure(pattern), hp.getSubSubStructure(pattern), mon)]->Fill(monitoring);
1304  hits_total_[Key(hp.getSubStructure(pattern), hp.getSubSubStructure(pattern), mon)]->Fill(monitoring);
1305  break;
1306  case 1:
1307  hits_total_[Key(hp.getSubStructure(pattern), hp.getSubSubStructure(pattern), mon)]->Fill(monitoring);
1308  break;
1309  default:
1310  LogDebug("TrackAnalyzer") << "Invalid hit category used " << hit_type << " ignored\n";
1311  }
1312  }
1313  }
1314  }
1315 
1316 }
1317 
1318 // book histograms at differnt measurement points
1319 // ---------------------------------------------------------------------------------//
1321 {
1322 
1323  // parameters from the configuration
1324  std::string QualName = conf_->getParameter<std::string>("Quality");
1325  std::string AlgoName = conf_->getParameter<std::string>("AlgoName");
1326 
1327  // use the AlgoName and Quality Name
1328  std::string CategoryName = QualName != "" ? AlgoName + "_" + QualName : AlgoName;
1329 
1330  // get binning from the configuration
1331  double Chi2NDFMin = conf_->getParameter<double>("Chi2NDFMin");
1332  double Chi2NDFMax = conf_->getParameter<double>("Chi2NDFMax");
1333 
1334  int RecHitBin = conf_->getParameter<int>( "RecHitBin");
1335  double RecHitMin = conf_->getParameter<double>("RecHitMin");
1336  double RecHitMax = conf_->getParameter<double>("RecHitMax");
1337 
1338  int RecLayBin = conf_->getParameter<int>( "RecHitBin");
1339  double RecLayMin = conf_->getParameter<double>("RecHitMin");
1340  double RecLayMax = conf_->getParameter<double>("RecHitMax");
1341 
1342 
1343  int PhiBin = conf_->getParameter<int>( "PhiBin");
1344  double PhiMin = conf_->getParameter<double>("PhiMin");
1345  double PhiMax = conf_->getParameter<double>("PhiMax");
1346 
1347  int EtaBin = conf_->getParameter<int>( "EtaBin");
1348  double EtaMin = conf_->getParameter<double>("EtaMin");
1349  double EtaMax = conf_->getParameter<double>("EtaMax");
1350 
1351  int ThetaBin = conf_->getParameter<int>( "ThetaBin");
1352  double ThetaMin = conf_->getParameter<double>("ThetaMin");
1353  double ThetaMax = conf_->getParameter<double>("ThetaMax");
1354 
1355  int TrackQBin = conf_->getParameter<int>( "TrackQBin");
1356  double TrackQMin = conf_->getParameter<double>("TrackQMin");
1357  double TrackQMax = conf_->getParameter<double>("TrackQMax");
1358 
1359  int TrackPtBin = conf_->getParameter<int>( "TrackPtBin");
1360  double TrackPtMin = conf_->getParameter<double>("TrackPtMin");
1361  double TrackPtMax = conf_->getParameter<double>("TrackPtMax");
1362 
1363  int TrackPBin = conf_->getParameter<int>( "TrackPBin");
1364  double TrackPMin = conf_->getParameter<double>("TrackPMin");
1365  double TrackPMax = conf_->getParameter<double>("TrackPMax");
1366 
1367  int TrackPxBin = conf_->getParameter<int>( "TrackPxBin");
1368  double TrackPxMin = conf_->getParameter<double>("TrackPxMin");
1369  double TrackPxMax = conf_->getParameter<double>("TrackPxMax");
1370 
1371  int TrackPyBin = conf_->getParameter<int>( "TrackPyBin");
1372  double TrackPyMin = conf_->getParameter<double>("TrackPyMin");
1373  double TrackPyMax = conf_->getParameter<double>("TrackPyMax");
1374 
1375  int TrackPzBin = conf_->getParameter<int>( "TrackPzBin");
1376  double TrackPzMin = conf_->getParameter<double>("TrackPzMin");
1377  double TrackPzMax = conf_->getParameter<double>("TrackPzMax");
1378 
1379  int ptErrBin = conf_->getParameter<int>( "ptErrBin");
1380  double ptErrMin = conf_->getParameter<double>("ptErrMin");
1381  double ptErrMax = conf_->getParameter<double>("ptErrMax");
1382 
1383  int pxErrBin = conf_->getParameter<int>( "pxErrBin");
1384  double pxErrMin = conf_->getParameter<double>("pxErrMin");
1385  double pxErrMax = conf_->getParameter<double>("pxErrMax");
1386 
1387  int pyErrBin = conf_->getParameter<int>( "pyErrBin");
1388  double pyErrMin = conf_->getParameter<double>("pyErrMin");
1389  double pyErrMax = conf_->getParameter<double>("pyErrMax");
1390 
1391  int pzErrBin = conf_->getParameter<int>( "pzErrBin");
1392  double pzErrMin = conf_->getParameter<double>("pzErrMin");
1393  double pzErrMax = conf_->getParameter<double>("pzErrMax");
1394 
1395  int pErrBin = conf_->getParameter<int>( "pErrBin");
1396  double pErrMin = conf_->getParameter<double>("pErrMin");
1397  double pErrMax = conf_->getParameter<double>("pErrMax");
1398 
1399  int phiErrBin = conf_->getParameter<int>( "phiErrBin");
1400  double phiErrMin = conf_->getParameter<double>("phiErrMin");
1401  double phiErrMax = conf_->getParameter<double>("phiErrMax");
1402 
1403  int etaErrBin = conf_->getParameter<int>( "etaErrBin");
1404  double etaErrMin = conf_->getParameter<double>("etaErrMin");
1405  double etaErrMax = conf_->getParameter<double>("etaErrMax");
1406 
1407 
1408  double Chi2ProbMin = conf_->getParameter<double>("Chi2ProbMin");
1409  double Chi2ProbMax = conf_->getParameter<double>("Chi2ProbMax");
1410 
1411  ibooker.setCurrentFolder(TopFolder_);
1412 
1413  TkParameterMEs tkmes;
1414 
1415  std::string histTag = (sname == "default") ? CategoryName : sname + "_" + CategoryName;
1416 
1417  if(doAllPlots_) {
1418 
1419  // general properties
1420  ibooker.setCurrentFolder(TopFolder_+"/GeneralProperties");
1421 
1422  if (doThetaPlots_) {
1423  histname = "Chi2oNDFVsTheta_" + histTag;
1424  tkmes.Chi2oNDFVsTheta = ibooker.bookProfile(histname, histname, ThetaBin, ThetaMin, ThetaMax, Chi2NDFMin, Chi2NDFMax,"");
1425  tkmes.Chi2oNDFVsTheta->setAxisTitle("Track #theta",1);
1426  tkmes.Chi2oNDFVsTheta->setAxisTitle("Track #chi^{2}/ndf",2);
1427  }
1428  histname = "Chi2oNDFVsPhi_" + histTag;
1429  tkmes.Chi2oNDFVsPhi = ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, Chi2NDFMin, Chi2NDFMax,"");
1430  tkmes.Chi2oNDFVsPhi->setAxisTitle("Track #phi",1);
1431  tkmes.Chi2oNDFVsPhi->setAxisTitle("Track #chi^{2}/ndf",2);
1432 
1433  histname = "Chi2ProbVsPhi_" + histTag;
1434  tkmes.Chi2ProbVsPhi = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, PhiBin, PhiMin, PhiMax, Chi2ProbMin, Chi2ProbMax);
1435  tkmes.Chi2ProbVsPhi->setAxisTitle("Tracks #phi" ,1);
1436  tkmes.Chi2ProbVsPhi->setAxisTitle("Track #chi^{2} probability",2);
1437 
1438  histname = "Chi2ProbVsEta_" + histTag;
1439  tkmes.Chi2ProbVsEta = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, EtaBin, EtaMin, EtaMax, Chi2ProbMin, Chi2ProbMax);
1440  tkmes.Chi2ProbVsEta->setAxisTitle("Tracks #eta" ,1);
1441  tkmes.Chi2ProbVsEta->setAxisTitle("Track #chi^{2} probability",2);
1442 
1443  }
1444 
1445  // general properties
1446  ibooker.setCurrentFolder(TopFolder_+"/GeneralProperties");
1447 
1448 
1449  histname = "Chi2oNDFVsEta_" + histTag;
1450  tkmes.Chi2oNDFVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, Chi2NDFMin, Chi2NDFMax,"");
1451  tkmes.Chi2oNDFVsEta->setAxisTitle("Track #eta",1);
1452  tkmes.Chi2oNDFVsEta->setAxisTitle("Track #chi^{2}/ndf",2);
1453 
1454  histname = "Chi2oNDFVsPt_" + histTag;
1455  tkmes.Chi2oNDFVsPt = ibooker.bookProfile(histname, histname, TrackPtBin, TrackPtMin, TrackPtMax, Chi2NDFMin, Chi2NDFMax,"");
1456  tkmes.Chi2oNDFVsPt->setAxisTitle("Track p_{T} (GeV/c)", 1);
1457  tkmes.Chi2oNDFVsPt->setAxisTitle("Track #chi^{2}/ndf",2);
1458 
1459  histname = "Chi2oNDFVsNHits_" + histTag;
1460  tkmes.Chi2oNDFVsNHits = ibooker.bookProfile(histname, histname, 50, 0, 50, Chi2NDFMin, Chi2NDFMax,"");
1461  tkmes.Chi2oNDFVsNHits->setAxisTitle("Track NHits", 1);
1462  tkmes.Chi2oNDFVsNHits->setAxisTitle("Track #chi^{2}/ndf",2);
1463 
1464  histname = "TrackP_" + histTag;
1465  tkmes.TrackP = ibooker.book1D(histname, histname, TrackPBin, TrackPMin, TrackPMax);
1466  tkmes.TrackP->setAxisTitle("Track |p| (GeV/c)", 1);
1467  tkmes.TrackP->setAxisTitle("Number of Tracks",2);
1468 
1469  histname = "TrackPt_" + histTag;
1470  tkmes.TrackPt = ibooker.book1D(histname, histname, TrackPtBin, TrackPtMin, TrackPtMax);
1471  tkmes.TrackPt->setAxisTitle("Track p_{T} (GeV/c)", 1);
1472  tkmes.TrackPt->setAxisTitle("Number of Tracks",2);
1473 
1474  if (doTrackPxPyPlots_) {
1475  histname = "TrackPx_" + histTag;
1476  tkmes.TrackPx = ibooker.book1D(histname, histname, TrackPxBin, TrackPxMin, TrackPxMax);
1477  tkmes.TrackPx->setAxisTitle("Track p_{x} (GeV/c)", 1);
1478  tkmes.TrackPx->setAxisTitle("Number of Tracks",2);
1479 
1480  histname = "TrackPy_" + histTag;
1481  tkmes.TrackPy = ibooker.book1D(histname, histname, TrackPyBin, TrackPyMin, TrackPyMax);
1482  tkmes.TrackPy->setAxisTitle("Track p_{y} (GeV/c)", 1);
1483  tkmes.TrackPy->setAxisTitle("Number of Tracks",2);
1484  }
1485  histname = "TrackPz_" + histTag;
1486  tkmes.TrackPz = ibooker.book1D(histname, histname, TrackPzBin, TrackPzMin, TrackPzMax);
1487  tkmes.TrackPz->setAxisTitle("Track p_{z} (GeV/c)", 1);
1488  tkmes.TrackPz->setAxisTitle("Number of Tracks",2);
1489 
1490  histname = "TrackPhi_" + histTag;
1491  tkmes.TrackPhi = ibooker.book1D(histname, histname, PhiBin, PhiMin, PhiMax);
1492  tkmes.TrackPhi->setAxisTitle("Track #phi", 1);
1493  tkmes.TrackPhi->setAxisTitle("Number of Tracks",2);
1494 
1495  histname = "TrackEta_" + histTag;
1496  tkmes.TrackEta = ibooker.book1D(histname, histname, EtaBin, EtaMin, EtaMax);
1497  tkmes.TrackEta->setAxisTitle("Track #eta", 1);
1498  tkmes.TrackEta->setAxisTitle("Number of Tracks",2);
1499 
1500  histname = "TrackEtaPhi_" + histTag;
1501  tkmes.TrackEtaPhi = ibooker.book2D(histname, histname, EtaBin, EtaMin, EtaMax, PhiBin, PhiMin, PhiMax);
1502  tkmes.TrackEtaPhi->setAxisTitle("Track #eta", 1);
1503  tkmes.TrackEtaPhi->setAxisTitle("Track #phi", 2);
1504 
1505  histname = "TrackEtaPhiInner_" + histTag;
1506  tkmes.TrackEtaPhiInner = ibooker.book2D(histname, histname, EtaBin, EtaMin, EtaMax, PhiBin, PhiMin, PhiMax);
1507  tkmes.TrackEtaPhiInner->setAxisTitle("Track #eta", 1);
1508  tkmes.TrackEtaPhiInner->setAxisTitle("Track #phi", 2);
1509 
1510  histname = "TrackEtaPhiOuter_" + histTag;
1511  tkmes.TrackEtaPhiOuter = ibooker.book2D(histname, histname, EtaBin, EtaMin, EtaMax, PhiBin, PhiMin, PhiMax);
1512  tkmes.TrackEtaPhiOuter->setAxisTitle("Track #eta", 1);
1513  tkmes.TrackEtaPhiOuter->setAxisTitle("Track #phi", 2);
1514 
1515 
1516 
1517  if (doThetaPlots_) {
1518  histname = "TrackTheta_" + histTag;
1519  tkmes.TrackTheta = ibooker.book1D(histname, histname, ThetaBin, ThetaMin, ThetaMax);
1520  tkmes.TrackTheta->setAxisTitle("Track #theta", 1);
1521  tkmes.TrackTheta->setAxisTitle("Number of Tracks",2);
1522  }
1523  histname = "TrackQ_" + histTag;
1524  tkmes.TrackQ = ibooker.book1D(histname, histname, TrackQBin, TrackQMin, TrackQMax);
1525  tkmes.TrackQ->setAxisTitle("Track Charge", 1);
1526  tkmes.TrackQ->setAxisTitle("Number of Tracks",2);
1527 
1528  histname = "TrackPErrOverP_" + histTag;
1529  tkmes.TrackPErr = ibooker.book1D(histname, histname, pErrBin, pErrMin, pErrMax);
1530  tkmes.TrackPErr->setAxisTitle("track error(p)/p", 1);
1531  tkmes.TrackPErr->setAxisTitle("Number of Tracks",2);
1532 
1533  histname = "TrackPtErrOverPt_" + histTag;
1534  tkmes.TrackPtErr = ibooker.book1D(histname, histname, ptErrBin, ptErrMin, ptErrMax);
1535  tkmes.TrackPtErr->setAxisTitle("track error(p_{T})/p_{T}", 1);
1536  tkmes.TrackPtErr->setAxisTitle("Number of Tracks",2);
1537 
1538  histname = "TrackPtErrOverPtVsEta_" + histTag;
1539  tkmes.TrackPtErrVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, ptErrMin, ptErrMax);
1540  tkmes.TrackPtErrVsEta->setAxisTitle("Track #eta",1);
1541  tkmes.TrackPtErrVsEta->setAxisTitle("track error(p_{T})/p_{T}", 2);
1542 
1543  if (doTrackPxPyPlots_) {
1544  histname = "TrackPxErrOverPx_" + histTag;
1545  tkmes.TrackPxErr = ibooker.book1D(histname, histname, pxErrBin, pxErrMin, pxErrMax);
1546  tkmes.TrackPxErr->setAxisTitle("track error(p_{x})/p_{x}", 1);
1547  tkmes.TrackPxErr->setAxisTitle("Number of Tracks",2);
1548 
1549  histname = "TrackPyErrOverPy_" + histTag;
1550  tkmes.TrackPyErr = ibooker.book1D(histname, histname, pyErrBin, pyErrMin, pyErrMax);
1551  tkmes.TrackPyErr->setAxisTitle("track error(p_{y})/p_{y}", 1);
1552  tkmes.TrackPyErr->setAxisTitle("Number of Tracks",2);
1553  }
1554  histname = "TrackPzErrOverPz_" + histTag;
1555  tkmes.TrackPzErr = ibooker.book1D(histname, histname, pzErrBin, pzErrMin, pzErrMax);
1556  tkmes.TrackPzErr->setAxisTitle("track error(p_{z})/p_{z}", 1);
1557  tkmes.TrackPzErr->setAxisTitle("Number of Tracks",2);
1558 
1559  histname = "TrackPhiErr_" + histTag;
1560  tkmes.TrackPhiErr = ibooker.book1D(histname, histname, phiErrBin, phiErrMin, phiErrMax);
1561  tkmes.TrackPhiErr->setAxisTitle("track error(#phi)");
1562  tkmes.TrackPhiErr->setAxisTitle("Number of Tracks",2);
1563 
1564  histname = "TrackEtaErr_" + histTag;
1565  tkmes.TrackEtaErr = ibooker.book1D(histname, histname, etaErrBin, etaErrMin, etaErrMax);
1566  tkmes.TrackEtaErr->setAxisTitle("track error(#eta)");
1567  tkmes.TrackEtaErr->setAxisTitle("Number of Tracks",2);
1568 
1569  // rec hit profiles
1570  ibooker.setCurrentFolder(TopFolder_+"/GeneralProperties");
1571  histname = "NumberOfRecHitsPerTrackVsPhi_" + histTag;
1572  tkmes.NumberOfRecHitsPerTrackVsPhi = ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, RecHitBin, RecHitMin, RecHitMax,"");
1573  tkmes.NumberOfRecHitsPerTrackVsPhi->setAxisTitle("Track #phi",1);
1574  tkmes.NumberOfRecHitsPerTrackVsPhi->setAxisTitle("Number of RecHits in each Track",2);
1575 
1576  if (doThetaPlots_) {
1577  histname = "NumberOfRecHitsPerTrackVsTheta_" + histTag;
1578  tkmes.NumberOfRecHitsPerTrackVsTheta = ibooker.bookProfile(histname, histname, ThetaBin, ThetaMin, ThetaMax, RecHitBin, RecHitMin, RecHitMax,"");
1579  tkmes.NumberOfRecHitsPerTrackVsTheta->setAxisTitle("Track #phi",1);
1580  tkmes.NumberOfRecHitsPerTrackVsTheta->setAxisTitle("Number of RecHits in each Track",2);
1581  }
1582  histname = "NumberOfRecHitsPerTrackVsEta_" + histTag;
1583  tkmes.NumberOfRecHitsPerTrackVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, RecHitBin, RecHitMin, RecHitMax,"");
1584  tkmes.NumberOfRecHitsPerTrackVsEta->setAxisTitle("Track #eta",1);
1585  tkmes.NumberOfRecHitsPerTrackVsEta->setAxisTitle("Number of RecHits in each Track",2);
1586 
1587  histname = "NumberOfValidRecHitsPerTrackVsPhi_" + histTag;
1588  tkmes.NumberOfValidRecHitsPerTrackVsPhi = ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, RecHitMin, RecHitMax,"");
1589  tkmes.NumberOfValidRecHitsPerTrackVsPhi->setAxisTitle("Track #phi",1);
1590  tkmes.NumberOfValidRecHitsPerTrackVsPhi->setAxisTitle("Number of valid RecHits in each Track",2);
1591 
1592  histname = "NumberOfValidRecHitsPerTrackVsEta_" + histTag;
1593  tkmes.NumberOfValidRecHitsPerTrackVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, RecHitMin, RecHitMax,"");
1594  tkmes.NumberOfValidRecHitsPerTrackVsEta->setAxisTitle("Track #eta",1);
1595  tkmes.NumberOfValidRecHitsPerTrackVsEta->setAxisTitle("Number of valid RecHits in each Track",2);
1596 
1597  histname = "NumberOfValidRecHitsPerTrackVsPt_" + histTag;
1598  tkmes.NumberOfValidRecHitsPerTrackVsPt = ibooker.bookProfile(histname, histname, TrackPtBin, TrackPtMin, TrackPtMax, RecHitMin, RecHitMax,"");
1599  tkmes.NumberOfValidRecHitsPerTrackVsPt->setAxisTitle("Track p_{T} [GeV]",1);
1600  tkmes.NumberOfValidRecHitsPerTrackVsPt->setAxisTitle("Number of valid RecHits in each Track",2);
1601 
1603  histname = "NumberOfLayersPerTrackVsPhi_" + histTag;
1604  tkmes.NumberOfLayersPerTrackVsPhi = ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, RecLayBin, RecLayMin, RecLayMax,"");
1605  tkmes.NumberOfLayersPerTrackVsPhi->setAxisTitle("Track #phi",1);
1606  tkmes.NumberOfLayersPerTrackVsPhi->setAxisTitle("Number of Layers in each Track",2);
1607 
1608  if (doThetaPlots_) {
1609  histname = "NumberOfLayersPerTrackVsTheta_" + histTag;
1610  tkmes.NumberOfLayersPerTrackVsTheta = ibooker.bookProfile(histname, histname, ThetaBin, ThetaMin, ThetaMax, RecLayBin, RecLayMin, RecLayMax,"");
1611  tkmes.NumberOfLayersPerTrackVsTheta->setAxisTitle("Track #phi",1);
1612  tkmes.NumberOfLayersPerTrackVsTheta->setAxisTitle("Number of Layers in each Track",2);
1613  }
1614  histname = "NumberOfLayersPerTrackVsEta_" + histTag;
1615  tkmes.NumberOfLayersPerTrackVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, RecLayBin, RecLayMin, RecLayMax,"");
1616  tkmes.NumberOfLayersPerTrackVsEta->setAxisTitle("Track #eta",1);
1617  tkmes.NumberOfLayersPerTrackVsEta->setAxisTitle("Number of Layers in each Track",2);
1618 
1619  if (doThetaPlots_) {
1620  histname = "Chi2oNDFVsTheta_" + histTag;
1621  tkmes.Chi2oNDFVsTheta = ibooker.bookProfile(histname, histname, ThetaBin, ThetaMin, ThetaMax, Chi2NDFMin, Chi2NDFMax,"");
1622  tkmes.Chi2oNDFVsTheta->setAxisTitle("Track #theta",1);
1623  tkmes.Chi2oNDFVsTheta->setAxisTitle("Track #chi^{2}/ndf",2);
1624  }
1625  if (doAllPlots_) {
1626  histname = "Chi2oNDFVsPhi_" + histTag;
1627  tkmes.Chi2oNDFVsPhi = ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, Chi2NDFMin, Chi2NDFMax,"");
1628  tkmes.Chi2oNDFVsPhi->setAxisTitle("Track #phi",1);
1629  tkmes.Chi2oNDFVsPhi->setAxisTitle("Track #chi^{2}/ndf",2);
1630 
1631  histname = "Chi2oNDFVsEta_" + histTag;
1632  tkmes.Chi2oNDFVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, Chi2NDFMin, Chi2NDFMax,"");
1633  tkmes.Chi2oNDFVsEta->setAxisTitle("Track #eta",1);
1634  tkmes.Chi2oNDFVsEta->setAxisTitle("Track #chi^{2}/ndf",2);
1635 
1636  histname = "Chi2ProbVsPhi_" + histTag;
1637  tkmes.Chi2ProbVsPhi = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, PhiBin, PhiMin, PhiMax, Chi2ProbMin, Chi2ProbMax);
1638  tkmes.Chi2ProbVsPhi->setAxisTitle("Tracks #phi" ,1);
1639  tkmes.Chi2ProbVsPhi->setAxisTitle("Track #chi^{2} probability",2);
1640 
1641  histname = "Chi2ProbVsEta_" + histTag;
1642  tkmes.Chi2ProbVsEta = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, EtaBin, EtaMin, EtaMax, Chi2ProbMin, Chi2ProbMax);
1643  tkmes.Chi2ProbVsEta->setAxisTitle("Tracks #eta" ,1);
1644  tkmes.Chi2ProbVsEta->setAxisTitle("Track #chi^{2} probability",2);
1645  }
1646 
1647  // now put the MEs in the map
1648  TkParameterMEMap.insert( std::make_pair(sname, tkmes) );
1649 
1650 }
1651 
1652 
1653 // fill histograms at differnt measurement points
1654 // ---------------------------------------------------------------------------------//
1656 {
1657  //get the kinematic parameters
1658  double p, px, py, pz, pt, theta, phi, eta, q;
1659  double pxerror, pyerror, pzerror, pterror, perror, phierror, etaerror;
1660 
1661  auto phiIn = track.innerPosition().phi();
1662  auto etaIn = track.innerPosition().eta();
1663  auto phiOut = track.outerPosition().phi();
1664  auto etaOut = track.outerPosition().eta();
1665 
1666 
1667  if (sname == "default") {
1668 
1669  p = track.p();
1670  px = track.px();
1671  py = track.py();
1672  pz = track.pz();
1673  pt = track.pt();
1674  phi = track.phi();
1675  theta = track.theta();
1676  eta = track.eta();
1677  q = track.charge();
1678 
1679  pterror = (pt) ? track.ptError()/(pt*pt) : 0.0;
1680  pxerror = -1.0;
1681  pyerror = -1.0;
1682  pzerror = -1.0;
1683  perror = -1.0;
1684  phierror = track.phiError();
1685  etaerror = track.etaError();
1686 
1687  } else {
1688 
1690  iSetup.get<TransientTrackRecord>().get("TransientTrackBuilder",theB);
1691  reco::TransientTrack TransTrack = theB->build(track);
1692 
1694 
1695  if (sname == "OuterSurface") TSOS = TransTrack.outermostMeasurementState();
1696  else if (sname == "InnerSurface") TSOS = TransTrack.innermostMeasurementState();
1697  else if (sname == "ImpactPoint") TSOS = TransTrack.impactPointState();
1698 
1699  p = TSOS.globalMomentum().mag();
1700  px = TSOS.globalMomentum().x();
1701  py = TSOS.globalMomentum().y();
1702  pz = TSOS.globalMomentum().z();
1703  pt = TSOS.globalMomentum().perp();
1704  phi = TSOS.globalMomentum().phi();
1705  theta = TSOS.globalMomentum().theta();
1706  eta = TSOS.globalMomentum().eta();
1707  q = TSOS.charge();
1708 
1709  //get the error of the kinimatic parameters
1711  double partialPterror = errors(3,3)*pow(TSOS.globalMomentum().x(),2) + errors(4,4)*pow(TSOS.globalMomentum().y(),2);
1712  pterror = sqrt(partialPterror)/TSOS.globalMomentum().perp();
1713  pxerror = sqrt(errors(3,3))/TSOS.globalMomentum().x();
1714  pyerror = sqrt(errors(4,4))/TSOS.globalMomentum().y();
1715  pzerror = sqrt(errors(5,5))/TSOS.globalMomentum().z();
1716  perror = sqrt(partialPterror+errors(5,5)*pow(TSOS.globalMomentum().z(),2))/TSOS.globalMomentum().mag();
1717  phierror = sqrt(TSOS.curvilinearError().matrix()(2,2));
1718  etaerror = sqrt(TSOS.curvilinearError().matrix()(1,1))*fabs(sin(TSOS.globalMomentum().theta()));
1719 
1720  }
1721 
1722  std::map<std::string, TkParameterMEs>::iterator iPos = TkParameterMEMap.find(sname);
1723  if (iPos != TkParameterMEMap.end()) {
1724 
1725  TkParameterMEs tkmes = iPos->second;
1726 
1727  // momentum
1728  tkmes.TrackP->Fill(p);
1729  if (doTrackPxPyPlots_) {
1730  tkmes.TrackPx->Fill(px);
1731  tkmes.TrackPy->Fill(py);
1732  }
1733  tkmes.TrackPz->Fill(pz);
1734  tkmes.TrackPt->Fill(pt);
1735 
1736  // angles
1737  tkmes.TrackPhi->Fill(phi);
1738  tkmes.TrackEta->Fill(eta);
1739  tkmes.TrackEtaPhi->Fill(eta,phi);
1740  tkmes.TrackEtaPhiInner->Fill(etaIn,phiIn);
1741  tkmes.TrackEtaPhiOuter->Fill(etaOut,phiOut);
1742 
1743  if (doThetaPlots_) {
1744  tkmes.TrackTheta->Fill(theta);
1745  }
1746  tkmes.TrackQ->Fill(q);
1747 
1748  // errors
1749  tkmes.TrackPtErr->Fill(pterror);
1750  tkmes.TrackPtErrVsEta->Fill(eta,pterror);
1751  if (doTrackPxPyPlots_) {
1752  tkmes.TrackPxErr->Fill(pxerror);
1753  tkmes.TrackPyErr->Fill(pyerror);
1754  }
1755  tkmes.TrackPzErr->Fill(pzerror);
1756  tkmes.TrackPErr->Fill(perror);
1757  tkmes.TrackPhiErr->Fill(phierror);
1758  tkmes.TrackEtaErr->Fill(etaerror);
1759 
1760  int nRecHits = track.hitPattern().numberOfHits(reco::HitPattern::TRACK_HITS);
1761  int nValidRecHits = track.numberOfValidHits();
1762  // rec hits
1763  tkmes.NumberOfRecHitsPerTrackVsPhi->Fill(phi, nRecHits);
1764  if (doThetaPlots_) {
1765  tkmes.NumberOfRecHitsPerTrackVsTheta->Fill(theta,nRecHits);
1766  }
1767  tkmes.NumberOfRecHitsPerTrackVsEta->Fill(eta, nRecHits);
1768 
1769  tkmes.NumberOfValidRecHitsPerTrackVsPhi->Fill(phi, nValidRecHits);
1770  tkmes.NumberOfValidRecHitsPerTrackVsEta->Fill(eta, nValidRecHits);
1771  tkmes.NumberOfValidRecHitsPerTrackVsPt ->Fill(pt, nValidRecHits);
1772 
1774  // rec layers
1775  tkmes.NumberOfLayersPerTrackVsPhi->Fill(phi, nLayers);
1776  if (doThetaPlots_) {
1777  tkmes.NumberOfLayersPerTrackVsTheta->Fill(theta, nLayers);
1778  }
1779  tkmes.NumberOfLayersPerTrackVsEta->Fill(eta, nLayers);
1780 
1781  double chi2prob = TMath::Prob(track.chi2(),(int)track.ndof());
1782  double chi2oNDF = track.normalizedChi2();
1783 
1784  tkmes.Chi2oNDFVsEta->Fill(eta, chi2oNDF);
1785  tkmes.Chi2oNDFVsPt->Fill(pt, chi2oNDF);
1786  tkmes.Chi2oNDFVsNHits->Fill(nRecHits, chi2oNDF);
1787 
1788  if(doAllPlots_) {
1789 
1790  // general properties
1791  if (doThetaPlots_) {
1792  tkmes.Chi2oNDFVsTheta->Fill(theta, chi2oNDF);
1793  }
1794  tkmes.Chi2oNDFVsPhi->Fill(phi, chi2oNDF);
1795  tkmes.Chi2ProbVsPhi->Fill(phi, chi2prob);
1796  tkmes.Chi2ProbVsEta->Fill(eta, chi2prob);
1797  }
1798 
1799  }
1800 
1801 }
1802 
1803 
1805 {
1806 
1807  // parameters from the configuration
1808  std::string QualName = conf_->getParameter<std::string>("Quality");
1809  std::string AlgoName = conf_->getParameter<std::string>("AlgoName");
1810 
1811  // use the AlgoName and Quality Name
1812  std::string CategoryName = QualName != "" ? AlgoName + "_" + QualName : AlgoName;
1813 
1814  int PhiBin = conf_->getParameter<int>( "PhiBin");
1815  double PhiMin = conf_->getParameter<double>("PhiMin");
1816  double PhiMax = conf_->getParameter<double>("PhiMax");
1817 
1818  int EtaBin = conf_->getParameter<int>( "EtaBin");
1819  double EtaMin = conf_->getParameter<double>("EtaMin");
1820  double EtaMax = conf_->getParameter<double>("EtaMax");
1821 
1822  int PtBin = conf_->getParameter<int>( "TrackPtBin");
1823  double PtMin = conf_->getParameter<double>("TrackPtMin");
1824  double PtMax = conf_->getParameter<double>("TrackPtMax");
1825 
1826  // book hit property histograms
1827  // ---------------------------------------------------------------------------------//
1828  ibooker.setCurrentFolder(TopFolder_+"/HitProperties");
1829 
1830 
1831 
1832  std::vector<std::string> subdetectors = conf_->getParameter<std::vector<std::string> >("subdetectors");
1833  int detBin = conf_->getParameter<int>("subdetectorBin");
1834 
1835  for ( auto det : subdetectors ) {
1836 
1837  // hits properties
1838  ibooker.setCurrentFolder(TopFolder_+"/HitProperties/"+det);
1839 
1840  TkRecHitsPerSubDetMEs recHitsPerSubDet_mes;
1841 
1842  recHitsPerSubDet_mes.detectorTag = det;
1843  int detID = -1;
1844  if ( det == "TIB" ) detID = StripSubdetector::TIB; // 3
1845  if ( det == "TOB" ) detID = StripSubdetector::TOB; // 5
1846  if ( det == "TID" ) detID = StripSubdetector::TID; // 4
1847  if ( det == "TEC" ) detID = StripSubdetector::TEC; // 6
1848  if ( det == "PixBarrel" ) detID = PixelSubdetector::PixelBarrel; // 1
1849  if ( det == "PixEndcap" ) detID = PixelSubdetector::PixelEndcap; // 2
1850  if ( det == "Pixel" ) detID = 0;
1851  if ( det == "Strip" ) detID = 7;
1852 
1853  recHitsPerSubDet_mes.detectorId = detID;
1854 
1855  histname = "NumberOfRecHitsPerTrack_" + det + "_" + CategoryName;
1856  recHitsPerSubDet_mes.NumberOfRecHitsPerTrack = ibooker.book1D(histname, histname, detBin, -0.5, double(detBin)-0.5);
1857  recHitsPerSubDet_mes.NumberOfRecHitsPerTrack->setAxisTitle("Number of " + det + " valid RecHits in each Track",1);
1858  recHitsPerSubDet_mes.NumberOfRecHitsPerTrack->setAxisTitle("Number of Tracks", 2);
1859 
1860  histname = "NumberOfRecHitsPerTrackVsPhi_" + det + "_" + CategoryName;
1861  recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsPhi = ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, detBin, -0.5, double(detBin)-0.5,"");
1862  recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsPhi->setAxisTitle("Track #phi",1);
1863  recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsPhi->setAxisTitle("Number of " + det + " valid RecHits in each Track",2);
1864 
1865  histname = "NumberOfRecHitsPerTrackVsEta_" + det + "_" + CategoryName;
1866  recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, detBin, -0.5, double(detBin)-0.5,"");
1867  recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsEta->setAxisTitle("Track #eta",1);
1868  recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsEta->setAxisTitle("Number of " + det + " valid RecHits in each Track",2);
1869 
1870  histname = "NumberOfRecHitsPerTrackVsPt_" + det + "_" + CategoryName;
1871  recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsPt = ibooker.bookProfile(histname, histname, PtBin, PtMin, PtMax, detBin, -0.5, double(detBin)-0.5,"");
1872  recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsPt->setAxisTitle("Track p_{T} [GeV]",1);
1873  recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsPt->setAxisTitle("Number of " + det + " valid RecHits in each Track",2);
1874 
1875  histname = "NumberOfLayersPerTrack_" + det + "_" + CategoryName;
1876  recHitsPerSubDet_mes.NumberOfLayersPerTrack = ibooker.book1D(histname, histname, detBin, -0.5, double(detBin)-0.5);
1877  recHitsPerSubDet_mes.NumberOfLayersPerTrack->setAxisTitle("Number of " + det + " valid Layers in each Track",1);
1878  recHitsPerSubDet_mes.NumberOfLayersPerTrack->setAxisTitle("Number of Tracks", 2);
1879 
1880  histname = "NumberOfLayersPerTrackVsPhi_" + det + "_" + CategoryName;
1881  recHitsPerSubDet_mes.NumberOfLayersPerTrackVsPhi = ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, detBin, -0.5, double(detBin)-0.5,"");
1882  recHitsPerSubDet_mes.NumberOfLayersPerTrackVsPhi->setAxisTitle("Track #phi",1);
1883  recHitsPerSubDet_mes.NumberOfLayersPerTrackVsPhi->setAxisTitle("Number of " + det + " valid Layers in each Track",2);
1884 
1885  histname = "NumberOfLayersPerTrackVsEta_" + det + "_" + CategoryName;
1886  recHitsPerSubDet_mes.NumberOfLayersPerTrackVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, detBin, -0.5, double(detBin)-0.5,"");
1887  recHitsPerSubDet_mes.NumberOfLayersPerTrackVsEta->setAxisTitle("Track #eta",1);
1888  recHitsPerSubDet_mes.NumberOfLayersPerTrackVsEta->setAxisTitle("Number of " + det + " valid Layers in each Track",2);
1889 
1890  histname = "NumberOfLayersPerTrackVsPt_" + det + "_" + CategoryName;
1891  recHitsPerSubDet_mes.NumberOfLayersPerTrackVsPt = ibooker.bookProfile(histname, histname, PtBin, PtMin, PtMax, detBin, -0.5, double(detBin)-0.5,"");
1892  recHitsPerSubDet_mes.NumberOfLayersPerTrackVsPt->setAxisTitle("Track p_{T} [GeV]",1);
1893  recHitsPerSubDet_mes.NumberOfLayersPerTrackVsPt->setAxisTitle("Number of " + det + " valid Layers in each Track",2);
1894 
1895  TkRecHitsPerSubDetMEMap.insert(std::pair<std::string,TkRecHitsPerSubDetMEs>(det,recHitsPerSubDet_mes));
1896 
1897 
1898  }
1899 
1900 
1901 }
1902 
1903 
1905 {
1906 
1907  double phi = track.phi();
1908  double eta = track.eta();
1909  double pt = track.pt();
1910 
1911  for ( std::map<std::string,TkRecHitsPerSubDetMEs>::iterator it = TkRecHitsPerSubDetMEMap.begin();
1912  it != TkRecHitsPerSubDetMEMap.end(); it++ ) {
1913 
1914  int nValidLayers = 0;
1915  int nValidRecHits = 0;
1916  int substr = it->second.detectorId;
1917  switch(substr) {
1918  case 0 :
1919  nValidLayers = track.hitPattern().pixelBarrelLayersWithMeasurement()
1920  + track.hitPattern().pixelEndcapLayersWithMeasurement(); // case 0: pixel
1921  nValidRecHits = track.hitPattern().numberOfValidPixelBarrelHits()
1922  + track.hitPattern().numberOfValidPixelEndcapHits(); // case 0: pixel
1923  break;
1924  case StripSubdetector::TIB :
1925  nValidLayers = track.hitPattern().stripTIBLayersWithMeasurement(); // case 3: strip TIB
1926  nValidRecHits = track.hitPattern().numberOfValidStripTIBHits(); // case 3: strip TIB
1927  break;
1928  case StripSubdetector::TID :
1929  nValidLayers = track.hitPattern().stripTIDLayersWithMeasurement(); // case 4: strip TID
1930  nValidRecHits = track.hitPattern().numberOfValidStripTIDHits(); // case 4: strip TID
1931  break;
1932  case StripSubdetector::TOB :
1933  nValidLayers = track.hitPattern().stripTOBLayersWithMeasurement(); // case 5: strip TOB
1934  nValidRecHits = track.hitPattern().numberOfValidStripTOBHits(); // case 5: strip TOB
1935  break;
1936  case StripSubdetector::TEC :
1937  nValidLayers = track.hitPattern().stripTECLayersWithMeasurement(); // case 6: strip TEC
1938  nValidRecHits = track.hitPattern().numberOfValidStripTECHits(); // case 6: strip TEC
1939  break;
1941  nValidLayers = track.hitPattern().pixelBarrelLayersWithMeasurement(); // case 1: pixel PXB
1942  nValidRecHits = track.hitPattern().numberOfValidPixelBarrelHits(); // case 1: pixel PXB
1943  break;
1945  nValidLayers = track.hitPattern().pixelEndcapLayersWithMeasurement(); // case 2: pixel PXF
1946  nValidRecHits = track.hitPattern().numberOfValidPixelEndcapHits(); // case 2: pixel PXF
1947  break;
1948  case 7 :
1949  nValidLayers = track.hitPattern().stripTIBLayersWithMeasurement() // case 7: strip
1953  nValidRecHits = track.hitPattern().numberOfValidStripTIBHits() // case 7: strip
1957  break;
1958  default :
1959  break;
1960  }
1961 
1962  //Fill Layers and RecHits
1963  it->second.NumberOfRecHitsPerTrack -> Fill(nValidRecHits);
1964  it->second.NumberOfRecHitsPerTrackVsPhi -> Fill(phi, nValidRecHits);
1965  it->second.NumberOfRecHitsPerTrackVsEta -> Fill(eta, nValidRecHits);
1966  it->second.NumberOfRecHitsPerTrackVsPt -> Fill(pt, nValidRecHits);
1967 
1968  it->second.NumberOfLayersPerTrack -> Fill(nValidLayers);
1969  it->second.NumberOfLayersPerTrackVsPhi -> Fill(phi, nValidLayers);
1970  it->second.NumberOfLayersPerTrackVsEta -> Fill(eta, nValidLayers);
1971  it->second.NumberOfLayersPerTrackVsPt -> Fill(pt, nValidLayers);
1972  }
1973 
1974 }
1975 //
1976 // -- Set Lumi Flag
1977 //
1979 
1980  TkParameterMEs tkmes;
1983 }
1984 //
1985 // -- Apply SoftReset
1986 //
1988  TkParameterMEs tkmes;
1989  dqmStore_->softReset(Chi2oNDF);
1990  dqmStore_->softReset(NumberOfRecHitsPerTrack);
1991 }
1992 //
1993 // -- Apply Reset
1994 //
1996  TkParameterMEs tkmes;
1999 }
2000 //
2001 // -- Remove SoftReset
2002 //
2004  TkParameterMEs tkmes;
2005  dqmStore_->disableSoftReset(Chi2oNDF);
2006  dqmStore_->disableSoftReset(NumberOfRecHitsPerTrack);
2007 }
2008 
2009 
#define LogDebug(id)
MonitorElement * sipDzToPV
std::map< std::string, TkParameterMEs > TkParameterMEMap
MonitorElement * NumberOfValidRecHitsPerTrack
MonitorElement * Ptdist_HighPurity
double p() const
momentum vector magnitude
Definition: TrackBase.h:615
EDGetTokenT< ProductType > consumes(edm::InputTag const &tag)
int stripTOBLayersWithMeasurement() const
Definition: HitPattern.cc:598
unsigned int bx_
T getParameter(std::string const &) const
MonitorElement * NumberOfValidRecHitsPerTrackVsPt
MonitorElement * sip2dToPV
const Point & referencePoint() const
Reference point on the track.
Definition: TrackBase.h:681
MonitorElement * Chi2oNDFVsTheta
double d0Error() const
error on d0
Definition: TrackBase.h:802
MonitorElement * xPointOfClosestApproachVsZ0wrtPV
boost::transform_iterator< IterHelp, const_IdIter > const_iterator
const_iterator end(bool update=false) const
MonitorElement * NumberOfValidRecHitsPerTrackVsEta
MonitorElement * NumberOfValidRecHitsPerTrackVsPhi
T perp() const
Definition: PV3DBase.h:72
MonitorElement * dNdPt_HighPurity
MonitorElement * sipDxyToPV
double validFraction() const
fraction of valid hits on the track
Definition: TrackBase.h:832
double d0() const
dxy parameter in perigee convention (d0 = -dxy)
Definition: TrackBase.h:597
EDGetTokenT< ProductType > mayConsume(edm::InputTag const &tag)
MonitorElement * NumberOfValidRecHitVsPhiVsEtaPerTrack
int stripTIBLayersWithMeasurement() const
Definition: HitPattern.cc:576
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:561
MonitorElement * bookProfile(Args &&...args)
Definition: DQMStore.h:157
MonitorElement * NumberOfValidRecHitsPerTrackVsPhi
MonitorElement * LongDCASig
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:460
double zError() const
error on z
Definition: Vertex.h:123
MonitorElement * yPointOfClosestApproach
double theta() const
polar angle
Definition: TrackBase.h:579
double dxyError() const
error on dxy
Definition: TrackBase.h:796
void doSoftReset(DQMStore *dqmStore_)
MonitorElement * NumberOfMIRecHitsPerTrackVsPt
const CurvilinearTrajectoryError & curvilinearError() const
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
MonitorElement * NumberOfValidRecHitsPerTrackVsPt
std::pair< bool, Measurement1D > signedTransverseImpactParameter(const reco::TransientTrack &track, const GlobalVector &direction, const reco::Vertex &vertex)
Definition: IPTools.cc:50
unsigned int good_vertices_
void initHisto(DQMStore::IBooker &ibooker, const edm::EventSetup &, const edm::ParameterSet &)
uint8_t stopReason() const
Definition: TrackBase.h:400
ROOT::Math::SMatrix< double, 6, 6, ROOT::Math::MatRepSym< double, 6 > > AlgebraicSymMatrix66
Geom::Phi< T > phi() const
Definition: PV3DBase.h:69
MonitorElement * DistanceOfClosestApproachToBSVsPhi
const CartesianTrajectoryError cartesianError() const
MonitorElement * zPointOfClosestApproachToPV
Geom::Theta< T > theta() const
reco::TransientTrack build(const reco::Track *p) const
T y() const
Definition: PV3DBase.h:63
double etaError() const
error on eta
Definition: TrackBase.h:784
int bunchCrossing() const
Definition: EventBase.h:66
std::string stateName_
Definition: TrackAnalyzer.h:85
void setBinLabel(int bin, const std::string &label, int axis=1)
set bin label for x, y or z axis (axis=1, 2, 3 respectively)
void fillHistosForEfficiencyFromHitPatter(const reco::Track &track, const std::string suffix, const float monitoring)
MonitorElement * NumberOfLostRecHitsPerTrackVsPt
std::pair< bool, Measurement1D > signedImpactParameter3D(const reco::TransientTrack &track, const GlobalVector &direction, const reco::Vertex &vertex)
Definition: IPTools.cc:71
double phi() const
azimuthal angle of momentum vector
Definition: TrackBase.h:645
unsigned short numberOfLostHits() const
number of cases where track crossed a layer without getting a hit.
Definition: TrackBase.h:826
std::vector< Vertex > VertexCollection
collection of Vertex objects
Definition: VertexFwd.h:9
data_type const * const_iterator
Definition: DetSetNew.h:30
const double EtaMax[kNumberCalorimeter]
double px() const
x coordinate of momentum vector
Definition: TrackBase.h:627
static const std::string StopReasonName[]
int pixelLayersWithMeasurement() const
Definition: HitPattern.cc:493
MonitorElement * yPointOfClosestApproachVsZ0wrtPV
#define nullptr
const math::XYZPoint & outerPosition() const
position of the outermost hit
Definition: Track.h:65
MonitorElement * NumberOfRecHitsPerTrackVsTheta
edm::EDGetTokenT< LumiScalersCollection > lumiscalersToken_
Definition: TrackAnalyzer.h:80
int trackerLayersWithMeasurement() const
Definition: HitPattern.cc:512
MonitorElement * sipDxyToBS
const Point & position() const
position
Definition: Vertex.h:109
int pixelEndcapLayersWithMeasurement() const
Definition: HitPattern.cc:564
int numberOfValidStripTOBHits() const
Definition: HitPattern.h:868
#define constexpr
MonitorElement * algorithm
MonitorElement * NumberOfLayersPerTrackVsTheta
TrajectoryStateOnSurface innermostMeasurementState() const
static double XSEC_PIXEL_CLUSTER
Definition: GetLumi.h:41
unsigned int numberOfLayers(int subdet) const
void Fill(long long x)
int numberOfLostTrackerHits(HitCategory category) const
Definition: HitPattern.h:907
Geom::Theta< T > theta() const
Definition: PV3DBase.h:75
const math::XYZPoint & innerPosition() const
position of the innermost hit
Definition: Track.h:55
TrackAlgorithm algo() const
Definition: TrackBase.h:497
void bookHistosForHitProperties(DQMStore::IBooker &ibooker)
MonitorElement * NumberOfMORecHitVsPtVsEtaPerTrack
MonitorElement * yPointOfClosestApproachToPV
void bookHistosForTrackerSpecific(DQMStore::IBooker &ibooker)
MonitorElement * xPointOfClosestApproach
MonitorElement * Chi2oNDF_lumiFlag
T x() const
Cartesian x coordinate.
MonitorElement * DistanceOfClosestApproach
MonitorElement * Chi2oNDF
MonitorElement * NumberOfRecHitsPerTrackVsPhi
static const unsigned int lastBunchCrossing
Definition: GetLumi.h:48
MonitorElement * ValidFractionPerTrack
bool doRecHitVsPtVsEtaPerTrack_
Definition: TrackAnalyzer.h:96
MonitorElement * NumberOfLostRecHitVsPhiVsEtaPerTrack
int iEvent
Definition: GenABIO.cc:230
def cat(path)
Definition: eostools.py:400
T mag() const
Definition: PV3DBase.h:67
double eta() const
pseudorapidity of momentum vector
Definition: TrackBase.h:651
int numberOfValidStripLayersWithMonoAndStereo(uint16_t stripdet, uint16_t layer) const
Definition: HitPattern.cc:335
int trackerLayersTotallyOffOrBad() const
Definition: HitPattern.h:1061
int numberOfValidPixelBarrelHits() const
Definition: HitPattern.h:843
void setBX(const edm::Event &)
double chi2() const
chi-squared of the fit
Definition: TrackBase.h:549
TrackAnalyzer(const edm::ParameterSet &)
MonitorElement * bookProfile2D(Args &&...args)
Definition: DQMStore.h:163
void Fill(HcalDetId &id, double val, std::vector< TH2F > &depth)
MonitorElement * DistanceOfClosestApproachToPVVsPhi
MonitorElement * NumberOfLayersPerTrackVsEta
double ndof() const
number of degrees of freedom of the fit
Definition: TrackBase.h:555
MonitorElement * NumberOfMORecHitsPerTrackVsPt
int stripTIDLayersWithMeasurement() const
Definition: HitPattern.cc:587
MonitorElement * NumberOfLayersPerTrackVsPhi
susybsm::HSCParticleRefProd hp
Definition: classes.h:27
T sqrt(T t)
Definition: SSEVec.h:18
MonitorElement * NumberOfRecHitsPerTrackVsEta
MonitorElement * xPointOfClosestApproachVsZ0wrtBS
double pt() const
track transverse momentum
Definition: TrackBase.h:621
MonitorElement * Chi2ProbVsEta
T z() const
Definition: PV3DBase.h:64
MonitorElement * stoppingSourceVSeta
void bookHistosForLScertification(DQMStore::IBooker &ibooker)
MonitorElement * DistanceOfClosestApproachToBS
MonitorElement * yPointOfClosestApproachVsZ0wrtBS
double ptError() const
error on Pt (set to 1000 TeV if charge==0 for safety)
Definition: TrackBase.h:763
double phiError() const
error on phi
Definition: TrackBase.h:790
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
void fillHistosForTrackerSpecific(const reco::Track &track)
def pv(vc)
Definition: MetAnalyzer.py:6
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
edm::ParameterSet const * conf_
Definition: TrackAnalyzer.h:83
int numberOfValidStripTIDHits() const
Definition: HitPattern.h:863
TH1 * getTH1(void) const
MonitorElement * NumberOfMIRecHitVsPtVsEtaPerTrack
const double EtaMin[kNumberCalorimeter]
unsigned short numberOfValidHits() const
number of valid hits found
Definition: TrackBase.h:820
MonitorElement * NumberOfLayersVsPhiVsEtaPerTrack[4]
int numberOfValidStripTECHits() const
Definition: HitPattern.h:873
static double CM2_TO_NANOBARN
Definition: GetLumi.h:47
MonitorElement * dNhitdPt_HighPurity
MonitorElement * sipDzToBS
T min(T a, T b)
Definition: MathUtil.h:58
MonitorElement * xPointOfClosestApproachVsZ0wrt000
edm::EDGetTokenT< reco::BeamSpot > beamSpotToken_
Definition: TrackAnalyzer.h:77
TrajectoryStateOnSurface outermostMeasurementState() const
MonitorElement * DistanceOfClosestApproachVsPhi
std::unordered_map< Key, MonitorElement *, KeyHasher > hits_valid_
MonitorElement * TESTDistanceOfClosestApproachToBS
void undoSoftReset(DQMStore *dqmStore_)
bool isValid() const
Definition: HandleBase.h:74
int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:37
std::string monName[monQuantity::END]
MonitorElement * NumberOfMIRecHitsPerTrack
edm::EDGetTokenT< reco::VertexCollection > pvToken_
Definition: TrackAnalyzer.h:78
const AlgebraicSymMatrix66 & matrix() const
MonitorElement * ValidFractionVsPhiVsEtaPerTrack
double pz() const
z coordinate of momentum vector
Definition: TrackBase.h:639
MonitorElement * NhitVsEta_HighPurity
MonitorElement * stoppingSourceVSphi
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:609
void setNumberOfGoodVertices(const edm::Event &)
double dzError() const
error on dz
Definition: TrackBase.h:814
void bookHistosForBeamSpot(DQMStore::IBooker &ibooker)
MonitorElement * NumberOfLostRecHitVsPtVsEtaPerTrack
MonitorElement * dNdPhi_HighPurity
double vz() const
z coordinate of the reference point on track
Definition: TrackBase.h:669
void fillHistosForState(const edm::EventSetup &iSetup, const reco::Track &track, std::string sname)
std::string histname
Definition: DetId.h:18
TrackAlgorithm originalAlgo() const
Definition: TrackBase.h:501
TrajectoryStateOnSurface TSOS
Definition: TestHits.cc:19
void bookHistosForState(std::string sname, DQMStore::IBooker &ibooker)
MonitorElement * TESTDistanceOfClosestApproachToBSVsPhi
MonitorElement * oriAlgo
bool doGeneralPropertiesPlots_
Definition: TrackAnalyzer.h:92
static TrackQuality qualityByName(const std::string &name)
Definition: TrackBase.cc:125
double xError() const
error on x
Definition: Vertex.h:119
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:277
#define N
Definition: blowfish.cc:9
MonitorElement * NumberOfRecHitsPerTrack
MonitorElement * book2D(Args &&...args)
Definition: DQMStore.h:133
const HitPattern & hitPattern() const
Access the hit pattern, indicating in which Tracker layers the track has hits.
Definition: TrackBase.h:446
MonitorElement * NhitVsPhi_HighPurity
MonitorElement * yPointOfClosestApproachVsZ0wrt000
std::string TopFolder_
Definition: TrackAnalyzer.h:75
bool doRecHitVsPhiVsEtaPerTrack_
Definition: TrackAnalyzer.h:95
const T & get() const
Definition: EventSetup.h:55
int pixelBarrelLayersWithMeasurement() const
Definition: HitPattern.cc:552
MonitorElement * NumberOfMIRecHitVsPhiVsEtaPerTrack
MonitorElement * NumberOfRecHitsPerTrackVsEta
static double rXSEC_PIXEL_CLUSTER
Definition: GetLumi.h:45
int numberOfValidStripTIBHits() const
Definition: HitPattern.h:858
static const std::string algoNames[]
Definition: TrackBase.h:148
bool quality(const TrackQuality) const
Track quality.
Definition: TrackBase.h:510
unsigned int layer(const DetId &id) const
MonitorElement * Chi2oNDFVsPhi
int numberOfValidPixelEndcapHits() const
Definition: HitPattern.h:848
std::map< std::string, TkRecHitsPerSubDetMEs > TkRecHitsPerSubDetMEMap
T eta() const
Definition: PV3DBase.h:76
int trackerLayersWithoutMeasurement(HitCategory category) const
Definition: HitPattern.cc:529
MonitorElement * xPointOfClosestApproachToPV
double vy() const
y coordinate of the reference point on track
Definition: TrackBase.h:663
const AlgebraicSymMatrix55 & matrix() const
GlobalVector globalMomentum() const
MonitorElement * NumberOfMORecHitVsPhiVsEtaPerTrack
MonitorElement * DistanceOfClosestApproachVsTheta
MonitorElement * dNdEta_HighPurity
int getNbinsX(void) const
get # of bins in X-axis
int stripTECLayersWithMeasurement() const
Definition: HitPattern.cc:609
MonitorElement * stoppingSource
edm::EDGetTokenT< edmNew::DetSetVector< SiPixelCluster > > pixelClustersToken_
Definition: TrackAnalyzer.h:79
std::vector< LumiScalers > LumiScalersCollection
Definition: LumiScalers.h:160
int charge() const
track electric charge
Definition: TrackBase.h:567
const Point & position() const
position
Definition: BeamSpot.h:62
TrajectoryStateOnSurface impactPointState() const
void bookHistosForEfficiencyFromHitPatter(DQMStore::IBooker &ibooker, const edm::EventSetup &iSetup, const std::string suffix)
MonitorElement * DeltaZToPV
Definition: errors.py:1
MonitorElement * zPointOfClosestApproachVsPhi
MonitorElement * Chi2oNDFVsEta
void Reset(std::vector< TH2F > &depth)
MonitorElement * NumberOfValidRecHitsPerTrackVsEta
std::string qualityString_
MonitorElement * NumberOfMORecHitsPerTrack
dbl *** dir
Definition: mlp_gen.cc:35
Definition: Chi2.h:17
size_type size() const
Definition: DetSetNew.h:87
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:591
T x() const
Definition: PV3DBase.h:62
MonitorElement * zPointOfClosestApproach
MonitorElement * Chi2ProbVsPhi
MonitorElement * AbsDistanceOfClosestApproachToBS
void setLumi(const edm::Event &, const edm::EventSetup &iSetup)
void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
std::unordered_map< Key, MonitorElement *, KeyHasher > hits_total_
MonitorElement * DistanceOfClosestApproachVsEta
T const * product() const
Definition: ESHandle.h:86
static double FREQ_ORBIT
Definition: GetLumi.h:32
MonitorElement * NumberOfRecHitsPerTrackVsTheta
MonitorElement * NumberOfValidRecHitVsPtVsEtaPerTrack
MonitorElement * sip3dToPV
MonitorElement * NumberOfRecHitVsPhiVsEtaPerTrack
MonitorElement * Chi2Prob
MonitorElement * NumberOfRecHitsPerTrackVsPhi
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:40
double yError() const
error on y
Definition: Vertex.h:121
MonitorElement * DistanceOfClosestApproachToPV
const_iterator begin(bool update=false) const
MonitorElement * TransDCASig
const int NBINS
double py() const
y coordinate of momentum vector
Definition: TrackBase.h:633
void analyze(const edm::Event &iEvent, const edm::EventSetup &iSetup, const reco::Track &track)
double vx() const
x coordinate of the reference point on track
Definition: TrackBase.h:657
bool doLayersVsPhiVsEtaPerTrack_
Definition: TrackAnalyzer.h:98
int numberOfHits(HitCategory category) const
Definition: HitPattern.h:807
MonitorElement * NumberOfLostRecHitsPerTrack
MonitorElement * NumberOfRecHitsPerTrack_lumiFlag
static double SECONDS_PER_LS
Definition: GetLumi.h:33
MonitorElement * NumberOfLayersPerTrack[4]