CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
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 
7 #include "DataFormats/TrackReco/interface/Track.h"
8 #include "DataFormats/TrackReco/interface/TrackFwd.h"
9 #include "TrackingTools/TransientTrack/interface/TransientTrack.h"
10 #include "TrackingTools/IPTools/interface/IPTools.h"
11 #include "MagneticField/Engine/interface/MagneticField.h"
12 
13 #include "FWCore/MessageLogger/interface/MessageLogger.h"
14 #include "FWCore/Utilities/interface/ESInputTag.h"
15 #include "FWCore/Utilities/interface/InputTag.h"
16 #include "FWCore/Utilities/interface/Transition.h"
17 #include "DQMServices/Core/interface/DQMStore.h"
18 #include "DQM/TrackingMonitor/interface/TrackAnalyzer.h"
19 #include <string>
20 #include "TMath.h"
21 #include "DQM/TrackingMonitor/interface/GetLumi.h"
22 
23 namespace {
24  template <typename T, size_t N>
25  std::array<T, N + 1> makeLogBins(const double min, const double max) {
26  const double minLog10 = std::log10(min);
27  const double maxLog10 = std::log10(max);
28  const double width = (maxLog10 - minLog10) / N;
29  std::array<T, N + 1> ret;
30  ret[0] = std::pow(10, minLog10);
31  const double mult = std::pow(10, width);
32  for (size_t i = 1; i <= N; ++i) {
33  ret[i] = ret[i - 1] * mult;
34  }
35  return ret;
36  }
37 } // namespace
38 
39 using namespace tadqm;
40 TrackAnalyzer::TrackAnalyzer(const edm::ParameterSet& iConfig)
41  : conf_(nullptr),
42  stateName_(iConfig.getParameter<std::string>("MeasurementState")),
43  doTrackerSpecific_(iConfig.getParameter<bool>("doTrackerSpecific")),
44  doAllPlots_(iConfig.getParameter<bool>("doAllPlots")),
45  doBSPlots_(iConfig.getParameter<bool>("doBeamSpotPlots")),
46  doPVPlots_(iConfig.getParameter<bool>("doPrimaryVertexPlots")),
47  doDCAPlots_(iConfig.getParameter<bool>("doDCAPlots")),
48  doGeneralPropertiesPlots_(iConfig.getParameter<bool>("doGeneralPropertiesPlots")),
49  doMeasurementStatePlots_(iConfig.getParameter<bool>("doMeasurementStatePlots")),
50  doHitPropertiesPlots_(iConfig.getParameter<bool>("doHitPropertiesPlots")),
51  doRecHitVsPhiVsEtaPerTrack_(iConfig.getParameter<bool>("doRecHitVsPhiVsEtaPerTrack")),
52  doRecHitVsPtVsEtaPerTrack_(iConfig.getParameter<bool>("doRecHitVsPtVsEtaPerTrack")),
53  doLayersVsPhiVsEtaPerTrack_(iConfig.getParameter<bool>("doLayersVsPhiVsEtaPerTrack")),
54  doRecHitsPerTrackProfile_(iConfig.getParameter<bool>("doRecHitsPerTrackProfile")),
55  doThetaPlots_(iConfig.getParameter<bool>("doThetaPlots")),
56  doTrackPxPyPlots_(iConfig.getParameter<bool>("doTrackPxPyPlots")),
57  doDCAwrtPVPlots_(iConfig.getParameter<bool>("doDCAwrtPVPlots")),
58  doDCAwrt000Plots_(iConfig.getParameter<bool>("doDCAwrt000Plots")),
59  doLumiAnalysis_(iConfig.getParameter<bool>("doLumiAnalysis")),
60  doTestPlots_(iConfig.getParameter<bool>("doTestPlots")),
61  doHIPlots_(iConfig.getParameter<bool>("doHIPlots")),
62  doSIPPlots_(iConfig.getParameter<bool>("doSIPPlots")),
63  doEffFromHitPatternVsPU_(iConfig.getParameter<bool>("doEffFromHitPatternVsPU")),
64  doEffFromHitPatternVsBX_(iConfig.getParameter<bool>("doEffFromHitPatternVsBX")),
65  doEffFromHitPatternVsLUMI_(iConfig.getParameter<bool>("doEffFromHitPatternVsLUMI")),
66  pvNDOF_(iConfig.getParameter<int>("pvNDOF")),
67  forceSCAL_(iConfig.getParameter<bool>("forceSCAL")),
68  useBPixLayer1_(iConfig.getParameter<bool>("useBPixLayer1")),
69  minNumberOfPixelsPerCluster_(iConfig.getParameter<int>("minNumberOfPixelsPerCluster")),
70  minPixelClusterCharge_(iConfig.getParameter<double>("minPixelClusterCharge")),
71  qualityString_(iConfig.getParameter<std::string>("qualityString")),
72  good_vertices_(0),
73  bx_(0),
74  pixel_lumi_(0.),
75  scal_lumi_(0.) {
76  initHistos();
77  TopFolder_ = iConfig.getParameter<std::string>("FolderName");
78 }
79 
80 TrackAnalyzer::TrackAnalyzer(const edm::ParameterSet& iConfig, edm::ConsumesCollector& iC) : TrackAnalyzer(iConfig) {
81  edm::InputTag bsSrc = iConfig.getParameter<edm::InputTag>("beamSpot");
82  edm::InputTag primaryVertexInputTag = iConfig.getParameter<edm::InputTag>("primaryVertex");
83  edm::InputTag pixelClusterInputTag = iConfig.getParameter<edm::InputTag>("pixelCluster4lumi");
84  edm::InputTag scalInputTag = iConfig.getParameter<edm::InputTag>("scal");
85  edm::InputTag metaDataInputTag = iConfig.getParameter<edm::InputTag>("metadata");
86  beamSpotToken_ = iC.consumes<reco::BeamSpot>(bsSrc);
87  pvToken_ = iC.consumes<reco::VertexCollection>(primaryVertexInputTag);
88  pixelClustersToken_ = iC.mayConsume<edmNew::DetSetVector<SiPixelCluster> >(pixelClusterInputTag);
89  lumiscalersToken_ = iC.mayConsume<LumiScalersCollection>(scalInputTag);
90  metaDataToken_ = iC.mayConsume<OnlineLuminosityRecord>(metaDataInputTag);
91 
92  if (doAllPlots_ || doEffFromHitPatternVsPU_ || doEffFromHitPatternVsBX_ || doEffFromHitPatternVsLUMI_) {
93  trackerGeometryToken_ = iC.esConsumes<TrackerGeometry, TrackerDigiGeometryRecord, edm::Transition::BeginRun>();
94  }
95  trackerTopologyToken_ = iC.esConsumes<TrackerTopology, TrackerTopologyRcd>();
96  if (doSIPPlots_ ||
97  ((doMeasurementStatePlots_ || doAllPlots_) && (stateName_ == "All" || stateName_ == "OuterSurface" ||
98  stateName_ == "InnerSurface" || stateName_ == "ImpactPoint"))) {
99  transientTrackBuilderToken_ =
100  iC.esConsumes<TransientTrackBuilder, TransientTrackRecord>(edm::ESInputTag("", "TransientTrackBuilder"));
101  }
102 
103  if (useBPixLayer1_)
104  lumi_factor_per_bx_ = GetLumi::FREQ_ORBIT * GetLumi::SECONDS_PER_LS / GetLumi::XSEC_PIXEL_CLUSTER;
105  else
106  lumi_factor_per_bx_ = GetLumi::FREQ_ORBIT * GetLumi::SECONDS_PER_LS / GetLumi::rXSEC_PIXEL_CLUSTER;
107 }
108 
109 void TrackAnalyzer::initHistos() {
110  Chi2 = nullptr;
111  Chi2Prob = nullptr;
112  Chi2ProbVsPhi = nullptr;
113  Chi2ProbVsEta = nullptr;
114  Chi2oNDF = nullptr;
115  Chi2oNDFVsEta = nullptr;
116  Chi2oNDFVsPhi = nullptr;
117  Chi2oNDFVsTheta = nullptr;
118 
119  NumberOfRecHitsPerTrack = nullptr;
120  NumberOfValidRecHitsPerTrack = nullptr;
121  NumberOfLostRecHitsPerTrack = nullptr;
122 
123  NumberOfRecHitsPerTrackVsPhi = nullptr;
124  NumberOfRecHitsPerTrackVsTheta = nullptr;
125  NumberOfRecHitsPerTrackVsEta = nullptr;
126 
127  NumberOfRecHitVsPhiVsEtaPerTrack = nullptr;
128 
129  NumberOfValidRecHitsPerTrackVsPhi = nullptr;
130  NumberOfValidRecHitsPerTrackVsEta = nullptr;
131 
132  DistanceOfClosestApproach = nullptr;
133  DistanceOfClosestApproachError = nullptr;
134  DistanceOfClosestApproachErrorVsPt = nullptr;
135  DistanceOfClosestApproachErrorVsEta = nullptr;
136  DistanceOfClosestApproachErrorVsPhi = nullptr;
137  DistanceOfClosestApproachErrorVsDxy = nullptr;
138  DistanceOfClosestApproachToBS = nullptr;
139  DistanceOfClosestApproachToBSdz = nullptr;
140  AbsDistanceOfClosestApproachToBS = nullptr;
141  DistanceOfClosestApproachToPV = nullptr;
142  DistanceOfClosestApproachToPVZoom = nullptr;
143  DeltaZToPV = nullptr;
144  DeltaZToPVZoom = nullptr;
145  DistanceOfClosestApproachVsTheta = nullptr;
146  DistanceOfClosestApproachVsPhi = nullptr;
147  DistanceOfClosestApproachToBSVsPhi = nullptr;
148  DistanceOfClosestApproachToBSVsEta = nullptr;
149  DistanceOfClosestApproachToPVVsPhi = nullptr;
150  DistanceOfClosestApproachVsEta = nullptr;
151  xPointOfClosestApproach = nullptr;
152  xPointOfClosestApproachVsZ0wrt000 = nullptr;
153  xPointOfClosestApproachVsZ0wrtBS = nullptr;
154  yPointOfClosestApproach = nullptr;
155  yPointOfClosestApproachVsZ0wrt000 = nullptr;
156  yPointOfClosestApproachVsZ0wrtBS = nullptr;
157  zPointOfClosestApproach = nullptr;
158  zPointOfClosestApproachVsPhi = nullptr;
159  algorithm = nullptr;
160  oriAlgo = nullptr;
161  stoppingSource = nullptr;
162  stoppingSourceVSeta = nullptr;
163  stoppingSourceVSphi = nullptr;
164  // TESTING
165  TESTDistanceOfClosestApproachToBS = nullptr;
166  TESTDistanceOfClosestApproachToBSVsPhi = nullptr;
167 
168  // by Mia in order to deal w/ LS transitions
169  Chi2oNDF_lumiFlag = nullptr;
170  NumberOfRecHitsPerTrack_lumiFlag = nullptr;
171 
173  //special Plots for HI DQM //SHOULD I ADD THE BOOL HERE??
175  LongDCASig = nullptr;
176  TransDCASig = nullptr;
177  dNdPhi_HighPurity = nullptr;
178  dNdEta_HighPurity = nullptr;
179  dNdPt_HighPurity = nullptr;
180  NhitVsEta_HighPurity = nullptr;
181  NhitVsPhi_HighPurity = nullptr;
182 
183  // IP significance
184  sipDxyToBS = nullptr;
185  sipDzToBS = nullptr;
186  sip3dToPV = nullptr;
187  sip2dToPV = nullptr;
188  sipDxyToPV = nullptr;
189  sipDzToPV = nullptr;
190 }
191 
192 TrackAnalyzer::~TrackAnalyzer() {}
193 
194 void TrackAnalyzer::initHisto(DQMStore::IBooker& ibooker,
195  const edm::EventSetup& iSetup,
196  const edm::ParameterSet& iConfig) {
197  conf_ = &iConfig;
198  bookHistosForHitProperties(ibooker);
199  bookHistosForBeamSpot(ibooker);
200  bookHistosForLScertification(ibooker);
201  if (doEffFromHitPatternVsPU_ || doAllPlots_)
202  bookHistosForEfficiencyFromHitPatter(ibooker, iSetup, "", false);
203  if (doEffFromHitPatternVsBX_ || doAllPlots_)
204  bookHistosForEfficiencyFromHitPatter(ibooker, iSetup, "VsBX", false);
205  if (doEffFromHitPatternVsLUMI_ || doAllPlots_)
206  bookHistosForEfficiencyFromHitPatter(ibooker, iSetup, "VsSCALLUMI", false);
207  // if (doEffFromHitPatternVsLUMI_ || doAllPlots_) bookHistosForEfficiencyFromHitPatter(ibooker, iSetup, "VsPIXELLUMI");
208  if (doEffFromHitPatternVsPU_ || doAllPlots_)
209  bookHistosForEfficiencyFromHitPatter(ibooker, iSetup, "", true);
210  if (doEffFromHitPatternVsLUMI_ || doAllPlots_)
211  bookHistosForEfficiencyFromHitPatter(ibooker, iSetup, "VsSCALLUMI", true);
212 
213  // book tracker specific related histograms
214  // ---------------------------------------------------------------------------------//
215  if (doTrackerSpecific_ || doAllPlots_)
216  bookHistosForTrackerSpecific(ibooker);
217 
218  // book state related histograms
219  // ---------------------------------------------------------------------------------//
220  if (doMeasurementStatePlots_ || doAllPlots_) {
221  if (stateName_ == "All") {
222  bookHistosForState("OuterSurface", ibooker);
223  bookHistosForState("InnerSurface", ibooker);
224  bookHistosForState("ImpactPoint", ibooker);
225  } else if (stateName_ != "OuterSurface" && stateName_ != "InnerSurface" && stateName_ != "ImpactPoint" &&
226  stateName_ != "default") {
227  bookHistosForState("default", ibooker);
228 
229  } else {
230  bookHistosForState(stateName_, ibooker);
231  }
232  conf_ = nullptr;
233  }
234 }
235 
236 void TrackAnalyzer::bookHistosForEfficiencyFromHitPatter(DQMStore::IBooker& ibooker,
237  const edm::EventSetup& iSetup,
238  const std::string suffix,
239  bool useInac) {
240  ibooker.setCurrentFolder(TopFolder_ + "/HitEffFromHitPattern" + (useInac ? "All" : "") + suffix);
241 
242  constexpr int LUMIBin = 300; // conf_->getParameter<int>("LUMIBin");
243  float LUMIMin = conf_->getParameter<double>("LUMIMin");
244  float LUMIMax = conf_->getParameter<double>("LUMIMax");
245 
246  int PVBin = conf_->getParameter<int>("PVBin");
247  float PVMin = conf_->getParameter<double>("PVMin");
248  float PVMax = conf_->getParameter<double>("PVMax");
249 
250  int NBINS[] = {PVBin, int(GetLumi::lastBunchCrossing), LUMIBin, LUMIBin};
251  float MIN[] = {PVMin, 0.5, LUMIMin, LUMIMin};
252  float MAX[] = {PVMax, float(GetLumi::lastBunchCrossing) + 0.5, LUMIMax, LUMIMax};
253  std::string NAME[] = {"", "VsBX", "VsLUMI", "VsLUMI"};
254 
255  auto logBins = makeLogBins<float, LUMIBin>(LUMIMin, LUMIMax);
256 
257  int mon = -1;
258  int nbins = -1;
259  float min = -1.;
260  float max = -1.;
261  bool logQ = false;
262  std::string name = "";
263  for (int i = 0; i < monQuantity::END; i++) {
264  if (monName[i] == suffix) {
265  logQ = (i > 1); // VsLUMI
266  mon = i;
267  if (useInac)
268  mon += monQuantity::END;
269  nbins = NBINS[i];
270  min = MIN[i];
271  max = MAX[i];
272  name = NAME[i];
273  }
274  }
275 
276  TrackerGeometry const& trackerGeometry = iSetup.getData(trackerGeometryToken_);
277 
278  // Values are not ordered randomly, but the order is taken from
279  // http://cmslxr.fnal.gov/dxr/CMSSW/source/Geometry/CommonDetUnit/interface/GeomDetEnumerators.h#15
280  const char* dets[] = {"None", "PXB", "PXF", "TIB", "TID", "TOB", "TEC"};
281 
282  // Also in this case, ordering is not random but extracted from
283  // http://cmslxr.fnal.gov/dxr/CMSSW/source/DataFormats/TrackReco/interface/HitPattern.h
284  // The category "total" is an addition to ease the computation of
285  // the efficiencies and is not part of the original HitPattern.
286  const char* hit_category[] = {"valid", "missing", "inactive", "bad", "total"};
287 
288  // We set sub_det to be a 1-based index since to it is the sub-sub-structure in the HitPattern
289  char title[50];
290  for (unsigned int det = 1; det < sizeof(dets) / sizeof(char*); ++det) {
291  for (unsigned int sub_det = 1; sub_det <= trackerGeometry.numberOfLayers(det); ++sub_det) {
292  for (unsigned int cat = 0; cat < sizeof(hit_category) / sizeof(char*); ++cat) {
293  memset(title, 0, sizeof(title));
294  snprintf(title, sizeof(title), "Hits%s_%s_%s_Subdet%d", name.c_str(), hit_category[cat], dets[det], sub_det);
295  switch (cat) {
296  case 0:
297  hits_valid_.insert(std::make_pair(Key(det, sub_det, mon),
298  logQ ? ibooker.book1D(title, title, nbins, &logBins[0])
299  : ibooker.book1D(title, title, nbins, min, max)));
300  break;
301  case 4:
302  hits_total_.insert(std::make_pair(Key(det, sub_det, mon),
303  logQ ? ibooker.book1D(title, title, nbins, &logBins[0])
304  : ibooker.book1D(title, title, nbins, min, max)));
305  break;
306  default:
307  LogDebug("TrackAnalyzer") << "Invalid hit category used " << cat << " ignored\n";
308  }
309  }
310  }
311  }
312 }
313 
314 #include "DataFormats/TrackCandidate/interface/TrajectoryStopReasons.h"
315 void TrackAnalyzer::bookHistosForHitProperties(DQMStore::IBooker& ibooker) {
316  // parameters from the configuration
317  std::string QualName = conf_->getParameter<std::string>("Quality");
318  std::string AlgoName = conf_->getParameter<std::string>("AlgoName");
319  std::string MEBSFolderName = conf_->getParameter<std::string>("BSFolderName");
320 
321  // use the AlgoName and Quality Name
322  std::string CategoryName = !QualName.empty() ? AlgoName + "_" + QualName : AlgoName;
323 
324  // get binning from the configuration
325  int TKHitBin = conf_->getParameter<int>("RecHitBin");
326  double TKHitMin = conf_->getParameter<double>("RecHitMin");
327  double TKHitMax = conf_->getParameter<double>("RecHitMax");
328 
329  int TKLostBin = conf_->getParameter<int>("RecLostBin");
330  double TKLostMin = conf_->getParameter<double>("RecLostMin");
331  double TKLostMax = conf_->getParameter<double>("RecLostMax");
332 
333  int TKLayBin = conf_->getParameter<int>("RecLayBin");
334  double TKLayMin = conf_->getParameter<double>("RecLayMin");
335  double TKLayMax = conf_->getParameter<double>("RecLayMax");
336 
337  int PhiBin = conf_->getParameter<int>("PhiBin");
338  double PhiMin = conf_->getParameter<double>("PhiMin");
339  double PhiMax = conf_->getParameter<double>("PhiMax");
340 
341  int EtaBin = conf_->getParameter<int>("EtaBin");
342  double EtaMin = conf_->getParameter<double>("EtaMin");
343  double EtaMax = conf_->getParameter<double>("EtaMax");
344 
345  int PtBin = conf_->getParameter<int>("TrackPtBin");
346  double PtMin = conf_->getParameter<double>("TrackPtMin");
347  double PtMax = conf_->getParameter<double>("TrackPtMax");
348 
349  int Phi2DBin = conf_->getParameter<int>("Phi2DBin");
350  int Eta2DBin = conf_->getParameter<int>("Eta2DBin");
351  int Pt2DBin = conf_->getParameter<int>("TrackPt2DBin");
352 
353  int VXBin = conf_->getParameter<int>("VXBin");
354  double VXMin = conf_->getParameter<double>("VXMin");
355  double VXMax = conf_->getParameter<double>("VXMax");
356 
357  int VYBin = conf_->getParameter<int>("VYBin");
358  double VYMin = conf_->getParameter<double>("VYMin");
359  double VYMax = conf_->getParameter<double>("VYMax");
360 
361  int VZBin = conf_->getParameter<int>("VZBin");
362  double VZMin = conf_->getParameter<double>("VZMin");
363  double VZMax = conf_->getParameter<double>("VZMax");
364 
365  ibooker.setCurrentFolder(TopFolder_);
366 
367  // book the Hit Property histograms
368  // ---------------------------------------------------------------------------------//
369 
370  TkParameterMEs tkmes;
371  if (doHitPropertiesPlots_ || doAllPlots_) {
372  ibooker.setCurrentFolder(TopFolder_ + "/HitProperties");
373 
374  histname = "NumberOfRecHitsPerTrack_";
375  NumberOfRecHitsPerTrack =
376  ibooker.book1D(histname + CategoryName, histname + CategoryName, TKHitBin, TKHitMin, TKHitMax);
377  NumberOfRecHitsPerTrack->setAxisTitle("Number of all RecHits of each Track");
378  NumberOfRecHitsPerTrack->setAxisTitle("Number of Tracks", 2);
379 
380  histname = "NumberOfValidRecHitsPerTrack_";
381  NumberOfValidRecHitsPerTrack =
382  ibooker.book1D(histname + CategoryName, histname + CategoryName, TKHitBin, TKHitMin, TKHitMax);
383  NumberOfValidRecHitsPerTrack->setAxisTitle("Number of valid RecHits for each Track");
384 
385  NumberOfValidRecHitsPerTrack->setAxisTitle("Number of Tracks", 2);
386 
387  histname = "NumberOfLostRecHitsPerTrack_";
388  NumberOfLostRecHitsPerTrack =
389  ibooker.book1D(histname + CategoryName, histname + CategoryName, TKLostBin, TKLostMin, TKLostMax);
390  NumberOfLostRecHitsPerTrack->setAxisTitle("Number of lost RecHits for each Track");
391  NumberOfLostRecHitsPerTrack->setAxisTitle("Number of Tracks", 2);
392 
393  histname = "NumberOfMissingInnerRecHitsPerTrack_";
394  NumberOfMIRecHitsPerTrack = ibooker.book1D(histname + CategoryName, histname + CategoryName, 10, -0.5, 9.5);
395  NumberOfMIRecHitsPerTrack->setAxisTitle("Number of missing-inner RecHits for each Track");
396  NumberOfMIRecHitsPerTrack->setAxisTitle("Number of Tracks", 2);
397 
398  histname = "NumberOfMissingOuterRecHitsPerTrack_";
399  NumberOfMORecHitsPerTrack = ibooker.book1D(histname + CategoryName, histname + CategoryName, 10, -0.5, 9.5);
400  NumberOfMORecHitsPerTrack->setAxisTitle("Number of missing-outer RecHits for each Track");
401  NumberOfMORecHitsPerTrack->setAxisTitle("Number of Tracks", 2);
402 
403  histname = "ValidFractionPerTrack_";
404  ValidFractionPerTrack = ibooker.book1D(histname + CategoryName, histname + CategoryName, 101, 0., 1.01);
405  ValidFractionPerTrack->setAxisTitle("ValidFraction of RecHits for each Track");
406  ValidFractionPerTrack->setAxisTitle("Number of Tracks", 2);
407 
408  if (doRecHitVsPhiVsEtaPerTrack_ || doAllPlots_) {
409  histname = "NumberOfValidRecHitVsPhiVsEtaPerTrack_";
410  NumberOfValidRecHitVsPhiVsEtaPerTrack = ibooker.bookProfile2D(histname + CategoryName,
411  histname + CategoryName,
412  Eta2DBin,
413  EtaMin,
414  EtaMax,
415  Phi2DBin,
416  PhiMin,
417  PhiMax,
418  0,
419  40.,
420  "");
421  NumberOfValidRecHitVsPhiVsEtaPerTrack->setAxisTitle("Track #eta ", 1);
422  NumberOfValidRecHitVsPhiVsEtaPerTrack->setAxisTitle("Track #phi ", 2);
423 
424  histname = "NumberOfLostRecHitVsPhiVsEtaPerTrack_";
425  NumberOfLostRecHitVsPhiVsEtaPerTrack = ibooker.bookProfile2D(histname + CategoryName,
426  histname + CategoryName,
427  Eta2DBin,
428  EtaMin,
429  EtaMax,
430  Phi2DBin,
431  PhiMin,
432  PhiMax,
433  0,
434  5.,
435  "");
436  NumberOfLostRecHitVsPhiVsEtaPerTrack->setAxisTitle("Track #eta ", 1);
437  NumberOfLostRecHitVsPhiVsEtaPerTrack->setAxisTitle("Track #phi ", 2);
438 
439  histname = "NumberMIRecHitVsPhiVsEtaPerTrack_";
440  NumberOfMIRecHitVsPhiVsEtaPerTrack = ibooker.bookProfile2D(histname + CategoryName,
441  histname + CategoryName,
442  Eta2DBin,
443  EtaMin,
444  EtaMax,
445  Phi2DBin,
446  PhiMin,
447  PhiMax,
448  0,
449  15.,
450  "");
451  NumberOfMIRecHitVsPhiVsEtaPerTrack->setAxisTitle("Track #eta ", 1);
452  NumberOfMIRecHitVsPhiVsEtaPerTrack->setAxisTitle("Track #phi ", 2);
453 
454  histname = "NumberMORecHitVsPhiVsEtaPerTrack_";
455  NumberOfMORecHitVsPhiVsEtaPerTrack = ibooker.bookProfile2D(histname + CategoryName,
456  histname + CategoryName,
457  Eta2DBin,
458  EtaMin,
459  EtaMax,
460  Phi2DBin,
461  PhiMin,
462  PhiMax,
463  0,
464  15.,
465  "");
466  NumberOfMORecHitVsPhiVsEtaPerTrack->setAxisTitle("Track #eta ", 1);
467  NumberOfMORecHitVsPhiVsEtaPerTrack->setAxisTitle("Track #phi ", 2);
468 
469  histname = "ValidFractionVsPhiVsEtaPerTrack_";
470  ValidFractionVsPhiVsEtaPerTrack = ibooker.bookProfile2D(histname + CategoryName,
471  histname + CategoryName,
472  Eta2DBin,
473  EtaMin,
474  EtaMax,
475  Phi2DBin,
476  PhiMin,
477  PhiMax,
478  0,
479  2.,
480  "");
481  ValidFractionVsPhiVsEtaPerTrack->setAxisTitle("Track #eta ", 1);
482  ValidFractionVsPhiVsEtaPerTrack->setAxisTitle("Track #phi ", 2);
483  }
484 
485  if (doRecHitVsPtVsEtaPerTrack_ || doAllPlots_) {
486  histname = "NumberOfValidRecHitVsPtVsEtaPerTrack_";
487  NumberOfValidRecHitVsPtVsEtaPerTrack = ibooker.bookProfile2D(
488  histname + CategoryName, histname + CategoryName, Eta2DBin, EtaMin, EtaMax, Pt2DBin, PtMin, PtMax, 0, 40., "");
489  NumberOfValidRecHitVsPtVsEtaPerTrack->setAxisTitle("Track #eta ", 1);
490  NumberOfValidRecHitVsPtVsEtaPerTrack->setAxisTitle("Track p_{T} [GeV] ", 2);
491 
492  histname = "NumberOfLostRecHitVsPtVsEtaPerTrack_";
493  NumberOfLostRecHitVsPtVsEtaPerTrack = ibooker.bookProfile2D(
494  histname + CategoryName, histname + CategoryName, Eta2DBin, EtaMin, EtaMax, Pt2DBin, PtMin, PtMax, 0, 5., "");
495  NumberOfLostRecHitVsPtVsEtaPerTrack->setAxisTitle("Track #eta ", 1);
496  NumberOfLostRecHitVsPtVsEtaPerTrack->setAxisTitle("Track p_{T} [GeV] ", 2);
497 
498  histname = "NumberMIRecHitVsPtVsEtaPerTrack_";
499  NumberOfMIRecHitVsPtVsEtaPerTrack = ibooker.bookProfile2D(
500  histname + CategoryName, histname + CategoryName, Eta2DBin, EtaMin, EtaMax, Pt2DBin, PtMin, PtMax, 0, 15., "");
501  NumberOfMIRecHitVsPtVsEtaPerTrack->setAxisTitle("Track #eta ", 1);
502  NumberOfMIRecHitVsPtVsEtaPerTrack->setAxisTitle("Track p_{T} [GeV] ", 2);
503 
504  histname = "NumberMORecHitVsPtVsEtaPerTrack_";
505  NumberOfMORecHitVsPtVsEtaPerTrack = ibooker.bookProfile2D(
506  histname + CategoryName, histname + CategoryName, Eta2DBin, EtaMin, EtaMax, Pt2DBin, PtMin, PtMax, 0, 15., "");
507  NumberOfMORecHitVsPtVsEtaPerTrack->setAxisTitle("Track #eta ", 1);
508  NumberOfMORecHitVsPtVsEtaPerTrack->setAxisTitle("Track p_{T} [GeV] ", 2);
509  }
510 
511  histname = "NumberOfValidRecHitsPerTrackVsPt_";
512  NumberOfValidRecHitsPerTrackVsPt = ibooker.bookProfile(
513  histname + CategoryName, histname + CategoryName, PtBin, PtMin, PtMax, TKHitMin, TKHitMax, "");
514  NumberOfValidRecHitsPerTrackVsPt->setAxisTitle("Track p_{T} [GeV]", 1);
515  NumberOfValidRecHitsPerTrackVsPt->setAxisTitle("Number of valid RecHits in each Track", 2);
516 
517  histname = "NumberOfLostRecHitsPerTrackVsPt_";
518  NumberOfLostRecHitsPerTrackVsPt = ibooker.bookProfile(
519  histname + CategoryName, histname + CategoryName, PtBin, PtMin, PtMax, TKHitMin, TKHitMax, "");
520  NumberOfLostRecHitsPerTrackVsPt->setAxisTitle("Track p_{T} [GeV]", 1);
521  NumberOfLostRecHitsPerTrackVsPt->setAxisTitle("Average Number of Lost RecHits per Track", 2);
522 
523  histname = "NumberMIRecHitsPerTrackVsPt_";
524  NumberOfMIRecHitsPerTrackVsPt = ibooker.bookProfile(
525  histname + CategoryName, histname + CategoryName, PtBin, PtMin, PtMax, TKHitMin, TKHitMax, "");
526  NumberOfMIRecHitsPerTrackVsPt->setAxisTitle("Track p_{T} [GeV]", 1);
527  NumberOfMIRecHitsPerTrackVsPt->setAxisTitle("Average Number of Lost RecHits per Track", 2);
528 
529  histname = "NumberMORecHitsPerTrackVsPt_";
530  NumberOfMORecHitsPerTrackVsPt = ibooker.bookProfile(
531  histname + CategoryName, histname + CategoryName, PtBin, PtMin, PtMax, TKHitMin, TKHitMax, "");
532  NumberOfMORecHitsPerTrackVsPt->setAxisTitle("Track p_{T} [GeV]", 1);
533  NumberOfMORecHitsPerTrackVsPt->setAxisTitle("Average Number of Lost RecHits per Track", 2);
534 
535  std::string layerTypeName[5] = {"", "Off", "3D", "Missing", "Pixel"};
536  for (int i = 0; i < 4; ++i) {
537  histname = "NumberOf" + layerTypeName[i] + "LayersPerTrack_";
538  NumberOfLayersPerTrack[i] =
539  ibooker.book1D(histname + CategoryName, histname + CategoryName, TKLayBin, TKLayMin, TKLayMax);
540  NumberOfLayersPerTrack[i]->setAxisTitle("Number of " + layerTypeName[i] + " Layers of each Track", 1);
541  NumberOfLayersPerTrack[i]->setAxisTitle("Number of Tracks", 2);
542  }
543  if (doLayersVsPhiVsEtaPerTrack_ || doAllPlots_)
544  for (int i = 0; i < 5; ++i) {
545  histname = "NumberOf" + layerTypeName[i] + "LayersVsPhiVsEtaPerTrack_";
546  NumberOfLayersVsPhiVsEtaPerTrack[i] = ibooker.bookProfile2D(histname + CategoryName,
547  histname + CategoryName,
548  Eta2DBin,
549  EtaMin,
550  EtaMax,
551  Phi2DBin,
552  PhiMin,
553  PhiMax,
554  0,
555  40.,
556  "");
557  NumberOfLayersVsPhiVsEtaPerTrack[i]->setAxisTitle("Track #eta ", 1);
558  NumberOfLayersVsPhiVsEtaPerTrack[i]->setAxisTitle("Track #phi ", 2);
559  }
560  }
561 
562  // book the General Property histograms
563  // ---------------------------------------------------------------------------------//
564 
565  if (doGeneralPropertiesPlots_ || doAllPlots_) {
566  int Chi2Bin = conf_->getParameter<int>("Chi2Bin");
567  double Chi2Min = conf_->getParameter<double>("Chi2Min");
568  double Chi2Max = conf_->getParameter<double>("Chi2Max");
569 
570  int Chi2NDFBin = conf_->getParameter<int>("Chi2NDFBin");
571  double Chi2NDFMin = conf_->getParameter<double>("Chi2NDFMin");
572  double Chi2NDFMax = conf_->getParameter<double>("Chi2NDFMax");
573 
574  int Chi2ProbBin = conf_->getParameter<int>("Chi2ProbBin");
575  double Chi2ProbMin = conf_->getParameter<double>("Chi2ProbMin");
576  double Chi2ProbMax = conf_->getParameter<double>("Chi2ProbMax");
577 
578  //HI PLOTS////
579  int TransDCABins = conf_->getParameter<int>("TransDCABins");
580  double TransDCAMin = conf_->getParameter<double>("TransDCAMin");
581  double TransDCAMax = conf_->getParameter<double>("TransDCAMax");
582 
583  int LongDCABins = conf_->getParameter<int>("LongDCABins");
584  double LongDCAMin = conf_->getParameter<double>("LongDCAMin");
585  double LongDCAMax = conf_->getParameter<double>("LongDCAMax");
587 
588  ibooker.setCurrentFolder(TopFolder_ + "/GeneralProperties");
589 
590  histname = "Chi2_";
591  Chi2 = ibooker.book1D(histname + CategoryName, histname + CategoryName, Chi2Bin, Chi2Min, Chi2Max);
592  Chi2->setAxisTitle("Track #chi^{2}", 1);
593  Chi2->setAxisTitle("Number of Tracks", 2);
594 
595  histname = "Chi2Prob_";
596  Chi2Prob = ibooker.book1D(histname + CategoryName, histname + CategoryName, Chi2ProbBin, Chi2ProbMin, Chi2ProbMax);
597  Chi2Prob->setAxisTitle("Track #chi^{2} probability", 1);
598  Chi2Prob->setAxisTitle("Number of Tracks", 2);
599 
600  histname = "Chi2oNDF_";
601  Chi2oNDF = ibooker.book1D(histname + CategoryName, histname + CategoryName, Chi2NDFBin, Chi2NDFMin, Chi2NDFMax);
602  Chi2oNDF->setAxisTitle("Track #chi^{2}/ndf", 1);
603  Chi2oNDF->setAxisTitle("Number of Tracks", 2);
604 
606  //HI PLOTS///
608  if (doHIPlots_) {
609  histname = "LongDCASig_";
610  LongDCASig =
611  ibooker.book1D(histname + CategoryName, histname + CategoryName, LongDCABins, LongDCAMin, LongDCAMax);
612  LongDCASig->setAxisTitle("dz/#sigma_{dz}", 1);
613 
614  histname = "TransDCASig_";
615  TransDCASig =
616  ibooker.book1D(histname + CategoryName, histname + CategoryName, TransDCABins, TransDCAMin, TransDCAMax);
617  TransDCASig->setAxisTitle("dxy/#sigma_{dxy}", 1);
618 
619  histname = "dNdPhi_HighPurity_";
620  dNdPhi_HighPurity = ibooker.book1D(histname + CategoryName, histname + CategoryName, PhiBin, PhiMin, PhiMax);
621  dNdPhi_HighPurity->setAxisTitle("#phi", 1);
622 
623  histname = "dNdEta_HighPurity_";
624  dNdEta_HighPurity = ibooker.book1D(histname + CategoryName, histname + CategoryName, EtaBin, EtaMin, EtaMax);
625  dNdEta_HighPurity->setAxisTitle("#eta", 1);
626 
627  histname = "dNdPt_HighPurity_";
628  dNdPt_HighPurity = ibooker.book1D(histname + CategoryName, histname + CategoryName, 150, 0, 0.3);
629  dNdPt_HighPurity->setAxisTitle("#sigma_{p_{T}}/p_{T}", 1);
630 
631  histname = "NhitVsEta_HighPurity_";
632  NhitVsEta_HighPurity =
633  ibooker.bookProfile(histname + CategoryName, histname + CategoryName, EtaBin, EtaMin, EtaMax, -0.5, 39.5, "");
634  NhitVsEta_HighPurity->setAxisTitle("Track #eta", 1);
635  NhitVsEta_HighPurity->setAxisTitle("Number of Valid RecHits in each Track", 2);
636 
637  histname = "NhitVsPhi_HighPurity_";
638  NhitVsPhi_HighPurity =
639  ibooker.bookProfile(histname + CategoryName, histname + CategoryName, PhiBin, PhiMin, PhiMax, -0.5, 39.5, "");
640  NhitVsPhi_HighPurity->setAxisTitle("Track #phi", 1);
641  NhitVsPhi_HighPurity->setAxisTitle("Number of Valid RecHits in each Track", 2);
642 
643  histname = "Ptdist_HighPurity_";
644  Ptdist_HighPurity = ibooker.book1D(histname + CategoryName, histname + CategoryName, 150, 0, 50.);
645  Ptdist_HighPurity->setAxisTitle("p_{T} (GeV/c)", 1);
646  Ptdist_HighPurity->setAxisTitle("Number of Tracks", 2);
647 
648  histname = "dNhitdPt_HighPurity_";
649  dNhitdPt_HighPurity =
650  ibooker.bookProfile(histname + CategoryName, histname + CategoryName, 150, 0, 25., -0.5, 39.5, "");
651  dNhitdPt_HighPurity->setAxisTitle("p_{T} (GeV/c)", 1);
652  dNhitdPt_HighPurity->setAxisTitle("N_{hit}", 2);
653  }
654 
655  if (doDCAPlots_ || doPVPlots_ || doSIPPlots_ || doAllPlots_) {
656  histname = "xPointOfClosestApproach_";
657  xPointOfClosestApproach = ibooker.book1D(histname + CategoryName, histname + CategoryName, VXBin, VXMin, VXMax);
658  xPointOfClosestApproach->setAxisTitle("x component of Track PCA to beam line (cm)", 1);
659  xPointOfClosestApproach->setAxisTitle("Number of Tracks", 2);
660 
661  histname = "yPointOfClosestApproach_";
662  yPointOfClosestApproach = ibooker.book1D(histname + CategoryName, histname + CategoryName, VYBin, VYMin, VYMax);
663  yPointOfClosestApproach->setAxisTitle("y component of Track PCA to beam line (cm)", 1);
664  yPointOfClosestApproach->setAxisTitle("Number of Tracks", 2);
665 
666  histname = "zPointOfClosestApproach_";
667  zPointOfClosestApproach = ibooker.book1D(histname + CategoryName, histname + CategoryName, VZBin, VZMin, VZMax);
668  zPointOfClosestApproach->setAxisTitle("z component of Track PCA to beam line (cm)", 1);
669  zPointOfClosestApproach->setAxisTitle("Number of Tracks", 2);
670 
671  histname = "xPointOfClosestApproachToPV_";
672  xPointOfClosestApproachToPV =
673  ibooker.book1D(histname + CategoryName, histname + CategoryName, VXBin, VXMin, VXMax);
674  xPointOfClosestApproachToPV->setAxisTitle("x component of Track PCA to pv (cm)", 1);
675  xPointOfClosestApproachToPV->setAxisTitle("Number of Tracks", 2);
676 
677  histname = "yPointOfClosestApproachToPV_";
678  yPointOfClosestApproachToPV =
679  ibooker.book1D(histname + CategoryName, histname + CategoryName, VYBin, VYMin, VYMax);
680  yPointOfClosestApproachToPV->setAxisTitle("y component of Track PCA to pv line (cm)", 1);
681  yPointOfClosestApproachToPV->setAxisTitle("Number of Tracks", 2);
682 
683  histname = "zPointOfClosestApproachToPV_";
684  zPointOfClosestApproachToPV =
685  ibooker.book1D(histname + CategoryName, histname + CategoryName, VZBin, VZMin, VZMax);
686  zPointOfClosestApproachToPV->setAxisTitle("z component of Track PCA to pv line (cm)", 1);
687  zPointOfClosestApproachToPV->setAxisTitle("Number of Tracks", 2);
688  }
689 
690  // See DataFormats/TrackReco/interface/TrackBase.h for track algorithm enum definition
691  // http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/CMSSW/DataFormats/TrackReco/interface/TrackBase.h?view=log
692  histname = "algorithm_";
693  algorithm = ibooker.book1D(histname + CategoryName,
694  histname + CategoryName,
695  reco::TrackBase::algoSize,
696  0.,
697  double(reco::TrackBase::algoSize));
698  algorithm->setAxisTitle("Tracking algorithm", 1);
699  algorithm->setAxisTitle("Number of Tracks", 2);
700 
701  histname = "originalAlgorithm_";
702  oriAlgo = ibooker.book1D(histname + CategoryName,
703  histname + CategoryName,
704  reco::TrackBase::algoSize,
705  0.,
706  double(reco::TrackBase::algoSize));
707  oriAlgo->setAxisTitle("Tracking algorithm", 1);
708  oriAlgo->setAxisTitle("Number of Tracks", 2);
709 
710  for (size_t ibin = 0; ibin < reco::TrackBase::algoSize - 1; ibin++) {
711  algorithm->setBinLabel(ibin + 1, reco::TrackBase::algoNames[ibin]);
712  oriAlgo->setBinLabel(ibin + 1, reco::TrackBase::algoNames[ibin]);
713  }
714 
715  size_t StopReasonNameSize = sizeof(StopReasonName::StopReasonName) / sizeof(std::string);
716  histname = "stoppingSource_";
717  stoppingSource = ibooker.book1D(
718  histname + CategoryName, histname + CategoryName, StopReasonNameSize, 0., double(StopReasonNameSize));
719  stoppingSource->setAxisTitle("stopping reason", 1);
720  stoppingSource->setAxisTitle("Number of Tracks", 2);
721 
722  histname = "stoppingSourceVSeta_";
723  stoppingSourceVSeta =
724  ibooker.bookProfile(histname + CategoryName, histname + CategoryName, EtaBin, EtaMin, EtaMax, 2, 0., 2.);
725  stoppingSourceVSeta->setAxisTitle("track #eta", 1);
726  stoppingSourceVSeta->setAxisTitle("stopped fraction", 2);
727 
728  histname = "stoppingSourceVSphi_";
729  stoppingSourceVSphi =
730  ibooker.bookProfile(histname + CategoryName, histname + CategoryName, PhiBin, PhiMin, PhiMax, 2, 0., 2.);
731  stoppingSourceVSphi->setAxisTitle("track #phi", 1);
732  stoppingSourceVSphi->setAxisTitle("stopped fraction", 2);
733 
734  for (size_t ibin = 0; ibin < StopReasonNameSize; ibin++) {
735  stoppingSource->setBinLabel(ibin + 1, StopReasonName::StopReasonName[ibin], 1);
736  }
737  }
738 }
739 
740 void TrackAnalyzer::bookHistosForLScertification(DQMStore::IBooker& ibooker) {
741  // parameters from the configuration
742  std::string QualName = conf_->getParameter<std::string>("Quality");
743  std::string AlgoName = conf_->getParameter<std::string>("AlgoName");
744 
745  // use the AlgoName and Quality Name
746  std::string CategoryName = !QualName.empty() ? AlgoName + "_" + QualName : AlgoName;
747 
748  // book LS analysis related histograms
749  // -----------------------------------
750  if (doLumiAnalysis_) {
751  // get binning from the configuration
752  int TKHitBin = conf_->getParameter<int>("RecHitBin");
753  double TKHitMin = conf_->getParameter<double>("RecHitMin");
754  double TKHitMax = conf_->getParameter<double>("RecHitMax");
755 
756  int Chi2NDFBin = conf_->getParameter<int>("Chi2NDFBin");
757  double Chi2NDFMin = conf_->getParameter<double>("Chi2NDFMin");
758  double Chi2NDFMax = conf_->getParameter<double>("Chi2NDFMax");
759 
760  // add by Mia in order to deal w/ LS transitions
761  ibooker.setCurrentFolder(TopFolder_ + "/LSanalysis");
762 
763  histname = "NumberOfRecHitsPerTrack_lumiFlag_";
764  NumberOfRecHitsPerTrack_lumiFlag =
765  ibooker.book1D(histname + CategoryName, histname + CategoryName, TKHitBin, TKHitMin, TKHitMax);
766  NumberOfRecHitsPerTrack_lumiFlag->setAxisTitle("Number of all RecHits of each Track");
767  NumberOfRecHitsPerTrack_lumiFlag->setAxisTitle("Number of Tracks", 2);
768 
769  histname = "Chi2oNDF_lumiFlag_";
770  Chi2oNDF_lumiFlag =
771  ibooker.book1D(histname + CategoryName, histname + CategoryName, Chi2NDFBin, Chi2NDFMin, Chi2NDFMax);
772  Chi2oNDF_lumiFlag->setAxisTitle("Track #chi^{2}/ndf", 1);
773  Chi2oNDF_lumiFlag->setAxisTitle("Number of Tracks", 2);
774  }
775 }
776 
777 void TrackAnalyzer::bookHistosForBeamSpot(DQMStore::IBooker& ibooker) {
778  // parameters from the configuration
779  std::string QualName = conf_->getParameter<std::string>("Quality");
780  std::string AlgoName = conf_->getParameter<std::string>("AlgoName");
781 
782  // use the AlgoName and Quality Name
783  std::string CategoryName = !QualName.empty() ? AlgoName + "_" + QualName : AlgoName;
784  std::string Folder = TopFolder_.substr(0, 2);
785 
786  // book the Beam Spot related histograms
787  // ---------------------------------------------------------------------------------//
788 
789  if (doDCAPlots_ || doBSPlots_ || doAllPlots_) {
790  int DxyErrBin = conf_->getParameter<int>("DxyErrBin");
791  double DxyErrMax = conf_->getParameter<double>("DxyErrMax");
792 
793  int DxyBin = conf_->getParameter<int>("DxyBin");
794  double DxyMin = conf_->getParameter<double>("DxyMin");
795  double DxyMax = conf_->getParameter<double>("DxyMax");
796 
797  int AbsDxyBin = conf_->getParameter<int>("AbsDxyBin");
798  double AbsDxyMin = conf_->getParameter<double>("AbsDxyMin");
799  double AbsDxyMax = conf_->getParameter<double>("AbsDxyMax");
800 
801  int PhiBin = conf_->getParameter<int>("PhiBin");
802  double PhiMin = conf_->getParameter<double>("PhiMin");
803  double PhiMax = conf_->getParameter<double>("PhiMax");
804 
805  int EtaBin = conf_->getParameter<int>("EtaBin");
806  double EtaMin = conf_->getParameter<double>("EtaMin");
807  double EtaMax = conf_->getParameter<double>("EtaMax");
808 
809  int PtBin = conf_->getParameter<int>("TrackPtBin");
810  double PtMin = conf_->getParameter<double>("TrackPtMin");
811  double PtMax = conf_->getParameter<double>("TrackPtMax");
812 
813  int X0Bin = conf_->getParameter<int>("X0Bin");
814  double X0Min = conf_->getParameter<double>("X0Min");
815  double X0Max = conf_->getParameter<double>("X0Max");
816 
817  int Y0Bin = conf_->getParameter<int>("Y0Bin");
818  double Y0Min = conf_->getParameter<double>("Y0Min");
819  double Y0Max = conf_->getParameter<double>("Y0Max");
820 
821  int Z0Bin = conf_->getParameter<int>("Z0Bin");
822  double Z0Min = conf_->getParameter<double>("Z0Min");
823  double Z0Max = conf_->getParameter<double>("Z0Max");
824 
825  int VZBinProf = conf_->getParameter<int>("VZBinProf");
826  double VZMinProf = conf_->getParameter<double>("VZMinProf");
827  double VZMaxProf = conf_->getParameter<double>("VZMaxProf");
828 
829  ibooker.setCurrentFolder(TopFolder_ + "/GeneralProperties");
830 
831  histname = "DistanceOfClosestApproachError_";
832  DistanceOfClosestApproachError =
833  ibooker.book1D(histname + CategoryName, histname + CategoryName, DxyErrBin, 0., DxyErrMax);
834  DistanceOfClosestApproachError->setAxisTitle("Track d_{xy} error (cm)", 1);
835  DistanceOfClosestApproachError->setAxisTitle("Number of Tracks", 2);
836 
837  histname = "DistanceOfClosestApproachErrorVsPt_";
838  DistanceOfClosestApproachErrorVsPt =
839  ibooker.bookProfile(histname + CategoryName, histname + CategoryName, PtBin, PtMin, PtMax, 0., DxyErrMax);
840  DistanceOfClosestApproachErrorVsPt->setAxisTitle("Track p_{T} (GeV)", 1);
841  DistanceOfClosestApproachErrorVsPt->setAxisTitle("Track d_{xy} error (cm)", 2);
842 
843  histname = "DistanceOfClosestApproachErrorVsEta_";
844  DistanceOfClosestApproachErrorVsEta =
845  ibooker.bookProfile(histname + CategoryName, histname + CategoryName, EtaBin, EtaMin, EtaMax, 0., DxyErrMax);
846  DistanceOfClosestApproachErrorVsEta->setAxisTitle("Track #eta", 1);
847  DistanceOfClosestApproachErrorVsEta->setAxisTitle("Track d_{xy} error (cm)", 2);
848 
849  histname = "DistanceOfClosestApproachErrorVsPhi_";
850  DistanceOfClosestApproachErrorVsPhi =
851  ibooker.bookProfile(histname + CategoryName, histname + CategoryName, PhiBin, PhiMin, PhiMax, 0., DxyErrMax);
852  DistanceOfClosestApproachErrorVsPhi->setAxisTitle("Track #phi", 1);
853  DistanceOfClosestApproachErrorVsPhi->setAxisTitle("Track d_{xy} error (cm)", 2);
854 
855  histname = "DistanceOfClosestApproachErrorVsDxy_";
856  DistanceOfClosestApproachErrorVsDxy =
857  ibooker.bookProfile(histname + CategoryName, histname + CategoryName, DxyBin, DxyMin, DxyMax, 0., DxyErrMax);
858  DistanceOfClosestApproachErrorVsDxy->setAxisTitle("Track d_{xy}", 1);
859  DistanceOfClosestApproachErrorVsDxy->setAxisTitle("Track d_{xy} error (cm)", 2);
860 
861  histname = "DistanceOfClosestApproachToBS_";
862  DistanceOfClosestApproachToBS =
863  ibooker.book1D(histname + CategoryName, histname + CategoryName, DxyBin, DxyMin, DxyMax);
864  DistanceOfClosestApproachToBS->setAxisTitle("Track d_{xy} wrt beam spot (cm)", 1);
865  DistanceOfClosestApproachToBS->setAxisTitle("Number of Tracks", 2);
866 
867  if (Folder == "Tr") {
868  histname = "DistanceOfClosestApproachToBSdz_";
869  DistanceOfClosestApproachToBSdz =
870  ibooker.book1D(histname + CategoryName, histname + CategoryName, 100, -20.1, 20.1);
871  DistanceOfClosestApproachToBSdz->setAxisTitle("Track d_{z} wrt beam spot (cm)", 1);
872  DistanceOfClosestApproachToBSdz->setAxisTitle("Number of Tracks", 2);
873 
874  histname = "DistanceOfClosestApproachToBSVsEta_";
875  DistanceOfClosestApproachToBSVsEta = ibooker.bookProfile(
876  histname + CategoryName, histname + CategoryName, EtaBin, EtaMin, EtaMax, DxyBin, DxyMin, DxyMax, "");
877  DistanceOfClosestApproachToBSVsEta->setAxisTitle("Track #eta", 1);
878  DistanceOfClosestApproachToBSVsEta->setAxisTitle("Track d_{xy} wrt beam spot (cm)", 2);
879  }
880 
881  histname = "AbsDistanceOfClosestApproachToBS_";
882  AbsDistanceOfClosestApproachToBS =
883  ibooker.book1D(histname + CategoryName, histname + CategoryName, AbsDxyBin, AbsDxyMin, AbsDxyMax);
884  AbsDistanceOfClosestApproachToBS->setAxisTitle("Track |d_{xy}| wrt beam spot (cm)", 1);
885  AbsDistanceOfClosestApproachToBS->setAxisTitle("Number of Tracks", 2);
886 
887  histname = "DistanceOfClosestApproachToBSVsPhi_";
888  DistanceOfClosestApproachToBSVsPhi = ibooker.bookProfile(
889  histname + CategoryName, histname + CategoryName, PhiBin, PhiMin, PhiMax, DxyBin, DxyMin, DxyMax, "");
890  DistanceOfClosestApproachToBSVsPhi->setAxisTitle("Track #phi", 1);
891  DistanceOfClosestApproachToBSVsPhi->setAxisTitle("Track d_{xy} wrt beam spot (cm)", 2);
892 
893  histname = "xPointOfClosestApproachVsZ0wrt000_";
894  xPointOfClosestApproachVsZ0wrt000 = ibooker.bookProfile(
895  histname + CategoryName, histname + CategoryName, Z0Bin, Z0Min, Z0Max, X0Bin, X0Min, X0Max, "");
896  xPointOfClosestApproachVsZ0wrt000->setAxisTitle("d_{z} (cm)", 1);
897  xPointOfClosestApproachVsZ0wrt000->setAxisTitle("x component of Track PCA to beam line (cm)", 2);
898 
899  histname = "yPointOfClosestApproachVsZ0wrt000_";
900  yPointOfClosestApproachVsZ0wrt000 = ibooker.bookProfile(
901  histname + CategoryName, histname + CategoryName, Z0Bin, Z0Min, Z0Max, Y0Bin, Y0Min, Y0Max, "");
902  yPointOfClosestApproachVsZ0wrt000->setAxisTitle("d_{z} (cm)", 1);
903  yPointOfClosestApproachVsZ0wrt000->setAxisTitle("y component of Track PCA to beam line (cm)", 2);
904 
905  histname = "xPointOfClosestApproachVsZ0wrtBS_";
906  xPointOfClosestApproachVsZ0wrtBS = ibooker.bookProfile(
907  histname + CategoryName, histname + CategoryName, Z0Bin, Z0Min, Z0Max, X0Bin, X0Min, X0Max, "");
908  xPointOfClosestApproachVsZ0wrtBS->setAxisTitle("d_{z} w.r.t. Beam Spot (cm)", 1);
909  xPointOfClosestApproachVsZ0wrtBS->setAxisTitle("x component of Track PCA to BS (cm)", 2);
910 
911  histname = "yPointOfClosestApproachVsZ0wrtBS_";
912  yPointOfClosestApproachVsZ0wrtBS = ibooker.bookProfile(
913  histname + CategoryName, histname + CategoryName, Z0Bin, Z0Min, Z0Max, Y0Bin, Y0Min, Y0Max, "");
914  yPointOfClosestApproachVsZ0wrtBS->setAxisTitle("d_{z} w.r.t. Beam Spot (cm)", 1);
915  yPointOfClosestApproachVsZ0wrtBS->setAxisTitle("y component of Track PCA to BS (cm)", 2);
916 
917  histname = "zPointOfClosestApproachVsPhi_";
918  zPointOfClosestApproachVsPhi = ibooker.bookProfile(
919  histname + CategoryName, histname + CategoryName, PhiBin, PhiMin, PhiMax, VZBinProf, VZMinProf, VZMaxProf, "");
920  zPointOfClosestApproachVsPhi->setAxisTitle("Track #phi", 1);
921  zPointOfClosestApproachVsPhi->setAxisTitle("z component of Track PCA to beam line (cm)", 2);
922  }
923 
924  if (doDCAPlots_ || doPVPlots_ || doAllPlots_) {
925  int DxyBin = conf_->getParameter<int>("DxyBin");
926  double DxyMin = conf_->getParameter<double>("DxyMin");
927  double DxyMax = conf_->getParameter<double>("DxyMax");
928 
929  int PhiBin = conf_->getParameter<int>("PhiBin");
930  double PhiMin = conf_->getParameter<double>("PhiMin");
931  double PhiMax = conf_->getParameter<double>("PhiMax");
932 
933  int X0Bin = conf_->getParameter<int>("X0Bin");
934  double X0Min = conf_->getParameter<double>("X0Min");
935  double X0Max = conf_->getParameter<double>("X0Max");
936 
937  int Y0Bin = conf_->getParameter<int>("Y0Bin");
938  double Y0Min = conf_->getParameter<double>("Y0Min");
939  double Y0Max = conf_->getParameter<double>("Y0Max");
940 
941  int Z0Bin = conf_->getParameter<int>("Z0Bin");
942  double Z0Min = conf_->getParameter<double>("Z0Min");
943  double Z0Max = conf_->getParameter<double>("Z0Max");
944 
945  ibooker.setCurrentFolder(TopFolder_ + "/GeneralProperties");
946 
947  histname = "DistanceOfClosestApproachToPV_";
948  DistanceOfClosestApproachToPV =
949  ibooker.book1D(histname + CategoryName, histname + CategoryName, DxyBin, DxyMin, DxyMax);
950  DistanceOfClosestApproachToPV->setAxisTitle("Track d_{xy} w.r.t. PV (cm)", 1);
951  DistanceOfClosestApproachToPV->setAxisTitle("Number of Tracks", 2);
952 
953  histname = "DistanceOfClosestApproachToPVZoom_";
954  DistanceOfClosestApproachToPVZoom =
955  ibooker.book1D(histname + CategoryName, histname + CategoryName, 100, -0.08, 0.08);
956  DistanceOfClosestApproachToPVZoom->setAxisTitle("Track d_{xy} w.r.t. PV (cm)", 1);
957  DistanceOfClosestApproachToPVZoom->setAxisTitle("Number of Tracks", 2);
958 
959  histname = "DeltaZToPV_";
960  DeltaZToPV = ibooker.book1D(histname + CategoryName, histname + CategoryName, Z0Bin, Z0Min, Z0Max);
961  DeltaZToPV->setAxisTitle("Track d_{z} w.r.t. PV (cm)", 1);
962  DeltaZToPV->setAxisTitle("Number of Tracks", 2);
963 
964  histname = "DeltaZToPVZoom_";
965  DeltaZToPVZoom = ibooker.book1D(histname + CategoryName, histname + CategoryName, 100, -0.15, 0.15);
966  DeltaZToPVZoom->setAxisTitle("Track d_{z} w.r.t. PV (cm)", 1);
967  DeltaZToPVZoom->setAxisTitle("Number of Tracks", 2);
968 
969  histname = "DistanceOfClosestApproachToPVVsPhi_";
970  DistanceOfClosestApproachToPVVsPhi = ibooker.bookProfile(
971  histname + CategoryName, histname + CategoryName, PhiBin, PhiMin, PhiMax, DxyBin, DxyMin, DxyMax, "");
972  DistanceOfClosestApproachToPVVsPhi->setAxisTitle("Track #phi", 1);
973  DistanceOfClosestApproachToPVVsPhi->setAxisTitle("Track d_{xy} w.r.t. PV (cm)", 2);
974 
975  histname = "xPointOfClosestApproachVsZ0wrtPV_";
976  xPointOfClosestApproachVsZ0wrtPV = ibooker.bookProfile(
977  histname + CategoryName, histname + CategoryName, Z0Bin, Z0Min, Z0Max, X0Bin, X0Min, X0Max, "");
978  xPointOfClosestApproachVsZ0wrtPV->setAxisTitle("d_{z} w.r.t. PV (cm)", 1);
979  xPointOfClosestApproachVsZ0wrtPV->setAxisTitle("x component of Track PCA to PV (cm)", 2);
980 
981  histname = "yPointOfClosestApproachVsZ0wrtPV_";
982  yPointOfClosestApproachVsZ0wrtPV = ibooker.bookProfile(
983  histname + CategoryName, histname + CategoryName, Z0Bin, Z0Min, Z0Max, Y0Bin, Y0Min, Y0Max, "");
984  yPointOfClosestApproachVsZ0wrtPV->setAxisTitle("d_{z} w.r.t. PV (cm)", 1);
985  yPointOfClosestApproachVsZ0wrtPV->setAxisTitle("y component of Track PCA to PV (cm)", 2);
986  }
987 
988  if (doBSPlots_ || doAllPlots_) {
989  if (doTestPlots_) {
990  int DxyBin = conf_->getParameter<int>("DxyBin");
991  double DxyMin = conf_->getParameter<double>("DxyMin");
992  double DxyMax = conf_->getParameter<double>("DxyMax");
993 
994  int PhiBin = conf_->getParameter<int>("PhiBin");
995  double PhiMin = conf_->getParameter<double>("PhiMin");
996  double PhiMax = conf_->getParameter<double>("PhiMax");
997 
998  histname = "TESTDistanceOfClosestApproachToBS_";
999  TESTDistanceOfClosestApproachToBS =
1000  ibooker.book1D(histname + CategoryName, histname + CategoryName, DxyBin, DxyMin, DxyMax);
1001  TESTDistanceOfClosestApproachToBS->setAxisTitle("Track d_{xy} wrt beam spot (cm)", 1);
1002  TESTDistanceOfClosestApproachToBS->setAxisTitle("Number of Tracks", 2);
1003 
1004  histname = "TESTDistanceOfClosestApproachToBSVsPhi_";
1005  TESTDistanceOfClosestApproachToBSVsPhi = ibooker.bookProfile(
1006  histname + CategoryName, histname + CategoryName, PhiBin, PhiMin, PhiMax, DxyBin, DxyMin, DxyMax, "");
1007  TESTDistanceOfClosestApproachToBSVsPhi->setAxisTitle("Track #phi", 1);
1008  TESTDistanceOfClosestApproachToBSVsPhi->setAxisTitle("Track d_{xy} wrt beam spot (cm)", 2);
1009  }
1010  }
1011 
1012  // book the Profile plots for DCA related histograms
1013  // ---------------------------------------------------------------------------------//
1014  if (doDCAPlots_ || doAllPlots_) {
1015  if (doDCAwrt000Plots_) {
1016  int EtaBin = conf_->getParameter<int>("EtaBin");
1017  double EtaMin = conf_->getParameter<double>("EtaMin");
1018  double EtaMax = conf_->getParameter<double>("EtaMax");
1019 
1020  int PhiBin = conf_->getParameter<int>("PhiBin");
1021  double PhiMin = conf_->getParameter<double>("PhiMin");
1022  double PhiMax = conf_->getParameter<double>("PhiMax");
1023 
1024  int DxyBin = conf_->getParameter<int>("DxyBin");
1025  double DxyMin = conf_->getParameter<double>("DxyMin");
1026  double DxyMax = conf_->getParameter<double>("DxyMax");
1027 
1028  if (doThetaPlots_) {
1029  int ThetaBin = conf_->getParameter<int>("ThetaBin");
1030  double ThetaMin = conf_->getParameter<double>("ThetaMin");
1031  double ThetaMax = conf_->getParameter<double>("ThetaMax");
1032 
1033  ibooker.setCurrentFolder(TopFolder_ + "/GeneralProperties");
1034  histname = "DistanceOfClosestApproachVsTheta_";
1035  DistanceOfClosestApproachVsTheta = ibooker.bookProfile(
1036  histname + CategoryName, histname + CategoryName, ThetaBin, ThetaMin, ThetaMax, DxyMin, DxyMax, "");
1037  DistanceOfClosestApproachVsTheta->setAxisTitle("Track #theta", 1);
1038  DistanceOfClosestApproachVsTheta->setAxisTitle("Track d_{xy} wrt (0,0,0) (cm)", 2);
1039  }
1040 
1041  histname = "DistanceOfClosestApproachVsEta_";
1042  DistanceOfClosestApproachVsEta = ibooker.bookProfile(
1043  histname + CategoryName, histname + CategoryName, EtaBin, EtaMin, EtaMax, DxyMin, DxyMax, "");
1044  DistanceOfClosestApproachVsEta->setAxisTitle("Track #eta", 1);
1045  DistanceOfClosestApproachVsEta->setAxisTitle("Track d_{xy} wrt (0,0,0) (cm)", 2);
1046  // temporary patch in order to put back those MEs in Muon Workspace
1047 
1048  histname = "DistanceOfClosestApproach_";
1049  DistanceOfClosestApproach =
1050  ibooker.book1D(histname + CategoryName, histname + CategoryName, DxyBin, DxyMin, DxyMax);
1051  DistanceOfClosestApproach->setAxisTitle("Track d_{xy} wrt (0,0,0) (cm)", 1);
1052  DistanceOfClosestApproach->setAxisTitle("Number of Tracks", 2);
1053 
1054  histname = "DistanceOfClosestApproachVsPhi_";
1055  DistanceOfClosestApproachVsPhi = ibooker.bookProfile(
1056  histname + CategoryName, histname + CategoryName, PhiBin, PhiMin, PhiMax, DxyMin, DxyMax, "");
1057  DistanceOfClosestApproachVsPhi->setAxisTitle("Track #phi", 1);
1058  DistanceOfClosestApproachVsPhi->setAxisTitle("Track d_{xy} wrt (0,0,0) (cm)", 2);
1059  }
1060  }
1061 
1062  if (doSIPPlots_ || doAllPlots_) {
1063  const double sipBins = 200;
1064  const double sipMin = -20;
1065  const double sipMax = 20;
1066 
1067  ibooker.setCurrentFolder(TopFolder_ + "/GeneralProperties");
1068 
1069  // SIP wrt. beamspot
1070  histname = "SIPDxyToBS_";
1071  sipDxyToBS = ibooker.book1D(histname + CategoryName, histname + CategoryName, sipBins, sipMin, sipMax);
1072  sipDxyToBS->setAxisTitle("Track dxy significance wrt beam spot", 1);
1073  sipDxyToBS->setAxisTitle("Number of Tracks", 2);
1074 
1075  histname = "SIPDzToBS_";
1076  sipDzToBS = ibooker.book1D(histname + CategoryName, histname + CategoryName, sipBins, sipMin, sipMax);
1077  sipDzToBS->setAxisTitle("Track dz significance wrt beam spot", 1);
1078  sipDzToBS->setAxisTitle("Number of Tracks", 2);
1079 
1080  // SIP wrt. vertex
1081  histname = "SIP3DToPV_";
1082  sip3dToPV = ibooker.book1D(histname + CategoryName, histname + CategoryName, sipBins, sipMin, sipMax);
1083  sip3dToPV->setAxisTitle("3D IP significance wrt primary vertex", 1);
1084  sip3dToPV->setAxisTitle("Number of Tracks", 2);
1085 
1086  histname = "SIP2DToPV_";
1087  sip2dToPV = ibooker.book1D(histname + CategoryName, histname + CategoryName, sipBins, sipMin, sipMax);
1088  sip2dToPV->setAxisTitle("2D IP significance wrt primary vertex", 1);
1089  sip2dToPV->setAxisTitle("Number of Tracks", 2);
1090 
1091  histname = "SIPDxyToPV_";
1092  sipDxyToPV = ibooker.book1D(histname + CategoryName, histname + CategoryName, sipBins, sipMin, sipMax);
1093  sipDxyToPV->setAxisTitle("Track dxy significance wrt primary vertex", 1);
1094  sipDxyToPV->setAxisTitle("Number of Tracks", 2);
1095 
1096  histname = "SIPDzToPV_";
1097  sipDzToPV = ibooker.book1D(histname + CategoryName, histname + CategoryName, sipBins, sipMin, sipMax);
1098  sipDzToPV->setAxisTitle("Track dz significance wrt primary vertex", 1);
1099  sipDzToPV->setAxisTitle("Number of Tracks", 2);
1100  }
1101 }
1102 
1103 // -- Analyse
1104 // ---------------------------------------------------------------------------------//
1105 void TrackAnalyzer::setNumberOfGoodVertices(const edm::Event& iEvent) {
1106  good_vertices_ = 0;
1107 
1108  edm::Handle<reco::VertexCollection> recoPrimaryVerticesHandle = iEvent.getHandle(pvToken_);
1109  if (recoPrimaryVerticesHandle.isValid())
1110  if (!recoPrimaryVerticesHandle->empty())
1111  for (const auto& v : *recoPrimaryVerticesHandle)
1112  if (v.ndof() >= pvNDOF_ && !v.isFake())
1113  ++good_vertices_;
1114 }
1115 
1116 void TrackAnalyzer::setBX(const edm::Event& iEvent) { bx_ = iEvent.bunchCrossing(); }
1117 
1118 void TrackAnalyzer::setLumi(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
1119  // as done by pixelLumi http://cmslxr.fnal.gov/source/DQM/PixelLumi/plugins/PixelLumiDQM.cc
1120 
1121  if (forceSCAL_) {
1122  edm::Handle<LumiScalersCollection> lumiScalers = iEvent.getHandle(lumiscalersToken_);
1123  if (lumiScalers.isValid() && !lumiScalers->empty()) {
1124  LumiScalersCollection::const_iterator scalit = lumiScalers->begin();
1125  scal_lumi_ = scalit->instantLumi();
1126  } else
1127  scal_lumi_ = -1;
1128  } else {
1129  edm::Handle<OnlineLuminosityRecord> metaData = iEvent.getHandle(metaDataToken_);
1130  if (metaData.isValid())
1131  scal_lumi_ = metaData->instLumi();
1132  else
1133  scal_lumi_ = -1;
1134  }
1135 
1136  edm::Handle<edmNew::DetSetVector<SiPixelCluster> > pixelClusters = iEvent.getHandle(pixelClustersToken_);
1137  if (pixelClusters.isValid()) {
1138  TrackerTopology const& tTopo = iSetup.getData(trackerTopologyToken_);
1139 
1140  // Count the number of clusters with at least a minimum
1141  // number of pixels per cluster and at least a minimum charge.
1142  size_t numClusters = 0;
1143  size_t tot = 0;
1144 
1145  edmNew::DetSetVector<SiPixelCluster>::const_iterator pixCluDet = pixelClusters->begin();
1146  for (; pixCluDet != pixelClusters->end(); ++pixCluDet) {
1147  DetId detid = pixCluDet->detId();
1148  size_t subdetid = detid.subdetId();
1149  // std::cout << tTopo.print(detid) << std::endl;
1150  if (subdetid == (int)PixelSubdetector::PixelBarrel)
1151  if (tTopo.layer(detid) == 1)
1152  continue;
1153 
1154  edmNew::DetSet<SiPixelCluster>::const_iterator pixClu = pixCluDet->begin();
1155  for (; pixClu != pixCluDet->end(); ++pixClu) {
1156  ++tot;
1157  if ((pixClu->size() >= minNumberOfPixelsPerCluster_) && (pixClu->charge() >= minPixelClusterCharge_)) {
1158  ++numClusters;
1159  }
1160  }
1161  }
1162  pixel_lumi_ = lumi_factor_per_bx_ * numClusters / GetLumi::CM2_TO_NANOBARN; // ?!?!
1163  } else
1164  pixel_lumi_ = -1.;
1165 }
1166 
1167 void TrackAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup, const reco::Track& track) {
1168  auto pt = track.pt();
1169  auto phi = track.phi();
1170  // double eta = track.eta();
1171  auto phiIn = track.innerPosition().phi();
1172  auto etaIn = track.innerPosition().eta();
1173  auto phiOut = track.outerPosition().phi();
1174  auto etaOut = track.outerPosition().eta();
1175 
1176  int nRecHits = track.hitPattern().numberOfAllHits(reco::HitPattern::TRACK_HITS);
1177  int nValidRecHits = track.numberOfValidHits();
1178  int nLostRecHits = track.numberOfLostHits();
1179  int nLostIn = track.hitPattern().numberOfLostTrackerHits(reco::HitPattern::MISSING_INNER_HITS);
1180  int nLostOut = track.hitPattern().numberOfLostTrackerHits(reco::HitPattern::MISSING_OUTER_HITS);
1181 
1182  auto chi2 = track.chi2();
1183  auto chi2prob = TMath::Prob(track.chi2(), (int)track.ndof());
1184  auto chi2oNDF = track.normalizedChi2();
1185 
1186  std::string Folder = TopFolder_.substr(0, 2);
1187 
1188  if (doHitPropertiesPlots_ || doAllPlots_) {
1189  // rec hits
1190  NumberOfRecHitsPerTrack->Fill(nRecHits);
1191  NumberOfValidRecHitsPerTrack->Fill(nValidRecHits);
1192  NumberOfLostRecHitsPerTrack->Fill(nLostRecHits);
1193  NumberOfMIRecHitsPerTrack->Fill(nLostIn);
1194  NumberOfMORecHitsPerTrack->Fill(nLostOut);
1195  ValidFractionPerTrack->Fill(track.validFraction());
1196 
1197  // 2D plots
1198  if (doRecHitVsPhiVsEtaPerTrack_ || doAllPlots_) {
1199  NumberOfValidRecHitVsPhiVsEtaPerTrack->Fill(etaIn, phiIn, nValidRecHits);
1200  NumberOfLostRecHitVsPhiVsEtaPerTrack->Fill(etaIn, phiIn, nLostRecHits);
1201  NumberOfMIRecHitVsPhiVsEtaPerTrack->Fill(etaIn, phiIn, nLostIn);
1202  NumberOfMORecHitVsPhiVsEtaPerTrack->Fill(etaOut, phiOut, nLostOut);
1203  ValidFractionVsPhiVsEtaPerTrack->Fill(etaIn, phiIn, track.validFraction());
1204  }
1205  if (doRecHitVsPtVsEtaPerTrack_ || doAllPlots_) {
1206  NumberOfValidRecHitVsPtVsEtaPerTrack->Fill(etaIn, pt, nValidRecHits);
1207  NumberOfLostRecHitVsPtVsEtaPerTrack->Fill(etaIn, pt, nLostRecHits);
1208  NumberOfMIRecHitVsPtVsEtaPerTrack->Fill(etaIn, pt, nLostIn);
1209  NumberOfMORecHitVsPtVsEtaPerTrack->Fill(etaOut, pt, nLostOut);
1210  }
1211  NumberOfValidRecHitsPerTrackVsPt->Fill(pt, nValidRecHits);
1212  NumberOfLostRecHitsPerTrackVsPt->Fill(pt, nLostRecHits);
1213  NumberOfMIRecHitsPerTrackVsPt->Fill(pt, nLostIn);
1214  NumberOfMORecHitsPerTrackVsPt->Fill(pt, nLostOut);
1215 
1216  int nLayers[5] = {track.hitPattern().trackerLayersWithMeasurement(),
1217  track.hitPattern().trackerLayersTotallyOffOrBad(),
1218  track.hitPattern().numberOfValidStripLayersWithMonoAndStereo() +
1219  track.hitPattern().pixelLayersWithMeasurement(),
1220  track.hitPattern().trackerLayersWithoutMeasurement(reco::HitPattern::TRACK_HITS),
1221  track.hitPattern().pixelLayersWithMeasurement()};
1222 
1223  // layers
1224  for (int i = 0; i < 4; ++i)
1225  NumberOfLayersPerTrack[i]->Fill(nLayers[i]);
1226 
1227  // 2D plots
1228  if (doLayersVsPhiVsEtaPerTrack_ || doAllPlots_)
1229  for (int i = 0; i < 5; ++i)
1230  NumberOfLayersVsPhiVsEtaPerTrack[i]->Fill(etaIn, phiIn, nLayers[i]);
1231  }
1232 
1233  if (doEffFromHitPatternVsPU_ || doAllPlots_)
1234  fillHistosForEfficiencyFromHitPatter(track, "", float(good_vertices_), false);
1235  if (doEffFromHitPatternVsBX_ || doAllPlots_)
1236  fillHistosForEfficiencyFromHitPatter(track, "VsBX", float(bx_), false);
1237  if (doEffFromHitPatternVsLUMI_ || doAllPlots_)
1238  fillHistosForEfficiencyFromHitPatter(track, "VsSCALLUMI", scal_lumi_, false);
1239  // if (doEffFromHitPatternVsLUMI_ || doAllPlots_) fillHistosForEfficiencyFromHitPatter(track,"VsPIXELLUMI", pixel_lumi_ );
1240  if (doEffFromHitPatternVsPU_ || doAllPlots_)
1241  fillHistosForEfficiencyFromHitPatter(track, "", float(good_vertices_), true);
1242  if (doEffFromHitPatternVsLUMI_ || doAllPlots_)
1243  fillHistosForEfficiencyFromHitPatter(track, "VsSCALLUMI", scal_lumi_, true);
1244 
1245  if (doGeneralPropertiesPlots_ || doAllPlots_) {
1246  // fitting
1247  Chi2->Fill(chi2);
1248  Chi2Prob->Fill(chi2prob);
1249  Chi2oNDF->Fill(chi2oNDF);
1250 
1251  // DCA
1252  // temporary patch in order to put back those MEs in Muon Workspace
1253  if (doDCAPlots_) {
1254  if (doDCAwrt000Plots_) {
1255  DistanceOfClosestApproach->Fill(track.dxy());
1256  DistanceOfClosestApproachVsPhi->Fill(phi, track.dxy());
1257  }
1258 
1259  // PCA
1260  xPointOfClosestApproach->Fill(track.referencePoint().x());
1261  yPointOfClosestApproach->Fill(track.referencePoint().y());
1262  zPointOfClosestApproach->Fill(track.referencePoint().z());
1263  }
1264 
1265  // algorithm
1266  algorithm->Fill(static_cast<double>(track.algo()));
1267  oriAlgo->Fill(static_cast<double>(track.originalAlgo()));
1268 
1269  // stopping source
1270  int max = stoppingSource->getNbinsX();
1271  double stop = track.stopReason() > max ? double(max - 1) : static_cast<double>(track.stopReason());
1272  double stopped = int(StopReason::NOT_STOPPED) == track.stopReason() ? 0. : 1.;
1273  stoppingSource->Fill(stop);
1274  stoppingSourceVSeta->Fill(track.eta(), stopped);
1275  stoppingSourceVSphi->Fill(track.phi(), stopped);
1276  }
1277 
1278  if (doLumiAnalysis_) {
1279  NumberOfRecHitsPerTrack_lumiFlag->Fill(nRecHits);
1280  Chi2oNDF_lumiFlag->Fill(chi2oNDF);
1281  }
1282 
1283  if (doDCAPlots_ || doBSPlots_ || doSIPPlots_ || doAllPlots_) {
1284  edm::Handle<reco::BeamSpot> recoBeamSpotHandle = iEvent.getHandle(beamSpotToken_);
1285  const reco::BeamSpot& bs = *recoBeamSpotHandle;
1286 
1287  DistanceOfClosestApproachError->Fill(track.dxyError());
1288  DistanceOfClosestApproachErrorVsPt->Fill(track.pt(), track.dxyError());
1289  DistanceOfClosestApproachErrorVsEta->Fill(track.eta(), track.dxyError());
1290  DistanceOfClosestApproachErrorVsPhi->Fill(track.phi(), track.dxyError());
1291  DistanceOfClosestApproachErrorVsDxy->Fill(track.dxy(bs.position()), track.dxyError());
1292 
1293  DistanceOfClosestApproachToBS->Fill(track.dxy(bs.position()));
1294 
1295  if (Folder == "Tr") {
1296  DistanceOfClosestApproachToBSdz->Fill(track.dz(bs.position()));
1297  DistanceOfClosestApproachToBSVsEta->Fill(track.eta(), track.dxy(bs.position()));
1298  }
1299 
1300  AbsDistanceOfClosestApproachToBS->Fill(std::abs(track.dxy(bs.position())));
1301  DistanceOfClosestApproachToBSVsPhi->Fill(track.phi(), track.dxy(bs.position()));
1302  zPointOfClosestApproachVsPhi->Fill(track.phi(), track.vz());
1303  xPointOfClosestApproachVsZ0wrt000->Fill(track.dz(), track.vx());
1304  yPointOfClosestApproachVsZ0wrt000->Fill(track.dz(), track.vy());
1305  xPointOfClosestApproachVsZ0wrtBS->Fill(track.dz(bs.position()), (track.vx() - bs.position(track.vz()).x()));
1306  yPointOfClosestApproachVsZ0wrtBS->Fill(track.dz(bs.position()), (track.vy() - bs.position(track.vz()).y()));
1307  if (doTestPlots_) {
1308  TESTDistanceOfClosestApproachToBS->Fill(track.dxy(bs.position(track.vz())));
1309  TESTDistanceOfClosestApproachToBSVsPhi->Fill(track.phi(), track.dxy(bs.position(track.vz())));
1310  }
1311 
1312  if (doSIPPlots_) {
1313  sipDxyToBS->Fill(track.dxy(bs.position()) / track.dxyError());
1314  sipDzToBS->Fill(track.dz(bs.position()) / track.dzError());
1315  }
1316  }
1317 
1318  if (doDCAPlots_ || doPVPlots_ || doSIPPlots_ || doAllPlots_) {
1319  edm::Handle<reco::VertexCollection> recoPrimaryVerticesHandle = iEvent.getHandle(pvToken_);
1320  if (recoPrimaryVerticesHandle.isValid() && !recoPrimaryVerticesHandle->empty()) {
1321  const reco::Vertex& pv = (*recoPrimaryVerticesHandle)[0];
1322 
1324  //HI PLOTS///////
1326 
1327  if (doHIPlots_) {
1328  double longDCAsig = 0, transDCAsig = 0;
1329  double zerr2 = track.dzError() * track.dzError() + pv.zError() * pv.zError();
1330  double xyerr2 = track.d0Error() * track.d0Error() + pv.xError() * pv.yError();
1331  if (zerr2 > 0)
1332  longDCAsig = track.dz(pv.position()) / zerr2;
1333  if (xyerr2 > 0)
1334  transDCAsig = track.dxy(pv.position()) / xyerr2;
1335  LongDCASig->Fill(longDCAsig);
1336  TransDCASig->Fill(transDCAsig);
1337 
1338  if (track.quality(reco::TrackBase::qualityByName(qualityString_)) == 1) {
1339  dNdEta_HighPurity->Fill(track.eta());
1340  dNdPhi_HighPurity->Fill(track.phi());
1341  dNdPt_HighPurity->Fill(track.ptError() / track.pt());
1342  NhitVsEta_HighPurity->Fill(track.eta(), track.numberOfValidHits());
1343  NhitVsPhi_HighPurity->Fill(track.phi(), track.numberOfValidHits());
1344  dNhitdPt_HighPurity->Fill(track.pt(), track.numberOfValidHits());
1345  Ptdist_HighPurity->Fill(track.pt());
1346  } //end of high quality tracks requirement
1347  }
1348 
1349  xPointOfClosestApproachToPV->Fill(track.vx() - pv.position().x());
1350  yPointOfClosestApproachToPV->Fill(track.vy() - pv.position().y());
1351  zPointOfClosestApproachToPV->Fill(track.dz(pv.position()));
1352  DistanceOfClosestApproachToPV->Fill(track.dxy(pv.position()));
1353  DeltaZToPV->Fill(track.dz(pv.position()));
1354  DistanceOfClosestApproachToPVZoom->Fill(track.dxy(pv.position()));
1355  DeltaZToPVZoom->Fill(track.dz(pv.position()));
1356  DistanceOfClosestApproachToPVVsPhi->Fill(track.phi(), track.dxy(pv.position()));
1357  xPointOfClosestApproachVsZ0wrtPV->Fill(track.dz(pv.position()), (track.vx() - pv.position().x()));
1358  yPointOfClosestApproachVsZ0wrtPV->Fill(track.dz(pv.position()), (track.vy() - pv.position().y()));
1359 
1360  if (doSIPPlots_) {
1361  TransientTrackBuilder const& theB = iSetup.getData(transientTrackBuilderToken_);
1362  reco::TransientTrack transTrack = theB.build(track);
1363 
1364  GlobalVector dir(track.px(), track.py(), track.pz());
1365  std::pair<bool, Measurement1D> ip3d = IPTools::signedImpactParameter3D(transTrack, dir, pv);
1366  std::pair<bool, Measurement1D> ip2d = IPTools::signedTransverseImpactParameter(transTrack, dir, pv);
1367  if (ip3d.first)
1368  sip3dToPV->Fill(ip3d.second.value() / ip3d.second.error());
1369  if (ip2d.first)
1370  sip2dToPV->Fill(ip2d.second.value() / ip2d.second.error());
1371  sipDxyToPV->Fill(track.dxy(pv.position()) / track.dxyError());
1372  sipDzToPV->Fill(track.dz(pv.position()) / track.dzError());
1373  }
1374  }
1375  }
1376 
1377  if (doDCAPlots_ || doAllPlots_) {
1378  if (doDCAwrt000Plots_) {
1379  if (doThetaPlots_) {
1380  DistanceOfClosestApproachVsTheta->Fill(track.theta(), track.d0());
1381  }
1382  DistanceOfClosestApproachVsEta->Fill(track.eta(), track.d0());
1383  }
1384  }
1385 
1386  //Tracker Specific Histograms
1387  if (doTrackerSpecific_ || doAllPlots_) {
1388  fillHistosForTrackerSpecific(track);
1389  }
1390  if (doMeasurementStatePlots_ || doAllPlots_) {
1391  if (stateName_ == "All") {
1392  fillHistosForState(iSetup, track, std::string("OuterSurface"));
1393  fillHistosForState(iSetup, track, std::string("InnerSurface"));
1394  fillHistosForState(iSetup, track, std::string("ImpactPoint"));
1395  } else if (stateName_ != "OuterSurface" && stateName_ != "InnerSurface" && stateName_ != "ImpactPoint" &&
1396  stateName_ != "default") {
1397  fillHistosForState(iSetup, track, std::string("default"));
1398  } else {
1399  fillHistosForState(iSetup, track, stateName_);
1400  }
1401  }
1402 
1403  if (doAllPlots_) {
1404  }
1405 }
1406 
1407 void TrackAnalyzer::fillHistosForEfficiencyFromHitPatter(const reco::Track& track,
1408  const std::string suffix,
1409  const float monitoring,
1410  bool useInac) {
1411  int mon = -1;
1412  for (int i = 0; i < monQuantity::END; i++) {
1413  if (monName[i] == suffix)
1414  mon = i;
1415  }
1416  if (useInac)
1417  mon += monQuantity::END;
1418 
1419  // if (track.pt() > 1.0 && track.dxy() < 0.1 and monitoring > 0) {
1420  if (track.pt() > 1.0 && track.dxy() < 0.1 and monitoring > -9.) {
1421  auto hp = track.hitPattern();
1422  // Here hit_category is meant to iterate over
1423  // reco::HitPattern::HitCategory, defined here:
1424  // http://cmslxr.fnal.gov/dxr/CMSSW/source/DataFormats/TrackReco/interface/HitPattern.h
1425  for (unsigned int category = 0; category < 3; ++category) {
1426  for (int hit = 0; hit < hp.numberOfAllHits((reco::HitPattern::HitCategory)(category)); ++hit) {
1427  auto pattern = hp.getHitPattern((reco::HitPattern::HitCategory)(category), hit);
1428  // Boolean bad is missing simply because it is inferred and the only missing case.
1429  bool valid = hp.validHitFilter(pattern);
1430  bool missing = hp.missingHitFilter(pattern);
1431  bool inactive = hp.inactiveHitFilter(pattern);
1432  int hit_type = -1;
1433  hit_type = valid ? 0 : (missing ? 1 : (inactive ? 2 : 3));
1434  if (hits_valid_.find(Key(hp.getSubStructure(pattern), hp.getSubSubStructure(pattern), mon)) ==
1435  hits_valid_.end()) {
1436  LogDebug("TrackAnalyzer") << "Invalid combination of detector and subdetector: ("
1437  << hp.getSubStructure(pattern) << ", " << hp.getSubSubStructure(pattern) << ", "
1438  << mon << "): ignoring it.\n";
1439  continue;
1440  }
1441  switch (hit_type) {
1442  case 0:
1443  hits_valid_[Key(hp.getSubStructure(pattern), hp.getSubSubStructure(pattern), mon)]->Fill(monitoring);
1444  hits_total_[Key(hp.getSubStructure(pattern), hp.getSubSubStructure(pattern), mon)]->Fill(monitoring);
1445  break;
1446  case 2:
1447  if (!useInac)
1448  break;
1449  [[fallthrough]];
1450  case 1:
1451  hits_total_[Key(hp.getSubStructure(pattern), hp.getSubSubStructure(pattern), mon)]->Fill(monitoring);
1452  break;
1453  default:
1454  LogDebug("TrackAnalyzer") << "Invalid hit category used " << hit_type << " ignored\n";
1455  }
1456  }
1457  }
1458  }
1459 }
1460 
1461 // book histograms at differnt measurement points
1462 // ---------------------------------------------------------------------------------//
1463 void TrackAnalyzer::bookHistosForState(std::string sname, DQMStore::IBooker& ibooker) {
1464  // parameters from the configuration
1465  std::string QualName = conf_->getParameter<std::string>("Quality");
1466  std::string AlgoName = conf_->getParameter<std::string>("AlgoName");
1467  std::string Folder = TopFolder_.substr(0, 2);
1468 
1469  // use the AlgoName and Quality Name
1470  std::string CategoryName = !QualName.empty() ? AlgoName + "_" + QualName : AlgoName;
1471 
1472  // get binning from the configuration
1473  double Chi2NDFMin = conf_->getParameter<double>("Chi2NDFMin");
1474  double Chi2NDFMax = conf_->getParameter<double>("Chi2NDFMax");
1475 
1476  int RecHitBin = conf_->getParameter<int>("RecHitBin");
1477  double RecHitMin = conf_->getParameter<double>("RecHitMin");
1478  double RecHitMax = conf_->getParameter<double>("RecHitMax");
1479 
1480  int RecLayBin = conf_->getParameter<int>("RecHitBin");
1481  double RecLayMin = conf_->getParameter<double>("RecHitMin");
1482  double RecLayMax = conf_->getParameter<double>("RecHitMax");
1483 
1484  int PhiBin = conf_->getParameter<int>("PhiBin");
1485  double PhiMin = conf_->getParameter<double>("PhiMin");
1486  double PhiMax = conf_->getParameter<double>("PhiMax");
1487 
1488  int EtaBin = conf_->getParameter<int>("EtaBin");
1489  double EtaMin = conf_->getParameter<double>("EtaMin");
1490  double EtaMax = conf_->getParameter<double>("EtaMax");
1491 
1492  int Phi2DBin = conf_->getParameter<int>("Phi2DBin");
1493  int Eta2DBin = conf_->getParameter<int>("Eta2DBin");
1494 
1495  int ThetaBin = conf_->getParameter<int>("ThetaBin");
1496  double ThetaMin = conf_->getParameter<double>("ThetaMin");
1497  double ThetaMax = conf_->getParameter<double>("ThetaMax");
1498 
1499  int TrackQBin = conf_->getParameter<int>("TrackQBin");
1500  double TrackQMin = conf_->getParameter<double>("TrackQMin");
1501  double TrackQMax = conf_->getParameter<double>("TrackQMax");
1502 
1503  int TrackPtBin = conf_->getParameter<int>("TrackPtBin");
1504  double TrackPtMin = conf_->getParameter<double>("TrackPtMin");
1505  double TrackPtMax = conf_->getParameter<double>("TrackPtMax");
1506 
1507  int TrackPBin = conf_->getParameter<int>("TrackPBin");
1508  double TrackPMin = conf_->getParameter<double>("TrackPMin");
1509  double TrackPMax = conf_->getParameter<double>("TrackPMax");
1510 
1511  int TrackPxBin = conf_->getParameter<int>("TrackPxBin");
1512  double TrackPxMin = conf_->getParameter<double>("TrackPxMin");
1513  double TrackPxMax = conf_->getParameter<double>("TrackPxMax");
1514 
1515  int TrackPyBin = conf_->getParameter<int>("TrackPyBin");
1516  double TrackPyMin = conf_->getParameter<double>("TrackPyMin");
1517  double TrackPyMax = conf_->getParameter<double>("TrackPyMax");
1518 
1519  int TrackPzBin = conf_->getParameter<int>("TrackPzBin");
1520  double TrackPzMin = conf_->getParameter<double>("TrackPzMin");
1521  double TrackPzMax = conf_->getParameter<double>("TrackPzMax");
1522 
1523  int ptErrBin = conf_->getParameter<int>("ptErrBin");
1524  double ptErrMin = conf_->getParameter<double>("ptErrMin");
1525  double ptErrMax = conf_->getParameter<double>("ptErrMax");
1526 
1527  int pxErrBin = conf_->getParameter<int>("pxErrBin");
1528  double pxErrMin = conf_->getParameter<double>("pxErrMin");
1529  double pxErrMax = conf_->getParameter<double>("pxErrMax");
1530 
1531  int pyErrBin = conf_->getParameter<int>("pyErrBin");
1532  double pyErrMin = conf_->getParameter<double>("pyErrMin");
1533  double pyErrMax = conf_->getParameter<double>("pyErrMax");
1534 
1535  int pzErrBin = conf_->getParameter<int>("pzErrBin");
1536  double pzErrMin = conf_->getParameter<double>("pzErrMin");
1537  double pzErrMax = conf_->getParameter<double>("pzErrMax");
1538 
1539  int pErrBin = conf_->getParameter<int>("pErrBin");
1540  double pErrMin = conf_->getParameter<double>("pErrMin");
1541  double pErrMax = conf_->getParameter<double>("pErrMax");
1542 
1543  int phiErrBin = conf_->getParameter<int>("phiErrBin");
1544  double phiErrMin = conf_->getParameter<double>("phiErrMin");
1545  double phiErrMax = conf_->getParameter<double>("phiErrMax");
1546 
1547  int etaErrBin = conf_->getParameter<int>("etaErrBin");
1548  double etaErrMin = conf_->getParameter<double>("etaErrMin");
1549  double etaErrMax = conf_->getParameter<double>("etaErrMax");
1550 
1551  double Chi2ProbMin = conf_->getParameter<double>("Chi2ProbMin");
1552  double Chi2ProbMax = conf_->getParameter<double>("Chi2ProbMax");
1553 
1554  ibooker.setCurrentFolder(TopFolder_);
1555 
1556  TkParameterMEs tkmes;
1557 
1558  std::string histTag = (sname == "default") ? CategoryName : sname + "_" + CategoryName;
1559 
1560  if (doAllPlots_) {
1561  // general properties
1562  ibooker.setCurrentFolder(TopFolder_ + "/GeneralProperties");
1563 
1564  if (doThetaPlots_) {
1565  histname = "Chi2oNDFVsTheta_" + histTag;
1566  tkmes.Chi2oNDFVsTheta =
1567  ibooker.bookProfile(histname, histname, ThetaBin, ThetaMin, ThetaMax, Chi2NDFMin, Chi2NDFMax, "");
1568  tkmes.Chi2oNDFVsTheta->setAxisTitle("Track #theta", 1);
1569  tkmes.Chi2oNDFVsTheta->setAxisTitle("Track #chi^{2}/ndf", 2);
1570  }
1571  histname = "Chi2oNDFVsPhi_" + histTag;
1572  tkmes.Chi2oNDFVsPhi = ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, Chi2NDFMin, Chi2NDFMax, "");
1573  tkmes.Chi2oNDFVsPhi->setAxisTitle("Track #phi", 1);
1574  tkmes.Chi2oNDFVsPhi->setAxisTitle("Track #chi^{2}/ndf", 2);
1575 
1576  histname = "Chi2ProbVsPhi_" + histTag;
1577  tkmes.Chi2ProbVsPhi = ibooker.bookProfile(
1578  histname + CategoryName, histname + CategoryName, PhiBin, PhiMin, PhiMax, Chi2ProbMin, Chi2ProbMax);
1579  tkmes.Chi2ProbVsPhi->setAxisTitle("Tracks #phi", 1);
1580  tkmes.Chi2ProbVsPhi->setAxisTitle("Track #chi^{2} probability", 2);
1581 
1582  histname = "Chi2ProbVsEta_" + histTag;
1583  tkmes.Chi2ProbVsEta = ibooker.bookProfile(
1584  histname + CategoryName, histname + CategoryName, EtaBin, EtaMin, EtaMax, Chi2ProbMin, Chi2ProbMax);
1585  tkmes.Chi2ProbVsEta->setAxisTitle("Tracks #eta", 1);
1586  tkmes.Chi2ProbVsEta->setAxisTitle("Track #chi^{2} probability", 2);
1587  }
1588 
1589  // general properties
1590  ibooker.setCurrentFolder(TopFolder_ + "/GeneralProperties");
1591 
1592  histname = "Chi2oNDFVsEta_" + histTag;
1593  tkmes.Chi2oNDFVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, Chi2NDFMin, Chi2NDFMax, "");
1594  tkmes.Chi2oNDFVsEta->setAxisTitle("Track #eta", 1);
1595  tkmes.Chi2oNDFVsEta->setAxisTitle("Track #chi^{2}/ndf", 2);
1596 
1597  histname = "Chi2oNDFVsPt_" + histTag;
1598  tkmes.Chi2oNDFVsPt =
1599  ibooker.bookProfile(histname, histname, TrackPtBin, TrackPtMin, TrackPtMax, Chi2NDFMin, Chi2NDFMax, "");
1600  tkmes.Chi2oNDFVsPt->setAxisTitle("Track p_{T} (GeV/c)", 1);
1601  tkmes.Chi2oNDFVsPt->setAxisTitle("Track #chi^{2}/ndf", 2);
1602 
1603  histname = "Chi2oNDFVsNHits_" + histTag;
1604  tkmes.Chi2oNDFVsNHits = ibooker.bookProfile(histname, histname, 50, 0., 50, Chi2NDFMin, Chi2NDFMax, "");
1605  tkmes.Chi2oNDFVsNHits->setAxisTitle("Track NHits", 1);
1606  tkmes.Chi2oNDFVsNHits->setAxisTitle("Track #chi^{2}/ndf", 2);
1607 
1608  histname = "TrackP_" + histTag;
1609  tkmes.TrackP = ibooker.book1D(histname, histname, TrackPBin, TrackPMin, TrackPMax);
1610  tkmes.TrackP->setAxisTitle("Track |p| (GeV/c)", 1);
1611  tkmes.TrackP->setAxisTitle("Number of Tracks", 2);
1612 
1613  histname = "TrackPt_" + histTag;
1614  tkmes.TrackPt = ibooker.book1D(histname, histname, TrackPtBin, TrackPtMin, TrackPtMax);
1615  tkmes.TrackPt->setAxisTitle("Track p_{T} (GeV/c)", 1);
1616  tkmes.TrackPt->setAxisTitle("Number of Tracks", 2);
1617 
1618  if (doTrackPxPyPlots_) {
1619  histname = "TrackPx_" + histTag;
1620  tkmes.TrackPx = ibooker.book1D(histname, histname, TrackPxBin, TrackPxMin, TrackPxMax);
1621  tkmes.TrackPx->setAxisTitle("Track p_{x} (GeV/c)", 1);
1622  tkmes.TrackPx->setAxisTitle("Number of Tracks", 2);
1623 
1624  histname = "TrackPy_" + histTag;
1625  tkmes.TrackPy = ibooker.book1D(histname, histname, TrackPyBin, TrackPyMin, TrackPyMax);
1626  tkmes.TrackPy->setAxisTitle("Track p_{y} (GeV/c)", 1);
1627  tkmes.TrackPy->setAxisTitle("Number of Tracks", 2);
1628  }
1629  histname = "TrackPz_" + histTag;
1630  tkmes.TrackPz = ibooker.book1D(histname, histname, TrackPzBin, TrackPzMin, TrackPzMax);
1631  tkmes.TrackPz->setAxisTitle("Track p_{z} (GeV/c)", 1);
1632  tkmes.TrackPz->setAxisTitle("Number of Tracks", 2);
1633 
1634  histname = "TrackPhi_" + histTag;
1635  tkmes.TrackPhi = ibooker.book1D(histname, histname, PhiBin, PhiMin, PhiMax);
1636  tkmes.TrackPhi->setAxisTitle("Track #phi", 1);
1637  tkmes.TrackPhi->setAxisTitle("Number of Tracks", 2);
1638 
1639  histname = "TrackEta_" + histTag;
1640  tkmes.TrackEta = ibooker.book1D(histname, histname, EtaBin, EtaMin, EtaMax);
1641  tkmes.TrackEta->setAxisTitle("Track #eta", 1);
1642  tkmes.TrackEta->setAxisTitle("Number of Tracks", 2);
1643 
1644  if (Folder == "Tr") {
1645  histname = "TrackPtHighPurity_" + histTag;
1646  tkmes.TrackPtHighPurity = ibooker.book1D(histname, histname, TrackPtBin, TrackPtMin, TrackPtMax);
1647  tkmes.TrackPtHighPurity->setAxisTitle("Track p_{T} (GeV/c)", 1);
1648  tkmes.TrackPtHighPurity->setAxisTitle("Number of High Purity Tracks", 2);
1649 
1650  histname = "TrackPtTight_" + histTag;
1651  tkmes.TrackPtTight = ibooker.book1D(histname, histname, TrackPtBin, TrackPtMin, TrackPtMax);
1652  tkmes.TrackPtTight->setAxisTitle("Track p_{T} (GeV/c)", 1);
1653  tkmes.TrackPtTight->setAxisTitle("Number of Tight Tracks", 2);
1654 
1655  histname = "TrackPtLoose_" + histTag;
1656  tkmes.TrackPtLoose = ibooker.book1D(histname, histname, TrackPtBin, TrackPtMin, TrackPtMax);
1657  tkmes.TrackPtLoose->setAxisTitle("Track p_{T} (GeV/c)", 1);
1658  tkmes.TrackPtLoose->setAxisTitle("Number of Loose Tracks", 2);
1659 
1660  histname = "Quality_";
1661  tkmes.Quality = ibooker.book1D(histname + CategoryName, histname + CategoryName, 3, 0., 3.);
1662  tkmes.Quality->setAxisTitle("Track quality", 1);
1663  tkmes.Quality->setAxisTitle("Number of Tracks", 2);
1664 
1665  for (size_t ibin = 0; ibin < 3; ibin++) {
1666  tkmes.Quality->setBinLabel(ibin + 1, reco::TrackBase::qualityNames[ibin]);
1667  }
1668 
1669  histname = "TrackPt_NegEta_Phi_btw_neg16_neg32_" + histTag;
1670  tkmes.TrackPt_NegEta_Phi_btw_neg16_neg32 = ibooker.book1D(histname, histname, TrackPtBin, TrackPtMin, TrackPtMax);
1671  tkmes.TrackPt_NegEta_Phi_btw_neg16_neg32->setAxisTitle("Track p_{T} (GeV/c)", 1);
1672  tkmes.TrackPt_NegEta_Phi_btw_neg16_neg32->setAxisTitle("Number of Tracks", 2);
1673 
1674  histname = "TrackPt_NegEta_Phi_btw_0_neg16_" + histTag;
1675  tkmes.TrackPt_NegEta_Phi_btw_0_neg16 = ibooker.book1D(histname, histname, TrackPtBin, TrackPtMin, TrackPtMax);
1676  tkmes.TrackPt_NegEta_Phi_btw_0_neg16->setAxisTitle("Track p_{T} (GeV/c)", 1);
1677  tkmes.TrackPt_NegEta_Phi_btw_0_neg16->setAxisTitle("Number of Tracks", 2);
1678 
1679  histname = "TrackPt_NegEta_Phi_btw_16_0_" + histTag;
1680  tkmes.TrackPt_NegEta_Phi_btw_16_0 = ibooker.book1D(histname, histname, TrackPtBin, TrackPtMin, TrackPtMax);
1681  tkmes.TrackPt_NegEta_Phi_btw_16_0->setAxisTitle("Track p_{T} (GeV/c)", 1);
1682  tkmes.TrackPt_NegEta_Phi_btw_16_0->setAxisTitle("Number of Tracks", 2);
1683 
1684  histname = "TrackPt_NegEta_Phi_btw_32_16_" + histTag;
1685  tkmes.TrackPt_NegEta_Phi_btw_32_16 = ibooker.book1D(histname, histname, TrackPtBin, TrackPtMin, TrackPtMax);
1686  tkmes.TrackPt_NegEta_Phi_btw_32_16->setAxisTitle("Track p_{T} (GeV/c)", 1);
1687  tkmes.TrackPt_NegEta_Phi_btw_32_16->setAxisTitle("Number of Tracks", 2);
1688 
1689  histname = "TrackPt_PosEta_Phi_btw_neg16_neg32_" + histTag;
1690  tkmes.TrackPt_PosEta_Phi_btw_neg16_neg32 = ibooker.book1D(histname, histname, TrackPtBin, TrackPtMin, TrackPtMax);
1691  tkmes.TrackPt_PosEta_Phi_btw_neg16_neg32->setAxisTitle("Track p_{T} (GeV/c)", 1);
1692  tkmes.TrackPt_PosEta_Phi_btw_neg16_neg32->setAxisTitle("Number of Tracks", 2);
1693 
1694  histname = "TrackPt_PosEta_Phi_btw_0_neg16_" + histTag;
1695  tkmes.TrackPt_PosEta_Phi_btw_0_neg16 = ibooker.book1D(histname, histname, TrackPtBin, TrackPtMin, TrackPtMax);
1696  tkmes.TrackPt_PosEta_Phi_btw_0_neg16->setAxisTitle("Track p_{T} (GeV/c)", 1);
1697  tkmes.TrackPt_PosEta_Phi_btw_0_neg16->setAxisTitle("Number of Tracks", 2);
1698 
1699  histname = "TrackPt_PosEta_Phi_btw_16_0_" + histTag;
1700  tkmes.TrackPt_PosEta_Phi_btw_16_0 = ibooker.book1D(histname, histname, TrackPtBin, TrackPtMin, TrackPtMax);
1701  tkmes.TrackPt_PosEta_Phi_btw_16_0->setAxisTitle("Track p_{T} (GeV/c)", 1);
1702  tkmes.TrackPt_PosEta_Phi_btw_16_0->setAxisTitle("Number of Tracks", 2);
1703 
1704  histname = "TrackPt_PosEta_Phi_btw_32_16_" + histTag;
1705  tkmes.TrackPt_PosEta_Phi_btw_32_16 = ibooker.book1D(histname, histname, TrackPtBin, TrackPtMin, TrackPtMax);
1706  tkmes.TrackPt_PosEta_Phi_btw_32_16->setAxisTitle("Track p_{T} (GeV/c)", 1);
1707  tkmes.TrackPt_PosEta_Phi_btw_32_16->setAxisTitle("Number of Tracks", 2);
1708 
1709  histname = "Ratio_byFolding_" + histTag;
1710  tkmes.Ratio_byFolding = ibooker.book1D(histname, histname, TrackPtBin, TrackPtMin, TrackPtMax);
1711  tkmes.Ratio_byFolding->setAxisTitle("Track p_{T} (GeV/c)", 1);
1712 
1713  histname = "Ratio_byFolding2_" + histTag;
1714  tkmes.Ratio_byFolding2 = ibooker.book1D(histname, histname, TrackPtBin, TrackPtMin, TrackPtMax);
1715  tkmes.Ratio_byFolding2->setAxisTitle("Track p_{T} (GeV/c)", 1);
1716 
1717  histname = "TrackEtaHighpurity_" + histTag;
1718  tkmes.TrackEtaHighPurity = ibooker.book1D(histname, histname, EtaBin, EtaMin, EtaMax);
1719  tkmes.TrackEtaHighPurity->setAxisTitle("Track #eta", 1);
1720  tkmes.TrackEtaHighPurity->setAxisTitle("Number of High Purity Tracks", 2);
1721 
1722  histname = "TrackEtaTight_" + histTag;
1723  tkmes.TrackEtaTight = ibooker.book1D(histname, histname, EtaBin, EtaMin, EtaMax);
1724  tkmes.TrackEtaTight->setAxisTitle("Track #eta", 1);
1725  tkmes.TrackEtaTight->setAxisTitle("Number of Tight Tracks", 2);
1726 
1727  histname = "TrackEtaLoose_" + histTag;
1728  tkmes.TrackEtaLoose = ibooker.book1D(histname, histname, EtaBin, EtaMin, EtaMax);
1729  tkmes.TrackEtaLoose->setAxisTitle("Track #eta", 1);
1730  tkmes.TrackEtaLoose->setAxisTitle("Number of Loose Tracks", 2);
1731 
1732  histname = "TrackEtaPhiInverted_" + histTag;
1733  tkmes.TrackEtaPhiInverted = ibooker.book2D(histname, histname, Eta2DBin, EtaMin, EtaMax, Phi2DBin, PhiMin, PhiMax);
1734  tkmes.TrackEtaPhiInverted->setAxisTitle("Track #eta", 1);
1735  tkmes.TrackEtaPhiInverted->setAxisTitle("Track #phi", 2);
1736 
1737  histname = "TrackEtaPhiInvertedoutofphase_" + histTag;
1738  tkmes.TrackEtaPhiInvertedoutofphase =
1739  ibooker.book2D(histname, histname, Eta2DBin, EtaMin, EtaMax, Phi2DBin, PhiMin, PhiMax);
1740  tkmes.TrackEtaPhiInvertedoutofphase->setAxisTitle("Track #eta", 1);
1741  tkmes.TrackEtaPhiInvertedoutofphase->setAxisTitle("Track #phi", 2);
1742 
1743  histname = "TrackQoverP_" + histTag;
1744  tkmes.TrackQoverP = ibooker.book1D(histname, histname, 10 * TrackQBin, TrackQMin, TrackQMax);
1745  tkmes.TrackQoverP->setAxisTitle("Track QoverP", 1);
1746  tkmes.TrackQoverP->setAxisTitle("Number of Tracks", 2);
1747  }
1748 
1749  histname = "TrackEtaPhi_" + histTag;
1750  tkmes.TrackEtaPhi = ibooker.book2D(histname, histname, Eta2DBin, EtaMin, EtaMax, Phi2DBin, PhiMin, PhiMax);
1751  tkmes.TrackEtaPhi->setAxisTitle("Track #eta", 1);
1752  tkmes.TrackEtaPhi->setAxisTitle("Track #phi", 2);
1753 
1754  histname = "TrackEtaPhiInner_" + histTag;
1755  tkmes.TrackEtaPhiInner = ibooker.book2D(histname, histname, Eta2DBin, EtaMin, EtaMax, Phi2DBin, PhiMin, PhiMax);
1756  tkmes.TrackEtaPhiInner->setAxisTitle("Track #eta", 1);
1757  tkmes.TrackEtaPhiInner->setAxisTitle("Track #phi", 2);
1758 
1759  histname = "TrackEtaPhiOuter_" + histTag;
1760  tkmes.TrackEtaPhiOuter = ibooker.book2D(histname, histname, Eta2DBin, EtaMin, EtaMax, Phi2DBin, PhiMin, PhiMax);
1761  tkmes.TrackEtaPhiOuter->setAxisTitle("Track #eta", 1);
1762  tkmes.TrackEtaPhiOuter->setAxisTitle("Track #phi", 2);
1763 
1764  if (doThetaPlots_) {
1765  histname = "TrackTheta_" + histTag;
1766  tkmes.TrackTheta = ibooker.book1D(histname, histname, ThetaBin, ThetaMin, ThetaMax);
1767  tkmes.TrackTheta->setAxisTitle("Track #theta", 1);
1768  tkmes.TrackTheta->setAxisTitle("Number of Tracks", 2);
1769  }
1770  histname = "TrackQ_" + histTag;
1771  tkmes.TrackQ = ibooker.book1D(histname, histname, TrackQBin, TrackQMin, TrackQMax);
1772  tkmes.TrackQ->setAxisTitle("Track Charge", 1);
1773  tkmes.TrackQ->setAxisTitle("Number of Tracks", 2);
1774 
1775  histname = "TrackPErrOverP_" + histTag;
1776  tkmes.TrackPErr = ibooker.book1D(histname, histname, pErrBin, pErrMin, pErrMax);
1777  tkmes.TrackPErr->setAxisTitle("track error(p)/p", 1);
1778  tkmes.TrackPErr->setAxisTitle("Number of Tracks", 2);
1779 
1780  histname = "TrackPtErrOverPt_" + histTag;
1781  tkmes.TrackPtErr = ibooker.book1D(histname, histname, ptErrBin, ptErrMin, ptErrMax);
1782  tkmes.TrackPtErr->setAxisTitle("track error(p_{T})/p_{T}", 1);
1783  tkmes.TrackPtErr->setAxisTitle("Number of Tracks", 2);
1784 
1785  histname = "TrackPtErrOverPtVsEta_" + histTag;
1786  tkmes.TrackPtErrVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, ptErrMin, ptErrMax);
1787  tkmes.TrackPtErrVsEta->setAxisTitle("Track #eta", 1);
1788  tkmes.TrackPtErrVsEta->setAxisTitle("track error(p_{T})/p_{T}", 2);
1789 
1790  if (doTrackPxPyPlots_) {
1791  histname = "TrackPxErrOverPx_" + histTag;
1792  tkmes.TrackPxErr = ibooker.book1D(histname, histname, pxErrBin, pxErrMin, pxErrMax);
1793  tkmes.TrackPxErr->setAxisTitle("track error(p_{x})/p_{x}", 1);
1794  tkmes.TrackPxErr->setAxisTitle("Number of Tracks", 2);
1795 
1796  histname = "TrackPyErrOverPy_" + histTag;
1797  tkmes.TrackPyErr = ibooker.book1D(histname, histname, pyErrBin, pyErrMin, pyErrMax);
1798  tkmes.TrackPyErr->setAxisTitle("track error(p_{y})/p_{y}", 1);
1799  tkmes.TrackPyErr->setAxisTitle("Number of Tracks", 2);
1800  }
1801  histname = "TrackPzErrOverPz_" + histTag;
1802  tkmes.TrackPzErr = ibooker.book1D(histname, histname, pzErrBin, pzErrMin, pzErrMax);
1803  tkmes.TrackPzErr->setAxisTitle("track error(p_{z})/p_{z}", 1);
1804  tkmes.TrackPzErr->setAxisTitle("Number of Tracks", 2);
1805 
1806  histname = "TrackPhiErr_" + histTag;
1807  tkmes.TrackPhiErr = ibooker.book1D(histname, histname, phiErrBin, phiErrMin, phiErrMax);
1808  tkmes.TrackPhiErr->setAxisTitle("track error(#phi)");
1809  tkmes.TrackPhiErr->setAxisTitle("Number of Tracks", 2);
1810 
1811  histname = "TrackEtaErr_" + histTag;
1812  tkmes.TrackEtaErr = ibooker.book1D(histname, histname, etaErrBin, etaErrMin, etaErrMax);
1813  tkmes.TrackEtaErr->setAxisTitle("track error(#eta)");
1814  tkmes.TrackEtaErr->setAxisTitle("Number of Tracks", 2);
1815 
1816  // rec hit profiles
1817  ibooker.setCurrentFolder(TopFolder_ + "/GeneralProperties");
1818  histname = "NumberOfRecHitsPerTrackVsPhi_" + histTag;
1819  tkmes.NumberOfRecHitsPerTrackVsPhi =
1820  ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, RecHitBin, RecHitMin, RecHitMax, "");
1821  tkmes.NumberOfRecHitsPerTrackVsPhi->setAxisTitle("Track #phi", 1);
1822  tkmes.NumberOfRecHitsPerTrackVsPhi->setAxisTitle("Number of RecHits in each Track", 2);
1823 
1824  if (doThetaPlots_) {
1825  histname = "NumberOfRecHitsPerTrackVsTheta_" + histTag;
1826  tkmes.NumberOfRecHitsPerTrackVsTheta =
1827  ibooker.bookProfile(histname, histname, ThetaBin, ThetaMin, ThetaMax, RecHitBin, RecHitMin, RecHitMax, "");
1828  tkmes.NumberOfRecHitsPerTrackVsTheta->setAxisTitle("Track #phi", 1);
1829  tkmes.NumberOfRecHitsPerTrackVsTheta->setAxisTitle("Number of RecHits in each Track", 2);
1830  }
1831  histname = "NumberOfRecHitsPerTrackVsEta_" + histTag;
1832  tkmes.NumberOfRecHitsPerTrackVsEta =
1833  ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, RecHitBin, RecHitMin, RecHitMax, "");
1834  tkmes.NumberOfRecHitsPerTrackVsEta->setAxisTitle("Track #eta", 1);
1835  tkmes.NumberOfRecHitsPerTrackVsEta->setAxisTitle("Number of RecHits in each Track", 2);
1836 
1837  histname = "NumberOfValidRecHitsPerTrackVsPhi_" + histTag;
1838  tkmes.NumberOfValidRecHitsPerTrackVsPhi =
1839  ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, RecHitMin, RecHitMax, "");
1840  tkmes.NumberOfValidRecHitsPerTrackVsPhi->setAxisTitle("Track #phi", 1);
1841  tkmes.NumberOfValidRecHitsPerTrackVsPhi->setAxisTitle("Number of valid RecHits in each Track", 2);
1842 
1843  histname = "NumberOfValidRecHitsPerTrackVsEta_" + histTag;
1844  tkmes.NumberOfValidRecHitsPerTrackVsEta =
1845  ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, RecHitMin, RecHitMax, "");
1846  tkmes.NumberOfValidRecHitsPerTrackVsEta->setAxisTitle("Track #eta", 1);
1847  tkmes.NumberOfValidRecHitsPerTrackVsEta->setAxisTitle("Number of valid RecHits in each Track", 2);
1848 
1849  histname = "NumberOfValidRecHitsPerTrackVsPt_" + histTag;
1850  tkmes.NumberOfValidRecHitsPerTrackVsPt =
1851  ibooker.bookProfile(histname, histname, TrackPtBin, TrackPtMin, TrackPtMax, RecHitMin, RecHitMax, "");
1852  tkmes.NumberOfValidRecHitsPerTrackVsPt->setAxisTitle("Track p_{T} [GeV]", 1);
1853  tkmes.NumberOfValidRecHitsPerTrackVsPt->setAxisTitle("Number of valid RecHits in each Track", 2);
1854 
1856  histname = "NumberOfLayersPerTrackVsPhi_" + histTag;
1857  tkmes.NumberOfLayersPerTrackVsPhi =
1858  ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, RecLayBin, RecLayMin, RecLayMax, "");
1859  tkmes.NumberOfLayersPerTrackVsPhi->setAxisTitle("Track #phi", 1);
1860  tkmes.NumberOfLayersPerTrackVsPhi->setAxisTitle("Number of Layers in each Track", 2);
1861 
1862  if (doThetaPlots_) {
1863  histname = "NumberOfLayersPerTrackVsTheta_" + histTag;
1864  tkmes.NumberOfLayersPerTrackVsTheta =
1865  ibooker.bookProfile(histname, histname, ThetaBin, ThetaMin, ThetaMax, RecLayBin, RecLayMin, RecLayMax, "");
1866  tkmes.NumberOfLayersPerTrackVsTheta->setAxisTitle("Track #phi", 1);
1867  tkmes.NumberOfLayersPerTrackVsTheta->setAxisTitle("Number of Layers in each Track", 2);
1868  }
1869  histname = "NumberOfLayersPerTrackVsEta_" + histTag;
1870  tkmes.NumberOfLayersPerTrackVsEta =
1871  ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, RecLayBin, RecLayMin, RecLayMax, "");
1872  tkmes.NumberOfLayersPerTrackVsEta->setAxisTitle("Track #eta", 1);
1873  tkmes.NumberOfLayersPerTrackVsEta->setAxisTitle("Number of Layers in each Track", 2);
1874 
1875  if (doThetaPlots_) {
1876  histname = "Chi2oNDFVsTheta_" + histTag;
1877  tkmes.Chi2oNDFVsTheta =
1878  ibooker.bookProfile(histname, histname, ThetaBin, ThetaMin, ThetaMax, Chi2NDFMin, Chi2NDFMax, "");
1879  tkmes.Chi2oNDFVsTheta->setAxisTitle("Track #theta", 1);
1880  tkmes.Chi2oNDFVsTheta->setAxisTitle("Track #chi^{2}/ndf", 2);
1881  }
1882  if (doAllPlots_) {
1883  histname = "Chi2oNDFVsPhi_" + histTag;
1884  tkmes.Chi2oNDFVsPhi = ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, Chi2NDFMin, Chi2NDFMax, "");
1885  tkmes.Chi2oNDFVsPhi->setAxisTitle("Track #phi", 1);
1886  tkmes.Chi2oNDFVsPhi->setAxisTitle("Track #chi^{2}/ndf", 2);
1887 
1888  histname = "Chi2oNDFVsEta_" + histTag;
1889  tkmes.Chi2oNDFVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, Chi2NDFMin, Chi2NDFMax, "");
1890  tkmes.Chi2oNDFVsEta->setAxisTitle("Track #eta", 1);
1891  tkmes.Chi2oNDFVsEta->setAxisTitle("Track #chi^{2}/ndf", 2);
1892 
1893  histname = "Chi2ProbVsPhi_" + histTag;
1894  tkmes.Chi2ProbVsPhi = ibooker.bookProfile(
1895  histname + CategoryName, histname + CategoryName, PhiBin, PhiMin, PhiMax, Chi2ProbMin, Chi2ProbMax);
1896  tkmes.Chi2ProbVsPhi->setAxisTitle("Tracks #phi", 1);
1897  tkmes.Chi2ProbVsPhi->setAxisTitle("Track #chi^{2} probability", 2);
1898 
1899  histname = "Chi2ProbVsEta_" + histTag;
1900  tkmes.Chi2ProbVsEta = ibooker.bookProfile(
1901  histname + CategoryName, histname + CategoryName, EtaBin, EtaMin, EtaMax, Chi2ProbMin, Chi2ProbMax);
1902  tkmes.Chi2ProbVsEta->setAxisTitle("Tracks #eta", 1);
1903  tkmes.Chi2ProbVsEta->setAxisTitle("Track #chi^{2} probability", 2);
1904  }
1905 
1906  // now put the MEs in the map
1907  TkParameterMEMap.insert(std::make_pair(sname, tkmes));
1908 }
1909 
1910 // fill histograms at differnt measurement points
1911 // ---------------------------------------------------------------------------------//
1912 void TrackAnalyzer::fillHistosForState(const edm::EventSetup& iSetup, const reco::Track& track, std::string sname) {
1913  //get the kinematic parameters
1914  double p, px, py, pz, pt, theta, phi, eta, q;
1915  double pxerror, pyerror, pzerror, pterror, perror, phierror, etaerror;
1916 
1917  std::string Folder = TopFolder_.substr(0, 2);
1918 
1919  auto phiIn = track.innerPosition().phi();
1920  auto etaIn = track.innerPosition().eta();
1921  auto phiOut = track.outerPosition().phi();
1922  auto etaOut = track.outerPosition().eta();
1923 
1924  if (sname == "default") {
1925  p = track.p();
1926  px = track.px();
1927  py = track.py();
1928  pz = track.pz();
1929  pt = track.pt();
1930  phi = track.phi();
1931  theta = track.theta();
1932  eta = track.eta();
1933  q = track.charge();
1934 
1935  pterror = (pt) ? track.ptError() / (pt * pt) : 0.0;
1936  pxerror = -1.0;
1937  pyerror = -1.0;
1938  pzerror = -1.0;
1939  perror = -1.0;
1940  phierror = track.phiError();
1941  etaerror = track.etaError();
1942 
1943  } else {
1944  TransientTrackBuilder const& theB = iSetup.getData(transientTrackBuilderToken_);
1945  reco::TransientTrack TransTrack = theB.build(track);
1946 
1947  TrajectoryStateOnSurface TSOS;
1948 
1949  if (sname == "OuterSurface")
1950  TSOS = TransTrack.outermostMeasurementState();
1951  else if (sname == "InnerSurface")
1952  TSOS = TransTrack.innermostMeasurementState();
1953  else if (sname == "ImpactPoint")
1954  TSOS = TransTrack.impactPointState();
1955 
1956  p = TSOS.globalMomentum().mag();
1957  px = TSOS.globalMomentum().x();
1958  py = TSOS.globalMomentum().y();
1959  pz = TSOS.globalMomentum().z();
1960  pt = TSOS.globalMomentum().perp();
1961  phi = TSOS.globalMomentum().phi();
1962  theta = TSOS.globalMomentum().theta();
1963  eta = TSOS.globalMomentum().eta();
1964  q = TSOS.charge();
1965 
1966  //get the error of the kinimatic parameters
1967  AlgebraicSymMatrix66 errors = TSOS.cartesianError().matrix();
1968  double partialPterror =
1969  errors(3, 3) * pow(TSOS.globalMomentum().x(), 2) + errors(4, 4) * pow(TSOS.globalMomentum().y(), 2);
1970  pterror = sqrt(partialPterror) / TSOS.globalMomentum().perp();
1971  pxerror = sqrt(errors(3, 3)) / TSOS.globalMomentum().x();
1972  pyerror = sqrt(errors(4, 4)) / TSOS.globalMomentum().y();
1973  pzerror = sqrt(errors(5, 5)) / TSOS.globalMomentum().z();
1974  perror = sqrt(partialPterror + errors(5, 5) * pow(TSOS.globalMomentum().z(), 2)) / TSOS.globalMomentum().mag();
1975  phierror = sqrt(TSOS.curvilinearError().matrix()(2, 2));
1976  etaerror = sqrt(TSOS.curvilinearError().matrix()(1, 1)) * fabs(sin(TSOS.globalMomentum().theta()));
1977  }
1978 
1979  std::map<std::string, TkParameterMEs>::iterator iPos = TkParameterMEMap.find(sname);
1980  if (iPos != TkParameterMEMap.end()) {
1981  TkParameterMEs tkmes = iPos->second;
1982 
1983  // momentum
1984  tkmes.TrackP->Fill(p);
1985  if (doTrackPxPyPlots_) {
1986  tkmes.TrackPx->Fill(px);
1987  tkmes.TrackPy->Fill(py);
1988  }
1989  tkmes.TrackPz->Fill(pz);
1990  tkmes.TrackPt->Fill(pt);
1991 
1992  // angles
1993  tkmes.TrackPhi->Fill(phi);
1994  tkmes.TrackEta->Fill(eta);
1995  tkmes.TrackEtaPhi->Fill(eta, phi);
1996 
1997  if (Folder == "Tr") {
1998  tkmes.TrackEtaPhiInverted->Fill(eta, -1 * phi);
1999  tkmes.TrackEtaPhiInvertedoutofphase->Fill(eta, M_PI - phi);
2000  tkmes.TrackEtaPhiInvertedoutofphase->Fill(eta, -(phi + M_PI));
2001  //pT histograms to create efficiency vs pT plot, only for the most inefficient region.
2002 
2003  if (eta < 0. && phi < -1.6) {
2004  tkmes.TrackPt_NegEta_Phi_btw_neg16_neg32->Fill(pt);
2005  }
2006  if (eta < 0. && phi < 0 && phi >= -1.6) {
2007  tkmes.TrackPt_NegEta_Phi_btw_0_neg16->Fill(pt);
2008  }
2009  if (eta < 0. && phi < 1.6 && phi >= 0) {
2010  tkmes.TrackPt_NegEta_Phi_btw_16_0->Fill(pt);
2011  }
2012  if (eta < 0. && phi >= 1.6) {
2013  tkmes.TrackPt_NegEta_Phi_btw_32_16->Fill(pt);
2014  }
2015  if (eta >= 0. && phi < -1.6) {
2016  tkmes.TrackPt_PosEta_Phi_btw_neg16_neg32->Fill(pt);
2017  }
2018  if (eta >= 0. && phi < 0 && phi >= -1.6) {
2019  tkmes.TrackPt_PosEta_Phi_btw_0_neg16->Fill(pt);
2020  }
2021  if (eta >= 0. && phi < 1.6 && phi >= 0) {
2022  tkmes.TrackPt_PosEta_Phi_btw_16_0->Fill(pt);
2023  }
2024  if (eta >= 0. && phi >= 1.6) {
2025  tkmes.TrackPt_PosEta_Phi_btw_32_16->Fill(pt);
2026  }
2027 
2028  float A[8];
2029  A[0] = tkmes.TrackPt_NegEta_Phi_btw_neg16_neg32->integral();
2030  A[1] = tkmes.TrackPt_NegEta_Phi_btw_0_neg16->integral();
2031  A[2] = tkmes.TrackPt_NegEta_Phi_btw_16_0->integral();
2032  A[3] = tkmes.TrackPt_NegEta_Phi_btw_32_16->integral();
2033  A[4] = tkmes.TrackPt_PosEta_Phi_btw_neg16_neg32->integral();
2034  A[5] = tkmes.TrackPt_PosEta_Phi_btw_0_neg16->integral();
2035  A[6] = tkmes.TrackPt_PosEta_Phi_btw_16_0->integral();
2036  A[7] = tkmes.TrackPt_PosEta_Phi_btw_32_16->integral();
2037 
2038  //WZ (the worst zone)
2039  int WZ = 0;
2040  float minA = A[0];
2041  for (int w = 1; w < 8; w++) {
2042  if (minA > A[w]) {
2043  minA = A[w];
2044  WZ = w;
2045  }
2046  }
2047 
2048  switch (WZ) {
2049  case 1:
2050  tkmes.Ratio_byFolding->divide(
2051  tkmes.TrackPt_NegEta_Phi_btw_neg16_neg32, tkmes.TrackPt_NegEta_Phi_btw_32_16, 1., 1., "B");
2052  tkmes.Ratio_byFolding2->divide(
2053  tkmes.TrackPt_NegEta_Phi_btw_neg16_neg32, tkmes.TrackPt_NegEta_Phi_btw_0_neg16, 1., 1., "B");
2054  break;
2055  case 2:
2056  tkmes.Ratio_byFolding->divide(
2057  tkmes.TrackPt_NegEta_Phi_btw_0_neg16, tkmes.TrackPt_NegEta_Phi_btw_16_0, 1., 1., "B");
2058  tkmes.Ratio_byFolding2->divide(
2059  tkmes.TrackPt_NegEta_Phi_btw_0_neg16, tkmes.TrackPt_NegEta_Phi_btw_neg16_neg32, 1., 1., "B");
2060  break;
2061  case 3:
2062  tkmes.Ratio_byFolding->divide(
2063  tkmes.TrackPt_NegEta_Phi_btw_16_0, tkmes.TrackPt_NegEta_Phi_btw_0_neg16, 1., 1., "B");
2064  tkmes.Ratio_byFolding2->divide(
2065  tkmes.TrackPt_NegEta_Phi_btw_16_0, tkmes.TrackPt_NegEta_Phi_btw_32_16, 1., 1., "B");
2066  break;
2067  case 4:
2068  tkmes.Ratio_byFolding->divide(
2069  tkmes.TrackPt_NegEta_Phi_btw_32_16, tkmes.TrackPt_NegEta_Phi_btw_neg16_neg32, 1., 1., "B");
2070  tkmes.Ratio_byFolding2->divide(
2071  tkmes.TrackPt_NegEta_Phi_btw_32_16, tkmes.TrackPt_NegEta_Phi_btw_16_0, 1., 1., "B");
2072  break;
2073  case 5:
2074  tkmes.Ratio_byFolding->divide(
2075  tkmes.TrackPt_PosEta_Phi_btw_neg16_neg32, tkmes.TrackPt_PosEta_Phi_btw_32_16, 1., 1., "B");
2076  tkmes.Ratio_byFolding2->divide(
2077  tkmes.TrackPt_PosEta_Phi_btw_neg16_neg32, tkmes.TrackPt_PosEta_Phi_btw_0_neg16, 1., 1., "B");
2078  break;
2079  case 6:
2080  tkmes.Ratio_byFolding->divide(
2081  tkmes.TrackPt_PosEta_Phi_btw_0_neg16, tkmes.TrackPt_PosEta_Phi_btw_16_0, 1., 1., "B");
2082  tkmes.Ratio_byFolding2->divide(
2083  tkmes.TrackPt_PosEta_Phi_btw_0_neg16, tkmes.TrackPt_PosEta_Phi_btw_neg16_neg32, 1., 1., "B");
2084  break;
2085  case 7:
2086  tkmes.Ratio_byFolding->divide(
2087  tkmes.TrackPt_PosEta_Phi_btw_16_0, tkmes.TrackPt_PosEta_Phi_btw_0_neg16, 1., 1., "B");
2088  tkmes.Ratio_byFolding2->divide(
2089  tkmes.TrackPt_PosEta_Phi_btw_16_0, tkmes.TrackPt_PosEta_Phi_btw_32_16, 1., 1., "B");
2090  break;
2091  case 8:
2092  tkmes.Ratio_byFolding->divide(
2093  tkmes.TrackPt_PosEta_Phi_btw_32_16, tkmes.TrackPt_PosEta_Phi_btw_neg16_neg32, 1., 1., "B");
2094  tkmes.Ratio_byFolding2->divide(
2095  tkmes.TrackPt_PosEta_Phi_btw_32_16, tkmes.TrackPt_PosEta_Phi_btw_16_0, 1., 1., "B");
2096  break;
2097  }
2098  tkmes.Ratio_byFolding->setAxisTitle("Efficiency(Ratio)_" + std::to_string(WZ), 2);
2099  tkmes.Ratio_byFolding2->setAxisTitle("Efficiency(Ratio)_" + std::to_string(WZ), 2);
2100 
2101  if (track.quality(reco::TrackBase::highPurity)) {
2102  tkmes.TrackPtHighPurity->Fill(pt);
2103  tkmes.Quality->Fill(reco::TrackBase::highPurity, 1.);
2104  }
2105  if (track.quality(reco::TrackBase::tight)) {
2106  tkmes.TrackPtTight->Fill(pt);
2107  tkmes.Quality->Fill(reco::TrackBase::tight, 1.);
2108  }
2109  if (track.quality(reco::TrackBase::loose)) {
2110  tkmes.TrackPtLoose->Fill(pt);
2111  tkmes.Quality->Fill(reco::TrackBase::loose, 1.);
2112  }
2113  if (track.quality(reco::TrackBase::highPurity)) {
2114  tkmes.TrackEtaHighPurity->Fill(eta);
2115  }
2116  if (track.quality(reco::TrackBase::tight)) {
2117  tkmes.TrackEtaTight->Fill(eta);
2118  }
2119  if (track.quality(reco::TrackBase::loose)) {
2120  tkmes.TrackEtaLoose->Fill(eta);
2121  }
2122 
2123  if (p > 0.) {
2124  tkmes.TrackQoverP->Fill(q / p);
2125  }
2126  }
2127 
2128  tkmes.TrackEtaPhiInner->Fill(etaIn, phiIn);
2129  tkmes.TrackEtaPhiOuter->Fill(etaOut, phiOut);
2130 
2131  if (doThetaPlots_) {
2132  tkmes.TrackTheta->Fill(theta);
2133  }
2134  tkmes.TrackQ->Fill(q);
2135 
2136  // errors
2137  tkmes.TrackPtErr->Fill(pterror);
2138  tkmes.TrackPtErrVsEta->Fill(eta, pterror);
2139  if (doTrackPxPyPlots_) {
2140  tkmes.TrackPxErr->Fill(pxerror);
2141  tkmes.TrackPyErr->Fill(pyerror);
2142  }
2143  tkmes.TrackPzErr->Fill(pzerror);
2144  tkmes.TrackPErr->Fill(perror);
2145  tkmes.TrackPhiErr->Fill(phierror);
2146  tkmes.TrackEtaErr->Fill(etaerror);
2147 
2148  int nRecHits = track.hitPattern().numberOfAllHits(reco::HitPattern::TRACK_HITS);
2149  int nValidRecHits = track.numberOfValidHits();
2150  // rec hits
2151  tkmes.NumberOfRecHitsPerTrackVsPhi->Fill(phi, nRecHits);
2152  if (doThetaPlots_) {
2153  tkmes.NumberOfRecHitsPerTrackVsTheta->Fill(theta, nRecHits);
2154  }
2155  tkmes.NumberOfRecHitsPerTrackVsEta->Fill(eta, nRecHits);
2156  tkmes.NumberOfValidRecHitsPerTrackVsPhi->Fill(phi, nValidRecHits);
2157  tkmes.NumberOfValidRecHitsPerTrackVsEta->Fill(eta, nValidRecHits);
2158  tkmes.NumberOfValidRecHitsPerTrackVsPt->Fill(pt, nValidRecHits);
2159 
2160  int nLayers = track.hitPattern().trackerLayersWithMeasurement();
2161  // rec layers
2162  tkmes.NumberOfLayersPerTrackVsPhi->Fill(phi, nLayers);
2163  if (doThetaPlots_) {
2164  tkmes.NumberOfLayersPerTrackVsTheta->Fill(theta, nLayers);
2165  }
2166  tkmes.NumberOfLayersPerTrackVsEta->Fill(eta, nLayers);
2167 
2168  double chi2prob = TMath::Prob(track.chi2(), (int)track.ndof());
2169  double chi2oNDF = track.normalizedChi2();
2170 
2171  tkmes.Chi2oNDFVsEta->Fill(eta, chi2oNDF);
2172  tkmes.Chi2oNDFVsPt->Fill(pt, chi2oNDF);
2173  tkmes.Chi2oNDFVsNHits->Fill(nRecHits, chi2oNDF);
2174 
2175  if (doAllPlots_) {
2176  // general properties
2177  if (doThetaPlots_) {
2178  tkmes.Chi2oNDFVsTheta->Fill(theta, chi2oNDF);
2179  }
2180  tkmes.Chi2oNDFVsPhi->Fill(phi, chi2oNDF);
2181  tkmes.Chi2ProbVsPhi->Fill(phi, chi2prob);
2182  tkmes.Chi2ProbVsEta->Fill(eta, chi2prob);
2183  }
2184  }
2185 }
2186 
2187 void TrackAnalyzer::bookHistosForTrackerSpecific(DQMStore::IBooker& ibooker) {
2188  // parameters from the configuration
2189  std::string QualName = conf_->getParameter<std::string>("Quality");
2190  std::string AlgoName = conf_->getParameter<std::string>("AlgoName");
2191 
2192  // use the AlgoName and Quality Name
2193  std::string CategoryName = !QualName.empty() ? AlgoName + "_" + QualName : AlgoName;
2194 
2195  int PhiBin = conf_->getParameter<int>("PhiBin");
2196  double PhiMin = conf_->getParameter<double>("PhiMin");
2197  double PhiMax = conf_->getParameter<double>("PhiMax");
2198 
2199  int EtaBin = conf_->getParameter<int>("EtaBin");
2200  double EtaMin = conf_->getParameter<double>("EtaMin");
2201  double EtaMax = conf_->getParameter<double>("EtaMax");
2202 
2203  int PtBin = conf_->getParameter<int>("TrackPtBin");
2204  double PtMin = conf_->getParameter<double>("TrackPtMin");
2205  double PtMax = conf_->getParameter<double>("TrackPtMax");
2206 
2207  // book hit property histograms
2208  // ---------------------------------------------------------------------------------//
2209  ibooker.setCurrentFolder(TopFolder_ + "/HitProperties");
2210 
2211  std::vector<std::string> subdetectors = conf_->getParameter<std::vector<std::string> >("subdetectors");
2212  int detBin = conf_->getParameter<int>("subdetectorBin");
2213 
2214  for (const auto& det : subdetectors) {
2215  // hits properties
2216  ibooker.setCurrentFolder(TopFolder_ + "/HitProperties/" + det);
2217 
2218  TkRecHitsPerSubDetMEs recHitsPerSubDet_mes;
2219 
2220  recHitsPerSubDet_mes.detectorTag = det;
2221  int detID = -1;
2222  if (det == "TIB")
2223  detID = StripSubdetector::TIB; // 3
2224  if (det == "TOB")
2225  detID = StripSubdetector::TOB; // 5
2226  if (det == "TID")
2227  detID = StripSubdetector::TID; // 4
2228  if (det == "TEC")
2229  detID = StripSubdetector::TEC; // 6
2230  if (det == "PixBarrel")
2231  detID = PixelSubdetector::PixelBarrel; // 1
2232  if (det == "PixEndcap")
2233  detID = PixelSubdetector::PixelEndcap; // 2
2234  if (det == "Pixel")
2235  detID = 0;
2236  if (det == "Strip")
2237  detID = 7;
2238 
2239  recHitsPerSubDet_mes.detectorId = detID;
2240 
2241  histname = "NumberOfRecHitsPerTrack_" + det + "_" + CategoryName;
2242  recHitsPerSubDet_mes.NumberOfRecHitsPerTrack =
2243  ibooker.book1D(histname, histname, detBin, -0.5, double(detBin) - 0.5);
2244  recHitsPerSubDet_mes.NumberOfRecHitsPerTrack->setAxisTitle("Number of " + det + " valid RecHits in each Track", 1);
2245  recHitsPerSubDet_mes.NumberOfRecHitsPerTrack->setAxisTitle("Number of Tracks", 2);
2246 
2247  histname = "NumberOfRecHitsPerTrackVsPhi_" + det + "_" + CategoryName;
2248  recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsPhi =
2249  ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, detBin, -0.5, double(detBin) - 0.5, "");
2250  recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsPhi->setAxisTitle("Track #phi", 1);
2251  recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsPhi->setAxisTitle("Number of " + det + " valid RecHits in each Track",
2252  2);
2253 
2254  histname = "NumberOfRecHitsPerTrackVsEta_" + det + "_" + CategoryName;
2255  recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsEta =
2256  ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, detBin, -0.5, double(detBin) - 0.5, "");
2257  recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsEta->setAxisTitle("Track #eta", 1);
2258  recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsEta->setAxisTitle("Number of " + det + " valid RecHits in each Track",
2259  2);
2260 
2261  histname = "NumberOfRecHitsPerTrackVsPt_" + det + "_" + CategoryName;
2262  recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsPt =
2263  ibooker.bookProfile(histname, histname, PtBin, PtMin, PtMax, detBin, -0.5, double(detBin) - 0.5, "");
2264  recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsPt->setAxisTitle("Track p_{T} [GeV]", 1);
2265  recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsPt->setAxisTitle("Number of " + det + " valid RecHits in each Track",
2266  2);
2267 
2268  histname = "NumberOfLayersPerTrack_" + det + "_" + CategoryName;
2269  recHitsPerSubDet_mes.NumberOfLayersPerTrack =
2270  ibooker.book1D(histname, histname, detBin, -0.5, double(detBin) - 0.5);
2271  recHitsPerSubDet_mes.NumberOfLayersPerTrack->setAxisTitle("Number of " + det + " valid Layers in each Track", 1);
2272  recHitsPerSubDet_mes.NumberOfLayersPerTrack->setAxisTitle("Number of Tracks", 2);
2273 
2274  histname = "NumberOfLayersPerTrackVsPhi_" + det + "_" + CategoryName;
2275  recHitsPerSubDet_mes.NumberOfLayersPerTrackVsPhi =
2276  ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, detBin, -0.5, double(detBin) - 0.5, "");
2277  recHitsPerSubDet_mes.NumberOfLayersPerTrackVsPhi->setAxisTitle("Track #phi", 1);
2278  recHitsPerSubDet_mes.NumberOfLayersPerTrackVsPhi->setAxisTitle("Number of " + det + " valid Layers in each Track",
2279  2);
2280 
2281  histname = "NumberOfLayersPerTrackVsEta_" + det + "_" + CategoryName;
2282  recHitsPerSubDet_mes.NumberOfLayersPerTrackVsEta =
2283  ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, detBin, -0.5, double(detBin) - 0.5, "");
2284  recHitsPerSubDet_mes.NumberOfLayersPerTrackVsEta->setAxisTitle("Track #eta", 1);
2285  recHitsPerSubDet_mes.NumberOfLayersPerTrackVsEta->setAxisTitle("Number of " + det + " valid Layers in each Track",
2286  2);
2287 
2288  histname = "NumberOfLayersPerTrackVsPt_" + det + "_" + CategoryName;
2289  recHitsPerSubDet_mes.NumberOfLayersPerTrackVsPt =
2290  ibooker.bookProfile(histname, histname, PtBin, PtMin, PtMax, detBin, -0.5, double(detBin) - 0.5, "");
2291  recHitsPerSubDet_mes.NumberOfLayersPerTrackVsPt->setAxisTitle("Track p_{T} [GeV]", 1);
2292  recHitsPerSubDet_mes.NumberOfLayersPerTrackVsPt->setAxisTitle("Number of " + det + " valid Layers in each Track",
2293  2);
2294 
2295  TkRecHitsPerSubDetMEMap.insert(std::pair<std::string, TkRecHitsPerSubDetMEs>(det, recHitsPerSubDet_mes));
2296  }
2297 }
2298 
2299 void TrackAnalyzer::fillHistosForTrackerSpecific(const reco::Track& track) {
2300  double phi = track.phi();
2301  double eta = track.eta();
2302  double pt = track.pt();
2303 
2304  for (std::map<std::string, TkRecHitsPerSubDetMEs>::iterator it = TkRecHitsPerSubDetMEMap.begin();
2305  it != TkRecHitsPerSubDetMEMap.end();
2306  it++) {
2307  int nValidLayers = 0;
2308  int nValidRecHits = 0;
2309  int substr = it->second.detectorId;
2310  switch (substr) {
2311  case 0:
2312  nValidLayers = track.hitPattern().pixelBarrelLayersWithMeasurement() +
2313  track.hitPattern().pixelEndcapLayersWithMeasurement(); // case 0: pixel
2314  nValidRecHits = track.hitPattern().numberOfValidPixelBarrelHits() +
2315  track.hitPattern().numberOfValidPixelEndcapHits(); // case 0: pixel
2316  break;
2317  case StripSubdetector::TIB:
2318  nValidLayers = track.hitPattern().stripTIBLayersWithMeasurement(); // case 3: strip TIB
2319  nValidRecHits = track.hitPattern().numberOfValidStripTIBHits(); // case 3: strip TIB
2320  break;
2321  case StripSubdetector::TID:
2322  nValidLayers = track.hitPattern().stripTIDLayersWithMeasurement(); // case 4: strip TID
2323  nValidRecHits = track.hitPattern().numberOfValidStripTIDHits(); // case 4: strip TID
2324  break;
2325  case StripSubdetector::TOB:
2326  nValidLayers = track.hitPattern().stripTOBLayersWithMeasurement(); // case 5: strip TOB
2327  nValidRecHits = track.hitPattern().numberOfValidStripTOBHits(); // case 5: strip TOB
2328  break;
2329  case StripSubdetector::TEC:
2330  nValidLayers = track.hitPattern().stripTECLayersWithMeasurement(); // case 6: strip TEC
2331  nValidRecHits = track.hitPattern().numberOfValidStripTECHits(); // case 6: strip TEC
2332  break;
2333  case PixelSubdetector::PixelBarrel:
2334  nValidLayers = track.hitPattern().pixelBarrelLayersWithMeasurement(); // case 1: pixel PXB
2335  nValidRecHits = track.hitPattern().numberOfValidPixelBarrelHits(); // case 1: pixel PXB
2336  break;
2337  case PixelSubdetector::PixelEndcap:
2338  nValidLayers = track.hitPattern().pixelEndcapLayersWithMeasurement(); // case 2: pixel PXF
2339  nValidRecHits = track.hitPattern().numberOfValidPixelEndcapHits(); // case 2: pixel PXF
2340  break;
2341  case 7:
2342  nValidLayers = track.hitPattern().stripTIBLayersWithMeasurement() // case 7: strip
2343  + track.hitPattern().stripTIDLayersWithMeasurement() +
2344  track.hitPattern().stripTOBLayersWithMeasurement() +
2345  track.hitPattern().stripTECLayersWithMeasurement();
2346  nValidRecHits = track.hitPattern().numberOfValidStripTIBHits() // case 7: strip
2347  + track.hitPattern().numberOfValidStripTIDHits() +
2348  track.hitPattern().numberOfValidStripTOBHits() + track.hitPattern().numberOfValidStripTECHits();
2349  break;
2350  default:
2351  break;
2352  }
2353 
2354  //Fill Layers and RecHits
2355  it->second.NumberOfRecHitsPerTrack->Fill(nValidRecHits);
2356  it->second.NumberOfRecHitsPerTrackVsPhi->Fill(phi, nValidRecHits);
2357  it->second.NumberOfRecHitsPerTrackVsEta->Fill(eta, nValidRecHits);
2358  it->second.NumberOfRecHitsPerTrackVsPt->Fill(pt, nValidRecHits);
2359 
2360  it->second.NumberOfLayersPerTrack->Fill(nValidLayers);
2361  it->second.NumberOfLayersPerTrackVsPhi->Fill(phi, nValidLayers);
2362  it->second.NumberOfLayersPerTrackVsEta->Fill(eta, nValidLayers);
2363  it->second.NumberOfLayersPerTrackVsPt->Fill(pt, nValidLayers);
2364  }
2365 }
tadqm::TrackAnalyzer::dNdPhi_HighPurity
MonitorElement * dNdPhi_HighPurity
Definition: TrackAnalyzer.h:442
reco::TrackBase::p
double p() const
momentum vector magnitude
Definition: TrackBase.h:631
edm::ConsumesCollector::consumes
EDGetTokenT< ProductType > consumes(edm::InputTag const &tag)
Definition: ConsumesCollector.h:55
reco::HitPattern::stripTOBLayersWithMeasurement
int stripTOBLayersWithMeasurement() const
Definition: HitPattern.cc:605
tadqm::TrackAnalyzer::NumberOfValidRecHitsPerTrackVsPt
MonitorElement * NumberOfValidRecHitsPerTrackVsPt
Definition: TrackAnalyzer.h:345
combine.missing
dictionary missing
Definition: combine.py:5
beam_dqm_sourceclient-live_cfg.Chi2NDFBin
int Chi2NDFBin
Definition: beam_dqm_sourceclient-live_cfg.py:200
StripSubdetector::TEC
static constexpr auto TEC
Definition: StripSubdetector.h:19
reco::TrackBase::referencePoint
const Point & referencePoint() const
Reference point on the track.
Definition: TrackBase.h:667
runTheMatrix.ret
tuple ret
prodAgent to be discontinued
Definition: runTheMatrix.py:596
reco::TrackBase::d0Error
double d0Error() const
error on d0
Definition: TrackBase.h:772
edmNew::DetSetVector::end
const_iterator end(bool update=false) const
Definition: DetSetVectorNew.h:550
dqm::implementation::IBooker::bookProfile2D
MonitorElement * bookProfile2D(TString const &name, TString const &title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, double lowZ, double highZ, char const *option="s", FUNC onbooking=NOOP())
Definition: DQMStore.h:399
mps_fire.i
i
Definition: mps_fire.py:428
tadqm::TrackAnalyzer::monName
std::string monName[monQuantity::END]
Definition: TrackAnalyzer.h:503
tadqm::TrackAnalyzer::TkParameterMEs::NumberOfRecHitsPerTrackVsPhi
MonitorElement * NumberOfRecHitsPerTrackVsPhi
Definition: TrackAnalyzer.h:282
tadqm::TrackAnalyzer::NumberOfLayersPerTrack
MonitorElement * NumberOfLayersPerTrack[4]
Definition: TrackAnalyzer.h:373
PV3DBase::perp
T perp() const
Definition: PV3DBase.h:69
tadqm::TrackAnalyzer::ValidFractionVsPhiVsEtaPerTrack
MonitorElement * ValidFractionVsPhiVsEtaPerTrack
Definition: TrackAnalyzer.h:371
DiDispStaMuonMonitor_cfi.pt
tuple pt
Definition: DiDispStaMuonMonitor_cfi.py:39
dqm::impl::MonitorElement::integral
virtual double integral() const
get integral of bins
Definition: MonitorElement.cc:662
reco::TrackBase::validFraction
double validFraction() const
fraction of valid hits on the track
Definition: TrackBase.h:816
reco::TrackBase::d0
double d0() const
dxy parameter in perigee convention (d0 = -dxy)
Definition: TrackBase.h:611
w
const double w
Definition: UKUtility.cc:23
tadqm::TrackAnalyzer::LongDCASig
MonitorElement * LongDCASig
Definition: TrackAnalyzer.h:440
beam_dqm_sourceclient-live_cfg.DxyBin
int DxyBin
Definition: beam_dqm_sourceclient-live_cfg.py:196
edm::ConsumesCollector::mayConsume
EDGetTokenT< ProductType > mayConsume(edm::InputTag const &tag)
Definition: ConsumesCollector.h:72
tadqm::TrackAnalyzer::hits_total_
std::unordered_map< Key, MonitorElement *, KeyHasher > hits_total_
Definition: TrackAnalyzer.h:497
tadqm::TrackAnalyzer::NumberOfRecHitsPerTrackVsEta
MonitorElement * NumberOfRecHitsPerTrackVsEta
Definition: TrackAnalyzer.h:339
tadqm::TrackAnalyzer::algorithm
MonitorElement * algorithm
Definition: TrackAnalyzer.h:427
tadqm::TrackAnalyzer::TkParameterMEs::TrackPt_NegEta_Phi_btw_32_16
MonitorElement * TrackPt_NegEta_Phi_btw_32_16
Definition: TrackAnalyzer.h:242
tadqm::TrackAnalyzer::sipDxyToPV
MonitorElement * sipDxyToPV
Definition: TrackAnalyzer.h:455
HLT_FULL_cff.EtaMax
tuple EtaMax
Definition: HLT_FULL_cff.py:6730
dqm::implementation::NavigatorBase::setCurrentFolder
virtual void setCurrentFolder(std::string const &fullpath)
Definition: DQMStore.cc:32
reco::HitPattern::stripTIBLayersWithMeasurement
int stripTIBLayersWithMeasurement() const
Definition: HitPattern.cc:585
reco::TrackBase::normalizedChi2
double normalizedChi2() const
chi-squared divided by n.d.o.f. (or chi-squared * 1e6 if n.d.o.f. is zero)
Definition: TrackBase.h:593
category
static const char category[]
Definition: L3MuonCandidateProducer.cc:40
tadqm::TrackAnalyzer::DistanceOfClosestApproach
MonitorElement * DistanceOfClosestApproach
Definition: TrackAnalyzer.h:395
reco::Vertex::zError
double zError() const
error on z
Definition: Vertex.h:141
tadqm::TrackAnalyzer::qualityString_
std::string qualityString_
Definition: TrackAnalyzer.h:146
reco::TrackBase::theta
double theta() const
polar angle
Definition: TrackBase.h:602
beam_dqm_sourceclient-live_cfg.VZMin
int VZMin
Definition: beam_dqm_sourceclient-live_cfg.py:203
reco::TrackBase::dxyError
double dxyError() const
error on dxy
Definition: TrackBase.h:769
tadqm::TrackAnalyzer::pixelClustersToken_
edm::EDGetTokenT< edmNew::DetSetVector< SiPixelCluster > > pixelClustersToken_
Definition: TrackAnalyzer.h:86
tadqm::TrackAnalyzer::stoppingSource
MonitorElement * stoppingSource
Definition: TrackAnalyzer.h:428
TrajectoryStateOnSurface::curvilinearError
const CurvilinearTrajectoryError & curvilinearError() const
Definition: TrajectoryStateOnSurface.h:72
tadqm::TrackAnalyzer::NumberOfLostRecHitsPerTrackVsPt
MonitorElement * NumberOfLostRecHitsPerTrackVsPt
Definition: TrackAnalyzer.h:352
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
IPTools::signedTransverseImpactParameter
std::pair< bool, Measurement1D > signedTransverseImpactParameter(const reco::TransientTrack &track, const GlobalVector &direction, const reco::Vertex &vertex)
Definition: IPTools.cc:57
reco::TrackBase::stopReason
uint8_t stopReason() const
Definition: TrackBase.h:449
PV3DBase::phi
Geom::Phi< T > phi() const
Definition: PV3DBase.h:66
OnlineLuminosityRecord
Class to contain the online luminosity from soft FED 1022.
Definition: OnlineLuminosityRecord.h:17
tadqm::TrackAnalyzer::bookHistosForTrackerSpecific
void bookHistosForTrackerSpecific(DQMStore::IBooker &ibooker)
Definition: TrackAnalyzer.cc:2187
tadqm::TrackAnalyzer::bookHistosForHitProperties
void bookHistosForHitProperties(DQMStore::IBooker &ibooker)
Definition: TrackAnalyzer.cc:315
TrajectoryStateOnSurface::cartesianError
const CartesianTrajectoryError cartesianError() const
Definition: TrajectoryStateOnSurface.h:71
theta
Geom::Theta< T > theta() const
Definition: Basic3DVectorLD.h:150
TransientTrackBuilder::build
reco::TransientTrack build(const reco::Track *p) const
Definition: TransientTrackBuilder.cc:20
PV3DBase::y
T y() const
Definition: PV3DBase.h:60
reco::TrackBase::etaError
double etaError() const
error on eta
Definition: TrackBase.h:763
edm::EventBase::bunchCrossing
int bunchCrossing() const
Definition: EventBase.h:64
tadqm::TrackAnalyzer::setBX
void setBX(const edm::Event &)
Definition: TrackAnalyzer.cc:1116
IPTools::signedImpactParameter3D
std::pair< bool, Measurement1D > signedImpactParameter3D(const reco::TransientTrack &track, const GlobalVector &direction, const reco::Vertex &vertex)
Definition: IPTools.cc:81
tadqm::TrackAnalyzer::DistanceOfClosestApproachToBSdz
MonitorElement * DistanceOfClosestApproachToBSdz
Definition: TrackAnalyzer.h:402
reco::TrackBase::phi
double phi() const
azimuthal angle of momentum vector
Definition: TrackBase.h:649
reco::TrackBase::numberOfLostHits
unsigned short numberOfLostHits() const
number of cases where track crossed a layer without getting a hit.
Definition: TrackBase.h:801
tadqm::TrackAnalyzer::NumberOfMORecHitVsPhiVsEtaPerTrack
MonitorElement * NumberOfMORecHitVsPhiVsEtaPerTrack
Definition: TrackAnalyzer.h:367
reco::VertexCollection
std::vector< Vertex > VertexCollection
collection of Vertex objects
Definition: VertexFwd.h:9
tadqm::TrackAnalyzer::DistanceOfClosestApproachError
MonitorElement * DistanceOfClosestApproachError
Definition: TrackAnalyzer.h:396
tadqm::TrackAnalyzer::Chi2oNDFVsPhi
MonitorElement * Chi2oNDFVsPhi
Definition: TrackAnalyzer.h:388
tadqm::TrackAnalyzer::TkParameterMEs::NumberOfLayersPerTrackVsPhi
MonitorElement * NumberOfLayersPerTrackVsPhi
Definition: TrackAnalyzer.h:315
tadqm::TrackAnalyzer::DeltaZToPVZoom
MonitorElement * DeltaZToPVZoom
Definition: TrackAnalyzer.h:407
edmNew::DetSet::const_iterator
data_type const * const_iterator
Definition: DetSetNew.h:31
tadqm::TrackAnalyzer::xPointOfClosestApproachVsZ0wrtPV
MonitorElement * xPointOfClosestApproachVsZ0wrtPV
Definition: TrackAnalyzer.h:418
HLT_FULL_cff.track
tuple track
Definition: HLT_FULL_cff.py:11953
reco::TrackBase::px
double px() const
x coordinate of momentum vector
Definition: TrackBase.h:640
StopReasonName::StopReasonName
static const std::string StopReasonName[]
Definition: TrajectoryStopReasons.h:25
tadqm::TrackAnalyzer::sip2dToPV
MonitorElement * sip2dToPV
Definition: TrackAnalyzer.h:454
reco::HitPattern::pixelLayersWithMeasurement
int pixelLayersWithMeasurement() const
Definition: HitPattern.cc:500
tadqm::TrackAnalyzer::Chi2oNDF
MonitorElement * Chi2oNDF
Definition: TrackAnalyzer.h:383
tadqm::TrackAnalyzer::TrackAnalyzer
TrackAnalyzer(const edm::ParameterSet &)
Definition: TrackAnalyzer.cc:40
tadqm::TrackAnalyzer::DeltaZToPV
MonitorElement * DeltaZToPV
Definition: TrackAnalyzer.h:406
reco::Track::outerPosition
const math::XYZPoint & outerPosition() const
position of the outermost hit
Definition: Track.h:62
tadqm::TrackAnalyzer::NumberOfLostRecHitsPerTrack
MonitorElement * NumberOfLostRecHitsPerTrack
Definition: TrackAnalyzer.h:333
tadqm::TrackAnalyzer::yPointOfClosestApproach
MonitorElement * yPointOfClosestApproach
Definition: TrackAnalyzer.h:419
reco::HitPattern::trackerLayersWithMeasurement
int trackerLayersWithMeasurement() const
Definition: HitPattern.cc:521
reco::Vertex::position
const Point & position() const
position
Definition: Vertex.h:127
tadqm::TrackAnalyzer::sipDxyToBS
MonitorElement * sipDxyToBS
Definition: TrackAnalyzer.h:451
reco::HitPattern::pixelEndcapLayersWithMeasurement
int pixelEndcapLayersWithMeasurement() const
Definition: HitPattern.cc:574
tadqm::TrackAnalyzer::initHisto
void initHisto(DQMStore::IBooker &ibooker, const edm::EventSetup &, const edm::ParameterSet &)
Definition: TrackAnalyzer.cc:194
tadqm::TrackAnalyzer::xPointOfClosestApproach
MonitorElement * xPointOfClosestApproach
Definition: TrackAnalyzer.h:414
GetLumi::FREQ_ORBIT
static constexpr double FREQ_ORBIT
Definition: GetLumi.h:26
tadqm::TrackAnalyzer::DistanceOfClosestApproachErrorVsEta
MonitorElement * DistanceOfClosestApproachErrorVsEta
Definition: TrackAnalyzer.h:398
reco::HitPattern::numberOfValidStripTOBHits
int numberOfValidStripTOBHits() const
Definition: HitPattern.h:849
tadqm::TrackAnalyzer::metaDataToken_
edm::EDGetTokenT< OnlineLuminosityRecord > metaDataToken_
Definition: TrackAnalyzer.h:88
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
tadqm::TrackAnalyzer::TkParameterMEs::TrackPt_NegEta_Phi_btw_16_0
MonitorElement * TrackPt_NegEta_Phi_btw_16_0
Definition: TrackAnalyzer.h:241
reco::TransientTrack::innermostMeasurementState
TrajectoryStateOnSurface innermostMeasurementState() const
Definition: TransientTrack.h:86
tadqm::TrackAnalyzer::analyze
void analyze(const edm::Event &iEvent, const edm::EventSetup &iSetup, const reco::Track &track)
Definition: TrackAnalyzer.cc:1167
TrackerGeometry::numberOfLayers
unsigned int numberOfLayers(int subdet) const
Definition: TrackerGeometry.cc:211
tadqm::TrackAnalyzer::TkParameterMEs::NumberOfLayersPerTrackVsEta
MonitorElement * NumberOfLayersPerTrackVsEta
Definition: TrackAnalyzer.h:317
tadqm::TrackAnalyzer::TransDCASig
MonitorElement * TransDCASig
Definition: TrackAnalyzer.h:441
reco::HitPattern::numberOfLostTrackerHits
int numberOfLostTrackerHits(HitCategory category) const
Definition: HitPattern.h:887
PV3DBase::theta
Geom::Theta< T > theta() const
Definition: PV3DBase.h:72
beam_dqm_sourceclient-live_cfg.AbsDxyBin
int AbsDxyBin
Definition: beam_dqm_sourceclient-live_cfg.py:193
tadqm::TrackAnalyzer::bookHistosForEfficiencyFromHitPatter
void bookHistosForEfficiencyFromHitPatter(DQMStore::IBooker &ibooker, const edm::EventSetup &iSetup, const std::string suffix, bool useInac)
Definition: TrackAnalyzer.cc:236
tadqm::TrackAnalyzer::DistanceOfClosestApproachVsPhi
MonitorElement * DistanceOfClosestApproachVsPhi
Definition: TrackAnalyzer.h:409
reco::Track::innerPosition
const math::XYZPoint & innerPosition() const
position of the innermost hit
Definition: Track.h:56
reco::TrackBase::algo
TrackAlgorithm algo() const
Definition: TrackBase.h:547
tadqm::TrackAnalyzer::Chi2oNDFVsTheta
MonitorElement * Chi2oNDFVsTheta
Definition: TrackAnalyzer.h:389
dqm::impl::MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:290
edm::EventSetup::getData
bool getData(T &iHolder) const
Definition: EventSetup.h:128
HLT_FULL_cff.AlgoName
tuple AlgoName
Definition: HLT_FULL_cff.py:6582
beam_dqm_sourceclient-live_cfg.DxyMin
float DxyMin
Definition: beam_dqm_sourceclient-live_cfg.py:194
beam_dqm_sourceclient-live_cfg.VZBin
int VZBin
Definition: beam_dqm_sourceclient-live_cfg.py:202
GetLumi::lastBunchCrossing
static const unsigned int lastBunchCrossing
Definition: GetLumi.h:43
edm::Event::getHandle
Handle< PROD > getHandle(EDGetTokenT< PROD > token) const
Definition: Event.h:563
tadqm::TrackAnalyzer::NumberOfMIRecHitVsPhiVsEtaPerTrack
MonitorElement * NumberOfMIRecHitVsPhiVsEtaPerTrack
Definition: TrackAnalyzer.h:360
tadqm::TrackAnalyzer::DistanceOfClosestApproachToPVVsPhi
MonitorElement * DistanceOfClosestApproachToPVVsPhi
Definition: TrackAnalyzer.h:412
tadqm::TrackAnalyzer::trackerGeometryToken_
edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord > trackerGeometryToken_
Definition: TrackAnalyzer.h:89
iEvent
int iEvent
Definition: GenABIO.cc:224
tadqm::TrackAnalyzer::stoppingSourceVSeta
MonitorElement * stoppingSourceVSeta
Definition: TrackAnalyzer.h:429
HLT_FULL_cff.chi2
tuple chi2
Definition: HLT_FULL_cff.py:10024
tadqm::TrackAnalyzer::dNdPt_HighPurity
MonitorElement * dNdPt_HighPurity
Definition: TrackAnalyzer.h:444
PV3DBase::mag
T mag() const
Definition: PV3DBase.h:64
reco::TrackBase::eta
double eta() const
pseudorapidity of momentum vector
Definition: TrackBase.h:652
reco::HitPattern::numberOfValidStripLayersWithMonoAndStereo
int numberOfValidStripLayersWithMonoAndStereo(uint16_t stripdet, uint16_t layer) const
Definition: HitPattern.cc:356
tadqm::TrackAnalyzer::lumiscalersToken_
edm::EDGetTokenT< LumiScalersCollection > lumiscalersToken_
Definition: TrackAnalyzer.h:87
tadqm::TrackAnalyzer::Chi2oNDF_lumiFlag
MonitorElement * Chi2oNDF_lumiFlag
Definition: TrackAnalyzer.h:436
reco::HitPattern::numberOfValidPixelBarrelHits
int numberOfValidPixelBarrelHits() const
Definition: HitPattern.h:829
tadqm::TrackAnalyzer::stoppingSourceVSphi
MonitorElement * stoppingSourceVSphi
Definition: TrackAnalyzer.h:430
tadqm::TrackAnalyzer::TkParameterMEs::NumberOfValidRecHitsPerTrackVsEta
MonitorElement * NumberOfValidRecHitsPerTrackVsEta
Definition: TrackAnalyzer.h:289
GetLumi::SECONDS_PER_LS
static constexpr double SECONDS_PER_LS
Definition: GetLumi.h:27
reco::TrackBase::qualityNames
static const std::string qualityNames[]
Definition: TrackBase.h:163
tadqm::TrackAnalyzer::TkParameterMEs::NumberOfLayersPerTrackVsTheta
MonitorElement * NumberOfLayersPerTrackVsTheta
Definition: TrackAnalyzer.h:316
dqm::impl::MonitorElement::getNbinsX
virtual int getNbinsX() const
get # of bins in X-axis
Definition: MonitorElement.cc:565
reco::TrackBase::chi2
double chi2() const
chi-squared of the fit
Definition: TrackBase.h:587
tadqm::TrackAnalyzer::DistanceOfClosestApproachErrorVsPt
MonitorElement * DistanceOfClosestApproachErrorVsPt
Definition: TrackAnalyzer.h:397
tadqm::TrackAnalyzer::sip3dToPV
MonitorElement * sip3dToPV
Definition: TrackAnalyzer.h:453
tadqm::TrackAnalyzer::fillHistosForState
void fillHistosForState(const edm::EventSetup &iSetup, const reco::Track &track, std::string sname)
Definition: TrackAnalyzer.cc:1912
tadqm::TrackAnalyzer::xPointOfClosestApproachToPV
MonitorElement * xPointOfClosestApproachToPV
Definition: TrackAnalyzer.h:415
dqm::implementation::IBooker::bookProfile
MonitorElement * bookProfile(TString const &name, TString const &title, int nchX, double lowX, double highX, int, double lowY, double highY, char const *option="s", FUNC onbooking=NOOP())
Definition: DQMStore.h:322
tadqm::TrackAnalyzer::NumberOfMORecHitsPerTrack
MonitorElement * NumberOfMORecHitsPerTrack
Definition: TrackAnalyzer.h:335
eostools.cat
def cat
Definition: eostools.py:401
HcalObjRepresent::Fill
void Fill(HcalDetId &id, double val, std::vector< TH2F > &depth)
Definition: HcalObjRepresent.h:1053
DeadROC_duringRun.dir
string dir
Definition: DeadROC_duringRun.py:23
reco::TrackBase::ndof
double ndof() const
number of degrees of freedom of the fit
Definition: TrackBase.h:590
reco::HitPattern::stripTIDLayersWithMeasurement
int stripTIDLayersWithMeasurement() const
Definition: HitPattern.cc:595
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
tadqm::TrackAnalyzer::Chi2Prob
MonitorElement * Chi2Prob
Definition: TrackAnalyzer.h:382
tadqm::TrackAnalyzer::dNhitdPt_HighPurity
MonitorElement * dNhitdPt_HighPurity
Definition: TrackAnalyzer.h:448
tadqm::TrackAnalyzer::good_vertices_
unsigned int good_vertices_
Definition: TrackAnalyzer.h:498
tadqm::TrackAnalyzer::NumberOfValidRecHitVsPhiVsEtaPerTrack
MonitorElement * NumberOfValidRecHitVsPhiVsEtaPerTrack
Definition: TrackAnalyzer.h:346
reco::TrackBase::pt
double pt() const
track transverse momentum
Definition: TrackBase.h:637
PV3DBase::z
T z() const
Definition: PV3DBase.h:61
tadqm::TrackAnalyzer::Chi2ProbVsEta
MonitorElement * Chi2ProbVsEta
Definition: TrackAnalyzer.h:391
reco::TrackBase::ptError
double ptError() const
error on Pt (set to 1000 TeV if charge==0 for safety)
Definition: TrackBase.h:754
tadqm::TrackAnalyzer::TkParameterMEs::TrackPt_PosEta_Phi_btw_16_0
MonitorElement * TrackPt_PosEta_Phi_btw_16_0
Definition: TrackAnalyzer.h:245
reco::TrackBase::phiError
double phiError() const
error on phi
Definition: TrackBase.h:766
DetId::subdetId
constexpr int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:48
reco::HitPattern::numberOfAllHits
int numberOfAllHits(HitCategory category) const
Definition: HitPattern.h:798
tadqm::TrackAnalyzer::fillHistosForTrackerSpecific
void fillHistosForTrackerSpecific(const reco::Track &track)
Definition: TrackAnalyzer.cc:2299
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
tadqm::TrackAnalyzer::stateName_
std::string stateName_
Definition: TrackAnalyzer.h:97
reco::HitPattern::numberOfValidStripTIDHits
int numberOfValidStripTIDHits() const
Definition: HitPattern.h:845
tadqm::TrackAnalyzer::yPointOfClosestApproachVsZ0wrtPV
MonitorElement * yPointOfClosestApproachVsZ0wrtPV
Definition: TrackAnalyzer.h:423
tadqm::TrackAnalyzer::zPointOfClosestApproachToPV
MonitorElement * zPointOfClosestApproachToPV
Definition: TrackAnalyzer.h:425
Gflash::EtaMin
const double EtaMin[kNumberCalorimeter]
Definition: GflashNameSpace.h:33
reco::TrackBase::numberOfValidHits
unsigned short numberOfValidHits() const
number of valid hits found
Definition: TrackBase.h:798
reco::HitPattern::numberOfValidStripTECHits
int numberOfValidStripTECHits() const
Definition: HitPattern.h:853
tadqm::TrackAnalyzer::NhitVsEta_HighPurity
MonitorElement * NhitVsEta_HighPurity
Definition: TrackAnalyzer.h:445
min
T min(T a, T b)
Definition: MathUtil.h:58
tadqm::TrackAnalyzer::DistanceOfClosestApproachVsTheta
MonitorElement * DistanceOfClosestApproachVsTheta
Definition: TrackAnalyzer.h:408
StripSubdetector::TOB
static constexpr auto TOB
Definition: StripSubdetector.h:18
reco::TransientTrack::outermostMeasurementState
TrajectoryStateOnSurface outermostMeasurementState() const
Definition: TransientTrack.h:84
tadqm::TrackAnalyzer::Chi2ProbVsPhi
MonitorElement * Chi2ProbVsPhi
Definition: TrackAnalyzer.h:392
beam_dqm_sourceclient-live_cfg.Chi2NDFMin
int Chi2NDFMin
Definition: beam_dqm_sourceclient-live_cfg.py:199
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
dqm::impl::MonitorElement::setBinLabel
virtual 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)
Definition: MonitorElement.cc:762
reco::HitPattern::trackerLayersTotallyOffOrBad
int trackerLayersTotallyOffOrBad(HitCategory category=TRACK_HITS) const
Definition: HitPattern.h:1017
tadqm::TrackAnalyzer::TkParameterMEMap
std::map< std::string, TkParameterMEs > TkParameterMEMap
Definition: TrackAnalyzer.h:329
tadqm::TrackAnalyzer::NumberOfLayersVsPhiVsEtaPerTrack
MonitorElement * NumberOfLayersVsPhiVsEtaPerTrack[5]
Definition: TrackAnalyzer.h:379
CartesianTrajectoryError::matrix
const AlgebraicSymMatrix66 & matrix() const
Definition: CartesianTrajectoryError.h:28
M_PI
#define M_PI
Definition: BXVectorInputProducer.cc:49
reco::TrackBase::pz
double pz() const
z coordinate of momentum vector
Definition: TrackBase.h:646
tadqm::TrackAnalyzer::NumberOfRecHitsPerTrackVsPhi
MonitorElement * NumberOfRecHitsPerTrackVsPhi
Definition: TrackAnalyzer.h:337
tadqm::TrackAnalyzer::NumberOfMIRecHitVsPtVsEtaPerTrack
MonitorElement * NumberOfMIRecHitVsPtVsEtaPerTrack
Definition: TrackAnalyzer.h:361
tadqm::TrackAnalyzer::zPointOfClosestApproach
MonitorElement * zPointOfClosestApproach
Definition: TrackAnalyzer.h:424
tadqm::TrackAnalyzer::conf_
edm::ParameterSet const * conf_
Definition: TrackAnalyzer.h:95
reco::TrackBase::dz
double dz() const
dz parameter (= dsz/cos(lambda)). This is the track z0 w.r.t (0,0,0) only if the refPoint is close to...
Definition: TrackBase.h:622
reco::TrackBase::dzError
double dzError() const
error on dz
Definition: TrackBase.h:778
AlgebraicSymMatrix66
ROOT::Math::SMatrix< double, 6, 6, ROOT::Math::MatRepSym< double, 6 > > AlgebraicSymMatrix66
Definition: AlgebraicROOTObjects.h:24
tadqm::TrackAnalyzer::sipDzToPV
MonitorElement * sipDzToPV
Definition: TrackAnalyzer.h:456
tadqm::TrackAnalyzer::sipDzToBS
MonitorElement * sipDzToBS
Definition: TrackAnalyzer.h:452
tadqm::TrackAnalyzer::TkParameterMEs::NumberOfValidRecHitsPerTrackVsPhi
MonitorElement * NumberOfValidRecHitsPerTrackVsPhi
Definition: TrackAnalyzer.h:287
tadqm::TrackAnalyzer::beamSpotToken_
edm::EDGetTokenT< reco::BeamSpot > beamSpotToken_
Definition: TrackAnalyzer.h:84
reco::TrackBase::vz
double vz() const
z coordinate of the reference point on track
Definition: TrackBase.h:661
edmNew::DetSetVector::const_iterator
boost::transform_iterator< IterHelp, const_IdIter > const_iterator
Definition: DetSetVectorNew.h:197
DetId
Definition: DetId.h:17
reco::TrackBase::originalAlgo
TrackAlgorithm originalAlgo() const
Definition: TrackBase.h:548
TSOS
TrajectoryStateOnSurface TSOS
Definition: TestHits.cc:19
tadqm::TrackAnalyzer::transientTrackBuilderToken_
edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord > transientTrackBuilderToken_
Definition: TrackAnalyzer.h:91
tadqm::TrackAnalyzer::bookHistosForState
void bookHistosForState(std::string sname, DQMStore::IBooker &ibooker)
Definition: TrackAnalyzer.cc:1463
tadqm::TrackAnalyzer::DistanceOfClosestApproachErrorVsPhi
MonitorElement * DistanceOfClosestApproachErrorVsPhi
Definition: TrackAnalyzer.h:399
tadqm::TrackAnalyzer::setLumi
void setLumi(const edm::Event &, const edm::EventSetup &iSetup)
Definition: TrackAnalyzer.cc:1118
tadqm::TrackAnalyzer::bookHistosForBeamSpot
void bookHistosForBeamSpot(DQMStore::IBooker &ibooker)
Definition: TrackAnalyzer.cc:777
reco::TrackBase::qualityByName
static TrackQuality qualityByName(const std::string &name)
Definition: TrackBase.cc:126
reco::Vertex::xError
double xError() const
error on x
Definition: Vertex.h:137
StripSubdetector::TIB
static constexpr auto TIB
Definition: StripSubdetector.h:16
tadqm::TrackAnalyzer::DistanceOfClosestApproachVsEta
MonitorElement * DistanceOfClosestApproachVsEta
Definition: TrackAnalyzer.h:413
N
#define N
Definition: blowfish.cc:9
tadqm::TrackAnalyzer::setNumberOfGoodVertices
void setNumberOfGoodVertices(const edm::Event &)
Definition: TrackAnalyzer.cc:1105
tadqm::TrackAnalyzer::TESTDistanceOfClosestApproachToBSVsPhi
MonitorElement * TESTDistanceOfClosestApproachToBSVsPhi
Definition: TrackAnalyzer.h:433
tadqm::TrackAnalyzer::DistanceOfClosestApproachToBS
MonitorElement * DistanceOfClosestApproachToBS
Definition: TrackAnalyzer.h:401
HLT_FULL_cff.PtMin
tuple PtMin
Definition: HLT_FULL_cff.py:10150
reco::TrackBase::hitPattern
const HitPattern & hitPattern() const
Access the hit pattern, indicating in which Tracker layers the track has hits.
Definition: TrackBase.h:504
tadqm::TrackAnalyzer::TopFolder_
std::string TopFolder_
Definition: TrackAnalyzer.h:82
tadqm::TrackAnalyzer::NumberOfValidRecHitsPerTrackVsEta
MonitorElement * NumberOfValidRecHitsPerTrackVsEta
Definition: TrackAnalyzer.h:344
beam_dqm_sourceclient-live_cfg.TrackPtMax
int TrackPtMax
Definition: beam_dqm_sourceclient-live_cfg.py:207
tadqm::TrackAnalyzer::NumberOfMIRecHitsPerTrackVsPt
MonitorElement * NumberOfMIRecHitsPerTrackVsPt
Definition: TrackAnalyzer.h:359
tadqm::TrackAnalyzer::NhitVsPhi_HighPurity
MonitorElement * NhitVsPhi_HighPurity
Definition: TrackAnalyzer.h:446
PVValHelper::makeLogBins
std::array< T, N+1 > makeLogBins(const T &min, const T &max)
Definition: PVValidationHelpers.h:30
dqm::implementation::IBooker::book2D
MonitorElement * book2D(TString const &name, TString const &title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, FUNC onbooking=NOOP())
Definition: DQMStore.h:177
reco::HitPattern::pixelBarrelLayersWithMeasurement
int pixelBarrelLayersWithMeasurement() const
Definition: HitPattern.cc:563
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
tadqm::TrackAnalyzer::NumberOfRecHitsPerTrack
MonitorElement * NumberOfRecHitsPerTrack
Definition: TrackAnalyzer.h:331
tadqm::TrackAnalyzer::xPointOfClosestApproachVsZ0wrtBS
MonitorElement * xPointOfClosestApproachVsZ0wrtBS
Definition: TrackAnalyzer.h:417
tadqm::TrackAnalyzer::NumberOfRecHitsPerTrack_lumiFlag
MonitorElement * NumberOfRecHitsPerTrack_lumiFlag
Definition: TrackAnalyzer.h:437
beam_dqm_sourceclient-live_cfg.Chi2NDFMax
int Chi2NDFMax
Definition: beam_dqm_sourceclient-live_cfg.py:198
tadqm::TrackAnalyzer::pvToken_
edm::EDGetTokenT< reco::VertexCollection > pvToken_
Definition: TrackAnalyzer.h:85
tadqm::TrackAnalyzer::Ptdist_HighPurity
MonitorElement * Ptdist_HighPurity
Definition: TrackAnalyzer.h:447
reco::HitPattern::numberOfValidStripTIBHits
int numberOfValidStripTIBHits() const
Definition: HitPattern.h:841
reco::TrackBase::algoNames
static const std::string algoNames[]
Definition: TrackBase.h:147
reco::TrackBase::quality
bool quality(const TrackQuality) const
Track quality.
Definition: TrackBase.h:552
HLT_FULL_cff.pixelClusters
tuple pixelClusters
Definition: HLT_FULL_cff.py:10254
tadqm::TrackAnalyzer::DistanceOfClosestApproachToPVZoom
MonitorElement * DistanceOfClosestApproachToPVZoom
Definition: TrackAnalyzer.h:405
TrackerTopology::layer
unsigned int layer(const DetId &id) const
reco::HitPattern::numberOfValidPixelEndcapHits
int numberOfValidPixelEndcapHits() const
Definition: HitPattern.h:833
tadqm::TrackAnalyzer::DistanceOfClosestApproachToBSVsEta
MonitorElement * DistanceOfClosestApproachToBSVsEta
Definition: TrackAnalyzer.h:411
PV3DBase::eta
T eta() const
Definition: PV3DBase.h:73
AlCaHLTBitMon_ParallelJobs.p
tuple p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
tadqm::TrackAnalyzer::DistanceOfClosestApproachErrorVsDxy
MonitorElement * DistanceOfClosestApproachErrorVsDxy
Definition: TrackAnalyzer.h:400
reco::HitPattern::trackerLayersWithoutMeasurement
int trackerLayersWithoutMeasurement(HitCategory category) const
Definition: HitPattern.cc:540
tadqm::TrackAnalyzer::NumberOfValidRecHitsPerTrack
MonitorElement * NumberOfValidRecHitsPerTrack
Definition: TrackAnalyzer.h:332
reco::TrackBase::vy
double vy() const
y coordinate of the reference point on track
Definition: TrackBase.h:658
GetLumi::rXSEC_PIXEL_CLUSTER
static constexpr double rXSEC_PIXEL_CLUSTER
Definition: GetLumi.h:40
tadqm::TrackAnalyzer::fillHistosForEfficiencyFromHitPatter
void fillHistosForEfficiencyFromHitPatter(const reco::Track &track, const std::string suffix, const float monitoring, bool useInac)
Definition: TrackAnalyzer.cc:1407
CurvilinearTrajectoryError::matrix
const AlgebraicSymMatrix55 & matrix() const
Definition: CurvilinearTrajectoryError.h:61
tadqm::TrackAnalyzer::AbsDistanceOfClosestApproachToBS
MonitorElement * AbsDistanceOfClosestApproachToBS
Definition: TrackAnalyzer.h:403
TrajectoryStateOnSurface::globalMomentum
GlobalVector globalMomentum() const
Definition: TrajectoryStateOnSurface.h:66
tadqm::TrackAnalyzer::yPointOfClosestApproachVsZ0wrtBS
MonitorElement * yPointOfClosestApproachVsZ0wrtBS
Definition: TrackAnalyzer.h:422
LaserDQM_cfi.mon
tuple mon
Definition: LaserDQM_cfi.py:3
tadqm::TrackAnalyzer::TESTDistanceOfClosestApproachToBS
MonitorElement * TESTDistanceOfClosestApproachToBS
Definition: TrackAnalyzer.h:432
tadqm::TrackAnalyzer::yPointOfClosestApproachToPV
MonitorElement * yPointOfClosestApproachToPV
Definition: TrackAnalyzer.h:420
GetLumi::CM2_TO_NANOBARN
static constexpr double CM2_TO_NANOBARN
Definition: GetLumi.h:42
tadqm::TrackAnalyzer::NumberOfRecHitsPerTrackVsTheta
MonitorElement * NumberOfRecHitsPerTrackVsTheta
Definition: TrackAnalyzer.h:338
tadqm::TrackAnalyzer::oriAlgo
MonitorElement * oriAlgo
Definition: TrackAnalyzer.h:427
beam_dqm_sourceclient-live_cfg.DxyMax
float DxyMax
Definition: beam_dqm_sourceclient-live_cfg.py:195
tadqm::TrackAnalyzer::TkParameterMEs::TrackPt_NegEta_Phi_btw_neg16_neg32
MonitorElement * TrackPt_NegEta_Phi_btw_neg16_neg32
Definition: TrackAnalyzer.h:239
reco::HitPattern::stripTECLayersWithMeasurement
int stripTECLayersWithMeasurement() const
Definition: HitPattern.cc:615
tadqm::TrackAnalyzer::TkParameterMEs::NumberOfValidRecHitsPerTrackVsPt
MonitorElement * NumberOfValidRecHitsPerTrackVsPt
Definition: TrackAnalyzer.h:290
tadqm::TrackAnalyzer::NumberOfLostRecHitVsPtVsEtaPerTrack
MonitorElement * NumberOfLostRecHitVsPtVsEtaPerTrack
Definition: TrackAnalyzer.h:354
LumiScalersCollection
std::vector< LumiScalers > LumiScalersCollection
Definition: LumiScalers.h:144
reco::TrackBase::charge
int charge() const
track electric charge
Definition: TrackBase.h:596
reco::BeamSpot::position
const Point & position() const
position
Definition: BeamSpot.h:59
reco::TransientTrack::impactPointState
TrajectoryStateOnSurface impactPointState() const
Definition: TransientTrack.h:96
tadqm::TrackAnalyzer::yPointOfClosestApproachVsZ0wrt000
MonitorElement * yPointOfClosestApproachVsZ0wrt000
Definition: TrackAnalyzer.h:421
hlt_dqm_clientPB-live_cfg.nbins
tuple nbins
Definition: hlt_dqm_clientPB-live_cfg.py:50
tadqm::TrackAnalyzer::hits_valid_
std::unordered_map< Key, MonitorElement *, KeyHasher > hits_valid_
Definition: TrackAnalyzer.h:493
tadqm::TrackAnalyzer::NumberOfMORecHitsPerTrackVsPt
MonitorElement * NumberOfMORecHitsPerTrackVsPt
Definition: TrackAnalyzer.h:366
tadqm::TrackAnalyzer::dNdEta_HighPurity
MonitorElement * dNdEta_HighPurity
Definition: TrackAnalyzer.h:443
beam_dqm_sourceclient-live_cfg.AbsDxyMax
float AbsDxyMax
Definition: beam_dqm_sourceclient-live_cfg.py:192
tadqm::TrackAnalyzer::NumberOfValidRecHitVsPtVsEtaPerTrack
MonitorElement * NumberOfValidRecHitVsPtVsEtaPerTrack
Definition: TrackAnalyzer.h:347
reco::HitPattern::getHitPattern
uint16_t getHitPattern(HitCategory category, int position) const
Definition: HitPattern.h:531
dqm::implementation::IBooker::book1D
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX, FUNC onbooking=NOOP())
Definition: DQMStore.h:98
Chi2
Definition: Chi2.h:15
edmNew::DetSet::size
size_type size() const
Definition: DetSetNew.h:68
beam_dqm_sourceclient-live_cfg.VZMax
int VZMax
Definition: beam_dqm_sourceclient-live_cfg.py:204
tadqm::TrackAnalyzer::xPointOfClosestApproachVsZ0wrt000
MonitorElement * xPointOfClosestApproachVsZ0wrt000
Definition: TrackAnalyzer.h:416
tadqm::TrackAnalyzer::TkRecHitsPerSubDetMEMap
std::map< std::string, TkRecHitsPerSubDetMEs > TkRecHitsPerSubDetMEMap
Definition: TrackAnalyzer.h:472
tadqm::TrackAnalyzer::TkParameterMEs::TrackPt_PosEta_Phi_btw_neg16_neg32
MonitorElement * TrackPt_PosEta_Phi_btw_neg16_neg32
Definition: TrackAnalyzer.h:243
tadqm::TrackAnalyzer::TkParameterMEs::TrackEtaPhiInvertedoutofphase
MonitorElement * TrackEtaPhiInvertedoutofphase
Definition: TrackAnalyzer.h:272
reco::TrackBase::dxy
double dxy() const
dxy parameter. (This is the transverse impact parameter w.r.t. to (0,0,0) ONLY if refPoint is close t...
Definition: TrackBase.h:608
tadqm::TrackAnalyzer::NumberOfMIRecHitsPerTrack
MonitorElement * NumberOfMIRecHitsPerTrack
Definition: TrackAnalyzer.h:334
GetLumi::XSEC_PIXEL_CLUSTER
static constexpr double XSEC_PIXEL_CLUSTER
Definition: GetLumi.h:36
PV3DBase::x
T x() const
Definition: PV3DBase.h:59
tadqm::TrackAnalyzer::NumberOfValidRecHitsPerTrackVsPhi
MonitorElement * NumberOfValidRecHitsPerTrackVsPhi
Definition: TrackAnalyzer.h:342
tadqm::TrackAnalyzer::zPointOfClosestApproachVsPhi
MonitorElement * zPointOfClosestApproachVsPhi
Definition: TrackAnalyzer.h:426
tadqm::TrackAnalyzer::TkParameterMEs::TrackPt_NegEta_Phi_btw_0_neg16
MonitorElement * TrackPt_NegEta_Phi_btw_0_neg16
Definition: TrackAnalyzer.h:240
StripSubdetector::TID
static constexpr auto TID
Definition: StripSubdetector.h:17
tadqm::TrackAnalyzer::NumberOfLostRecHitVsPhiVsEtaPerTrack
MonitorElement * NumberOfLostRecHitVsPhiVsEtaPerTrack
Definition: TrackAnalyzer.h:353
tadqm::TrackAnalyzer::NumberOfMORecHitVsPtVsEtaPerTrack
MonitorElement * NumberOfMORecHitVsPtVsEtaPerTrack
Definition: TrackAnalyzer.h:368
tadqm::TrackAnalyzer::DistanceOfClosestApproachToPV
MonitorElement * DistanceOfClosestApproachToPV
Definition: TrackAnalyzer.h:404
beam_dqm_sourceclient-live_cfg.TrackPtBin
int TrackPtBin
Definition: beam_dqm_sourceclient-live_cfg.py:208
tadqm::TrackAnalyzer::Chi2oNDFVsEta
MonitorElement * Chi2oNDFVsEta
Definition: TrackAnalyzer.h:387
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:29
reco::Vertex::yError
double yError() const
error on y
Definition: Vertex.h:139
tadqm::TrackAnalyzer::TkParameterMEs::NumberOfRecHitsPerTrackVsTheta
MonitorElement * NumberOfRecHitsPerTrackVsTheta
Definition: TrackAnalyzer.h:283
edmNew::DetSetVector::begin
const_iterator begin(bool update=false) const
Definition: DetSetVectorNew.h:545
dqm::impl::MonitorElement::divide
virtual void divide(const MonitorElement *, const MonitorElement *, double, double, const char *)
Replace entries with results of dividing num by denom.
Definition: MonitorElement.cc:735
NBINS
const int NBINS
Definition: CaloCachedShapeIntegrator.cc:3
reco::TrackBase::py
double py() const
y coordinate of momentum vector
Definition: TrackBase.h:643
reco::TrackBase::vx
double vx() const
x coordinate of the reference point on track
Definition: TrackBase.h:655
tadqm::TrackAnalyzer::DistanceOfClosestApproachToBSVsPhi
MonitorElement * DistanceOfClosestApproachToBSVsPhi
Definition: TrackAnalyzer.h:410
beam_dqm_sourceclient-live_cfg.TrackPtMin
int TrackPtMin
Definition: beam_dqm_sourceclient-live_cfg.py:206
tadqm::TrackAnalyzer::NumberOfRecHitVsPhiVsEtaPerTrack
MonitorElement * NumberOfRecHitVsPhiVsEtaPerTrack
Definition: TrackAnalyzer.h:340
tadqm::TrackAnalyzer::TkParameterMEs::NumberOfRecHitsPerTrackVsEta
MonitorElement * NumberOfRecHitsPerTrackVsEta
Definition: TrackAnalyzer.h:284
tadqm::TrackAnalyzer::ValidFractionPerTrack
MonitorElement * ValidFractionPerTrack
Definition: TrackAnalyzer.h:370
tadqm::TrackAnalyzer::trackerTopologyToken_
edm::ESGetToken< TrackerTopology, TrackerTopologyRcd > trackerTopologyToken_
Definition: TrackAnalyzer.h:90
tadqm::TrackAnalyzer::bookHistosForLScertification
void bookHistosForLScertification(DQMStore::IBooker &ibooker)
Definition: TrackAnalyzer.cc:740
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:233
tadqm::TrackAnalyzer::TkParameterMEs::TrackPt_PosEta_Phi_btw_0_neg16
MonitorElement * TrackPt_PosEta_Phi_btw_0_neg16
Definition: TrackAnalyzer.h:244
dqm::impl::MonitorElement::setAxisTitle
virtual void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:791
tadqm::TrackAnalyzer::TkParameterMEs::TrackPt_PosEta_Phi_btw_32_16
MonitorElement * TrackPt_PosEta_Phi_btw_32_16
Definition: TrackAnalyzer.h:246
Generated for CMSSW Reference Manual by doxygen 1.8.5