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