CMS 3D CMS Logo
PackedCandidateTrackValidator.cc
Go to the documentation of this file.
1 #include "FWCore/Framework/interface/Event.h"
2 #include "FWCore/Framework/interface/ESHandle.h"
3 #include "FWCore/ParameterSet/interface/ParameterSet.h"
4 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
5 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
6 #include "FWCore/MessageLogger/interface/MessageLogger.h"
7 #include "FWCore/Utilities/interface/VecArray.h"
8 #include "FWCore/Utilities/interface/isFinite.h"
9 
10 #include "DQMServices/Core/interface/DQMEDAnalyzer.h"
11 #include "DQMServices/Core/interface/DQMStore.h"
12 
13 #include "DataFormats/Common/interface/Association.h"
14 #include "DataFormats/TrackReco/interface/Track.h"
15 #include "DataFormats/PatCandidates/interface/PackedCandidate.h"
16 #include "DataFormats/Math/interface/libminifloat.h"
17 #include "DataFormats/Math/interface/liblogintpack.h"
18 #include "DataFormats/VertexReco/interface/Vertex.h"
19 #include "DataFormats/VertexReco/interface/VertexFwd.h"
20 #include "DataFormats/Math/interface/deltaPhi.h"
21 
22 #include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
23 #include "Geometry/Records/interface/TrackerTopologyRcd.h"
24 
25 #include "boost/math/special_functions/sign.hpp"
26 
27 #include <iomanip>
28 
29 namespace {
30  using dqm::reco::DQMStore;
31  using dqm::reco::MonitorElement;
32 
33  template <typename T>
34  void fillNoFlow(MonitorElement* me, T val) {
35  auto h = me->getTH1();
36  const auto xaxis = h->GetXaxis();
37  if (val <= xaxis->GetXmin())
38  h->AddBinContent(xaxis->GetFirst());
39  else if (val >= xaxis->GetXmax())
40  h->AddBinContent(xaxis->GetLast());
41  else
42  h->Fill(val);
43  }
44 
45  class HitPatternPrinter {
46  public:
47  explicit HitPatternPrinter(const reco::Track& trk) : track(trk) {}
48 
49  void print(std::ostream& os) const {
50  const reco::HitPattern& p = track.hitPattern();
51 
52  for (int i = 0; i < p.numberOfAllHits(reco::HitPattern::TRACK_HITS); ++i) {
53  uint32_t hit = p.getHitPattern(reco::HitPattern::TRACK_HITS, i);
54 
55  detLayer(os, p, hit);
56  if (p.missingHitFilter(hit)) {
57  os << "(miss)";
58  } else if (p.inactiveHitFilter(hit)) {
59  os << "(inact)";
60  } else if (p.badHitFilter(hit)) {
61  os << "(bad)";
62  }
63  os << " ";
64  }
65 
66  if (p.numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS) > 0) {
67  os << "lost inner ";
68 
69  for (int i = 0; i < p.numberOfAllHits(reco::HitPattern::MISSING_INNER_HITS); ++i) {
70  uint32_t hit = p.getHitPattern(reco::HitPattern::MISSING_INNER_HITS, i);
71  detLayer(os, p, hit);
72  if (p.missingHitFilter(hit)) {
73  os << "(miss)";
74  } else if (p.inactiveHitFilter(hit)) {
75  os << "(inact)";
76  }
77  }
78  }
79  if (p.numberOfLostHits(reco::HitPattern::MISSING_OUTER_HITS) > 0) {
80  os << "lost outer ";
81 
82  for (int i = 0; i < p.numberOfAllHits(reco::HitPattern::MISSING_OUTER_HITS); ++i) {
83  uint32_t hit = p.getHitPattern(reco::HitPattern::MISSING_OUTER_HITS, i);
84  detLayer(os, p, hit);
85  if (p.missingHitFilter(hit)) {
86  os << "(miss)";
87  } else if (p.inactiveHitFilter(hit)) {
88  os << "(inact)";
89  }
90  }
91  }
92  }
93 
94  private:
95  static void detLayer(std::ostream& os, const reco::HitPattern& p, uint32_t hit) {
96  if (p.pixelBarrelHitFilter(hit)) {
97  os << "BPIX";
98  } else if (p.pixelEndcapHitFilter(hit)) {
99  os << "FPIX";
100  } else if (p.stripTIBHitFilter(hit)) {
101  os << "TIB";
102  } else if (p.stripTIDHitFilter(hit)) {
103  os << "TID";
104  } else if (p.stripTOBHitFilter(hit)) {
105  os << "TOB";
106  } else if (p.stripTECHitFilter(hit)) {
107  os << "TEC";
108  }
109  os << p.getLayer(hit);
110  }
111 
112  const reco::Track& track;
113  };
114 
115  std::ostream& operator<<(std::ostream& os, const HitPatternPrinter& hpp) {
116  hpp.print(os);
117  return os;
118  }
119 
120  class TrackAlgoPrinter {
121  public:
122  explicit TrackAlgoPrinter(const reco::Track& trk) : track(trk) {}
123 
124  void print(std::ostream& os) const {
125  edm::VecArray<reco::TrackBase::TrackAlgorithm, reco::TrackBase::algoSize> algos;
126  for (int ialgo = 0; ialgo < reco::TrackBase::algoSize; ++ialgo) {
127  auto algo = static_cast<reco::TrackBase::TrackAlgorithm>(ialgo);
128  if (track.isAlgoInMask(algo)) {
129  algos.push_back(algo);
130  }
131  }
132 
133  os << "algo " << reco::TrackBase::algoName(track.algo());
134  if (track.originalAlgo() != track.algo())
135  os << " originalAlgo " << reco::TrackBase::algoName(track.originalAlgo());
136  if (algos.size() > 1) {
137  os << " algoMask";
138  for (auto algo : algos) {
139  os << " " << reco::TrackBase::algoName(algo);
140  }
141  }
142  }
143 
144  private:
145  const reco::Track& track;
146  };
147  std::ostream& operator<<(std::ostream& os, const TrackAlgoPrinter& tap) {
148  tap.print(os);
149  return os;
150  }
151 
152  double diffRelative(double a, double b) { return (a - b) / b; }
153 
154  class LogIntHelper {
155  public:
156  LogIntHelper(double lmin, double lmax) : lmin_(lmin), lmax_(lmax) {}
157 
158  class UnderOverflow {
159  public:
160  UnderOverflow(double largestValue, double smallestValue, std::function<double(double)> modifyUnpack)
161  : unpackedLargestValue_(modifyUnpack ? modifyUnpack(largestValue) : largestValue),
162  unpackedSmallestValue_(modifyUnpack ? modifyUnpack(smallestValue) : smallestValue) {}
163 
164  bool compatibleWithUnderflow(double value) const { return value == unpackedSmallestValue_; }
165  void printNonOkUnderflow(std::ostream& os) const { os << " (not min " << unpackedSmallestValue_ << ")"; }
166 
167  bool compatibleWithOverflow(double value) const { return value == unpackedLargestValue_; }
168  void printNonOkOverflow(std::ostream& os) const { os << " (not max " << unpackedLargestValue_ << ")"; }
169 
170  private:
171  // narrow to float to compare apples to apples with values from
172  // PackedCandidate (even though the final comparison is done in
173  // double)
174  const float unpackedLargestValue_;
175  const float unpackedSmallestValue_;
176  };
177 
178  static std::string maxName() { return "max"; }
179  static std::string minName() { return "min"; }
180 
181  UnderOverflow underOverflowHelper(double value, std::function<double(double)> modifyUnpack) const {
182  return UnderOverflow(
183  largestValue(), value >= 0 ? smallestPositiveValue() : std::abs(smallestNegativeValue()), modifyUnpack);
184  }
185 
186  double largestValue() const { return logintpack::unpack8log(127, lmin_, lmax_); }
187 
188  static bool wouldBeDenorm(double value) { return false; }
189 
190  // lessThan means closer to zero
191  bool lessThanSmallestValue(double value) const {
192  if (value >= 0)
193  return value < smallestPositiveValue();
194  else
195  return value > smallestNegativeValue();
196  }
197 
198  double smallestPositiveValue() const { return logintpack::unpack8log(logintpack::smallestPositive, lmin_, lmax_); }
199 
200  double smallestNegativeValue() const { return logintpack::unpack8log(logintpack::smallestNegative, lmin_, lmax_); }
201 
202  private:
203  const double lmin_;
204  const double lmax_;
205  };
206  class Float16Helper {
207  public:
208  class UnderOverflow {
209  public:
210  static void printNonOkUnderflow(std::ostream& os) { os << " (not 0)"; }
211  static bool compatibleWithUnderflow(double value) { return value == 0.0; }
212  static void printNonOkOverflow(std::ostream& os) { os << " (not inf)"; }
213  static bool compatibleWithOverflow(double value) { return edm::isNotFinite(value); }
214  };
215 
216  static std::string maxName() { return "inf"; }
217  static std::string minName() { return "0"; }
218 
219  static UnderOverflow underOverflowHelper(double value, std::function<double(double)>) { return UnderOverflow(); }
220 
221  static double largestValue() { return MiniFloatConverter::max32RoundedToMax16(); }
222 
223  static bool wouldBeDenorm(double value) {
224  const float valuef = static_cast<float>(value);
225  return valuef >= MiniFloatConverter::denorm_min() && valuef < MiniFloatConverter::min();
226  }
227 
228  static bool lessThanSmallestValue(double value) { return std::abs(value) < smallestValue(); }
229 
230  static double smallestValue() { return MiniFloatConverter::denorm_min(); }
231  };
232 
233  enum class RangeStatus {
234  inrange = 0,
235  inrange_signflip = 1,
236  denormal = 2,
237  underflow_OK = 3,
238  underflow_notOK = 4,
239  overflow_OK = 5,
240  overflow_notOK = 6
241  };
242  bool isInRange(RangeStatus status) { return status == RangeStatus::inrange || status == RangeStatus::denormal; }
243 
244  template <typename T>
245  class PackedValueCheckResult {
246  public:
247  PackedValueCheckResult(RangeStatus status,
248  double diff,
249  double pcvalue,
250  double trackvalue,
251  double rangeMin,
252  double rangeMax,
253  const typename T::UnderOverflow& underOverflow)
254  : diff_(diff),
255  pcvalue_(pcvalue),
256  trackvalue_(trackvalue),
257  rangeMin_(rangeMin),
258  rangeMax_(rangeMax),
259  status_(status),
260  underOverflow_(underOverflow) {}
261 
262  RangeStatus status() const { return status_; }
263  double diff() const { return diff_; }
264 
265  bool outsideExpectedRange() const {
266  if (status_ == RangeStatus::inrange)
267  return diff_ < rangeMin_ || diff_ > rangeMax_;
268  // denormal is considered as "in range" regardless of the expected range
269  return status_ == RangeStatus::underflow_notOK || status_ == RangeStatus::overflow_notOK ||
270  status_ == RangeStatus::inrange_signflip;
271  }
272 
273  void print(std::ostream& os) const {
274  if (outsideExpectedRange())
275  os << "!! ";
276  os << "(" << rangeMin_ << "," << rangeMax_ << ") ";
277 
278  os << diff_ << " " << pcvalue_;
279  if (status_ == RangeStatus::underflow_OK || status_ == RangeStatus::underflow_notOK) {
280  os << " (underflow) ";
281  if (status_ == RangeStatus::underflow_notOK)
282  underOverflow_.printNonOkUnderflow(os);
283  } else if (status_ == RangeStatus::overflow_OK || status_ == RangeStatus::overflow_notOK) {
284  os << " (overflow) ";
285  if (status_ == RangeStatus::overflow_notOK)
286  underOverflow_.printNonOkOverflow(os);
287  } else if (status_ == RangeStatus::denormal)
288  os << " (denormal)";
289  os << " " << trackvalue_;
290  }
291 
292  private:
293  const double diff_;
294  const double pcvalue_;
295  const double trackvalue_;
296  const double rangeMin_;
297  const double rangeMax_;
298  const RangeStatus status_;
299  const typename T::UnderOverflow underOverflow_;
300  };
301 
302  struct Range {
303  Range(double mi, double ma) : min(mi), max(ma) {}
304  const double min, max;
305  };
306  struct RangeAbs {
307  RangeAbs(double val) : min(-val), max(val) {}
308  const double min, max;
309  };
310 
311  template <typename T>
312  class PackedValueCheck {
313  public:
314  template <typename R, typename... Args>
315  PackedValueCheck(const R& range, Args&&... args)
316  : helper_(std::forward<Args>(args)...), rangeMin_(range.min), rangeMax_(range.max) {}
317 
318  void book(DQMStore::IBooker& iBooker,
319  const std::string& name,
320  const std::string& title,
321  int nbins,
322  double min,
323  double max,
324  int flow_nbins,
325  double flow_min,
326  double flow_max) {
327  hInrange = iBooker.book1D(name, title, nbins, min, max);
328  hUnderOverflowSign = iBooker.book1D(name + "UnderOverFlowSign",
329  title + " with over- and underflow, and sign flip",
330  flow_nbins,
331  flow_min,
332  flow_max);
333  hStatus = iBooker.book1D(name + "Status", title + " status", 7, -0.5, 6.5);
334  hStatus->setBinLabel(1, "In range");
335  hStatus->setBinLabel(2, "In range, sign flip");
336  hStatus->setBinLabel(3, "Denormal");
337  hStatus->setBinLabel(4, "Underflow, PC is " + T::minName());
338  hStatus->setBinLabel(5, "Underflow, PC is not " + T::minName());
339  hStatus->setBinLabel(6, "Overflow, PC is " + T::maxName());
340  hStatus->setBinLabel(7, "Overflow, PC is not " + T::maxName());
341  }
342 
343  PackedValueCheckResult<T> fill(double pcvalue,
344  double trackvalue,
345  std::function<double(double)> modifyPack = std::function<double(double)>(),
346  std::function<double(double)> modifyUnpack = std::function<double(double)>()) {
347  const auto diff = diffRelative(pcvalue, trackvalue);
348 
349  const auto tmpSigned = modifyPack ? modifyPack(trackvalue) : trackvalue;
350  const auto tmp = std::abs(tmpSigned);
351  const auto underOverflow = helper_.underOverflowHelper(tmpSigned, modifyUnpack);
352  RangeStatus status;
353  if (tmp > helper_.largestValue()) {
354  fillNoFlow(hUnderOverflowSign, diff);
355  if (underOverflow.compatibleWithOverflow(std::abs(pcvalue))) {
356  status = RangeStatus::overflow_OK;
357  } else {
358  status = RangeStatus::overflow_notOK;
359  }
360  } else if (helper_.lessThanSmallestValue(tmpSigned)) {
361  fillNoFlow(hUnderOverflowSign, diff);
362  if (underOverflow.compatibleWithUnderflow(std::abs(pcvalue))) {
363  status = RangeStatus::underflow_OK;
364  } else {
365  status = RangeStatus::underflow_notOK;
366  }
367  } else {
368  if (boost::math::sign(pcvalue) == boost::math::sign(trackvalue)) {
369  if (T::wouldBeDenorm(tmp)) {
370  status = RangeStatus::denormal;
371  } else {
372  status = RangeStatus::inrange;
373  }
374  fillNoFlow(hInrange, diff);
375  } else {
376  fillNoFlow(hUnderOverflowSign, diff);
377  status = RangeStatus::inrange_signflip;
378  }
379  }
380  hStatus->Fill(static_cast<int>(status));
381 
382  return PackedValueCheckResult<T>(status, diff, pcvalue, trackvalue, rangeMin_, rangeMax_, underOverflow);
383  }
384 
385  private:
386  const T helper_;
387  const double rangeMin_;
388  const double rangeMax_;
389 
390  MonitorElement* hInrange;
391  MonitorElement* hUnderOverflowSign;
392  MonitorElement* hStatus;
393  };
394  template <typename T>
395  std::ostream& operator<<(std::ostream& os, const PackedValueCheckResult<T>& res) {
396  res.print(os);
397  return os;
398  }
399 } // namespace
400 
401 class PackedCandidateTrackValidator : public DQMEDAnalyzer {
402 public:
403  PackedCandidateTrackValidator(const edm::ParameterSet& pset);
404  ~PackedCandidateTrackValidator() override;
405 
406  void bookHistograms(DQMStore::IBooker&, edm::Run const&, edm::EventSetup const&) override;
407  void analyze(const edm::Event&, const edm::EventSetup&) override;
408 
409  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
410 
411 private:
412  edm::EDGetTokenT<edm::View<reco::Track>> tracksToken_;
413  edm::EDGetTokenT<reco::VertexCollection> verticesToken_;
414  edm::EDGetTokenT<edm::Association<pat::PackedCandidateCollection>> trackToPackedCandidateToken_;
415 
416  std::string rootFolder_;
417  bool debug_;
418 
419  enum {
420  sf_AllTracks = 0,
421  sf_AssociatedToPC = 1,
422  sf_PCIsCharged = 2,
423  sf_PCHasTrack = 3,
424  sf_PCIsNotElectron = 4,
425  sf_PCHasHits = 5,
426  sf_PCNdofNot0 = 6,
427  sf_NoMissingInnerHits = 7
428  };
429  MonitorElement* h_selectionFlow;
430 
431  MonitorElement* h_diffVx;
432  MonitorElement* h_diffVy;
433  MonitorElement* h_diffVz;
434 
435  MonitorElement* h_diffNormalizedChi2;
436  MonitorElement* h_diffNdof;
437 
438  MonitorElement* h_diffCharge;
439  MonitorElement* h_diffIsHighPurity;
440 
441  MonitorElement* h_diffPt;
442  MonitorElement* h_diffEta;
443  MonitorElement* h_diffPhi;
444  PackedValueCheck<Float16Helper> h_diffDxyAssocPV;
445  PackedValueCheck<Float16Helper> h_diffDzAssocPV;
446  MonitorElement* h_diffDxyPV;
447  MonitorElement* h_diffDzPV;
448 
449  MonitorElement* h_diffTrackDxyAssocPV;
450  MonitorElement* h_diffTrackDzAssocPV;
451 
452  PackedValueCheck<LogIntHelper> h_diffCovQoverpQoverp;
453  PackedValueCheck<LogIntHelper> h_diffCovLambdaLambda;
454  PackedValueCheck<LogIntHelper> h_diffCovLambdaDsz;
455  PackedValueCheck<LogIntHelper> h_diffCovPhiPhi;
456  PackedValueCheck<LogIntHelper> h_diffCovPhiDxy;
457  PackedValueCheck<Float16Helper> h_diffCovDxyDxy;
458  PackedValueCheck<Float16Helper> h_diffCovDxyDsz;
459  PackedValueCheck<Float16Helper> h_diffCovDszDsz;
460 
461  MonitorElement* h_diffDxyError;
462  MonitorElement* h_diffDszError;
463  MonitorElement* h_diffDzError;
464 
465  MonitorElement* h_diffTrackDxyError;
466  MonitorElement* h_diffTrackDzError;
467 
468  MonitorElement* h_diffPtError;
469  MonitorElement* h_diffEtaError;
470 
471  MonitorElement* h_diffNumberOfPixelLayers;
472  MonitorElement* h_diffNumberOfStripLayers;
473  MonitorElement* h_diffNumberOfPixelHits;
474  MonitorElement* h_diffNumberOfHits;
475  MonitorElement* h_diffLostInnerHits;
476 
477  MonitorElement* h_diffHitPatternPixelLayersWithMeasurement;
478  MonitorElement* h_diffHitPatternTrackerLayersWithMeasurement;
479  MonitorElement* h_diffHitPatternStripLayersWithMeasurement;
480  MonitorElement* h_diffHitPatternNumberOfValidPixelHits;
481  MonitorElement* h_diffHitPatternNumberOfValidHits;
482  MonitorElement* h_diffHitPatternNumberOfLostInnerHits;
483  MonitorElement* h_diffHitPatternHasValidHitInFirstPixelBarrel;
484 
485  MonitorElement* h_numberPixelLayersOverMax;
486  MonitorElement* h_numberStripLayersOverMax;
487  MonitorElement* h_numberLayersOverMax;
488  MonitorElement* h_numberPixelHitsOverMax;
489  MonitorElement* h_numberStripHitsOverMax;
490  MonitorElement* h_numberHitsOverMax;
491 };
492 
493 PackedCandidateTrackValidator::PackedCandidateTrackValidator(const edm::ParameterSet& iConfig)
494  : tracksToken_(consumes<edm::View<reco::Track>>(iConfig.getUntrackedParameter<edm::InputTag>("tracks"))),
495  verticesToken_(consumes<reco::VertexCollection>(iConfig.getUntrackedParameter<edm::InputTag>("vertices"))),
496  trackToPackedCandidateToken_(consumes<edm::Association<pat::PackedCandidateCollection>>(
497  iConfig.getUntrackedParameter<edm::InputTag>("trackToPackedCandidateAssociation"))),
498  rootFolder_(iConfig.getUntrackedParameter<std::string>("rootFolder")),
499  debug_(iConfig.getUntrackedParameter<bool>("debug")),
500  h_diffDxyAssocPV(RangeAbs(0.001)),
501  h_diffDzAssocPV(RangeAbs(0.001)),
502  h_diffCovQoverpQoverp(Range(-1e-6, 0.13), -15, 0), // despite of ceil in pack, there is rounding in double->float
503  h_diffCovLambdaLambda(
504  Range(-1e-6, 0.13), -20, -5), // despite of ceil in pack, there is rounding in double->float
505  h_diffCovLambdaDsz(RangeAbs(0.13), -17, -4),
506  h_diffCovPhiPhi(RangeAbs(0.13), -15, 0),
507  h_diffCovPhiDxy(RangeAbs(0.13), -17, -4),
508  h_diffCovDxyDxy(RangeAbs(0.001)),
509  h_diffCovDxyDsz(RangeAbs(0.001)),
510  h_diffCovDszDsz(RangeAbs(0.001)) {}
511 
512 PackedCandidateTrackValidator::~PackedCandidateTrackValidator() {}
513 
514 void PackedCandidateTrackValidator::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
515  edm::ParameterSetDescription desc;
516 
517  desc.addUntracked<edm::InputTag>("tracks", edm::InputTag("generalTracks"));
518  desc.addUntracked<edm::InputTag>("vertices", edm::InputTag("offlinePrimaryVertices"));
519  desc.addUntracked<edm::InputTag>("trackToPackedCandidateAssociation", edm::InputTag("packedPFCandidates"));
520  desc.addUntracked<std::string>("rootFolder", "Tracking/PackedCandidate");
521  desc.addUntracked<bool>("debug", false);
522 
523  descriptions.add("packedCandidateTrackValidator", desc);
524 }
525 
526 void PackedCandidateTrackValidator::bookHistograms(DQMStore::IBooker& iBooker,
527  edm::Run const&,
528  edm::EventSetup const&) {
529  iBooker.setCurrentFolder(rootFolder_);
530 
531  h_selectionFlow = iBooker.book1D("selectionFlow", "Track selection flow", 8, -0.5, 7.5);
532  h_selectionFlow->setBinLabel(1, "All tracks");
533  h_selectionFlow->setBinLabel(2, "Associated to PackedCandidate");
534  h_selectionFlow->setBinLabel(3, "PC is charged"), h_selectionFlow->setBinLabel(4, "PC has track");
535  h_selectionFlow->setBinLabel(5, "PC is not electron");
536  h_selectionFlow->setBinLabel(6, "PC has hits");
537  h_selectionFlow->setBinLabel(7, "PC ndof != 0");
538  h_selectionFlow->setBinLabel(8, "Track: no missing inner hits");
539 
540  constexpr int diffBins = 50;
541 
542  h_diffVx =
543  iBooker.book1D("diffVx", "PackedCandidate::bestTrack() - reco::Track in vx()", diffBins, -0.2, 0.2); // not equal
544  h_diffVy =
545  iBooker.book1D("diffVy", "PackedCandidate::bestTrack() - reco::Track in vy()", diffBins, -0.2, 0.2); // not equal
546  h_diffVz =
547  iBooker.book1D("diffVz", "PackedCandidate::bestTrack() - reco::Track in vz()", diffBins, -0.4, 0.4); // not equal
548 
549  h_diffNormalizedChi2 = iBooker.book1D("diffNormalizedChi2",
550  "PackedCandidate::bestTrack() - reco::Track in normalizedChi2()",
551  30,
552  -1.5,
553  1.5); // expected difference in -1...0
554  h_diffNdof = iBooker.book1D(
555  "diffNdof", "PackedCandidate::bestTrack() - reco::Track in ndof()", 33, -30.5, 2.5); // to monitor the difference
556 
557  h_diffCharge = iBooker.book1D(
558  "diffCharge", "PackedCandidate::bestTrack() - reco::Track in charge()", 5, -2.5, 2.5); // expect equality
559  h_diffIsHighPurity = iBooker.book1D("diffIsHighPurity",
560  "PackedCandidate::bestTrack() - reco::Track in quality(highPurity)",
561  3,
562  -1.5,
563  1.5); // expect equality
564 
565  h_diffPt = iBooker.book1D("diffPt",
566  "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in pt()",
567  diffBins,
568  -1.1,
569  1.1); // not equal, keep
570  h_diffEta = iBooker.book1D(
571  "diffEta", "PackedCandidate::bestTrack() - reco::Track in eta()", diffBins, -0.001, 0.001); // not equal, keep
572  h_diffPhi = iBooker.book1D("diffPhi",
573  "PackedCandidate::bestTrack() - reco::Track in phi()",
574  diffBins,
575  -0.0005,
576  0.0005); // expect equality within precision
577 
578  h_diffDxyAssocPV.book(iBooker,
579  "diffDxyAssocPV",
580  "(PackedCandidate::dxy() - reco::Track::dxy(assocPV))/reco::Track",
581  40,
582  -0.001,
583  0.001, // expect equality within precision
584  50,
585  -0.5,
586  0.5);
587  h_diffDzAssocPV.book(iBooker,
588  "diffDzAssocPV",
589  "(PackedCandidate::dzAssociatedPV() - reco::Track::dz(assocPV))/reco::Track",
590  40,
591  -0.001,
592  0.001, // expect equality within precision
593  50,
594  -0.5,
595  0.5);
596  h_diffDxyPV = iBooker.book1D("diffDxyPV",
597  "(PackedCandidate::dxy(PV) - reco::Track::dxy(PV))/reco::Track",
598  diffBins,
599  -0.01,
600  0.01); // expect equality within precision (worse than assocPV)
601  h_diffDzPV = iBooker.book1D("diffDzPV",
602  "(PackedCandidate::dz(PV) - reco::Track::dz(PV))/reco::Track",
603  diffBins,
604  -0.01,
605  0.01); // expect equality wihtin precision (worse than assocPV)
606  h_diffTrackDxyAssocPV =
607  iBooker.book1D("diffTrackDxyAssocPV",
608  "(PackedCandidate::bestTrack()::dxy(assocPV)) - reco::Track::dxy(assocPV))/reco::Track",
609  diffBins,
610  -0.01,
611  0.01); // not equal
612  h_diffTrackDzAssocPV =
613  iBooker.book1D("diffTrackDzAssocPV",
614  "(PackedCandidate::bestTrack()::dz(assocPV)) - reco::Track::dz(assocPV))/reco::Track",
615  diffBins,
616  -0.01,
617  0.01); // not equal
618 
619  h_diffCovQoverpQoverp.book(iBooker,
620  "diffCovQoverpQoverp",
621  "(PackedCandidate::bestTrack() - reco::Track)/reco::track in cov(qoverp, qoverp)",
622  40,
623  -0.05,
624  0.15, // expect equality within precision (worst precision is exp(1/128*15) =~ 12 %
625  50,
626  -0.5,
627  0.5);
628  h_diffCovLambdaLambda.book(
629  iBooker,
630  "diffCovLambdaLambda",
631  "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in cov(lambda, lambda)",
632  40,
633  -0.05,
634  0.15, // expect equality within precision worst precision is exp(1/128*(20-5)) =~ 12 % (multiplied by pt^2 in packing & unpacking)
635  50,
636  -0.5,
637  0.5);
638  h_diffCovLambdaDsz.book(iBooker,
639  "diffCovLambdaDsz",
640  "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in cov(lambda, dsz)",
641  60,
642  -0.15,
643  0.15, // expect equality within precision, worst precision is exp(1/128*(17-4) =~ 11 %
644  50,
645  -1,
646  1);
647  h_diffCovPhiPhi.book(
648  iBooker,
649  "diffCovPhiPhi",
650  "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in cov(phi, phi)",
651  40,
652  -0.05,
653  0.15, // expect equality within precision worst precision is exp(1/128*(20-5)) =~ 12 % (multiplied by pt^2 in packing & unpacking)
654  50,
655  -0.5,
656  0.5);
657  h_diffCovPhiDxy.book(iBooker,
658  "diffCovPhiDxy",
659  "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in cov(phi, dxy)",
660  60,
661  -0.15,
662  0.15, // expect equality within precision, wors precision is exp(1/128)*(17-4) =~ 11 %
663  50,
664  -1,
665  1);
666  h_diffCovDxyDxy.book(iBooker,
667  "diffCovDxyDxy",
668  "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in cov(dxy, dxy)",
669  40,
670  -0.001,
671  0.001,
672  50,
673  -0.1,
674  0.1);
675  h_diffCovDxyDsz.book(iBooker,
676  "diffCovDxyDsz",
677  "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in cov(dxy, dsz)",
678  40,
679  -0.001,
680  0.001, // expect equality within precision
681  50,
682  -0.5,
683  0.5);
684  h_diffCovDszDsz.book(iBooker,
685  "diffCovDszDsz",
686  "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in cov(dsz, dsz)",
687  40,
688  -0.001,
689  0.001, // expect equality within precision
690  50,
691  -0.1,
692  0.1);
693 
694  h_diffDxyError = iBooker.book1D("diffDxyError",
695  "(PackedCandidate::dxyError() - reco::Track::dxyError())/reco::Track",
696  40,
697  -0.001,
698  0.001); // expect equality within precision
699  h_diffDszError = iBooker.book1D("diffDszError",
700  "(PackedCandidate::dzError() - reco::Track::dszError())/reco::Track",
701  40,
702  -0.001,
703  0.001); // ideally, not equal, but for now they are
704  h_diffDzError = iBooker.book1D("diffDzError",
705  "(PackedCandidate::dzError() - reco::Track::dzError())/reco::Track",
706  40,
707  -0.001,
708  0.001); // expect equality within precision (not currently the case)
709 
710  h_diffTrackDxyError = iBooker.book1D("diffTrackDxyError",
711  "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in dxyError()",
712  40,
713  -0.001,
714  0.001); // expect equality within precision
715  h_diffTrackDzError = iBooker.book1D("diffTrackDzError",
716  "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in dzError()",
717  40,
718  -0.05,
719  0.05); // not equal
720 
721  h_diffPtError = iBooker.book1D("diffPtError",
722  "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in ptError()",
723  diffBins,
724  -1.1,
725  1.1); // not equal
726  h_diffEtaError = iBooker.book1D("diffEtaError",
727  "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in etaError()",
728  60,
729  -0.15,
730  0.15); // not equal
731 
732  h_diffNumberOfPixelLayers = iBooker.book1D(
733  "diffNumberOfPixelLayers",
734  "PackedCandidate::pixelLayersWithMeasurement() - reco::Track::hitPattern::pixelLayersWithMeasurement()",
735  5,
736  -2.5,
737  2.5); // expect equality
738  h_diffNumberOfStripLayers = iBooker.book1D(
739  "diffNumberOfStripLayers",
740  "PackedCandidate::stripLayersWithMeasurement() - reco::Track::hitPattern::stripLayersWithMeasurement()",
741  5,
742  -2.5,
743  2.5); // expect equality
744  h_diffNumberOfPixelHits =
745  iBooker.book1D("diffNumberOfPixelHits",
746  "PackedCandidate::numberOfPixelHits() - reco::Track::hitPattern::numberOfValidPixelHits()",
747  5,
748  -2.5,
749  2.5); // expect equality
750  h_diffNumberOfHits = iBooker.book1D("diffNumberOfHits",
751  "PackedCandidate::numberHits() - reco::Track::hitPattern::numberOfValidHits()",
752  5,
753  -2.5,
754  2.5); // expect equality
755  h_diffLostInnerHits =
756  iBooker.book1D("diffLostInnerHits",
757  "PackedCandidate::lostInnerHits() - reco::Track::hitPattern::numberOfLostHits(MISSING_INNER_HITS)",
758  5,
759  -2.5,
760  2.5); // expect equality
761 
762  h_diffHitPatternPixelLayersWithMeasurement =
763  iBooker.book1D("diffHitPatternPixelLayersWithMeasurement",
764  "PackedCandidate::bestTrack() - reco::Track in hitPattern::pixelLayersWithMeasurement()",
765  13,
766  -10.5,
767  2.5); // not equal
768  h_diffHitPatternStripLayersWithMeasurement =
769  iBooker.book1D("diffHitPatternStripLayersWithMeasurement",
770  "PackedCandidate::bestTrack() - reco::Track in hitPattern::stripLayersWithMeasurement()",
771  13,
772  -10.5,
773  2.5); // not equal
774  h_diffHitPatternTrackerLayersWithMeasurement =
775  iBooker.book1D("diffHitPatternTrackerLayersWithMeasurement",
776  "PackedCandidate::bestTrack() - reco::Track in hitPattern::trackerLayersWithMeasurement()",
777  13,
778  -10.5,
779  2.5); // not equal
780  h_diffHitPatternNumberOfValidPixelHits =
781  iBooker.book1D("diffHitPatternNumberOfValidPixelHits",
782  "PackedCandidate::bestTrack() - reco::Track in hitPattern::numberOfValidPixelHits()",
783  13,
784  -10.5,
785  2.5); // not equal
786  h_diffHitPatternNumberOfValidHits =
787  iBooker.book1D("diffHitPatternNumberOfValidHits",
788  "PackedCandidate::bestTrack() - reco::Track in hitPattern::numberOfValidHits()",
789  13,
790  -10.5,
791  2.5); // not equal
792  h_diffHitPatternNumberOfLostInnerHits =
793  iBooker.book1D("diffHitPatternNumberOfLostPixelHits",
794  "PackedCandidate::bestTrack() - reco::Track in hitPattern::numberOfLostHits(MISSING_INNER_HITS)",
795  13,
796  -10.5,
797  2.5); // not equal
798  h_diffHitPatternHasValidHitInFirstPixelBarrel =
799  iBooker.book1D("diffHitPatternHasValidHitInFirstPixelBarrel",
800  "PackedCandidate::bestTrack() - reco::Track in hitPattern::hasValidHitInFirstPixelBarrel",
801  3,
802  -1.5,
803  1.5); // expect equality
804 
805  h_numberPixelLayersOverMax = iBooker.book1D(
806  "numberPixelLayersOverMax", "Number of pixel layers over the maximum of PackedCandidate", 10, 0, 10);
807  h_numberStripLayersOverMax = iBooker.book1D(
808  "numberStripLayersOverMax", "Number of strip layers over the maximum of PackedCandidate", 10, 0, 10);
809  h_numberLayersOverMax =
810  iBooker.book1D("numberLayersOverMax", "Number of layers over the maximum of PackedCandidate", 20, 0, 20);
811  h_numberPixelHitsOverMax =
812  iBooker.book1D("numberPixelHitsOverMax", "Number of pixel hits over the maximum of PackedCandidate", 10, 0, 10);
813  h_numberStripHitsOverMax =
814  iBooker.book1D("numberStripHitsOverMax", "Number of strip hits over the maximum of PackedCandidate", 10, 0, 10);
815  h_numberHitsOverMax =
816  iBooker.book1D("numberHitsOverMax", "Number of hits over the maximum of PackedCandidate", 20, 0, 20);
817 }
818 
819 void PackedCandidateTrackValidator::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
820  edm::Handle<edm::View<reco::Track>> htracks;
821  iEvent.getByToken(tracksToken_, htracks);
822  const auto& tracks = *htracks;
823 
824  edm::Handle<reco::VertexCollection> hvertices;
825  iEvent.getByToken(verticesToken_, hvertices);
826  const auto& vertices = *hvertices;
827 
828  if (vertices.empty())
829  return;
830  const reco::Vertex& pv = vertices[0];
831 
832  edm::Handle<edm::Association<pat::PackedCandidateCollection>> hassoc;
833  iEvent.getByToken(trackToPackedCandidateToken_, hassoc);
834  const auto& trackToPackedCandidate = *hassoc;
835 
836  for (size_t i = 0; i < tracks.size(); ++i) {
837  auto trackPtr = tracks.ptrAt(i);
838  const reco::Track& track = *trackPtr;
839  h_selectionFlow->Fill(sf_AllTracks);
840 
841  pat::PackedCandidateRef pcRef = trackToPackedCandidate[trackPtr];
842  if (pcRef.isNull()) {
843  continue;
844  }
845  h_selectionFlow->Fill(sf_AssociatedToPC);
846 
847  // Filter out neutral PackedCandidates, some of them may have track associated, and for those the charge comparison fails
848  if (pcRef->charge() == 0) {
849  continue;
850  }
851  h_selectionFlow->Fill(sf_PCIsCharged);
852 
853  const reco::Track* trackPcPtr = pcRef->bestTrack();
854  if (!trackPcPtr) {
855  continue;
856  }
857  h_selectionFlow->Fill(sf_PCHasTrack);
858 
859  // Filter out electrons to avoid comparisons to PackedCandidates with GsfTrack
860  if (std::abs(pcRef->pdgId()) == 11) {
861  continue;
862  }
863  h_selectionFlow->Fill(sf_PCIsNotElectron);
864 
865  // Filter out PackedCandidate-tracks with no hits, as they won't have their details filled
866  const reco::Track& trackPc = *trackPcPtr;
867  if (trackPc.hitPattern().numberOfValidHits() == 0) {
868  continue;
869  }
870  h_selectionFlow->Fill(sf_PCHasHits);
871 
872  auto slimmedVertexRef = pcRef->vertexRef();
873  const reco::Vertex& pcVertex = vertices[slimmedVertexRef.key()];
874 
875  fillNoFlow(h_diffVx, trackPc.vx() - track.vx());
876  fillNoFlow(h_diffVy, trackPc.vy() - track.vy());
877  fillNoFlow(h_diffVz, trackPc.vz() - track.vz());
878 
879  // PackedCandidate recalculates the ndof in unpacking as
880  // (nhits+npixelhits-5), but some strip hits may have dimension 2.
881  // If PackedCandidate has ndof=0, the resulting normalizedChi2
882  // will be 0 too. Hence, the comparison makes sense only for those
883  // PackedCandidates that have ndof != 0.
884  double diffNormalizedChi2 = 0;
885  if (trackPc.ndof() != 0) {
886  h_selectionFlow->Fill(sf_PCNdofNot0);
887  diffNormalizedChi2 = trackPc.normalizedChi2() - track.normalizedChi2();
888  fillNoFlow(h_diffNormalizedChi2, diffNormalizedChi2);
889  }
890  fillNoFlow(h_diffNdof, trackPc.ndof() - track.ndof());
891 
892  auto diffCharge = trackPc.charge() - track.charge();
893  fillNoFlow(h_diffCharge, diffCharge);
894  int diffHP = static_cast<int>(trackPc.quality(reco::TrackBase::highPurity)) -
895  static_cast<int>(track.quality(reco::TrackBase::highPurity));
896  fillNoFlow(h_diffIsHighPurity, diffHP);
897 
898  const auto diffPt = diffRelative(trackPc.pt(), track.pt());
899  const auto diffPhi = reco::deltaPhi(trackPc.phi(), track.phi());
900  fillNoFlow(h_diffPt, diffPt);
901  fillNoFlow(h_diffEta, trackPc.eta() - track.eta());
902  fillNoFlow(h_diffPhi, diffPhi);
903 
904  const auto diffDxyAssocPV =
905  h_diffDxyAssocPV.fill(pcRef->dxy(), track.dxy(pcVertex.position()), [](double value) { return value * 100.; });
906  const auto diffDzAssocPV = h_diffDzAssocPV.fill(
907  pcRef->dzAssociatedPV(), track.dz(pcVertex.position()), [](double value) { return value * 100.; });
908  const auto diffDxyPV = diffRelative(pcRef->dxy(pv.position()), track.dxy(pv.position()));
909  const auto diffDzPV = diffRelative(pcRef->dz(pv.position()), track.dz(pv.position()));
910  fillNoFlow(h_diffDxyPV, diffDxyPV);
911  fillNoFlow(h_diffDzPV, diffDzPV);
912  fillNoFlow(h_diffTrackDxyAssocPV, diffRelative(trackPc.dxy(pcVertex.position()), track.dxy(pcVertex.position())));
913  fillNoFlow(h_diffTrackDzAssocPV, diffRelative(trackPc.dz(pcVertex.position()), track.dz(pcVertex.position())));
914 
915  auto fillCov1 = [&](auto& hlp, const int i, const int j) {
916  return hlp.fill(trackPc.covariance(i, j), track.covariance(i, j));
917  };
918  auto fillCov2 = [&](auto& hlp, const int i, const int j, std::function<double(double)> modifyPack) {
919  return hlp.fill(trackPc.covariance(i, j), track.covariance(i, j), modifyPack);
920  };
921  auto fillCov3 = [&](auto& hlp,
922  const int i,
923  const int j,
924  std::function<double(double)> modifyPack,
925  std::function<double(double)> modifyUnpack) {
926  return hlp.fill(trackPc.covariance(i, j), track.covariance(i, j), modifyPack, modifyUnpack);
927  };
928 
929  const auto pcPt = pcRef->pt();
930  const auto diffCovQoverpQoverp = fillCov3(
931  h_diffCovQoverpQoverp,
932  reco::TrackBase::i_qoverp,
933  reco::TrackBase::i_qoverp,
934  [=](double val) { return val * pcPt * pcPt; },
935  [=](double val) { return val / pcPt / pcPt; });
936  const auto diffCovLambdaLambda =
937  fillCov1(h_diffCovLambdaLambda, reco::TrackBase::i_lambda, reco::TrackBase::i_lambda);
938  const auto diffCovLambdaDsz = fillCov1(h_diffCovLambdaDsz, reco::TrackBase::i_lambda, reco::TrackBase::i_dsz);
939  const auto diffCovPhiPhi = fillCov3(
940  h_diffCovPhiPhi,
941  reco::TrackBase::i_phi,
942  reco::TrackBase::i_phi,
943  [=](double val) { return val * pcPt * pcPt; },
944  [=](double val) { return val / pcPt / pcPt; });
945  const auto diffCovPhiDxy = fillCov1(h_diffCovPhiDxy, reco::TrackBase::i_phi, reco::TrackBase::i_dxy);
946  const auto diffCovDxyDxy = fillCov2(
947  h_diffCovDxyDxy, reco::TrackBase::i_dxy, reco::TrackBase::i_dxy, [](double value) { return value * 10000.; });
948  const auto diffCovDxyDsz = fillCov2(
949  h_diffCovDxyDsz, reco::TrackBase::i_dxy, reco::TrackBase::i_dsz, [](double value) { return value * 10000.; });
950  const auto diffCovDszDsz = fillCov2(
951  h_diffCovDszDsz, reco::TrackBase::i_dsz, reco::TrackBase::i_dsz, [](double value) { return value * 10000.; });
952 
953  if (isInRange(diffCovDszDsz.status())) {
954  fillNoFlow(h_diffDszError, diffRelative(pcRef->dzError(), track.dszError()));
955  fillNoFlow(h_diffDzError, diffRelative(pcRef->dzError(), track.dzError()));
956  fillNoFlow(h_diffTrackDzError, diffRelative(trackPc.dzError(), track.dzError()));
957  }
958  if (isInRange(diffCovDxyDxy.status())) {
959  fillNoFlow(h_diffDxyError, diffRelative(pcRef->dxyError(), track.dxyError()));
960  fillNoFlow(h_diffTrackDxyError, diffRelative(trackPc.dxyError(), track.dxyError()));
961  }
962  fillNoFlow(h_diffPtError, diffRelative(trackPc.ptError(), track.ptError()));
963  fillNoFlow(h_diffEtaError, diffRelative(trackPc.etaError(), track.etaError()));
964 
965  // For the non-HitPattern ones, take into account the PackedCandidate packing precision
966  const auto trackNumberOfHits = track.hitPattern().numberOfValidHits();
967  const auto trackNumberOfPixelHits = track.hitPattern().numberOfValidPixelHits();
968  const auto trackNumberOfStripHits = track.hitPattern().numberOfValidStripHits();
969  const auto pcNumberOfHits = pcRef->numberOfHits();
970  const auto pcNumberOfPixelHits = pcRef->numberOfPixelHits();
971  const auto pcNumberOfStripHits = pcNumberOfHits - pcNumberOfPixelHits;
972  const auto trackNumberOfLayers = track.hitPattern().trackerLayersWithMeasurement();
973  const auto trackNumberOfPixelLayers = track.hitPattern().pixelLayersWithMeasurement();
974  const auto trackNumberOfStripLayers = track.hitPattern().stripLayersWithMeasurement();
975  const auto pcNumberOfLayers = pcRef->trackerLayersWithMeasurement();
976  const auto pcNumberOfPixelLayers = pcRef->pixelLayersWithMeasurement();
977  const auto pcNumberOfStripLayers = pcRef->stripLayersWithMeasurement();
978 
979  // layer number overflow (should be zero)
980  const int pixelLayerOverflow = trackNumberOfPixelLayers > pat::PackedCandidate::trackPixelHitsMask
981  ? trackNumberOfPixelLayers - pat::PackedCandidate::trackPixelHitsMask
982  : 0;
983  const int stripLayerOverflow = trackNumberOfStripLayers > pat::PackedCandidate::trackStripHitsMask
984  ? trackNumberOfStripLayers - pat::PackedCandidate::trackStripHitsMask
985  : 0;
986  const int layerOverflow =
987  trackNumberOfLayers > (pat::PackedCandidate::trackPixelHitsMask + pat::PackedCandidate::trackStripHitsMask)
988  ? trackNumberOfLayers -
989  (pat::PackedCandidate::trackPixelHitsMask + pat::PackedCandidate::trackStripHitsMask)
990  : 0;
991 
992  // hit overflow (should also be zero)
993  const int pixelOverflow =
994  trackNumberOfPixelHits - pcNumberOfPixelLayers > pat::PackedCandidate::trackPixelHitsMask
995  ? trackNumberOfPixelHits - pcNumberOfPixelLayers - pat::PackedCandidate::trackPixelHitsMask
996  : 0;
997  const int stripOverflow =
998  trackNumberOfStripHits - pcNumberOfStripLayers > pat::PackedCandidate::trackStripHitsMask
999  ? trackNumberOfStripHits - pcNumberOfStripLayers - pat::PackedCandidate::trackStripHitsMask
1000  : 0;
1001  const int hitsOverflow =
1002  trackNumberOfHits - pcNumberOfLayers >
1003  (pat::PackedCandidate::trackPixelHitsMask + pat::PackedCandidate::trackStripHitsMask)
1004  ? trackNumberOfHits - pcNumberOfLayers -
1005  (pat::PackedCandidate::trackPixelHitsMask + pat::PackedCandidate::trackStripHitsMask)
1006  : 0;
1007  // PackedCandidate counts overflow pixel hits as strip
1008  const int pixelInducedStripOverflow =
1009  (trackNumberOfStripHits + pixelOverflow - pcNumberOfStripLayers) > pat::PackedCandidate::trackStripHitsMask
1010  ? (trackNumberOfStripHits + pixelOverflow - stripOverflow - pcNumberOfStripLayers) -
1011  pat::PackedCandidate::trackStripHitsMask
1012  : 0;
1013  h_numberPixelLayersOverMax->Fill(pixelLayerOverflow);
1014  h_numberStripLayersOverMax->Fill(stripLayerOverflow);
1015  h_numberLayersOverMax->Fill(layerOverflow);
1016  h_numberPixelHitsOverMax->Fill(pixelOverflow);
1017  h_numberStripHitsOverMax->Fill(stripOverflow);
1018  h_numberHitsOverMax->Fill(hitsOverflow);
1019 
1020  int diffNumberOfPixelHits = 0;
1021  int diffNumberOfHits = 0;
1022  int diffNumberOfPixelLayers = 0;
1023  int diffNumberOfStripLayers = 0;
1024  if (pixelLayerOverflow) {
1025  diffNumberOfPixelLayers = pcNumberOfPixelLayers - pat::PackedCandidate::trackPixelHitsMask;
1026  } else {
1027  diffNumberOfPixelLayers = pcNumberOfPixelLayers - trackNumberOfPixelLayers;
1028  }
1029  if (pixelOverflow) {
1030  diffNumberOfPixelHits = pcNumberOfPixelHits - pcNumberOfPixelLayers - pat::PackedCandidate::trackPixelHitsMask;
1031  } else {
1032  diffNumberOfPixelHits = pcNumberOfPixelHits - trackNumberOfPixelHits;
1033  }
1034  if (stripLayerOverflow) {
1035  diffNumberOfStripLayers = pcNumberOfStripLayers - pat::PackedCandidate::trackStripHitsMask;
1036  } else {
1037  diffNumberOfStripLayers = pcNumberOfStripLayers - trackNumberOfStripLayers;
1038  }
1039  if (stripOverflow || pixelInducedStripOverflow || pixelOverflow) {
1040  int diffNumberOfStripHits = 0;
1041  if (stripOverflow || pixelInducedStripOverflow) {
1042  diffNumberOfStripHits = pcNumberOfStripHits - pat::PackedCandidate::trackStripHitsMask;
1043  } else if (pixelOverflow) {
1044  diffNumberOfStripHits = (pcNumberOfStripHits - pixelOverflow) - trackNumberOfStripHits;
1045  }
1046 
1047  diffNumberOfHits = diffNumberOfPixelHits + diffNumberOfStripHits;
1048  } else {
1049  diffNumberOfHits = pcNumberOfHits - trackNumberOfHits;
1050  }
1051 
1052  fillNoFlow(h_diffNumberOfPixelHits, diffNumberOfPixelHits);
1053  fillNoFlow(h_diffNumberOfHits, diffNumberOfHits);
1054  fillNoFlow(h_diffNumberOfPixelLayers, diffNumberOfPixelLayers);
1055  fillNoFlow(h_diffNumberOfStripLayers, diffNumberOfStripLayers);
1056 
1057  int diffLostInnerHits = 0;
1058  const auto trackLostInnerHits = track.hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS);
1059  switch (pcRef->lostInnerHits()) {
1060  case pat::PackedCandidate::validHitInFirstPixelBarrelLayer:
1061  case pat::PackedCandidate::noLostInnerHits:
1062  diffLostInnerHits = -trackLostInnerHits;
1063  break;
1064  case pat::PackedCandidate::oneLostInnerHit:
1065  diffLostInnerHits = 1 - trackLostInnerHits;
1066  break;
1067  case pat::PackedCandidate::moreLostInnerHits:
1068  diffLostInnerHits = trackLostInnerHits >= 2 ? 0 : 2 - trackLostInnerHits;
1069  break;
1070  }
1071  fillNoFlow(h_diffLostInnerHits, diffLostInnerHits);
1072 
1073  // For HitPattern ones, calculate the full diff (i.e. some differences are expected)
1074  auto diffHitPatternPixelLayersWithMeasurement =
1075  trackPc.hitPattern().pixelLayersWithMeasurement() - trackNumberOfPixelLayers;
1076  fillNoFlow(h_diffHitPatternPixelLayersWithMeasurement, diffHitPatternPixelLayersWithMeasurement);
1077  auto diffHitPatternStripLayersWithMeasurement =
1078  trackPc.hitPattern().stripLayersWithMeasurement() - trackNumberOfStripLayers;
1079  fillNoFlow(h_diffHitPatternStripLayersWithMeasurement, diffHitPatternStripLayersWithMeasurement);
1080  auto diffHitPatternTrackerLayersWithMeasurement =
1081  trackPc.hitPattern().trackerLayersWithMeasurement() - trackNumberOfLayers;
1082  fillNoFlow(h_diffHitPatternTrackerLayersWithMeasurement, diffHitPatternTrackerLayersWithMeasurement);
1083  auto diffHitPatternNumberOfValidPixelHits = trackPc.hitPattern().numberOfValidPixelHits() - trackNumberOfPixelHits;
1084  fillNoFlow(h_diffHitPatternNumberOfValidPixelHits, diffHitPatternNumberOfValidPixelHits);
1085  auto diffHitPatternNumberOfValidHits = trackPc.hitPattern().numberOfValidHits() - trackNumberOfHits;
1086  fillNoFlow(h_diffHitPatternNumberOfValidHits, diffHitPatternNumberOfValidHits);
1087  fillNoFlow(h_diffHitPatternNumberOfLostInnerHits,
1088  trackPc.hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS) -
1089  track.hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS));
1090 
1091  // hasValidHitInFirstPixelBarrel is set only if numberOfLostHits(MISSING_INNER_HITS) == 0
1092  int diffHitPatternHasValidHitInFirstPixelBarrel = 0;
1093  if (track.hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS) == 0) {
1094  h_selectionFlow->Fill(sf_NoMissingInnerHits);
1095  diffHitPatternHasValidHitInFirstPixelBarrel =
1096  static_cast<int>(
1097  trackPc.hitPattern().hasValidHitInPixelLayer(PixelSubdetector::SubDetector::PixelBarrel, 1)) -
1098  static_cast<int>(track.hitPattern().hasValidHitInPixelLayer(PixelSubdetector::SubDetector::PixelBarrel, 1));
1099  fillNoFlow(h_diffHitPatternHasValidHitInFirstPixelBarrel, diffHitPatternHasValidHitInFirstPixelBarrel);
1100  }
1101 
1102  // Print warning if there are differences outside the expected range
1103  if (debug_ &&
1104  (diffNormalizedChi2 < -1 || diffNormalizedChi2 > 0 || diffCharge != 0 || diffHP != 0 ||
1105  std::abs(diffPhi) > 5e-4 || diffDxyAssocPV.outsideExpectedRange() || diffDzAssocPV.outsideExpectedRange() ||
1106  std::abs(diffDxyPV) > 0.05 || std::abs(diffDzPV) > 0.05 || diffCovQoverpQoverp.outsideExpectedRange() ||
1107  diffCovLambdaLambda.outsideExpectedRange() || diffCovLambdaDsz.outsideExpectedRange() ||
1108  diffCovPhiPhi.outsideExpectedRange() || diffCovPhiDxy.outsideExpectedRange() ||
1109  diffCovDxyDxy.outsideExpectedRange() || diffCovDxyDsz.outsideExpectedRange() ||
1110  diffCovDszDsz.outsideExpectedRange() || diffNumberOfPixelHits != 0 || diffNumberOfHits != 0 ||
1111  diffLostInnerHits != 0 || diffHitPatternHasValidHitInFirstPixelBarrel != 0)) {
1112  edm::LogInfo("PackedCandidateTrackValidator")
1113  << "Track " << i << " pt " << track.pt() << " eta " << track.eta() << " phi " << track.phi() << " chi2 "
1114  << track.chi2() << " ndof " << track.ndof() << "\n"
1115  << " ptError " << track.ptError() << " etaError " << track.etaError() << " phiError " << track.phiError()
1116  << " dxyError " << track.dxyError() << " dzError " << track.dzError() << "\n"
1117  << " refpoint " << track.referencePoint() << " momentum " << track.momentum() << "\n"
1118  << " dxy " << track.dxy() << " dz " << track.dz() << "\n"
1119  << " " << TrackAlgoPrinter(track) << " lost inner hits " << trackLostInnerHits << " lost outer hits "
1120  << track.hitPattern().numberOfLostHits(reco::HitPattern::MISSING_OUTER_HITS) << " hitpattern "
1121  << HitPatternPrinter(track) << " \n"
1122  << " PC " << pcRef.id() << ":" << pcRef.key() << " track pt " << trackPc.pt() << " eta " << trackPc.eta()
1123  << " phi " << trackPc.phi() << " (PC " << pcRef->phi() << ") chi2 " << trackPc.chi2() << " ndof "
1124  << trackPc.ndof() << " pdgId " << pcRef->pdgId() << " mass " << pcRef->mass() << "\n"
1125  << " ptError " << trackPc.ptError() << " etaError " << trackPc.etaError() << " phiError "
1126  << trackPc.phiError() << "\n"
1127  << " pc.vertex " << pcRef->vertex() << " momentum " << pcRef->momentum() << " track " << trackPc.momentum()
1128  << "\n"
1129  << " dxy " << trackPc.dxy() << " dz " << trackPc.dz() << " pc.dz " << pcRef->dz() << " dxyError "
1130  << trackPc.dxyError() << " dzError " << trackPc.dzError() << "\n"
1131  << " dxy(PV) " << trackPc.dxy(pv.position()) << " dz(PV) " << trackPc.dz(pv.position()) << " dxy(assocPV) "
1132  << trackPc.dxy(pcVertex.position()) << " dz(assocPV) " << trackPc.dz(pcVertex.position()) << "\n"
1133  << " (diff PackedCandidate track)"
1134  << " highPurity " << diffHP << " " << trackPc.quality(reco::TrackBase::highPurity) << " "
1135  << track.quality(reco::TrackBase::highPurity) << " charge " << diffCharge << " " << trackPc.charge() << " "
1136  << track.charge() << " normalizedChi2 " << diffNormalizedChi2 << " " << trackPc.normalizedChi2() << " "
1137  << track.normalizedChi2() << "\n "
1138  << " numberOfAllHits " << diffNumberOfHits << " " << pcNumberOfHits << " " << trackNumberOfHits
1139  << " numberOfPixelHits " << diffNumberOfPixelHits << " " << pcNumberOfPixelHits << " "
1140  << trackNumberOfPixelHits << " numberOfStripHits # " << pcNumberOfStripHits << " " << trackNumberOfStripHits
1141  << "\n "
1142  << " hitPattern.numberOfValidPixelHits " << diffHitPatternNumberOfValidPixelHits << " "
1143  << trackPc.hitPattern().numberOfValidPixelHits() << " " << track.hitPattern().numberOfValidPixelHits()
1144  << " hitPattern.numberOfValidHits " << diffHitPatternNumberOfValidHits << " "
1145  << trackPc.hitPattern().numberOfValidHits() << " " << track.hitPattern().numberOfValidHits()
1146  << " hitPattern.hasValidHitInFirstPixelBarrel " << diffHitPatternHasValidHitInFirstPixelBarrel << " "
1147  << trackPc.hitPattern().hasValidHitInPixelLayer(PixelSubdetector::SubDetector::PixelBarrel, 1) << " "
1148  << track.hitPattern().hasValidHitInPixelLayer(PixelSubdetector::SubDetector::PixelBarrel, 1) << "\n "
1149  << " lostInnerHits " << diffLostInnerHits << " " << pcRef->lostInnerHits() << " #"
1150  << " phi (5e-4) " << diffPhi << " " << trackPc.phi() << " " << track.phi() << "\n "
1151  << " dxy(assocPV) " << diffDxyAssocPV << "\n "
1152  << " dz(assocPV) " << diffDzAssocPV << "\n "
1153  << " dxy(PV) (0.05) " << diffDxyPV << " " << pcRef->dxy(pv.position()) << " " << track.dxy(pv.position())
1154  << "\n "
1155  << " dz(PV) (0.05) " << diffDzPV << " " << pcRef->dz(pv.position()) << " " << track.dz(pv.position()) << "\n "
1156  << " cov(qoverp, qoverp) " << diffCovQoverpQoverp << "\n "
1157  << " cov(lambda, lambda) " << diffCovLambdaLambda << "\n "
1158  << " cov(lambda, dsz) " << diffCovLambdaDsz << "\n "
1159  << " cov(phi, phi) " << diffCovPhiPhi << "\n "
1160  << " cov(phi, dxy) " << diffCovPhiDxy << "\n "
1161  << " cov(dxy, dxy) " << diffCovDxyDxy << "\n "
1162  << " cov(dxy, dsz) " << diffCovDxyDsz << "\n "
1163  << " cov(dsz, dsz) " << diffCovDszDsz;
1164  }
1165  }
1166 }
1167 
1168 #include "FWCore/Framework/interface/MakerMacros.h"
1169 DEFINE_FWK_MODULE(PackedCandidateTrackValidator);
ConfigurationDescriptions.h
PackedCandidateTrackValidator::h_diffCovLambdaDsz
PackedValueCheck< LogIntHelper > h_diffCovLambdaDsz
Definition: PackedCandidateTrackValidator.cc:454
writedatasetfile.args
args
Definition: writedatasetfile.py:18
change_name.diff
diff
Definition: change_name.py:13
PackedCandidateTrackValidator::PackedCandidateTrackValidator
PackedCandidateTrackValidator(const edm::ParameterSet &pset)
Definition: PackedCandidateTrackValidator.cc:493
reco::HitPattern::MISSING_OUTER_HITS
Definition: HitPattern.h:155
PackedCandidateTrackValidator::h_diffNumberOfPixelLayers
MonitorElement * h_diffNumberOfPixelLayers
Definition: PackedCandidateTrackValidator.cc:471
FastTimerService_cff.range
range
Definition: FastTimerService_cff.py:34
PackedCandidateTrackValidator::h_diffDxyAssocPV
PackedValueCheck< Float16Helper > h_diffDxyAssocPV
Definition: PackedCandidateTrackValidator.cc:444
PDWG_EXOHSCP_cff.tracks
tracks
Definition: PDWG_EXOHSCP_cff.py:28
logintpack::smallestNegative
constexpr int8_t smallestNegative
Definition: liblogintpack.h:11
PackedCandidateTrackValidator::h_diffNumberOfStripLayers
MonitorElement * h_diffNumberOfStripLayers
Definition: PackedCandidateTrackValidator.cc:472
electrons_cff.bool
bool
Definition: electrons_cff.py:372
mps_fire.i
i
Definition: mps_fire.py:355
reco::TrackBase::ptError
double ptError() const
error on Pt (set to 1000 TeV if charge==0 for safety)
Definition: TrackBase.h:702
MessageLogger.h
PackedCandidateTrackValidator::h_diffTrackDxyError
MonitorElement * h_diffTrackDxyError
Definition: PackedCandidateTrackValidator.cc:465
logintpack::unpack8log
double unpack8log(int8_t i, double lmin, double lmax, uint8_t base=128)
Definition: liblogintpack.h:136
ESHandle.h
PackedCandidateTrackValidator::h_numberHitsOverMax
MonitorElement * h_numberHitsOverMax
Definition: PackedCandidateTrackValidator.cc:490
reco::TrackBase::etaError
double etaError() const
error on eta
Definition: TrackBase.h:716
PackedCandidateTrackValidator::h_diffNormalizedChi2
MonitorElement * h_diffNormalizedChi2
Definition: PackedCandidateTrackValidator.cc:435
Range
PixelRecoRange< float > Range
Definition: PixelTripletHLTGenerator.cc:31
sistrip::View
View
Definition: ConstantsForView.h:26
edm::isNotFinite
constexpr bool isNotFinite(T x)
Definition: isFinite.h:9
PackedCandidateTrackValidator::h_diffEtaError
MonitorElement * h_diffEtaError
Definition: PackedCandidateTrackValidator.cc:469
PackedCandidateTrackValidator::h_numberPixelHitsOverMax
MonitorElement * h_numberPixelHitsOverMax
Definition: PackedCandidateTrackValidator.cc:488
PackedCandidateTrackValidator::fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
Definition: PackedCandidateTrackValidator.cc:514
mps_update.status
status
Definition: mps_update.py:69
edm::Run
Definition: Run.h:45
min
T min(T a, T b)
Definition: MathUtil.h:58
reco::deltaPhi
constexpr double deltaPhi(double phi1, double phi2)
Definition: deltaPhi.h:26
pat::PackedCandidate::oneLostInnerHit
Definition: PackedCandidate.h:802
PackedCandidateTrackValidator::h_diffVz
MonitorElement * h_diffVz
Definition: PackedCandidateTrackValidator.cc:433
edm::EDGetTokenT
Definition: EDGetToken.h:33
edm::Ref::isNull
bool isNull() const
Checks for null.
Definition: Ref.h:235
edm
HLT enums.
Definition: AlignableModifier.h:19
AlCaHLTBitMon_ParallelJobs.p
p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
PackedCandidateTrackValidator::trackToPackedCandidateToken_
edm::EDGetTokenT< edm::Association< pat::PackedCandidateCollection > > trackToPackedCandidateToken_
Definition: PackedCandidateTrackValidator.cc:414
reco::VertexCollection
std::vector< Vertex > VertexCollection
collection of Vertex objects
Definition: VertexFwd.h:9
edm::LogInfo
Definition: MessageLogger.h:254
liblogintpack.h
edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52
pat::PackedCandidate::moreLostInnerHits
Definition: PackedCandidate.h:803
dqm::implementation::NavigatorBase::setCurrentFolder
virtual void setCurrentFolder(std::string const &fullpath)
Definition: DQMStore.cc:32
reco::TrackBase::vx
double vx() const
x coordinate of the reference point on track
Definition: TrackBase.h:626
PackedCandidateTrackValidator::sf_AssociatedToPC
Definition: PackedCandidateTrackValidator.cc:421
PackedCandidateTrackValidator::h_diffCovLambdaLambda
PackedValueCheck< LogIntHelper > h_diffCovLambdaLambda
Definition: PackedCandidateTrackValidator.cc:453
Validation_hcalonly_cfi.sign
sign
Definition: Validation_hcalonly_cfi.py:32
DQMStore.h
PackedCandidateTrackValidator::h_diffVy
MonitorElement * h_diffVy
Definition: PackedCandidateTrackValidator.cc:432
reco::Vertex::position
const Point & position() const
position
Definition: Vertex.h:114
dqm::legacy::MonitorElement
Definition: MonitorElement.h:461
PackedCandidateTrackValidator::sf_PCIsCharged
Definition: PackedCandidateTrackValidator.cc:422
PackedCandidateTrackValidator
Definition: PackedCandidateTrackValidator.cc:401
reco::TrackBase::i_lambda
Definition: TrackBase.h:83
reco::TrackBase::ndof
double ndof() const
number of degrees of freedom of the fit
Definition: TrackBase.h:575
pat::PackedCandidate::trackPixelHitsMask
Definition: PackedCandidate.h:620
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:45
reco::TrackBase::i_dxy
Definition: TrackBase.h:83
Association.h
dqm::reco::MonitorElement
dqm::impl::MonitorElement MonitorElement
Definition: MonitorElement.h:458
createJobs.tmp
tmp
align.sh
Definition: createJobs.py:716
reco::HitPattern::numberOfLostHits
int numberOfLostHits(HitCategory category) const
Definition: HitPattern.h:860
PackedCandidateTrackValidator::sf_PCNdofNot0
Definition: PackedCandidateTrackValidator.cc:426
PackedCandidateTrackValidator::h_diffPhi
MonitorElement * h_diffPhi
Definition: PackedCandidateTrackValidator.cc:443
edm::Handle
Definition: AssociativeIterator.h:50
PackedCandidateTrackValidator::sf_PCHasHits
Definition: PackedCandidateTrackValidator.cc:425
reco::TrackBase::dxyError
double dxyError() const
error on dxy
Definition: TrackBase.h:722
PackedCandidateTrackValidator::~PackedCandidateTrackValidator
~PackedCandidateTrackValidator() override
Definition: PackedCandidateTrackValidator.cc:512
PackedCandidateTrackValidator::h_diffTrackDzError
MonitorElement * h_diffTrackDzError
Definition: PackedCandidateTrackValidator.cc:466
reco::HitPattern::pixelLayersWithMeasurement
int pixelLayersWithMeasurement() const
Definition: HitPattern.cc:492
edm::Ref< pat::PackedCandidateCollection >
PackedCandidateTrackValidator::sf_PCHasTrack
Definition: PackedCandidateTrackValidator.cc:423
PackedCandidateTrackValidator::h_diffLostInnerHits
MonitorElement * h_diffLostInnerHits
Definition: PackedCandidateTrackValidator.cc:475
PackedCandidateTrackValidator::h_selectionFlow
MonitorElement * h_selectionFlow
Definition: PackedCandidateTrackValidator.cc:429
pat::PackedCandidate::validHitInFirstPixelBarrelLayer
Definition: PackedCandidate.h:799
reco::TrackBase::pt
double pt() const
track transverse momentum
Definition: TrackBase.h:608
cmsdt::algo
algo
Definition: constants.h:164
GeomDetEnumerators::PixelBarrel
Definition: GeomDetEnumerators.h:11
PackedCandidateTrackValidator::h_diffCharge
MonitorElement * h_diffCharge
Definition: PackedCandidateTrackValidator.cc:438
MakerMacros.h
TrackerTopology.h
reco::HitPattern
Definition: HitPattern.h:147
reco::HitPattern::stripLayersWithMeasurement
int stripLayersWithMeasurement() const
Definition: HitPattern.h:974
TrackerTopologyRcd.h
Track.h
libminifloat.h
dqm::reco::DQMStore
dqm::legacy::DQMStore DQMStore
Definition: DQMStore.h:736
PackedCandidateTrackValidator::h_diffTrackDxyAssocPV
MonitorElement * h_diffTrackDxyAssocPV
Definition: PackedCandidateTrackValidator.cc:449
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
jets_cff.algos
algos
Definition: jets_cff.py:644
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
reco::HitPattern::trackerLayersWithMeasurement
int trackerLayersWithMeasurement() const
Definition: HitPattern.cc:513
reco::TrackBase::vz
double vz() const
z coordinate of the reference point on track
Definition: TrackBase.h:632
PackedCandidateTrackValidator::h_diffCovDxyDxy
PackedValueCheck< Float16Helper > h_diffCovDxyDxy
Definition: PackedCandidateTrackValidator.cc:457
PackedCandidateTrackValidator::h_diffHitPatternTrackerLayersWithMeasurement
MonitorElement * h_diffHitPatternTrackerLayersWithMeasurement
Definition: PackedCandidateTrackValidator.cc:478
PackedCandidateTrackValidator::h_diffCovPhiPhi
PackedValueCheck< LogIntHelper > h_diffCovPhiPhi
Definition: PackedCandidateTrackValidator.cc:455
dqm::impl::MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:290
PackedCandidateTrackValidator::h_numberStripHitsOverMax
MonitorElement * h_numberStripHitsOverMax
Definition: PackedCandidateTrackValidator.cc:489
reco::Track
Definition: Track.h:27
reco::TrackBase::i_dsz
Definition: TrackBase.h:83
PackedCandidateTrackValidator::h_numberLayersOverMax
MonitorElement * h_numberLayersOverMax
Definition: PackedCandidateTrackValidator.cc:487
PackedCandidateTrackValidator::h_diffNumberOfPixelHits
MonitorElement * h_diffNumberOfPixelHits
Definition: PackedCandidateTrackValidator.cc:473
LaserClient_cfi.nbins
nbins
Definition: LaserClient_cfi.py:51
reco::HitPattern::hasValidHitInPixelLayer
bool hasValidHitInPixelLayer(enum PixelSubdetector::SubDetector, uint16_t layer) const
Definition: HitPattern.cc:337
reco::TrackBase::algoName
std::string algoName() const
Definition: TrackBase.h:535
reco::TrackBase::charge
int charge() const
track electric charge
Definition: TrackBase.h:581
reco::TrackBase::dz
double dz() const
dz parameter (= dsz/cos(lambda)). This is the track z0 w.r.t (0,0,0) only if the refPoint is close to...
Definition: TrackBase.h:602
h
reco::TrackBase::covariance
CovarianceMatrix covariance() const
return track covariance matrix
Definition: TrackBase.h:683
ParameterSetDescription.h
b
double b
Definition: hdecay.h:118
reco::TrackBase::phi
double phi() const
azimuthal angle of momentum vector
Definition: TrackBase.h:620
PackedCandidateTrackValidator::debug_
bool debug_
Definition: PackedCandidateTrackValidator.cc:417
PackedCandidateTrackValidator::h_diffCovPhiDxy
PackedValueCheck< LogIntHelper > h_diffCovPhiDxy
Definition: PackedCandidateTrackValidator.cc:456
DQMEDAnalyzer.h
edm::ConfigurationDescriptions
Definition: ConfigurationDescriptions.h:28
pat::PackedCandidate::noLostInnerHits
Definition: PackedCandidate.h:800
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
Vertex.h
PackedCandidateTrackValidator::h_diffDzError
MonitorElement * h_diffDzError
Definition: PackedCandidateTrackValidator.cc:463
DQMEDAnalyzer
Definition: DQMEDAnalyzer.py:1
PackedCandidateTrackValidator::h_diffDzPV
MonitorElement * h_diffDzPV
Definition: PackedCandidateTrackValidator.cc:447
ntuplemaker.fill
fill
Definition: ntuplemaker.py:304
edm::ParameterSetDescription::addUntracked
ParameterDescriptionBase * addUntracked(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:100
edm::VecArray
Definition: VecArray.h:28
PackedCandidateTrackValidator::h_diffDxyPV
MonitorElement * h_diffDxyPV
Definition: PackedCandidateTrackValidator.cc:446
reco::TrackBase::i_qoverp
Definition: TrackBase.h:83
HLT_2018_cff.InputTag
InputTag
Definition: HLT_2018_cff.py:79016
edm::ParameterSet
Definition: ParameterSet.h:36
PackedCandidateTrackValidator::h_diffDszError
MonitorElement * h_diffDszError
Definition: PackedCandidateTrackValidator.cc:462
a
double a
Definition: hdecay.h:119
Event.h
operator<<
std::ostream & operator<<(std::ostream &out, const ALILine &li)
Definition: ALILine.cc:167
SiStripPI::max
Definition: SiStripPayloadInspectorHelper.h:169
MiniFloatConverter::max32RoundedToMax16
static float max32RoundedToMax16()
Definition: libminifloat.h:126
PackedCandidate.h
PackedCandidateTrackValidator::sf_AllTracks
Definition: PackedCandidateTrackValidator.cc:420
reco::TrackBase::eta
double eta() const
pseudorapidity of momentum vector
Definition: TrackBase.h:623
reco::TrackBase::dzError
double dzError() const
error on dz
Definition: TrackBase.h:731
MetAnalyzer.pv
def pv(vc)
Definition: MetAnalyzer.py:7
iEvent
int iEvent
Definition: GenABIO.cc:224
reco::TrackBase::i_phi
Definition: TrackBase.h:83
value
Definition: value.py:1
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:771
PackedCandidateTrackValidator::verticesToken_
edm::EDGetTokenT< reco::VertexCollection > verticesToken_
Definition: PackedCandidateTrackValidator.cc:413
logintpack::smallestPositive
constexpr int8_t smallestPositive
Definition: liblogintpack.h:8
RangeStatus
RangeStatus
Definition: PackedCandidateTrackValidator.cc:233
PackedCandidateTrackValidator::h_diffHitPatternHasValidHitInFirstPixelBarrel
MonitorElement * h_diffHitPatternHasValidHitInFirstPixelBarrel
Definition: PackedCandidateTrackValidator.cc:483
edm::EventSetup
Definition: EventSetup.h:57
pat
Definition: HeavyIon.h:7
reco::TrackBase::chi2
double chi2() const
chi-squared of the fit
Definition: TrackBase.h:572
reco::TrackBase::normalizedChi2
double normalizedChi2() const
chi-squared divided by n.d.o.f. (or chi-squared * 1e6 if n.d.o.f. is zero)
Definition: TrackBase.h:578
PackedCandidateTrackValidator::h_diffHitPatternPixelLayersWithMeasurement
MonitorElement * h_diffHitPatternPixelLayersWithMeasurement
Definition: PackedCandidateTrackValidator.cc:477
PackedCandidateTrackValidator::h_diffTrackDzAssocPV
MonitorElement * h_diffTrackDzAssocPV
Definition: PackedCandidateTrackValidator.cc:450
PackedCandidateTrackValidator::h_diffHitPatternNumberOfLostInnerHits
MonitorElement * h_diffHitPatternNumberOfLostInnerHits
Definition: PackedCandidateTrackValidator.cc:482
res
Definition: Electron.h:6
PackedCandidateTrackValidator::h_diffDxyError
MonitorElement * h_diffDxyError
Definition: PackedCandidateTrackValidator.cc:461
edm::print
S & print(S &os, JobReport::InputFile const &f)
Definition: JobReport.cc:66
PackedCandidateTrackValidator::bookHistograms
void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
Definition: PackedCandidateTrackValidator.cc:526
reco::HitPattern::TRACK_HITS
Definition: HitPattern.h:155
pat::PackedCandidateCollection
std::vector< pat::PackedCandidate > PackedCandidateCollection
Definition: PackedCandidate.h:1130
overlapproblemtsosanalyzer_cfi.title
title
Definition: overlapproblemtsosanalyzer_cfi.py:7
PackedCandidateTrackValidator::h_diffVx
MonitorElement * h_diffVx
Definition: PackedCandidateTrackValidator.cc:431
VertexFwd.h
PackedCandidateTrackValidator::h_diffIsHighPurity
MonitorElement * h_diffIsHighPurity
Definition: PackedCandidateTrackValidator.cc:439
reco::TrackBase::hitPattern
const HitPattern & hitPattern() const
Access the hit pattern, indicating in which Tracker layers the track has hits.
Definition: TrackBase.h:489
edm::Ref::id
ProductID id() const
Accessor for product ID.
Definition: Ref.h:244
heppy_batch.val
val
Definition: heppy_batch.py:351
std
Definition: JetResolutionObject.h:76
PackedCandidateTrackValidator::h_diffEta
MonitorElement * h_diffEta
Definition: PackedCandidateTrackValidator.cc:442
PackedCandidateTrackValidator::h_diffPtError
MonitorElement * h_diffPtError
Definition: PackedCandidateTrackValidator.cc:468
reco::TrackBase::vy
double vy() const
y coordinate of the reference point on track
Definition: TrackBase.h:629
PackedCandidateTrackValidator::h_diffHitPatternNumberOfValidHits
MonitorElement * h_diffHitPatternNumberOfValidHits
Definition: PackedCandidateTrackValidator.cc:481
isFinite.h
PackedCandidateTrackValidator::analyze
void analyze(const edm::Event &, const edm::EventSetup &) override
Definition: PackedCandidateTrackValidator.cc:819
reco::TrackBase::algoSize
Definition: TrackBase.h:141
T
long double T
Definition: Basic3DVectorLD.h:48
PackedCandidateTrackValidator::h_diffCovDszDsz
PackedValueCheck< Float16Helper > h_diffCovDszDsz
Definition: PackedCandidateTrackValidator.cc:459
PackedCandidateTrackValidator::h_diffPt
MonitorElement * h_diffPt
Definition: PackedCandidateTrackValidator.cc:441
PackedCandidateTrackValidator::h_diffNumberOfHits
MonitorElement * h_diffNumberOfHits
Definition: PackedCandidateTrackValidator.cc:474
reco::HitPattern::MISSING_INNER_HITS
Definition: HitPattern.h:155
PackedCandidateTrackValidator::h_diffNdof
MonitorElement * h_diffNdof
Definition: PackedCandidateTrackValidator.cc:436
HiBiasedCentrality_cfi.function
function
Definition: HiBiasedCentrality_cfi.py:4
Skims_PA_cff.name
name
Definition: Skims_PA_cff.py:17
VecArray.h
dqm::implementation::IBooker
Definition: DQMStore.h:43
reco::HitPattern::numberOfValidPixelHits
int numberOfValidPixelHits() const
Definition: HitPattern.h:800
reco::TrackBase::phiError
double phiError() const
error on phi
Definition: TrackBase.h:719
edm::Ref::key
key_type key() const
Accessor for product key.
Definition: Ref.h:250
HLT_2018_cff.track
track
Definition: HLT_2018_cff.py:10352
PackedCandidateTrackValidator::sf_NoMissingInnerHits
Definition: PackedCandidateTrackValidator.cc:427
MiniFloatConverter::min
static float min()
Definition: libminifloat.h:137
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
LaserClient_cfi.xaxis
xaxis
Definition: LaserClient_cfi.py:49
ParameterSet.h
PackedCandidateTrackValidator::h_diffHitPatternNumberOfValidPixelHits
MonitorElement * h_diffHitPatternNumberOfValidPixelHits
Definition: PackedCandidateTrackValidator.cc:480
dqmiolumiharvest.j
j
Definition: dqmiolumiharvest.py:66
reco::TrackBase::momentum
const Vector & momentum() const
track momentum vector
Definition: TrackBase.h:635
hlt_dqm_clientPB-live_cfg.me
me
Definition: hlt_dqm_clientPB-live_cfg.py:61
reco::HitPattern::numberOfValidHits
int numberOfValidHits() const
Definition: HitPattern.h:786
MiniFloatConverter::denorm_min
static float denorm_min()
Definition: libminifloat.h:158
PackedCandidateTrackValidator::h_numberPixelLayersOverMax
MonitorElement * h_numberPixelLayersOverMax
Definition: PackedCandidateTrackValidator.cc:485
edm::Event
Definition: Event.h:73
PackedCandidateTrackValidator::sf_PCIsNotElectron
Definition: PackedCandidateTrackValidator.cc:424
PackedCandidateTrackValidator::h_diffDzAssocPV
PackedValueCheck< Float16Helper > h_diffDzAssocPV
Definition: PackedCandidateTrackValidator.cc:445
PackedCandidateTrackValidator::h_diffHitPatternStripLayersWithMeasurement
MonitorElement * h_diffHitPatternStripLayersWithMeasurement
Definition: PackedCandidateTrackValidator.cc:479
dttmaxenums::R
Definition: DTTMax.h:29
reco::TrackBase::dxy
double dxy() const
dxy parameter. (This is the transverse impact parameter w.r.t. to (0,0,0) ONLY if refPoint is close t...
Definition: TrackBase.h:593
reco::TrackBase::quality
bool quality(const TrackQuality) const
Track quality.
Definition: TrackBase.h:537
edm::InputTag
Definition: InputTag.h:15
reco::Vertex
Definition: Vertex.h:35
deltaPhi.h
hit
Definition: SiStripHitEffFromCalibTree.cc:88
muonDTDigis_cfi.pset
pset
Definition: muonDTDigis_cfi.py:27
PackedCandidateTrackValidator::h_diffCovQoverpQoverp
PackedValueCheck< LogIntHelper > h_diffCovQoverpQoverp
Definition: PackedCandidateTrackValidator.cc:452
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
PackedCandidateTrackValidator::tracksToken_
edm::EDGetTokenT< edm::View< reco::Track > > tracksToken_
Definition: PackedCandidateTrackValidator.cc:412
pwdgSkimBPark_cfi.vertices
vertices
Definition: pwdgSkimBPark_cfi.py:7
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
PackedCandidateTrackValidator::h_diffCovDxyDsz
PackedValueCheck< Float16Helper > h_diffCovDxyDsz
Definition: PackedCandidateTrackValidator.cc:458
PackedCandidateTrackValidator::rootFolder_
std::string rootFolder_
Definition: PackedCandidateTrackValidator.cc:416
PackedCandidateTrackValidator::h_numberStripLayersOverMax
MonitorElement * h_numberStripLayersOverMax
Definition: PackedCandidateTrackValidator.cc:486
reco::TrackBase::highPurity
Definition: TrackBase.h:154
pat::PackedCandidate::trackStripHitsMask
Definition: PackedCandidate.h:620
Generated for CMSSW Reference Manual by doxygen 1.8.16