CMS 3D CMS Logo
DMRChecker.cc
Go to the documentation of this file.
1 // -*- C++ -*-
2 //
3 // Package: Alignment/OfflineValidation
4 // Class: DMRChecker
5 //
9 //
10 // Original Author: Marco Musich
11 // Created: Mon, 10 Aug 2020 15:45:00 GMT
12 //
13 //
14 
15 // ROOT includes
16 
17 #include "RtypesCore.h"
18 #include "TAxis.h"
19 #include "TCanvas.h"
20 #include "TColor.h"
21 #include "TH1.h"
22 #include "TH2.h"
23 #include "TLatex.h"
24 #include "TMath.h"
25 #include "TProfile.h"
26 #include "TString.h"
27 #include "TStyle.h"
28 #include "TVirtualPad.h"
29 
30 // STL includes
31 
32 #include <algorithm>
33 #include <array>
34 #include <cmath>
35 #include <cstdint>
36 #include <cstdlib>
37 #include <ctime>
38 #include <ext/alloc_traits.h>
39 #include <fmt/printf.h>
40 #include <iomanip>
41 #include <iostream>
42 #include <map>
43 #include <memory>
44 #include <string>
45 #include <type_traits>
46 #include <utility>
47 #include <vector>
48 #include "boost/range/adaptor/indexed.hpp"
49 
50 // user system includes
51 
52 #include "CalibTracker/StandaloneTrackerTopology/interface/StandaloneTrackerTopology.h"
53 #include "CommonTools/TrackerMap/interface/TrackerMap.h"
54 #include "CommonTools/UtilAlgos/interface/TFileService.h"
55 #include "CommonTools/Utils/interface/TFileDirectory.h"
56 #include "DQM/TrackerRemapper/interface/Phase1PixelMaps.h"
57 #include "DQM/TrackerRemapper/interface/Phase1PixelSummaryMap.h"
58 #include "CondCore/SiPixelPlugins/interface/PixelRegionContainers.h"
59 #include "CondCore/SiPixelPlugins/interface/SiPixelPayloadInspectorHelper.h"
60 #include "CondFormats/DataRecord/interface/RunSummaryRcd.h"
61 #include "CondFormats/DataRecord/interface/SiStripCondDataRecords.h"
62 #include "CondFormats/RunInfo/interface/RunInfo.h"
63 #include "CondFormats/SiStripObjects/interface/SiStripLatency.h"
64 #include "DataFormats/BeamSpot/interface/BeamSpot.h"
65 #include "DataFormats/Common/interface/Handle.h"
66 #include "DataFormats/Common/interface/RefTraits.h"
67 #include "DataFormats/Common/interface/TriggerResults.h"
68 #include "DataFormats/DetId/interface/DetId.h"
69 #include "DataFormats/GeometrySurface/interface/Plane.h"
70 #include "DataFormats/GeometryVector/interface/GlobalPoint.h"
71 #include "DataFormats/GeometryVector/interface/GlobalVector.h"
72 #include "DataFormats/GeometryVector/interface/LocalPoint.h"
73 #include "DataFormats/GeometryVector/interface/Phi.h"
74 #include "DataFormats/GeometryVector/interface/Theta.h"
75 #include "DataFormats/Math/interface/Point3D.h"
76 #include "DataFormats/Math/interface/deltaPhi.h"
77 #include "DataFormats/Provenance/interface/RunLumiEventNumber.h"
78 #include "DataFormats/SiPixelDetId/interface/PixelSubdetector.h"
79 #include "DataFormats/SiStripDetId/interface/SiStripDetId.h"
80 #include "DataFormats/SiStripDetId/interface/StripSubdetector.h"
81 #include "DataFormats/TrackReco/interface/HitPattern.h"
82 #include "DataFormats/TrackReco/interface/Track.h"
83 #include "DataFormats/TrackReco/interface/TrackBase.h"
84 #include "DataFormats/TrackReco/interface/TrackExtraFwd.h"
85 #include "DataFormats/TrackReco/interface/TrackFwd.h"
86 #include "DataFormats/TrackReco/interface/TrackResiduals.h"
87 #include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
88 #include "DataFormats/TrackerRecHit2D/interface/ProjectedSiStripRecHit2D.h"
89 #include "DataFormats/TrackerRecHit2D/interface/SiPixelRecHit.h"
90 #include "DataFormats/TrackerRecHit2D/interface/SiStripMatchedRecHit2D.h"
91 #include "DataFormats/TrackerRecHit2D/interface/SiStripRecHit1D.h"
92 #include "DataFormats/TrackerRecHit2D/interface/SiStripRecHit2D.h"
93 #include "DataFormats/TrackingRecHit/interface/TrackingRecHit.h"
94 #include "DataFormats/TrackingRecHit/interface/TrackingRecHitFwd.h"
95 #include "DataFormats/VertexReco/interface/Vertex.h"
96 #include "DataFormats/VertexReco/interface/VertexFwd.h"
97 #include "FWCore/Common/interface/TriggerNames.h"
98 #include "FWCore/Framework/interface/Event.h"
99 #include "FWCore/Framework/interface/EventSetup.h"
100 #include "FWCore/Framework/interface/MakerMacros.h"
101 #include "FWCore/Framework/interface/one/EDAnalyzer.h"
102 #include "FWCore/MessageLogger/interface/ErrorObj.h"
103 #include "FWCore/MessageLogger/interface/MessageLogger.h"
104 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
105 #include "FWCore/ParameterSet/interface/ParameterSet.h"
106 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
107 #include "FWCore/ParameterSet/interface/ParameterSetDescriptionFiller.h"
108 #include "FWCore/ServiceRegistry/interface/Service.h"
109 #include "FWCore/Utilities/interface/EDGetToken.h"
110 #include "FWCore/Utilities/interface/ESGetToken.h"
111 #include "FWCore/Utilities/interface/InputTag.h"
112 #include "Geometry/CommonTopologies/interface/GeomDet.h"
113 #include "Geometry/CommonTopologies/interface/TrackerGeomDet.h"
114 #include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"
115 #include "Geometry/Records/interface/TrackerTopologyRcd.h"
116 #include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
117 #include "MagneticField/Engine/interface/MagneticField.h"
118 #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
119 
120 #define DEBUG 0
121 
122 using namespace std;
123 using namespace edm;
124 
125 const int kBPIX = PixelSubdetector::PixelBarrel;
126 const int kFPIX = PixelSubdetector::PixelEndcap;
127 constexpr float cmToUm = 10000.;
128 
134 namespace running {
135  struct Estimators {
136  int rDirection;
137  int zDirection;
138  int rOrZDirection;
139  int hitCount;
140  float runningMeanOfRes_;
141  float runningVarOfRes_;
142  float runningNormMeanOfRes_;
143  float runningNormVarOfRes_;
144  };
145 
146  using estimatorMap = std::map<uint32_t, running::Estimators>;
147 
148 } // namespace running
149 
150 class DMRChecker : public edm::one::EDAnalyzer<edm::one::WatchRuns, edm::one::SharedResources> {
151 public:
152  DMRChecker(const edm::ParameterSet &pset)
153  : geomToken_(esConsumes<edm::Transition::BeginRun>()),
154  runInfoToken_(esConsumes<edm::Transition::BeginRun>()),
155  magFieldToken_(esConsumes<edm::Transition::BeginRun>()),
156  topoToken_(esConsumes<edm::Transition::BeginRun>()),
157  latencyToken_(esConsumes<edm::Transition::BeginRun>()),
158  isCosmics_(pset.getParameter<bool>("isCosmics")) {
159  usesResource(TFileService::kSharedResource);
160 
161  TkTag_ = pset.getParameter<edm::InputTag>("TkTag");
162  theTrackCollectionToken_ = consumes<reco::TrackCollection>(TkTag_);
163 
164  TriggerResultsTag_ = pset.getParameter<edm::InputTag>("TriggerResultsTag");
165  hltresultsToken_ = consumes<edm::TriggerResults>(TriggerResultsTag_);
166 
167  BeamSpotTag_ = pset.getParameter<edm::InputTag>("BeamSpotTag");
168  beamspotToken_ = consumes<reco::BeamSpot>(BeamSpotTag_);
169 
170  VerticesTag_ = pset.getParameter<edm::InputTag>("VerticesTag");
171  vertexToken_ = consumes<reco::VertexCollection>(VerticesTag_);
172 
173  // initialize conventional Tracker maps
174 
175  pmap = std::make_unique<TrackerMap>("Pixel");
176  pmap->onlyPixel(true);
177  pmap->setTitle("Pixel Hit entries");
178  pmap->setPalette(1);
179 
180  tmap = std::make_unique<TrackerMap>("Strip");
181  tmap->setTitle("Strip Hit entries");
182  tmap->setPalette(1);
183 
184  // initialize Phase1 Pixel Maps
185 
186  pixelmap = std::make_unique<Phase1PixelMaps>("COLZ0 L");
187  pixelmap->bookBarrelHistograms("DMRsX", "Median Residuals x-direction", "Median Residuals");
188  pixelmap->bookForwardHistograms("DMRsX", "Median Residuals x-direction", "Median Residuals");
189 
190  pixelmap->bookBarrelHistograms("DMRsY", "Median Residuals y-direction", "Median Residuals");
191  pixelmap->bookForwardHistograms("DMRsY", "Median Residuals y-direction", "Median Residuals");
192 
193  // set no rescale
194  pixelmap->setNoRescale();
195 
196  // initialize Full Pixel Map
197  fullPixelmapXDMR = std::make_unique<Phase1PixelSummaryMap>("", "DMR-x", "median of residuals [#mum]");
198  fullPixelmapYDMR = std::make_unique<Phase1PixelSummaryMap>("", "DMR-y", "median of residuals [#mum]");
199  }
200 
201  static void fillDescriptions(edm::ConfigurationDescriptions &);
202 
203  ~DMRChecker() override = default;
204 
205  /*_______________________________________________________
206  //
207  // auxilliary method to retrieve certain histogram types
208  //_______________________________________________________
209  */
210  template <class OBJECT_TYPE>
211  int index(const std::vector<OBJECT_TYPE *> &vec, const std::string &name) {
212  for (const auto &iter : vec | boost::adaptors::indexed(0)) {
213  if (iter.value() && iter.value()->GetName() == name) {
214  return iter.index();
215  }
216  }
217  edm::LogError("Alignment") << "@SUB=DMRChecker::index"
218  << " could not find " << name;
219  return -1;
220  }
221 
222  template <typename T, typename... Args>
223  T *book(const Args &...args) const {
224  T *t = fs->make<T>(args...);
225  return t;
226  }
227 
228 private:
229  // tokens for the event setup
230  const edm::ESGetToken<TrackerGeometry, TrackerDigiGeometryRecord> geomToken_;
231  const edm::ESGetToken<RunInfo, RunInfoRcd> runInfoToken_;
232  const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> magFieldToken_;
233  const edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> topoToken_;
234  const edm::ESGetToken<SiStripLatency, SiStripLatencyRcd> latencyToken_;
235 
236  const MagneticField *magneticField_;
237  const TrackerGeometry *trackerGeometry_;
238  const TrackerTopology *trackerTopology_;
239 
240  edm::Service<TFileService> fs;
241 
242  std::unique_ptr<Phase1PixelMaps> pixelmap;
243  std::unique_ptr<Phase1PixelSummaryMap> fullPixelmapXDMR;
244  std::unique_ptr<Phase1PixelSummaryMap> fullPixelmapYDMR;
245 
246  std::unique_ptr<PixelRegions::PixelRegionContainers> PixelDMRS_x_ByLayer;
247  std::unique_ptr<PixelRegions::PixelRegionContainers> PixelDMRS_y_ByLayer;
248 
249  std::unique_ptr<TrackerMap> tmap;
250  std::unique_ptr<TrackerMap> pmap;
251 
252  TH1D *hchi2ndof;
253  TH1D *hNtrk;
254  TH1D *hNtrkZoom;
255  TH1I *htrkQuality;
256  TH1I *htrkAlgo;
257  TH1D *hNhighPurity;
258  TH1D *hP;
259  TH1D *hPPlus;
260  TH1D *hPMinus;
261  TH1D *hPt;
262  TH1D *hMinPt;
263  TH1D *hPtPlus;
264  TH1D *hPtMinus;
265  TH1D *hHit;
266  TH1D *hHit2D;
267 
268  TH1D *hBPixResXPrime;
269  TH1D *hFPixResXPrime;
270  TH1D *hFPixZPlusResXPrime;
271  TH1D *hFPixZMinusResXPrime;
272 
273  TH1D *hBPixResYPrime;
274  TH1D *hFPixResYPrime;
275  TH1D *hFPixZPlusResYPrime;
276  TH1D *hFPixZMinusResYPrime;
277 
278  TH1D *hBPixResXPull;
279  TH1D *hFPixResXPull;
280  TH1D *hFPixZPlusResXPull;
281  TH1D *hFPixZMinusResXPull;
282 
283  TH1D *hBPixResYPull;
284  TH1D *hFPixResYPull;
285  TH1D *hFPixZPlusResYPull;
286  TH1D *hFPixZMinusResYPull;
287 
288  TH1D *hTIBResXPrime;
289  TH1D *hTOBResXPrime;
290  TH1D *hTIDResXPrime;
291  TH1D *hTECResXPrime;
292 
293  TH1D *hTIBResXPull;
294  TH1D *hTOBResXPull;
295  TH1D *hTIDResXPull;
296  TH1D *hTECResXPull;
297 
298  TH1D *hHitCountVsXBPix;
299  TH1D *hHitCountVsXFPix;
300  TH1D *hHitCountVsYBPix;
301  TH1D *hHitCountVsYFPix;
302  TH1D *hHitCountVsZBPix;
303  TH1D *hHitCountVsZFPix;
304 
305  TH1D *hHitCountVsThetaBPix;
306  TH1D *hHitCountVsPhiBPix;
307 
308  TH1D *hHitCountVsThetaFPix;
309  TH1D *hHitCountVsPhiFPix;
310 
311  TH1D *hHitCountVsXFPixPlus;
312  TH1D *hHitCountVsXFPixMinus;
313  TH1D *hHitCountVsYFPixPlus;
314  TH1D *hHitCountVsYFPixMinus;
315  TH1D *hHitCountVsZFPixPlus;
316  TH1D *hHitCountVsZFPixMinus;
317 
318  TH1D *hHitCountVsThetaFPixPlus;
319  TH1D *hHitCountVsPhiFPixPlus;
320 
321  TH1D *hHitCountVsThetaFPixMinus;
322  TH1D *hHitCountVsPhiFPixMinus;
323 
324  TH1D *hHitPlus;
325  TH1D *hHitMinus;
326 
327  TH1D *hPhp;
328  TH1D *hPthp;
329  TH1D *hHithp;
330  TH1D *hEtahp;
331  TH1D *hPhihp;
332  TH1D *hchi2ndofhp;
333  TH1D *hchi2Probhp;
334 
335  TH1D *hCharge;
336  TH1D *hQoverP;
337  TH1D *hQoverPZoom;
338  TH1D *hEta;
339  TH1D *hEtaPlus;
340  TH1D *hEtaMinus;
341  TH1D *hPhi;
342  TH1D *hPhiBarrel;
343  TH1D *hPhiOverlapPlus;
344  TH1D *hPhiOverlapMinus;
345  TH1D *hPhiEndcapPlus;
346  TH1D *hPhiEndcapMinus;
347  TH1D *hPhiPlus;
348  TH1D *hPhiMinus;
349 
350  TH1D *hDeltaPhi;
351  TH1D *hDeltaEta;
352  TH1D *hDeltaR;
353 
354  TH1D *hvx;
355  TH1D *hvy;
356  TH1D *hvz;
357  TH1D *hd0;
358  TH1D *hdz;
359  TH1D *hdxy;
360 
361  TH2D *hd0PVvsphi;
362  TH2D *hd0PVvseta;
363  TH2D *hd0PVvspt;
364 
365  TH2D *hd0vsphi;
366  TH2D *hd0vseta;
367  TH2D *hd0vspt;
368 
369  TH1D *hnhpxb;
370  TH1D *hnhpxe;
371  TH1D *hnhTIB;
372  TH1D *hnhTID;
373  TH1D *hnhTOB;
374  TH1D *hnhTEC;
375 
376  TH1D *hHitComposition;
377 
378  TProfile *pNBpixHitsVsVx;
379  TProfile *pNBpixHitsVsVy;
380  TProfile *pNBpixHitsVsVz;
381 
382  TH1D *hMultCand;
383 
384  TH1D *hdxyBS;
385  TH1D *hd0BS;
386  TH1D *hdzBS;
387  TH1D *hdxyPV;
388  TH1D *hd0PV;
389  TH1D *hdzPV;
390  TH1D *hrun;
391  TH1D *hlumi;
392 
393  std::vector<TH1 *> vTrackHistos_;
394  std::vector<TH1 *> vTrackProfiles_;
395  std::vector<TH1 *> vTrack2DHistos_;
396 
397  TH1D *tksByTrigger_;
398  TH1D *evtsByTrigger_;
399 
400  TH1D *modeByRun_;
401  TH1D *fieldByRun_;
402 
403  TH1D *tracksByRun_;
404  TH1D *hitsByRun_;
405 
406  TH1D *trackRatesByRun_;
407  TH1D *eventRatesByRun_;
408 
409  TH1D *hitsinBPixByRun_;
410  TH1D *hitsinFPixByRun_;
411 
412  // Pixel
413 
414  TH1D *DMRBPixX_;
415  TH1D *DMRBPixY_;
416 
417  TH1D *DMRFPixX_;
418  TH1D *DMRFPixY_;
419 
420  TH1D *DRnRBPixX_;
421  TH1D *DRnRBPixY_;
422 
423  TH1D *DRnRFPixX_;
424  TH1D *DRnRFPixY_;
425 
426  // Strips
427 
428  TH1D *DMRTIB_;
429  TH1D *DMRTOB_;
430 
431  TH1D *DMRTID_;
432  TH1D *DMRTEC_;
433 
434  TH1D *DRnRTIB_;
435  TH1D *DRnRTOB_;
436 
437  TH1D *DRnRTID_;
438  TH1D *DRnRTEC_;
439 
440  // Split DMRs
441 
442  std::array<TH1D *, 2> DMRBPixXSplit_;
443  std::array<TH1D *, 2> DMRBPixYSplit_;
444 
445  std::array<TH1D *, 2> DMRFPixXSplit_;
446  std::array<TH1D *, 2> DMRFPixYSplit_;
447 
448  std::array<TH1D *, 2> DMRTIBSplit_;
449  std::array<TH1D *, 2> DMRTOBSplit_;
450 
451  // residuals
452 
453  std::map<unsigned int, TH1D *> barrelLayersResidualsX;
454  std::map<unsigned int, TH1D *> barrelLayersPullsX;
455  std::map<unsigned int, TH1D *> barrelLayersResidualsY;
456  std::map<unsigned int, TH1D *> barrelLayersPullsY;
457 
458  std::map<unsigned int, TH1D *> endcapDisksResidualsX;
459  std::map<unsigned int, TH1D *> endcapDisksPullsX;
460  std::map<unsigned int, TH1D *> endcapDisksResidualsY;
461  std::map<unsigned int, TH1D *> endcapDisksPullsY;
462 
463  int ievt;
464  int itrks;
465  int mode;
466  bool firstEvent_;
467 
468  SiPixelPI::phase phase_;
469  float etaMax_;
470 
471  const bool isCosmics_;
472 
473  edm::InputTag TkTag_;
474  edm::InputTag TriggerResultsTag_;
475  edm::InputTag BeamSpotTag_;
476  edm::InputTag VerticesTag_;
477 
478  edm::EDGetTokenT<reco::TrackCollection> theTrackCollectionToken_;
479  edm::EDGetTokenT<edm::TriggerResults> hltresultsToken_;
480  edm::EDGetTokenT<reco::BeamSpot> beamspotToken_;
481  edm::EDGetTokenT<reco::VertexCollection> vertexToken_;
482 
483  std::map<std::string, std::pair<int, int> > triggerMap_;
484  std::map<int, std::pair<int, float> > conditionsMap_;
485  std::map<int, std::pair<int, int> > runInfoMap_;
486  std::map<int, std::array<int, 6> > runHitsMap_;
487 
488  std::map<int, float> timeMap_;
489 
490  // Pixel
491 
492  running::estimatorMap resDetailsBPixX_;
493  running::estimatorMap resDetailsBPixY_;
494  running::estimatorMap resDetailsFPixX_;
495  running::estimatorMap resDetailsFPixY_;
496 
497  // Strips
498 
499  running::estimatorMap resDetailsTIB_;
500  running::estimatorMap resDetailsTOB_;
501  running::estimatorMap resDetailsTID_;
502  running::estimatorMap resDetailsTEC_;
503 
504  void analyze(const edm::Event &event, const edm::EventSetup &setup) override {
505  ievt++;
506 
507  edm::Handle<reco::TrackCollection> trackCollection = event.getHandle(theTrackCollectionToken_);
508 
509  if (firstEvent_) {
510  if (trackerGeometry_->isThere(GeomDetEnumerators::P2PXB) ||
511  trackerGeometry_->isThere(GeomDetEnumerators::P2PXEC)) {
512  phase_ = SiPixelPI::phase::two;
513  } else if (trackerGeometry_->isThere(GeomDetEnumerators::P1PXB) ||
514  trackerGeometry_->isThere(GeomDetEnumerators::P1PXEC)) {
515  phase_ = SiPixelPI::phase::one;
516  } else {
517  phase_ = SiPixelPI::phase::zero;
518  }
519  firstEvent_ = false;
520  }
521 
522  GlobalPoint zeroPoint(0, 0, 0);
523  if (DEBUG)
524  edm::LogVerbatim("DMRChecker") << "event #" << ievt << " Event ID = " << event.id()
525  << " magnetic field: " << magneticField_->inTesla(zeroPoint) << std::endl;
526 
527  const reco::TrackCollection tC = *(trackCollection.product());
528  itrks += tC.size();
529 
530  runInfoMap_[event.run()].first += 1;
531  runInfoMap_[event.run()].second += tC.size();
532 
533  if (DEBUG)
534  edm::LogVerbatim("DMRChecker") << "Reconstructed " << tC.size() << " tracks" << std::endl;
535 
536  edm::Handle<edm::TriggerResults> hltresults = event.getHandle(hltresultsToken_);
537  if (hltresults.isValid()) {
538  const edm::TriggerNames &triggerNames_ = event.triggerNames(*hltresults);
539  int ntrigs = hltresults->size();
540 
541  for (int itrig = 0; itrig != ntrigs; ++itrig) {
542  const string &trigName = triggerNames_.triggerName(itrig);
543  bool accept = hltresults->accept(itrig);
544  if (accept == 1) {
545  if (DEBUG)
546  edm::LogVerbatim("DMRChecker") << trigName << " " << accept << " ,track size: " << tC.size() << endl;
547  triggerMap_[trigName].first += 1;
548  triggerMap_[trigName].second += tC.size();
549  }
550  }
551  }
552 
553  hrun->Fill(event.run());
554  hlumi->Fill(event.luminosityBlock());
555 
556  int nHighPurityTracks = 0;
557 
558  for (const auto &track : tC) {
559  auto const &residuals = track.extra()->residuals();
560 
561  unsigned int nHit2D = 0;
562  int h_index = 0;
563  for (trackingRecHit_iterator iHit = track.recHitsBegin(); iHit != track.recHitsEnd(); ++iHit, ++h_index) {
564  if (this->isHit2D(**iHit))
565  ++nHit2D;
566 
567  double resX = residuals.residualX(h_index);
568  double resY = residuals.residualY(h_index);
569  double pullX = residuals.pullX(h_index);
570  double pullY = residuals.pullY(h_index);
571 
572  const DetId &detId = (*iHit)->geographicalId();
573 
574  unsigned int subid = detId.subdetId();
575  uint32_t detid_db = detId.rawId();
576 
577  const GeomDet *geomDet(trackerGeometry_->idToDet(detId));
578 
579  float uOrientation(-999.F), vOrientation(-999.F);
580  LocalPoint lPModule(0., 0., 0.), lUDirection(1., 0., 0.), lVDirection(0., 1., 0.), lWDirection(0., 0., 1.);
581 
582  // do all the transformations here
583  GlobalPoint gUDirection = geomDet->surface().toGlobal(lUDirection);
584  GlobalPoint gVDirection = geomDet->surface().toGlobal(lVDirection);
585  GlobalPoint gWDirection = geomDet->surface().toGlobal(lWDirection);
586  GlobalPoint gPModule = geomDet->surface().toGlobal(lPModule);
587 
588  if (!(*iHit)->detUnit())
589  continue; // is it a single physical module?
590 
591  if ((*iHit)->isValid() && (subid > PixelSubdetector::PixelEndcap)) {
592  tmap->fill(detid_db, 1);
593 
594  //LocalPoint lp = (*iHit)->localPosition();
595  //LocalError le = (*iHit)->localPositionError();
596 
597  // fill DMRs and DrNRs
598  if (subid == StripSubdetector::TIB) {
599  uOrientation = deltaPhi(gUDirection.barePhi(), gPModule.barePhi()) >= 0. ? +1.F : -1.F;
600  //vOrientation = gVDirection.z() - gPModule.z() >= 0 ? +1.F : -1.F; // not used for Strips
601 
602  // if the detid has never occcurred yet, set the local orientations
603  if (resDetailsTIB_.find(detid_db) == resDetailsTIB_.end()) {
604  resDetailsTIB_[detid_db].rDirection = gWDirection.perp() - gPModule.perp() >= 0 ? +1 : -1;
605  resDetailsTIB_[detid_db].zDirection = gVDirection.z() - gPModule.z() >= 0 ? +1 : -1;
606  resDetailsTIB_[detid_db].rOrZDirection = resDetailsTIB_[detid_db].rDirection; // barrel (split in r)
607  }
608 
609  hTIBResXPrime->Fill(uOrientation * resX * cmToUm);
610  hTIBResXPull->Fill(pullX);
611 
612  // update residuals
613  this->updateOnlineMomenta(resDetailsTIB_, detid_db, uOrientation * resX * cmToUm, pullX);
614 
615  } else if (subid == StripSubdetector::TOB) {
616  uOrientation = deltaPhi(gUDirection.barePhi(), gPModule.barePhi()) >= 0. ? +1.F : -1.F;
617  //vOrientation = gVDirection.z() - gPModule.z() >= 0 ? +1.F : -1.F; // not used for Strips
618 
619  hTOBResXPrime->Fill(uOrientation * resX * cmToUm);
620  hTOBResXPull->Fill(pullX);
621 
622  // if the detid has never occcurred yet, set the local orientations
623  if (resDetailsTOB_.find(detid_db) == resDetailsTOB_.end()) {
624  resDetailsTOB_[detid_db].rDirection = gWDirection.perp() - gPModule.perp() >= 0 ? +1 : -1;
625  resDetailsTOB_[detid_db].zDirection = gVDirection.z() - gPModule.z() >= 0 ? +1 : -1;
626  resDetailsTOB_[detid_db].rOrZDirection = resDetailsTOB_[detid_db].rDirection; // barrel (split in r)
627  }
628 
629  // update residuals
630  this->updateOnlineMomenta(resDetailsTOB_, detid_db, uOrientation * resX * cmToUm, pullX);
631 
632  } else if (subid == StripSubdetector::TID) {
633  uOrientation = deltaPhi(gUDirection.barePhi(), gPModule.barePhi()) >= 0. ? +1.F : -1.F;
634  //vOrientation = gVDirection.perp() - gPModule.perp() >= 0. ? +1.F : -1.F; // not used for Strips
635 
636  hTIDResXPrime->Fill(uOrientation * resX * cmToUm);
637  hTIDResXPull->Fill(pullX);
638 
639  // update residuals
640  this->updateOnlineMomenta(resDetailsTID_, detid_db, uOrientation * resX * cmToUm, pullX);
641 
642  } else if (subid == StripSubdetector::TEC) {
643  uOrientation = deltaPhi(gUDirection.barePhi(), gPModule.barePhi()) >= 0. ? +1.F : -1.F;
644  //vOrientation = gVDirection.perp() - gPModule.perp() >= 0. ? +1.F : -1.F; // not used for Strips
645 
646  hTECResXPrime->Fill(uOrientation * resX * cmToUm);
647  hTECResXPull->Fill(pullX);
648 
649  // update residuals
650  this->updateOnlineMomenta(resDetailsTEC_, detid_db, uOrientation * resX * cmToUm, pullX);
651  }
652  }
653 
654  const SiPixelRecHit *pixhit = dynamic_cast<const SiPixelRecHit *>(*iHit);
655 
656  if (pixhit) {
657  if (pixhit->isValid()) {
658  if (phase_ == SiPixelPI::phase::zero) {
659  pmap->fill(detid_db, 1);
660  }
661 
662  LocalPoint lp = (*iHit)->localPosition();
663  //LocalError le = (*iHit)->localPositionError();
664  GlobalPoint GP = geomDet->surface().toGlobal(lp);
665 
666  if ((subid == PixelSubdetector::PixelBarrel) || (subid == PixelSubdetector::PixelEndcap)) {
667  // 1 = PXB, 2 = PXF
668  if (subid == PixelSubdetector::PixelBarrel) {
669  int layer_num = trackerTopology_->pxbLayer(detid_db);
670 
671  uOrientation = deltaPhi(gUDirection.barePhi(), gPModule.barePhi()) >= 0. ? +1.F : -1.F;
672  vOrientation = gVDirection.z() - gPModule.z() >= 0 ? +1.F : -1.F;
673 
674  // if the detid has never occcurred yet, set the local orientations
675  if (resDetailsBPixX_.find(detid_db) == resDetailsBPixX_.end()) {
676  resDetailsBPixX_[detid_db].rDirection = gWDirection.perp() - gPModule.perp() >= 0 ? +1 : -1;
677  resDetailsBPixX_[detid_db].zDirection = gVDirection.z() - gPModule.z() >= 0 ? +1 : -1;
678  resDetailsBPixX_[detid_db].rOrZDirection =
679  resDetailsBPixX_[detid_db].rDirection; // barrel (split in r)
680  }
681 
682  // if the detid has never occcurred yet, set the local orientations
683  if (resDetailsBPixY_.find(detid_db) == resDetailsBPixY_.end()) {
684  resDetailsBPixY_[detid_db].rDirection = gWDirection.perp() - gPModule.perp() >= 0 ? +1 : -1;
685  resDetailsBPixY_[detid_db].zDirection = gVDirection.z() - gPModule.z() >= 0 ? +1 : -1;
686  resDetailsBPixY_[detid_db].rOrZDirection =
687  resDetailsBPixY_[detid_db].rDirection; // barrel (split in r)
688  }
689 
690  hHitCountVsThetaBPix->Fill(GP.theta());
691  hHitCountVsPhiBPix->Fill(GP.phi());
692 
693  hHitCountVsZBPix->Fill(GP.z());
694  hHitCountVsXBPix->Fill(GP.x());
695  hHitCountVsYBPix->Fill(GP.y());
696 
697  hBPixResXPrime->Fill(uOrientation * resX * cmToUm);
698  hBPixResYPrime->Fill(vOrientation * resY * cmToUm);
699  hBPixResXPull->Fill(pullX);
700  hBPixResYPull->Fill(pullY);
701 
702  if (DEBUG)
703  edm::LogVerbatim("DMRChecker") << "layer: " << layer_num << std::endl;
704 
705  // update residuals X
706  this->updateOnlineMomenta(resDetailsBPixX_, detid_db, uOrientation * resX * cmToUm, pullX);
707 
708  // update residuals Y
709  this->updateOnlineMomenta(resDetailsBPixY_, detid_db, vOrientation * resY * cmToUm, pullY);
710 
711  fillByIndex(barrelLayersResidualsX, layer_num, uOrientation * resX * cmToUm);
712  fillByIndex(barrelLayersPullsX, layer_num, pullX);
713  fillByIndex(barrelLayersResidualsY, layer_num, vOrientation * resY * cmToUm);
714  fillByIndex(barrelLayersPullsY, layer_num, pullY);
715 
716  } else if (subid == PixelSubdetector::PixelEndcap) {
717  uOrientation = gUDirection.perp() - gPModule.perp() >= 0 ? +1.F : -1.F;
718  vOrientation = deltaPhi(gVDirection.barePhi(), gPModule.barePhi()) >= 0. ? +1.F : -1.F;
719 
720  int side_num = trackerTopology_->pxfSide(detid_db);
721  int disk_num = trackerTopology_->pxfDisk(detid_db);
722 
723  int packedTopo = disk_num + 3 * (side_num - 1);
724 
725  if (DEBUG)
726  edm::LogVerbatim("DMRChecker") << "side: " << side_num << " disk: " << disk_num
727  << " packedTopo: " << packedTopo << " GP.z(): " << GP.z() << std::endl;
728 
729  hHitCountVsThetaFPix->Fill(GP.theta());
730  hHitCountVsPhiFPix->Fill(GP.phi());
731 
732  hHitCountVsZFPix->Fill(GP.z());
733  hHitCountVsXFPix->Fill(GP.x());
734  hHitCountVsYFPix->Fill(GP.y());
735 
736  hFPixResXPrime->Fill(uOrientation * resX * cmToUm);
737  hFPixResYPrime->Fill(vOrientation * resY * cmToUm);
738  hFPixResXPull->Fill(pullX);
739  hFPixResYPull->Fill(pullY);
740 
741  fillByIndex(endcapDisksResidualsX, packedTopo, uOrientation * resX * cmToUm);
742  fillByIndex(endcapDisksPullsX, packedTopo, pullX);
743  fillByIndex(endcapDisksResidualsY, packedTopo, vOrientation * resY * cmToUm);
744  fillByIndex(endcapDisksPullsY, packedTopo, pullY);
745 
746  // if the detid has never occcurred yet, set the local orientations
747  if (resDetailsFPixX_.find(detid_db) == resDetailsFPixX_.end()) {
748  resDetailsFPixX_[detid_db].rDirection = gUDirection.perp() - gPModule.perp() >= 0 ? +1 : -1;
749  resDetailsFPixX_[detid_db].zDirection = gWDirection.z() - gPModule.z() >= 0 ? +1 : -1;
750  resDetailsFPixX_[detid_db].rOrZDirection =
751  resDetailsFPixX_[detid_db].zDirection; // endcaps (split in z)
752  }
753 
754  // if the detid has never occcurred yet, set the local orientations
755  if (resDetailsFPixY_.find(detid_db) == resDetailsFPixY_.end()) {
756  resDetailsFPixY_[detid_db].rDirection = gUDirection.perp() - gPModule.perp() >= 0 ? +1 : -1;
757  resDetailsFPixY_[detid_db].zDirection = gWDirection.z() - gPModule.z() >= 0 ? +1 : -1;
758  resDetailsFPixY_[detid_db].rOrZDirection =
759  resDetailsFPixY_[detid_db].zDirection; // endcaps (split in z)
760  }
761 
762  // update residuals X
763  this->updateOnlineMomenta(resDetailsFPixX_, detid_db, uOrientation * resX * cmToUm, pullX);
764 
765  // update residuals Y
766  this->updateOnlineMomenta(resDetailsFPixY_, detid_db, vOrientation * resY * cmToUm, pullY);
767 
768  if (side_num == 1) {
769  hHitCountVsXFPixMinus->Fill(GP.x());
770  hHitCountVsYFPixMinus->Fill(GP.y());
771  hHitCountVsZFPixMinus->Fill(GP.z());
772  hHitCountVsThetaFPixMinus->Fill(GP.theta());
773  hHitCountVsPhiFPixMinus->Fill(GP.phi());
774 
775  hFPixZMinusResXPrime->Fill(uOrientation * resX * cmToUm);
776  hFPixZMinusResYPrime->Fill(vOrientation * resY * cmToUm);
777  hFPixZMinusResXPull->Fill(pullX);
778  hFPixZMinusResYPull->Fill(pullY);
779 
780  } else {
781  hHitCountVsXFPixPlus->Fill(GP.x());
782  hHitCountVsYFPixPlus->Fill(GP.y());
783  hHitCountVsZFPixPlus->Fill(GP.z());
784  hHitCountVsThetaFPixPlus->Fill(GP.theta());
785  hHitCountVsPhiFPixPlus->Fill(GP.phi());
786 
787  hFPixZPlusResXPrime->Fill(uOrientation * resX * cmToUm);
788  hFPixZPlusResYPrime->Fill(vOrientation * resY * cmToUm);
789  hFPixZPlusResXPull->Fill(pullX);
790  hFPixZPlusResYPull->Fill(pullY);
791  }
792  }
793  }
794  }
795  }
796  }
797 
798  hHit2D->Fill(nHit2D);
799  hHit->Fill(track.numberOfValidHits());
800  hnhpxb->Fill(track.hitPattern().numberOfValidPixelBarrelHits());
801  hnhpxe->Fill(track.hitPattern().numberOfValidPixelEndcapHits());
802  hnhTIB->Fill(track.hitPattern().numberOfValidStripTIBHits());
803  hnhTID->Fill(track.hitPattern().numberOfValidStripTIDHits());
804  hnhTOB->Fill(track.hitPattern().numberOfValidStripTOBHits());
805  hnhTEC->Fill(track.hitPattern().numberOfValidStripTECHits());
806 
807  runHitsMap_[event.run()][0] += track.hitPattern().numberOfValidPixelBarrelHits();
808  runHitsMap_[event.run()][1] += track.hitPattern().numberOfValidPixelEndcapHits();
809  runHitsMap_[event.run()][2] += track.hitPattern().numberOfValidStripTIBHits();
810  runHitsMap_[event.run()][3] += track.hitPattern().numberOfValidStripTIDHits();
811  runHitsMap_[event.run()][4] += track.hitPattern().numberOfValidStripTOBHits();
812  runHitsMap_[event.run()][5] += track.hitPattern().numberOfValidStripTECHits();
813 
814  // fill hit composition histogram
815  if (track.hitPattern().numberOfValidPixelBarrelHits() != 0) {
816  hHitComposition->Fill(0., track.hitPattern().numberOfValidPixelBarrelHits());
817 
818  pNBpixHitsVsVx->Fill(track.vx(), track.hitPattern().numberOfValidPixelBarrelHits());
819  pNBpixHitsVsVy->Fill(track.vy(), track.hitPattern().numberOfValidPixelBarrelHits());
820  pNBpixHitsVsVz->Fill(track.vz(), track.hitPattern().numberOfValidPixelBarrelHits());
821  }
822  if (track.hitPattern().numberOfValidPixelEndcapHits() != 0) {
823  hHitComposition->Fill(1., track.hitPattern().numberOfValidPixelEndcapHits());
824  }
825  if (track.hitPattern().numberOfValidStripTIBHits() != 0) {
826  hHitComposition->Fill(2., track.hitPattern().numberOfValidStripTIBHits());
827  }
828  if (track.hitPattern().numberOfValidStripTIDHits() != 0) {
829  hHitComposition->Fill(3., track.hitPattern().numberOfValidStripTIDHits());
830  }
831  if (track.hitPattern().numberOfValidStripTOBHits() != 0) {
832  hHitComposition->Fill(4., track.hitPattern().numberOfValidStripTOBHits());
833  }
834  if (track.hitPattern().numberOfValidStripTECHits() != 0) {
835  hHitComposition->Fill(5., track.hitPattern().numberOfValidStripTECHits());
836  }
837 
838  hCharge->Fill(track.charge());
839  hQoverP->Fill(track.qoverp());
840  hQoverPZoom->Fill(track.qoverp());
841  hPt->Fill(track.pt());
842  hP->Fill(track.p());
843  hchi2ndof->Fill(track.normalizedChi2());
844  hEta->Fill(track.eta());
845  hPhi->Fill(track.phi());
846 
847  if (fabs(track.eta()) < 0.8)
848  hPhiBarrel->Fill(track.phi());
849  if (track.eta() > 0.8 && track.eta() < 1.4)
850  hPhiOverlapPlus->Fill(track.phi());
851  if (track.eta() < -0.8 && track.eta() > -1.4)
852  hPhiOverlapMinus->Fill(track.phi());
853  if (track.eta() > 1.4)
854  hPhiEndcapPlus->Fill(track.phi());
855  if (track.eta() < -1.4)
856  hPhiEndcapMinus->Fill(track.phi());
857 
858  hd0->Fill(track.d0());
859  hdz->Fill(track.dz());
860  hdxy->Fill(track.dxy());
861  hvx->Fill(track.vx());
862  hvy->Fill(track.vy());
863  hvz->Fill(track.vz());
864 
865  htrkAlgo->Fill(track.algo());
866 
867  int myquality = -99;
868  if (track.quality(reco::TrackBase::undefQuality)) {
869  myquality = -1;
870  htrkQuality->Fill(myquality);
871  }
872  if (track.quality(reco::TrackBase::loose)) {
873  myquality = 0;
874  htrkQuality->Fill(myquality);
875  }
876  if (track.quality(reco::TrackBase::tight)) {
877  myquality = 1;
878  htrkQuality->Fill(myquality);
879  }
880  if (track.quality(reco::TrackBase::highPurity) && (!isCosmics_)) {
881  myquality = 2;
882  htrkQuality->Fill(myquality);
883  hPhp->Fill(track.p());
884  hPthp->Fill(track.pt());
885  hHithp->Fill(track.numberOfValidHits());
886  hEtahp->Fill(track.eta());
887  hPhihp->Fill(track.phi());
888  hchi2ndofhp->Fill(track.normalizedChi2());
889  hchi2Probhp->Fill(TMath::Prob(track.chi2(), track.ndof()));
890  nHighPurityTracks++;
891  }
892  if (track.quality(reco::TrackBase::confirmed)) {
893  myquality = 3;
894  htrkQuality->Fill(myquality);
895  }
896  if (track.quality(reco::TrackBase::goodIterative)) {
897  myquality = 4;
898  htrkQuality->Fill(myquality);
899  }
900 
901  // Fill 1D track histos
902  static const int etaindex = this->index(vTrackHistos_, "h_tracketa");
903  vTrackHistos_[etaindex]->Fill(track.eta());
904  static const int phiindex = this->index(vTrackHistos_, "h_trackphi");
905  vTrackHistos_[phiindex]->Fill(track.phi());
906  static const int numOfValidHitsindex = this->index(vTrackHistos_, "h_trackNumberOfValidHits");
907  vTrackHistos_[numOfValidHitsindex]->Fill(track.numberOfValidHits());
908  static const int numOfLostHitsindex = this->index(vTrackHistos_, "h_trackNumberOfLostHits");
909  vTrackHistos_[numOfLostHitsindex]->Fill(track.numberOfLostHits());
910 
911  GlobalPoint gPoint(track.vx(), track.vy(), track.vz());
912  double theLocalMagFieldInInverseGeV = magneticField_->inInverseGeV(gPoint).z();
913  double kappa = -track.charge() * theLocalMagFieldInInverseGeV / track.pt();
914 
915  static const int kappaindex = this->index(vTrackHistos_, "h_curvature");
916  vTrackHistos_[kappaindex]->Fill(kappa);
917  static const int kappaposindex = this->index(vTrackHistos_, "h_curvature_pos");
918  if (track.charge() > 0)
919  vTrackHistos_[kappaposindex]->Fill(fabs(kappa));
920  static const int kappanegindex = this->index(vTrackHistos_, "h_curvature_neg");
921  if (track.charge() < 0)
922  vTrackHistos_[kappanegindex]->Fill(fabs(kappa));
923 
924  double chi2Prob = TMath::Prob(track.chi2(), track.ndof());
925  double normchi2 = track.normalizedChi2();
926 
927  static const int normchi2index = this->index(vTrackHistos_, "h_normchi2");
928  vTrackHistos_[normchi2index]->Fill(normchi2);
929  static const int chi2index = this->index(vTrackHistos_, "h_chi2");
930  vTrackHistos_[chi2index]->Fill(track.chi2());
931  static const int chi2Probindex = this->index(vTrackHistos_, "h_chi2Prob");
932  vTrackHistos_[chi2Probindex]->Fill(chi2Prob);
933  static const int ptindex = this->index(vTrackHistos_, "h_pt");
934  static const int pt2index = this->index(vTrackHistos_, "h_ptrebin");
935  vTrackHistos_[ptindex]->Fill(track.pt());
936  vTrackHistos_[pt2index]->Fill(track.pt());
937  if (track.ptError() != 0.) {
938  static const int ptResolutionindex = this->index(vTrackHistos_, "h_ptResolution");
939  vTrackHistos_[ptResolutionindex]->Fill(track.ptError() / track.pt());
940  }
941  // Fill track profiles
942  static const int d0phiindex = this->index(vTrackProfiles_, "p_d0_vs_phi");
943  vTrackProfiles_[d0phiindex]->Fill(track.phi(), track.d0());
944  static const int dzphiindex = this->index(vTrackProfiles_, "p_dz_vs_phi");
945  vTrackProfiles_[dzphiindex]->Fill(track.phi(), track.dz());
946  static const int d0etaindex = this->index(vTrackProfiles_, "p_d0_vs_eta");
947  vTrackProfiles_[d0etaindex]->Fill(track.eta(), track.d0());
948  static const int dzetaindex = this->index(vTrackProfiles_, "p_dz_vs_eta");
949  vTrackProfiles_[dzetaindex]->Fill(track.eta(), track.dz());
950  static const int chiProbphiindex = this->index(vTrackProfiles_, "p_chi2Prob_vs_phi");
951  vTrackProfiles_[chiProbphiindex]->Fill(track.phi(), chi2Prob);
952  static const int chiProbabsd0index = this->index(vTrackProfiles_, "p_chi2Prob_vs_d0");
953  vTrackProfiles_[chiProbabsd0index]->Fill(fabs(track.d0()), chi2Prob);
954  static const int chiProbabsdzindex = this->index(vTrackProfiles_, "p_chi2Prob_vs_dz");
955  vTrackProfiles_[chiProbabsdzindex]->Fill(track.dz(), chi2Prob);
956  static const int chiphiindex = this->index(vTrackProfiles_, "p_chi2_vs_phi");
957  vTrackProfiles_[chiphiindex]->Fill(track.phi(), track.chi2());
958  static const int normchiphiindex = this->index(vTrackProfiles_, "p_normchi2_vs_phi");
959  vTrackProfiles_[normchiphiindex]->Fill(track.phi(), normchi2);
960  static const int chietaindex = this->index(vTrackProfiles_, "p_chi2_vs_eta");
961  vTrackProfiles_[chietaindex]->Fill(track.eta(), track.chi2());
962  static const int normchiptindex = this->index(vTrackProfiles_, "p_normchi2_vs_pt");
963  vTrackProfiles_[normchiptindex]->Fill(track.pt(), normchi2);
964  static const int normchipindex = this->index(vTrackProfiles_, "p_normchi2_vs_p");
965  vTrackProfiles_[normchipindex]->Fill(track.p(), normchi2);
966  static const int chiProbetaindex = this->index(vTrackProfiles_, "p_chi2Prob_vs_eta");
967  vTrackProfiles_[chiProbetaindex]->Fill(track.eta(), chi2Prob);
968  static const int normchietaindex = this->index(vTrackProfiles_, "p_normchi2_vs_eta");
969  vTrackProfiles_[normchietaindex]->Fill(track.eta(), normchi2);
970  static const int kappaphiindex = this->index(vTrackProfiles_, "p_kappa_vs_phi");
971  vTrackProfiles_[kappaphiindex]->Fill(track.phi(), kappa);
972  static const int kappaetaindex = this->index(vTrackProfiles_, "p_kappa_vs_eta");
973  vTrackProfiles_[kappaetaindex]->Fill(track.eta(), kappa);
974  static const int ptResphiindex = this->index(vTrackProfiles_, "p_ptResolution_vs_phi");
975  vTrackProfiles_[ptResphiindex]->Fill(track.phi(), track.ptError() / track.pt());
976  static const int ptResetaindex = this->index(vTrackProfiles_, "p_ptResolution_vs_eta");
977  vTrackProfiles_[ptResetaindex]->Fill(track.eta(), track.ptError() / track.pt());
978 
979  // Fill 2D track histos
980  static const int etaphiindex_2d = this->index(vTrack2DHistos_, "h2_phi_vs_eta");
981  vTrack2DHistos_[etaphiindex_2d]->Fill(track.eta(), track.phi());
982  static const int d0phiindex_2d = this->index(vTrack2DHistos_, "h2_d0_vs_phi");
983  vTrack2DHistos_[d0phiindex_2d]->Fill(track.phi(), track.d0());
984  static const int dzphiindex_2d = this->index(vTrack2DHistos_, "h2_dz_vs_phi");
985  vTrack2DHistos_[dzphiindex_2d]->Fill(track.phi(), track.dz());
986  static const int d0etaindex_2d = this->index(vTrack2DHistos_, "h2_d0_vs_eta");
987  vTrack2DHistos_[d0etaindex_2d]->Fill(track.eta(), track.d0());
988  static const int dzetaindex_2d = this->index(vTrack2DHistos_, "h2_dz_vs_eta");
989  vTrack2DHistos_[dzetaindex_2d]->Fill(track.eta(), track.dz());
990  static const int chiphiindex_2d = this->index(vTrack2DHistos_, "h2_chi2_vs_phi");
991  vTrack2DHistos_[chiphiindex_2d]->Fill(track.phi(), track.chi2());
992  static const int chiProbphiindex_2d = this->index(vTrack2DHistos_, "h2_chi2Prob_vs_phi");
993  vTrack2DHistos_[chiProbphiindex_2d]->Fill(track.phi(), chi2Prob);
994  static const int chiProbabsd0index_2d = this->index(vTrack2DHistos_, "h2_chi2Prob_vs_d0");
995  vTrack2DHistos_[chiProbabsd0index_2d]->Fill(fabs(track.d0()), chi2Prob);
996  static const int normchiphiindex_2d = this->index(vTrack2DHistos_, "h2_normchi2_vs_phi");
997  vTrack2DHistos_[normchiphiindex_2d]->Fill(track.phi(), normchi2);
998  static const int chietaindex_2d = this->index(vTrack2DHistos_, "h2_chi2_vs_eta");
999  vTrack2DHistos_[chietaindex_2d]->Fill(track.eta(), track.chi2());
1000  static const int chiProbetaindex_2d = this->index(vTrack2DHistos_, "h2_chi2Prob_vs_eta");
1001  vTrack2DHistos_[chiProbetaindex_2d]->Fill(track.eta(), chi2Prob);
1002  static const int normchietaindex_2d = this->index(vTrack2DHistos_, "h2_normchi2_vs_eta");
1003  vTrack2DHistos_[normchietaindex_2d]->Fill(track.eta(), normchi2);
1004  static const int kappaphiindex_2d = this->index(vTrack2DHistos_, "h2_kappa_vs_phi");
1005  vTrack2DHistos_[kappaphiindex_2d]->Fill(track.phi(), kappa);
1006  static const int kappaetaindex_2d = this->index(vTrack2DHistos_, "h2_kappa_vs_eta");
1007  vTrack2DHistos_[kappaetaindex_2d]->Fill(track.eta(), kappa);
1008  static const int normchi2kappa_2d = this->index(vTrack2DHistos_, "h2_normchi2_vs_kappa");
1009  vTrack2DHistos_[normchi2kappa_2d]->Fill(normchi2, kappa);
1010 
1011  if (DEBUG)
1012  edm::LogVerbatim("DMRChecker") << "filling histos" << std::endl;
1013 
1014  //dxy with respect to the beamspot
1015  reco::BeamSpot beamSpot;
1016  edm::Handle<reco::BeamSpot> beamSpotHandle = event.getHandle(beamspotToken_);
1017  if (beamSpotHandle.isValid()) {
1018  beamSpot = *beamSpotHandle;
1019  math::XYZPoint point(beamSpot.x0(), beamSpot.y0(), beamSpot.z0());
1020  double dxy = track.dxy(point);
1021  double dz = track.dz(point);
1022  hdxyBS->Fill(dxy);
1023  hd0BS->Fill(-dxy);
1024  hdzBS->Fill(dz);
1025  }
1026 
1027  //dxy with respect to the primary vertex
1028  reco::Vertex pvtx;
1029  edm::Handle<reco::VertexCollection> vertexHandle = event.getHandle(vertexToken_);
1030  double mindxy = 100.;
1031  double dz = 100;
1032  if (vertexHandle.isValid() && !isCosmics_) {
1033  for (reco::VertexCollection::const_iterator pvtx = vertexHandle->begin(); pvtx != vertexHandle->end(); ++pvtx) {
1034  math::XYZPoint mypoint(pvtx->x(), pvtx->y(), pvtx->z());
1035  if (abs(mindxy) > abs(track.dxy(mypoint))) {
1036  mindxy = track.dxy(mypoint);
1037  dz = track.dz(mypoint);
1038  if (DEBUG)
1039  edm::LogVerbatim("DMRChecker") << "dxy: " << mindxy << " dz: " << dz << std::endl;
1040  }
1041  }
1042 
1043  hdxyPV->Fill(mindxy);
1044  hd0PV->Fill(-mindxy);
1045  hdzPV->Fill(dz);
1046 
1047  hd0PVvsphi->Fill(track.phi(), -mindxy);
1048  hd0PVvseta->Fill(track.eta(), -mindxy);
1049  hd0PVvspt->Fill(track.pt(), -mindxy);
1050 
1051  } else {
1052  hdxyPV->Fill(100);
1053  hd0PV->Fill(100);
1054  hdzPV->Fill(100);
1055  }
1056 
1057  if (DEBUG)
1058  edm::LogVerbatim("DMRChecker") << "end of track loop" << std::endl;
1059  }
1060 
1061  if (DEBUG)
1062  edm::LogVerbatim("DMRChecker") << "end of analysis" << std::endl;
1063 
1064  hNtrk->Fill(tC.size());
1065  hNtrkZoom->Fill(tC.size());
1066  hNhighPurity->Fill(nHighPurityTracks);
1067 
1068  if (DEBUG)
1069  edm::LogVerbatim("DMRChecker") << "end of analysis" << std::endl;
1070  }
1071 
1072  //*************************************************************
1073  void beginRun(edm::Run const &run, edm::EventSetup const &setup) override
1074  //*************************************************************
1075  {
1076  // initialize runInfoMap_
1077  runInfoMap_[run.run()].first = 0;
1078  runInfoMap_[run.run()].second = 0;
1079 
1080  // initialize runHitsMap
1081  for (int n : {0, 1, 2, 3, 4, 5}) {
1082  runHitsMap_[run.run()][n] = 0; // 6 subdets
1083  }
1084 
1085  // Magnetic Field setup
1086  magneticField_ = &setup.getData(magFieldToken_);
1087  float B_ = magneticField_->inTesla(GlobalPoint(0, 0, 0)).mag();
1088 
1089  edm::LogInfo("DMRChecker") << "run number:" << run.run() << " magnetic field: " << B_ << " [T]" << std::endl;
1090 
1091  const RunInfo *summary = &setup.getData(runInfoToken_);
1092  time_t start_time = summary->m_start_time_ll;
1093  ctime(&start_time);
1094  time_t end_time = summary->m_stop_time_ll;
1095  ctime(&end_time);
1096 
1097  float average_current = summary->m_avg_current;
1098  float uptimeInSeconds = summary->m_run_intervall_micros;
1099  edm::LogVerbatim("DMRChecker") << " start_time: " << start_time << " ( " << summary->m_start_time_str << " )"
1100  << " | end_time: " << end_time << " ( " << summary->m_stop_time_str << " )"
1101  << " | average current: " << average_current
1102  << " | uptime in seconds: " << uptimeInSeconds << std::endl;
1103 
1104  double seconds = difftime(end_time, start_time) / 1.0e+6; // convert from micros-seconds
1105  edm::LogVerbatim("DMRChecker") << "time difference: " << seconds << " s" << std::endl;
1106  timeMap_[run.run()] = seconds;
1107 
1108  //SiStrip Latency
1109  const SiStripLatency *apvlat = &setup.getData(latencyToken_);
1110  if (apvlat->singleReadOutMode() == 1) {
1111  mode = 1; // peak mode
1112  } else if (apvlat->singleReadOutMode() == 0) {
1113  mode = -1; // deco mode
1114  }
1115 
1116  conditionsMap_[run.run()].first = mode;
1117  conditionsMap_[run.run()].second = B_;
1118 
1119  // set geometry and topology
1120  trackerGeometry_ = &setup.getData(geomToken_);
1121  trackerTopology_ = &setup.getData(topoToken_);
1122  }
1123 
1124  //*************************************************************
1125  void endRun(edm::Run const &, edm::EventSetup const &) override {}
1126  //*************************************************************
1127 
1128  void beginJob() override {
1129  if (DEBUG)
1130  edm::LogVerbatim("DMRChecker") << __LINE__ << endl;
1131 
1132  TH1D::SetDefaultSumw2(kTRUE);
1133 
1134  etaMax_ = 3.; // assign max value to eta
1135 
1136  // intialize counters
1137  ievt = 0;
1138  itrks = 0;
1139 
1140  hrun = book<TH1D>("h_run", "run", 100000, 230000, 240000);
1141  hlumi = book<TH1D>("h_lumi", "lumi", 1000, 0, 1000);
1142 
1143  // clang-format off
1144 
1145  hchi2ndof = book<TH1D>("h_chi2ndof", "chi2/ndf;#chi^{2}/ndf;tracks", 100, 0, 5.);
1146  hCharge = book<TH1D>("h_charge", "charge;Charge of the track;tracks", 5, -2.5, 2.5);
1147  hNtrk = book<TH1D>("h_Ntrk", "ntracks;Number of Tracks;events", 200, 0., 200.);
1148  hNtrkZoom = book<TH1D>("h_NtrkZoom", "Number of tracks; number of tracks;events", 10, 0., 10.);
1149  hNhighPurity = book<TH1D>("h_NhighPurity", "n. high purity tracks;Number of high purity tracks;events", 200, 0., 200.);
1150 
1151  int nAlgos = reco::TrackBase::algoSize;
1152  htrkAlgo = book<TH1I>("h_trkAlgo", "tracking step;iterative tracking step;tracks", nAlgos, -0.5, nAlgos - 0.5);
1153  for (int nbin = 1; nbin <= htrkAlgo->GetNbinsX(); nbin++) {
1154  htrkAlgo->GetXaxis()->SetBinLabel(nbin, reco::TrackBase::algoNames[nbin - 1].c_str());
1155  }
1156 
1157  htrkQuality = book<TH1I>("h_trkQuality", "track quality;track quality;tracks", 6, -1, 5);
1158  std::string qualities[7] = {"undef", "loose", "tight", "highPurity", "confirmed", "goodIterative"};
1159  for (int nbin = 1; nbin <= htrkQuality->GetNbinsX(); nbin++) {
1160  htrkQuality->GetXaxis()->SetBinLabel(nbin, qualities[nbin - 1].c_str());
1161  }
1162 
1163  hP = book<TH1D>("h_P", "Momentum;track momentum [GeV];tracks", 100, 0., 100.);
1164  hQoverP = book<TH1D>("h_qoverp", "Track q/p; track q/p [GeV^{-1}];tracks", 100, -1., 1.);
1165  hQoverPZoom = book<TH1D>("h_qoverpZoom", "Track q/p; track q/p [GeV^{-1}];tracks", 100, -0.1, 0.1);
1166  hPt = book<TH1D>("h_Pt", "Transverse Momentum;track p_{T} [GeV];tracks", 100, 0., 100.);
1167  hHit = book<TH1D>("h_nHits", "Number of hits;track n. hits;tracks", 50, -0.5, 49.5);
1168  hHit2D = book<TH1D>("h_nHit2D", "Number of 2D hits; number of 2D hits;tracks", 20, 0, 20);
1169 
1170  // Pixel
1171 
1172  hBPixResXPrime = book<TH1D>("h_BPixResXPrime", "BPix track X-residuals;res_{X'} [#mum];hits", 100, -1000., 1000.);
1173  hFPixResXPrime = book<TH1D>("h_FPixResXPrime", "FPix track X-residuals;res_{X'} [#mum];hits", 100, -1000., 1000.);
1174  hFPixZPlusResXPrime = book<TH1D>("h_FPixZPlusResXPrime", "FPix (Z+) track X-residuals;res_{X'} [#mum];hits", 100, -1000., 1000.);
1175  hFPixZMinusResXPrime = book<TH1D>("h_FPixZMinusResXPrime", "FPix (Z-) track X-residuals;res_{X'} [#mum];hits", 100, -1000., 1000.);
1176 
1177  hBPixResYPrime = book<TH1D>("h_BPixResYPrime", "BPix track Y-residuals;res_{Y'} [#mum];hits", 100, -1000., 1000.);
1178  hFPixResYPrime = book<TH1D>("h_FPixResYPrime", "FPix track Y-residuals;res_{Y'} [#mum];hits", 100, -1000., 1000.);
1179  hFPixZPlusResYPrime = book<TH1D>("h_FPixZPlusResYPrime", "FPix (Z+) track Y-residuals;res_{Y'} [#mum];hits", 100, -1000., 1000.);
1180  hFPixZMinusResYPrime = book<TH1D>("h_FPixZMinusResYPrime", "FPix (Z-) track Y-residuals;res_{Y'} [#mum];hits", 100, -1000., 1000.);
1181 
1182  hBPixResXPull = book<TH1D>("h_BPixResXPull", "BPix track X-pulls;res_{X'}/#sigma_{res_{X'}};hits", 100, -5., 5.);
1183  hFPixResXPull = book<TH1D>("h_FPixResXPull", "FPix track X-pulls;res_{X'}/#sigma_{res_{X'}};hits", 100, -5., 5.);
1184  hFPixZPlusResXPull = book<TH1D>("h_FPixZPlusResXPull", "FPix (Z+) track X-pulls;res_{X'}/#sigma_{res_{X'}};hits", 100, -5., 5.);
1185  hFPixZMinusResXPull = book<TH1D>("h_FPixZMinusResXPull", "FPix (Z-) track X-pulls;res_{X'}/#sigma_{res_{X'}};hits", 100, -5., 5.);
1186 
1187  hBPixResYPull = book<TH1D>("h_BPixResYPull", "BPix track Y-pulls;res_{Y'}/#sigma_{res_{Y'}};hits", 100, -5., 5.);
1188  hFPixResYPull = book<TH1D>("h_FPixResYPull", "FPix track Y-pulls;res_{Y'}/#sigma_{res_{Y'}};hits", 100, -5., 5.);
1189  hFPixZPlusResYPull = book<TH1D>("h_FPixZPlusResYPull", "FPix (Z+) track Y-pulls;res_{Y'}/#sigma_{res_{Y'}};hits", 100, -5., 5.);
1190  hFPixZMinusResYPull = book<TH1D>("h_FPixZMinusResYPull", "FPix (Z-) track Y-pulls;res_{Y'}/#sigma_{res_{Y'}};hits", 100, -5., 5.);
1191 
1192  // Strips
1193 
1194  hTIBResXPrime = book<TH1D>("h_TIBResXPrime", "TIB track X-residuals;res_{X'} [#mum];hits", 100, -1000., 1000.);
1195  hTOBResXPrime = book<TH1D>("h_TOBResXPrime", "TOB track X-residuals;res_{X'} [#mum];hits", 100, -1000., 1000.);
1196  hTIDResXPrime = book<TH1D>("h_TIDResXPrime", "TID track X-residuals;res_{X'} [#mum];hits", 100, -1000., 1000.);
1197  hTECResXPrime = book<TH1D>("h_TECResXPrime", "TEC track X-residuals;res_{X'} [#mum];hits", 100, -1000., 1000.);
1198 
1199  hTIBResXPull = book<TH1D>("h_TIBResXPull", "TIB track X-pulls;res_{X'}/#sigma_{res_{X'}};hits", 100, -5., 5.);
1200  hTOBResXPull = book<TH1D>("h_TOBResXPull", "TOB track X-pulls;res_{X'}/#sigma_{res_{X'}};hits", 100, -5., 5.);
1201  hTIDResXPull = book<TH1D>("h_TIDResXPull", "TID track X-pulls;res_{X'}/#sigma_{res_{X'}};hits", 100, -5., 5.);
1202  hTECResXPull = book<TH1D>("h_TECResXPull", "TEC track X-pulls;res_{X'}/#sigma_{res_{X'}};hits", 100, -5., 5.);
1203 
1204  // hit counts
1205 
1206  hHitCountVsZBPix = book<TH1D>("h_HitCountVsZBpix", "Number of BPix hits vs z;hit global z;hits", 60, -30, 30);
1207  hHitCountVsZFPix = book<TH1D>("h_HitCountVsZFpix", "Number of FPix hits vs z;hit global z;hits", 100, -100, 100);
1208 
1209  hHitCountVsXBPix = book<TH1D>("h_HitCountVsXBpix", "Number of BPix hits vs x;hit global x;hits", 20, -20, 20);
1210  hHitCountVsXFPix = book<TH1D>("h_HitCountVsXFpix", "Number of FPix hits vs x;hit global x;hits", 20, -20, 20);
1211 
1212  hHitCountVsYBPix = book<TH1D>("h_HitCountVsYBpix", "Number of BPix hits vs y;hit global y;hits", 20, -20, 20);
1213  hHitCountVsYFPix = book<TH1D>("h_HitCountVsYFpix", "Number of FPix hits vs y;hit global y;hits", 20, -20, 20);
1214 
1215  hHitCountVsThetaBPix = book<TH1D>("h_HitCountVsThetaBpix", "Number of BPix hits vs #theta;hit global #theta;hits", 20, 0., M_PI);
1216  hHitCountVsPhiBPix = book<TH1D>("h_HitCountVsPhiBpix", "Number of BPix hits vs #phi;hit global #phi;hits", 20, -M_PI, M_PI);
1217 
1218  hHitCountVsThetaFPix = book<TH1D>("h_HitCountVsThetaFpix", "Number of FPix hits vs #theta;hit global #theta;hits", 40, 0., M_PI);
1219  hHitCountVsPhiFPix = book<TH1D>("h_HitCountVsPhiFpix", "Number of FPix hits vs #phi;hit global #phi;hits", 20, -M_PI, M_PI);
1220 
1221  // two sides of FPix
1222 
1223  hHitCountVsZFPixPlus = book<TH1D>("h_HitCountVsZFPixPlus", "Number of FPix(Z+) hits vs z;hit global z;hits", 60, 15., 60);
1224  hHitCountVsZFPixMinus = book<TH1D>("h_HitCountVsZFPixMinus", "Number of FPix(Z-) hits vs z;hit global z;hits", 100, -60., -15.);
1225 
1226  hHitCountVsXFPixPlus = book<TH1D>("h_HitCountVsXFPixPlus", "Number of FPix(Z+) hits vs x;hit global x;hits", 20, -20, 20);
1227  hHitCountVsXFPixMinus = book<TH1D>("h_HitCountVsXFPixMinus", "Number of FPix(Z-) hits vs x;hit global x;hits", 20, -20, 20);
1228 
1229  hHitCountVsYFPixPlus = book<TH1D>("h_HitCountVsYFPixPlus", "Number of FPix(Z+) hits vs y;hit global y;hits", 20, -20, 20);
1230  hHitCountVsYFPixMinus = book<TH1D>("h_HitCountVsYFPixMinus", "Number of FPix(Z-) hits vs y;hit global y;hits", 20, -20, 20);
1231 
1232  hHitCountVsThetaFPixPlus = book<TH1D>("h_HitCountVsThetaFPixPlus", "Number of FPix(Z+) hits vs #theta;hit global #theta;hits", 20, 0., M_PI);
1233  hHitCountVsPhiFPixPlus = book<TH1D>("h_HitCountVsPhiFPixPlus","Number of FPix(Z+) hits vs #phi;hit global #phi;hits",20,-M_PI,M_PI);
1234 
1235  hHitCountVsThetaFPixMinus = book<TH1D>("h_HitCountVsThetaFPixMinus", "Number of FPix(Z+) hits vs #theta;hit global #theta;hits", 40, 0., M_PI);
1236  hHitCountVsPhiFPixMinus = book<TH1D>("h_HitCountVsPhiFPixMinus","Number of FPix(Z+) hits vs #phi;hit global #phi;hits",20,-M_PI,M_PI);
1237 
1238  TFileDirectory ByLayerResiduals = fs->mkdir("ByLayerResiduals");
1239  barrelLayersResidualsX = bookResidualsHistogram(ByLayerResiduals, 4, "X", "Res", "BPix");
1240  endcapDisksResidualsX = bookResidualsHistogram(ByLayerResiduals, 6, "X", "Res", "FPix");
1241  barrelLayersResidualsY = bookResidualsHistogram(ByLayerResiduals, 4, "Y", "Res", "BPix");
1242  endcapDisksResidualsY = bookResidualsHistogram(ByLayerResiduals, 6, "Y", "Res", "FPix");
1243 
1244  TFileDirectory ByLayerPulls = fs->mkdir("ByLayerPulls");
1245  barrelLayersPullsX = bookResidualsHistogram(ByLayerPulls, 4, "X", "Pull", "BPix");
1246  endcapDisksPullsX = bookResidualsHistogram(ByLayerPulls, 6, "X", "Pull", "FPix");
1247  barrelLayersPullsY = bookResidualsHistogram(ByLayerPulls, 4, "Y", "Pull", "BPix");
1248  endcapDisksPullsY = bookResidualsHistogram(ByLayerPulls, 6, "Y", "Pull", "FPix");
1249 
1250  hEta = book<TH1D>("h_Eta", "Track pseudorapidity; track #eta;tracks", 100, -etaMax_, etaMax_);
1251  hPhi = book<TH1D>("h_Phi", "Track azimuth; track #phi;tracks", 100, -M_PI, M_PI);
1252 
1253  hPhiBarrel = book<TH1D>("h_PhiBarrel", "hPhiBarrel (0<|#eta|<0.8);track #Phi;tracks", 100, -M_PI, M_PI);
1254  hPhiOverlapPlus = book<TH1D>("h_PhiOverlapPlus", "hPhiOverlapPlus (0.8<#eta<1.4);track #phi;tracks", 100, -M_PI, M_PI);
1255  hPhiOverlapMinus = book<TH1D>("h_PhiOverlapMinus", "hPhiOverlapMinus (-1.4<#eta<-0.8);track #phi;tracks", 100, -M_PI, M_PI);
1256  hPhiEndcapPlus = book<TH1D>("h_PhiEndcapPlus", "hPhiEndcapPlus (#eta>1.4);track #phi;track", 100, -M_PI, M_PI);
1257  hPhiEndcapMinus = book<TH1D>("h_PhiEndcapMinus", "hPhiEndcapMinus (#eta<1.4);track #phi;tracks", 100, -M_PI, M_PI);
1258 
1259  if (!isCosmics_) {
1260  hPhp = book<TH1D>("h_P_hp", "Momentum (high purity);track momentum [GeV];tracks", 100, 0., 100.);
1261  hPthp = book<TH1D>("h_Pt_hp", "Transverse Momentum (high purity);track p_{T} [GeV];tracks", 100, 0., 100.);
1262  hHithp = book<TH1D>("h_nHit_hp", "Number of hits (high purity);track n. hits;tracks", 30, 0, 30);
1263  hEtahp = book<TH1D>("h_Eta_hp", "Track pseudorapidity (high purity); track #eta;tracks", 100, -etaMax_, etaMax_);
1264  hPhihp = book<TH1D>("h_Phi_hp", "Track azimuth (high purity); track #phi;tracks", 100, -M_PI, M_PI);
1265  hchi2ndofhp = book<TH1D>("h_chi2ndof_hp", "chi2/ndf (high purity);#chi^{2}/ndf;tracks", 100, 0, 5.);
1266  hchi2Probhp = book<TH1D>("hchi2_Prob_hp", "#chi^{2} probability (high purity);#chi^{2}prob_{Track};Number of Tracks", 100, 0.0, 1.);
1267 
1268  hvx = book<TH1D>("h_vx", "Track v_{x} ; track v_{x} [cm];tracks", 100, -1.5, 1.5);
1269  hvy = book<TH1D>("h_vy", "Track v_{y} ; track v_{y} [cm];tracks", 100, -1.5, 1.5);
1270  hvz = book<TH1D>("h_vz", "Track v_{z} ; track v_{z} [cm];tracks", 100, -20., 20.);
1271  hd0 = book<TH1D>("h_d0", "Track d_{0} ; track d_{0} [cm];tracks", 100, -1., 1.);
1272  hdxy = book<TH1D>("h_dxy", "Track d_{xy}; track d_{xy} [cm]; tracks", 100, -0.5, 0.5);
1273  hdz = book<TH1D>("h_dz", "Track d_{z} ; track d_{z} [cm]; tracks", 100, -20, 20);
1274 
1275  hd0PVvsphi = book<TH2D>("h2_d0PVvsphi", "hd0PVvsphi;track #phi;track d_{0}(PV) [cm]", 160, -M_PI, M_PI, 100, -1., 1.);
1276  hd0PVvseta = book<TH2D>("h2_d0PVvseta", "hdPV0vseta;track #eta;track d_{0}(PV) [cm]", 160, -etaMax_, etaMax_, 100, -1., 1.);
1277  hd0PVvspt = book<TH2D>("h2_d0PVvspt", "hdPV0vspt;track p_{T};d_{0}(PV) [cm]", 50, 0., 100., 100, -1, 1.);
1278 
1279  hdxyBS = book<TH1D>("h_dxyBS", "hdxyBS; track d_{xy}(BS) [cm];tracks", 100, -0.1, 0.1);
1280  hd0BS = book<TH1D>("h_d0BS", "hd0BS ; track d_{0}(BS) [cm];tracks", 100, -0.1, 0.1);
1281  hdzBS = book<TH1D>("h_dzBS", "hdzBS ; track d_{z}(BS) [cm];tracks", 100, -12, 12);
1282  hdxyPV = book<TH1D>("h_dxyPV", "hdxyPV; track d_{xy}(PV) [cm];tracks", 100, -0.1, 0.1);
1283  hd0PV = book<TH1D>("h_d0PV", "hd0PV ; track d_{0}(PV) [cm];tracks", 100, -0.15, 0.15);
1284  hdzPV = book<TH1D>("h_dzPV", "hdzPV ; track d_{z}(PV) [cm];tracks", 100, -0.1, 0.1);
1285 
1286  hnhTIB = book<TH1D>("h_nHitTIB", "nhTIB;# hits in TIB; tracks", 20, 0., 20.);
1287  hnhTID = book<TH1D>("h_nHitTID", "nhTID;# hits in TID; tracks", 20, 0., 20.);
1288  hnhTOB = book<TH1D>("h_nHitTOB", "nhTOB;# hits in TOB; tracks", 20, 0., 20.);
1289  hnhTEC = book<TH1D>("h_nHitTEC", "nhTEC;# hits in TEC; tracks", 20, 0., 20.);
1290 
1291  } else {
1292  hvx = book<TH1D>("h_vx", "Track v_{x};track v_{x} [cm];tracks", 100, -100., 100.);
1293  hvy = book<TH1D>("h_vy", "Track v_{y};track v_{y} [cm];tracks", 100, -100., 100.);
1294  hvz = book<TH1D>("h_vz", "Track v_{z};track v_{z} [cm];track", 100, -100., 100.);
1295  hd0 = book<TH1D>("h_d0", "Track d_{0};track d_{0} [cm];track", 100, -100., 100.);
1296  hdxy = book<TH1D>("h_dxy", "Track d_{xy};track d_{xy} [cm];tracks", 100, -100, 100);
1297  hdz = book<TH1D>("h_dz", "Track d_{z};track d_{z} [cm];tracks", 100, -200, 200);
1298 
1299  hd0vsphi = book<TH2D>("h2_d0vsphi", "Track d_{0} vs #phi; track #phi;track d_{0} [cm]", 160, -M_PI, M_PI, 100, -100., 100.);
1300  hd0vseta = book<TH2D>("h2_d0vseta", "Track d_{0} vs #eta; track #eta;track d_{0} [cm]", 160, -etaMax_, etaMax_, 100, -100., 100.);
1301  hd0vspt = book<TH2D>("h2_d0vspt", "Track d_{0} vs p_{T};track p_{T};track d_{0} [cm]", 50, 0., 100., 100, -100, 100);
1302 
1303  hdxyBS = book<TH1D>("h_dxyBS", "Track d_{xy}(BS);d_{xy}(BS) [cm];tracks", 100, -100., 100.);
1304  hd0BS = book<TH1D>("h_d0BS", "Track d_{0}(BS);d_{0}(BS) [cm];tracks", 100, -100., 100.);
1305  hdzBS = book<TH1D>("h_dzBS", "Track d_{z}(BS);d_{z}(BS) [cm];tracks", 100, -100., 100.);
1306  hdxyPV = book<TH1D>("h_dxyPV", "Track d_{xy}(PV); d_{xy}(PV) [cm];tracks", 100, -100., 100.);
1307  hd0PV = book<TH1D>("h_d0PV", "Track d_{0}(PV); d_{0}(PV) [cm];tracks", 100, -100., 100.);
1308  hdzPV = book<TH1D>("h_dzPV", "Track d_{z}(PV); d_{z}(PV) [cm];tracks", 100, -100., 100.);
1309 
1310  hnhTIB = book<TH1D>("h_nHitTIB", "nhTIB;# hits in TIB; tracks", 30, 0., 30.);
1311  hnhTID = book<TH1D>("h_nHitTID", "nhTID;# hits in TID; tracks", 30, 0., 30.);
1312  hnhTOB = book<TH1D>("h_nHitTOB", "nhTOB;# hits in TOB; tracks", 30, 0., 30.);
1313  hnhTEC = book<TH1D>("h_nHitTEC", "nhTEC;# hits in TEC; tracks", 30, 0., 30.);
1314  }
1315 
1316  hnhpxb = book<TH1D>("h_nHitPXB", "nhpxb;# hits in Pixel Barrel; tracks", 10, 0., 10.);
1317  hnhpxe = book<TH1D>("h_nHitPXE", "nhpxe;# hits in Pixel Endcap; tracks", 10, 0., 10.);
1318 
1319  hHitComposition = book<TH1D>("h_hitcomposition", "track hit composition;;# hits", 6, -0.5, 5.5);
1320  pNBpixHitsVsVx = book<TProfile>("p_NpixHits_vs_Vx", "n. Barrel Pixel hits vs. v_{x};v_{x} (cm);n. BPix hits", 20, -20, 20);
1321  pNBpixHitsVsVy = book<TProfile>("p_NpixHits_vs_Vy", "n. Barrel Pixel hits vs. v_{y};v_{y} (cm);n. BPix hits", 20, -20, 20);
1322  pNBpixHitsVsVz = book<TProfile>("p_NpixHits_vs_Vz", "n. Barrel Pixel hits vs. v_{z};v_{z} (cm);n. BPix hits", 20, -100, 100);
1323 
1324  std::string dets[6] = {"PXB", "PXF", "TIB", "TID", "TOB", "TEC"};
1325  for (int i = 1; i <= hHitComposition->GetNbinsX(); i++) {
1326  hHitComposition->GetXaxis()->SetBinLabel(i, dets[i - 1].c_str());
1327  }
1328 
1329  vTrackHistos_.push_back(book<TH1F>("h_tracketa", "Track #eta;#eta_{Track};Number of Tracks", 90, -etaMax_, etaMax_));
1330  vTrackHistos_.push_back(book<TH1F>("h_trackphi", "Track #phi;#phi_{Track};Number of Tracks", 90, -M_PI, M_PI));
1331  vTrackHistos_.push_back(book<TH1F>("h_trackNumberOfValidHits", "Track # of valid hits;# of valid hits _{Track};Number of Tracks", 40, 0., 40.));
1332  vTrackHistos_.push_back(book<TH1F>("h_trackNumberOfLostHits", "Track # of lost hits;# of lost hits _{Track};Number of Tracks", 10, 0., 10.));
1333  vTrackHistos_.push_back(book<TH1F>("h_curvature", "Curvature #kappa;#kappa_{Track};Number of Tracks", 100, -.05, .05));
1334  vTrackHistos_.push_back(book<TH1F>("h_curvature_pos", "Curvature |#kappa| Positive Tracks;|#kappa_{pos Track}|;Number of Tracks", 100, .0, .05));
1335  vTrackHistos_.push_back(book<TH1F>("h_curvature_neg", "Curvature |#kappa| Negative Tracks;|#kappa_{neg Track}|;Number of Tracks", 100, .0, .05));
1336  vTrackHistos_.push_back(book<TH1F>("h_diff_curvature", "Curvature |#kappa| Tracks Difference;|#kappa_{Track}|;# Pos Tracks - # Neg Tracks", 100,.0,.05));
1337 
1338  vTrackHistos_.push_back(book<TH1F>("h_chi2", "Track #chi^{2};#chi^{2}_{Track};Number of Tracks", 500, -0.01, 500.));
1339  vTrackHistos_.push_back(book<TH1F>("h_chi2Prob", "#chi^{2} probability;Track Prob(#chi^{2},ndof);Number of Tracks", 100, 0.0, 1.));
1340  vTrackHistos_.push_back(book<TH1F>("h_normchi2", "#chi^{2}/ndof;#chi^{2}/ndof;Number of Tracks", 100, -0.01, 10.));
1341 
1342  //variable binning for chi2/ndof vs. pT
1343  double xBins[19] = {0., 0.15, 0.5, 1., 1.5, 2., 2.5, 3., 3.5, 4., 4.5, 5., 7., 10., 15., 25., 40., 100., 200.};
1344  vTrackHistos_.push_back(book<TH1F>("h_pt", "Track p_{T};p_{T}^{track} [GeV];Number of Tracks", 250, 0., 250));
1345  vTrackHistos_.push_back(book<TH1F>("h_ptrebin", "Track p_{T};p_{T}^{track} [GeV];Number of Tracks", 18, xBins));
1346 
1347  vTrackHistos_.push_back(book<TH1F>("h_ptResolution", "#delta_{p_{T}}/p_{T}^{track};#delta_{p_{T}}/p_{T}^{track};Number of Tracks", 100, 0., 0.5));
1348  vTrackProfiles_.push_back(book<TProfile>("p_d0_vs_phi", "Transverse Impact Parameter vs. #phi;#phi_{Track};#LT d_{0} #GT [cm]", 100, -M_PI, M_PI));
1349  vTrackProfiles_.push_back(book<TProfile>("p_dz_vs_phi", "Longitudinal Impact Parameter vs. #phi;#phi_{Track};#LT d_{z} #GT [cm]", 100, -M_PI, M_PI));
1350  vTrackProfiles_.push_back(book<TProfile>("p_d0_vs_eta", "Transverse Impact Parameter vs. #eta;#eta_{Track};#LT d_{0} #GT [cm]", 100, -etaMax_, etaMax_));
1351  vTrackProfiles_.push_back(book<TProfile>("p_dz_vs_eta", "Longitudinal Impact Parameter vs. #eta;#eta_{Track};#LT d_{z} #GT [cm]", 100, -etaMax_, etaMax_));
1352  vTrackProfiles_.push_back(book<TProfile>("p_chi2_vs_phi", "#chi^{2} vs. #phi;#phi_{Track};#LT #chi^{2} #GT", 100, -M_PI, M_PI));
1353  vTrackProfiles_.push_back(book<TProfile>("p_chi2Prob_vs_phi","#chi^{2} probablility vs. #phi;#phi_{Track};#LT #chi^{2} probability#GT",100,-M_PI,M_PI));
1354  vTrackProfiles_.push_back(book<TProfile>("p_chi2Prob_vs_d0", "#chi^{2} probablility vs. |d_{0}|;|d_{0}|[cm];#LT #chi^{2} probability#GT", 100, 0, 80));
1355  vTrackProfiles_.push_back(book<TProfile>("p_chi2Prob_vs_dz", "#chi^{2} probablility vs. dz;d_{z} [cm];#LT #chi^{2} probability#GT", 100, -30, 30));
1356  vTrackProfiles_.push_back(book<TProfile>("p_normchi2_vs_phi", "#chi^{2}/ndof vs. #phi;#phi_{Track};#LT #chi^{2}/ndof #GT", 100, -M_PI, M_PI));
1357  vTrackProfiles_.push_back(book<TProfile>("p_chi2_vs_eta", "#chi^{2} vs. #eta;#eta_{Track};#LT #chi^{2} #GT", 100, -etaMax_, etaMax_));
1358  vTrackProfiles_.push_back(book<TProfile>("p_normchi2_vs_pt", "norm #chi^{2} vs. p_{T}_{Track}; p_{T}_{Track};#LT #chi^{2}/ndof #GT", 18, xBins));
1359  vTrackProfiles_.push_back(book<TProfile>("p_normchi2_vs_p", "#chi^{2}/ndof vs. p_{Track};p_{Track};#LT #chi^{2}/ndof #GT", 18, xBins));
1360  vTrackProfiles_.push_back(book<TProfile>("p_chi2Prob_vs_eta","#chi^{2} probability vs. #eta;#eta_{Track};#LT #chi^{2} probability #GT",100,-etaMax_, etaMax_));
1361  vTrackProfiles_.push_back(book<TProfile>("p_normchi2_vs_eta", "#chi^{2}/ndof vs. #eta;#eta_{Track};#LT #chi^{2}/ndof #GT", 100, -etaMax_, etaMax_));
1362  vTrackProfiles_.push_back(book<TProfile>("p_kappa_vs_phi", "#kappa vs. #phi;#phi_{Track};#kappa", 100, -M_PI, M_PI));
1363  vTrackProfiles_.push_back(book<TProfile>("p_kappa_vs_eta", "#kappa vs. #eta;#eta_{Track};#kappa", 100, -etaMax_, etaMax_));
1364  vTrackProfiles_.push_back(book<TProfile>("p_ptResolution_vs_phi","#delta_{p_{T}}/p_{T}^{track};#phi^{track};#delta_{p_{T}}/p_{T}^{track}", 100,-M_PI,M_PI));
1365  vTrackProfiles_.push_back(book<TProfile>("p_ptResolution_vs_eta","#delta_{p_{T}}/p_{T}^{track};#eta^{track};#delta_{p_{T}}/p_{T}^{track}", 100, -etaMax_, etaMax_));
1366  vTrack2DHistos_.push_back(book<TH2F>("h2_d0_vs_phi","Transverse Impact Parameter vs. #phi;#phi_{Track};d_{0} [cm]", 100, -M_PI, M_PI, 100, -1., 1.));
1367  vTrack2DHistos_.push_back(book<TH2F>("h2_phi_vs_eta", "Track #phi vs. #eta;#eta_{Track};#phi_{Track}",50, -etaMax_, etaMax_, 50, -M_PI, M_PI));
1368  vTrack2DHistos_.push_back(book<TH2F>("h2_dz_vs_phi","Longitudinal Impact Parameter vs. #phi;#phi_{Track};d_{z} [cm]",100,-M_PI,M_PI,100,-100.,100.));
1369  vTrack2DHistos_.push_back(book<TH2F>("h2_d0_vs_eta","Transverse Impact Parameter vs. #eta;#eta_{Track};d_{0} [cm]", 100, -etaMax_, etaMax_, 100, -1., 1.));
1370  vTrack2DHistos_.push_back(book<TH2F>("h2_dz_vs_eta","Longitudinal Impact Parameter vs. #eta;#eta_{Track};d_{z} [cm]",100, -etaMax_, etaMax_, 100,-100.,100.));
1371  vTrack2DHistos_.push_back(book<TH2F>("h2_chi2_vs_phi", "#chi^{2} vs. #phi;#phi_{Track};#chi^{2}", 100, -M_PI, M_PI, 500, 0., 500.));
1372  vTrack2DHistos_.push_back(book<TH2F>("h2_chi2Prob_vs_phi","#chi^{2} probability vs. #phi;#phi_{Track};#chi^{2} probability",100,-M_PI,M_PI,100,0.,1.));
1373  vTrack2DHistos_.push_back(book<TH2F>("h2_chi2Prob_vs_d0","#chi^{2} probability vs. |d_{0}|;|d_{0}| [cm];#chi^{2} probability",100,0,80,100,0.,1.));
1374  vTrack2DHistos_.push_back(book<TH2F>("h2_normchi2_vs_phi", "#chi^{2}/ndof vs. #phi;#phi_{Track};#chi^{2}/ndof", 100, -M_PI, M_PI, 100, 0., 10.));
1375  vTrack2DHistos_.push_back(book<TH2F>("h2_chi2_vs_eta", "#chi^{2} vs. #eta;#eta_{Track};#chi^{2}", 100, -etaMax_, etaMax_, 500, 0., 500.));
1376  vTrack2DHistos_.push_back(book<TH2F>("h2_chi2Prob_vs_eta","#chi^{2} probaility vs. #eta;#eta_{Track};#chi^{2} probability",100,-M_PI,M_PI,100,0.,1.));
1377  vTrack2DHistos_.push_back(book<TH2F>("h2_normchi2_vs_eta", "#chi^{2}/ndof vs. #eta;#eta_{Track};#chi^{2}/ndof", 100, -etaMax_, etaMax_, 100, 0., 10.));
1378  vTrack2DHistos_.push_back(book<TH2F>("h2_kappa_vs_phi", "#kappa vs. #phi;#phi_{Track};#kappa", 100, -M_PI, M_PI, 100, .0, .05));
1379  vTrack2DHistos_.push_back(book<TH2F>("h2_kappa_vs_eta", "#kappa vs. #eta;#eta_{Track};#kappa", 100, -etaMax_, etaMax_, 100, .0, .05));
1380  vTrack2DHistos_.push_back(book<TH2F>("h2_normchi2_vs_kappa", "#kappa vs. #chi^{2}/ndof;#chi^{2}/ndof;#kappa", 100, 0., 10, 100, -.03, .03));
1381 
1382  // clang-format on
1383 
1384  firstEvent_ = true;
1385 
1386  // create the full maps
1387  fullPixelmapXDMR->createTrackerBaseMap();
1388  fullPixelmapYDMR->createTrackerBaseMap();
1389 
1390  } //beginJob
1391 
1392  void endJob() override {
1393  edm::LogPrint("DMRChecker") << "*******************************" << std::endl;
1394  edm::LogPrint("DMRChecker") << "Events run in total: " << ievt << std::endl;
1395  edm::LogPrint("DMRChecker") << "n. tracks: " << itrks << std::endl;
1396  edm::LogPrint("DMRChecker") << "*******************************" << std::endl;
1397 
1398  int nFiringTriggers = !triggerMap_.empty() ? triggerMap_.size() : 1;
1399  edm::LogPrint("DMRChecker") << "firing triggers: " << triggerMap_.size() << std::endl;
1400  edm::LogPrint("DMRChecker") << "*******************************" << std::endl;
1401 
1402  tksByTrigger_ =
1403  book<TH1D>("tksByTrigger", "tracks by HLT path;;% of # traks", nFiringTriggers, -0.5, nFiringTriggers - 0.5);
1404  evtsByTrigger_ =
1405  book<TH1D>("evtsByTrigger", "events by HLT path;;% of # events", nFiringTriggers, -0.5, nFiringTriggers - 0.5);
1406 
1407  if (DEBUG)
1408  edm::LogPrint("DMRChecker") << __FILE__ << "@" << __FUNCTION__ << " L-" << __LINE__ << std::endl;
1409 
1410  int i = 0;
1411  for (const auto &it : triggerMap_) {
1412  i++;
1413 
1414  double trkpercent = ((it.second).second) * 100. / double(itrks);
1415  double evtpercent = ((it.second).first) * 100. / double(ievt);
1416 
1417  std::cout.precision(4);
1418 
1419  edm::LogPrint("DMRChecker") << "HLT path: " << std::setw(60) << left << it.first << " | events firing: " << right
1420  << std::setw(8) << (it.second).first << " (" << setw(8) << fixed << evtpercent << "%)"
1421  << " | tracks collected: " << std::setw(10) << (it.second).second << " (" << setw(8)
1422  << fixed << trkpercent << "%)";
1423 
1424  tksByTrigger_->SetBinContent(i, trkpercent);
1425  tksByTrigger_->GetXaxis()->SetBinLabel(i, (it.first).c_str());
1426 
1427  evtsByTrigger_->SetBinContent(i, evtpercent);
1428  evtsByTrigger_->GetXaxis()->SetBinLabel(i, (it.first).c_str());
1429  }
1430 
1431  if (DEBUG)
1432  edm::LogPrint("DMRChecker") << __FILE__ << "@" << __FUNCTION__ << " L-" << __LINE__ << std::endl;
1433 
1434  int nRuns = conditionsMap_.size();
1435  if (nRuns < 1)
1436  return;
1437 
1438  vector<int> theRuns_;
1439  theRuns_.reserve(conditionsMap_.size());
1440  for (const auto &it : conditionsMap_) {
1441  theRuns_.push_back(it.first);
1442  }
1443 
1444  std::sort(theRuns_.begin(), theRuns_.end());
1445  int runRange = theRuns_.back() - theRuns_.front() + 1;
1446 
1447  edm::LogPrint("DMRChecker") << "*******************************" << std::endl;
1448  edm::LogPrint("DMRChecker") << "first run: " << theRuns_.front() << std::endl;
1449  edm::LogPrint("DMRChecker") << "last run: " << theRuns_.back() << std::endl;
1450  edm::LogPrint("DMRChecker") << "considered runs: " << nRuns << std::endl;
1451  edm::LogPrint("DMRChecker") << "*******************************" << std::endl;
1452 
1453  modeByRun_ = book<TH1D>("modeByRun",
1454  "Strip APV mode by run number;;APV mode (-1=deco,+1=peak)",
1455  runRange,
1456  theRuns_.front() - 0.5,
1457  theRuns_.back() + 0.5);
1458  fieldByRun_ = book<TH1D>("fieldByRun",
1459  "CMS B-field intensity by run number;;B-field intensity [T]",
1460  runRange,
1461  theRuns_.front() - 0.5,
1462  theRuns_.back() + 0.5);
1463 
1464  tracksByRun_ = book<TH1D>("tracksByRun",
1465  "n. AlCaReco Tracks by run number;;n. of tracks",
1466  runRange,
1467  theRuns_.front() - 0.5,
1468  theRuns_.back() + 0.5);
1469  hitsByRun_ = book<TH1D>(
1470  "histByRun", "n. of hits by run number;;n. of hits", runRange, theRuns_.front() - 0.5, theRuns_.back() + 0.5);
1471 
1472  trackRatesByRun_ = book<TH1D>("trackRatesByRun",
1473  "rate of AlCaReco Tracks by run number;;n. of tracks/s",
1474  runRange,
1475  theRuns_.front() - 0.5,
1476  theRuns_.back() + 0.5);
1477  eventRatesByRun_ = book<TH1D>("eventRatesByRun",
1478  "rate of AlCaReco Events by run number;;n. of events/s",
1479  runRange,
1480  theRuns_.front() - 0.5,
1481  theRuns_.back() + 0.5);
1482 
1483  hitsinBPixByRun_ = book<TH1D>("histinBPixByRun",
1484  "n. of hits in BPix by run number;;n. of BPix hits",
1485  runRange,
1486  theRuns_.front() - 0.5,
1487  theRuns_.back() + 0.5);
1488  hitsinFPixByRun_ = book<TH1D>("histinFPixByRun",
1489  "n. of hits in FPix by run number;;n. of FPix hits",
1490  runRange,
1491  theRuns_.front() - 0.5,
1492  theRuns_.back() + 0.5);
1493 
1494  for (const auto &the_r : theRuns_) {
1495  if (conditionsMap_.find(the_r)->second.first != 0) {
1496  auto indexing = (the_r - theRuns_.front()) + 1;
1497  double runTime = timeMap_.find(the_r)->second;
1498 
1499  edm::LogPrint("DMRChecker") << "run:" << the_r << " | isPeak: " << std::setw(4)
1500  << conditionsMap_.find(the_r)->second.first
1501  << "| B-field: " << conditionsMap_.find(the_r)->second.second << " [T]"
1502  << "| events: " << setw(10) << runInfoMap_.find(the_r)->second.first
1503  << "(rate: " << setw(10) << (runInfoMap_.find(the_r)->second.first) / runTime
1504  << " ev/s)"
1505  << ", tracks " << setw(10) << runInfoMap_.find(the_r)->second.second
1506  << "(rate: " << setw(10) << (runInfoMap_.find(the_r)->second.second) / runTime
1507  << " trk/s)" << std::endl;
1508 
1509  // int the_bin = modeByRun_->GetXaxis()->FindBin(the_r);
1510  modeByRun_->SetBinContent(indexing, conditionsMap_.find(the_r)->second.first);
1511  modeByRun_->GetXaxis()->SetBinLabel(indexing, Form("%d", the_r));
1512  fieldByRun_->SetBinContent(indexing, conditionsMap_.find(the_r)->second.second);
1513  fieldByRun_->GetXaxis()->SetBinLabel(indexing, Form("%d", the_r));
1514 
1515  tracksByRun_->SetBinContent(indexing, runInfoMap_.find(the_r)->second.first);
1516  tracksByRun_->GetXaxis()->SetBinLabel(indexing, Form("%d", the_r));
1517  hitsByRun_->SetBinContent(indexing, runInfoMap_.find(the_r)->second.second);
1518  hitsByRun_->GetXaxis()->SetBinLabel(indexing, Form("%d", the_r));
1519 
1520  hitsinBPixByRun_->SetBinContent(indexing, (runHitsMap_.find(the_r)->second)[0]);
1521  hitsinBPixByRun_->GetXaxis()->SetBinLabel(indexing, Form("%d", the_r));
1522  hitsinFPixByRun_->SetBinContent(indexing, (runHitsMap_.find(the_r)->second)[1]);
1523  hitsinFPixByRun_->GetXaxis()->SetBinLabel(indexing, Form("%d", the_r));
1524 
1525  trackRatesByRun_->SetBinContent(indexing, (runInfoMap_.find(the_r)->second.second) / runTime);
1526  trackRatesByRun_->GetXaxis()->SetBinLabel(indexing, Form("%d", the_r));
1527  eventRatesByRun_->SetBinContent(indexing, (runInfoMap_.find(the_r)->second.first) / runTime);
1528  eventRatesByRun_->GetXaxis()->SetBinLabel(indexing, Form("%d", the_r));
1529 
1530  constexpr const char *subdets[]{"BPix", "FPix", "TIB", "TID", "TOB", "TEC"};
1531 
1532  edm::LogPrint("DMRChecker") << "*******************************" << std::endl;
1533  edm::LogPrint("DMRChecker") << "Hits by SubDetector" << std::endl;
1534  int si = 0;
1535  for (const auto &entry : runHitsMap_.find(the_r)->second) {
1536  edm::LogPrint("DMRChecker") << subdets[si] << " " << entry << std::endl;
1537  si++;
1538  }
1539  edm::LogPrint("DMRChecker") << "*******************************" << std::endl;
1540  }
1541 
1542  // modeByRun_->GetXaxis()->SetBinLabel(the_r-theRuns_[0]+1,(const char*)the_r);
1543  }
1544 
1545  if (DEBUG)
1546  edm::LogPrint("DMRChecker") << __FILE__ << "@" << __FUNCTION__ << " L-" << __LINE__ << std::endl;
1547 
1548  // DMRs
1549 
1550  TFileDirectory DMeanR = fs->mkdir("DMRs");
1551 
1552  DMRBPixX_ = DMeanR.make<TH1D>("DMRBPix-X", "DMR of BPix-X;mean of X-residuals;modules", 100., -200, 200);
1553  DMRBPixY_ = DMeanR.make<TH1D>("DMRBPix-Y", "DMR of BPix-Y;mean of Y-residuals;modules", 100., -200, 200);
1554 
1555  DMRFPixX_ = DMeanR.make<TH1D>("DMRFPix-X", "DMR of FPix-X;mean of X-residuals;modules", 100., -200, 200);
1556  DMRFPixY_ = DMeanR.make<TH1D>("DMRFPix-Y", "DMR of FPix-Y;mean of Y-residuals;modules", 100., -200, 200);
1557 
1558  DMRTIB_ = DMeanR.make<TH1D>("DMRTIB", "DMR of TIB;mean of X-residuals;modules", 100., -200, 200);
1559  DMRTOB_ = DMeanR.make<TH1D>("DMRTOB", "DMR of TOB;mean of X-residuals;modules", 100., -200, 200);
1560 
1561  DMRTID_ = DMeanR.make<TH1D>("DMRTID", "DMR of TID;mean of X-residuals;modules", 100., -200, 200);
1562  DMRTEC_ = DMeanR.make<TH1D>("DMRTEC", "DMR of TEC;mean of X-residuals;modules", 100., -200, 200);
1563 
1564  TFileDirectory DMeanRSplit = fs->mkdir("SplitDMRs");
1565 
1566  DMRBPixXSplit_ = bookSplitDMRHistograms(DMeanRSplit, "BPix", "X", true);
1567  DMRBPixYSplit_ = bookSplitDMRHistograms(DMeanRSplit, "BPix", "Y", true);
1568 
1569  DMRFPixXSplit_ = bookSplitDMRHistograms(DMeanRSplit, "FPix", "X", false);
1570  DMRFPixYSplit_ = bookSplitDMRHistograms(DMeanRSplit, "FPix", "Y", false);
1571 
1572  DMRTIBSplit_ = bookSplitDMRHistograms(DMeanRSplit, "TIB", "X", true);
1573  DMRTOBSplit_ = bookSplitDMRHistograms(DMeanRSplit, "TOB", "X", true);
1574 
1575  // DRnRs
1576  TFileDirectory DRnRs = fs->mkdir("DRnRs");
1577 
1578  DRnRBPixX_ = DRnRs.make<TH1D>("DRnRBPix-X", "DRnR of BPix-X;rms of normalized X-residuals;modules", 100., 0., 3.);
1579  DRnRBPixY_ = DRnRs.make<TH1D>("DRnRBPix-Y", "DRnR of BPix-Y;rms of normalized Y-residuals;modules", 100., 0., 3.);
1580 
1581  DRnRFPixX_ = DRnRs.make<TH1D>("DRnRFPix-X", "DRnR of FPix-X;rms of normalized X-residuals;modules", 100., 0., 3.);
1582  DRnRFPixY_ = DRnRs.make<TH1D>("DRnRFPix-Y", "DRnR of FPix-Y;rms of normalized Y-residuals;modules", 100., 0., 3.);
1583 
1584  DRnRTIB_ = DRnRs.make<TH1D>("DRnRTIB", "DRnR of TIB;rms of normalized X-residuals;modules", 100., 0., 3.);
1585  DRnRTOB_ = DRnRs.make<TH1D>("DRnRTOB", "DRnR of TOB;rms of normalized Y-residuals;modules", 100., 0., 3.);
1586 
1587  DRnRTID_ = DRnRs.make<TH1D>("DRnRTID", "DRnR of TID;rms of normalized X-residuals;modules", 100., 0., 3.);
1588  DRnRTEC_ = DRnRs.make<TH1D>("DRnRTEC", "DRnR of TEC;rms of normalized Y-residuals;modules", 100., 0., 3.);
1589 
1590  // initialize the topology first
1591 
1592  SiPixelPI::PhaseInfo ph_info(phase_);
1593  const char *path_toTopologyXML = ph_info.pathToTopoXML();
1594  const TrackerTopology standaloneTopo =
1595  StandaloneTrackerTopology::fromTrackerParametersXMLFile(edm::FileInPath(path_toTopologyXML).fullPath());
1596 
1597  // initialize PixelRegionContainers
1598  PixelDMRS_x_ByLayer = std::make_unique<PixelRegions::PixelRegionContainers>(&standaloneTopo, ph_info.phase());
1599  PixelDMRS_y_ByLayer = std::make_unique<PixelRegions::PixelRegionContainers>(&standaloneTopo, ph_info.phase());
1600 
1601  // book PixelRegionContainers
1602  PixelDMRS_x_ByLayer->bookAll("Barrel Pixel DMRs", "median(x'_{pred}-x'_{hit}) [#mum]", "# modules", 100, -50, 50);
1603  PixelDMRS_y_ByLayer->bookAll("Barrel Pixel DMRs", "median(y'_{pred}-y'_{hit}) [#mum]", "# modules", 100, -50, 50);
1604 
1605  if (DEBUG) {
1606  auto dets = PixelRegions::attachedDets(PixelRegions::PixelId::L1, &standaloneTopo, phase_);
1607  for (const auto &det : dets) {
1608  auto myLocalTopo = PixelDMRS_x_ByLayer->getTheTopo();
1609  edm::LogVerbatim("DMRChecker") << myLocalTopo->print(det) << std::endl;
1610  }
1611  }
1612 
1613  // pixel
1614 
1615  for (auto &bpixid : resDetailsBPixX_) {
1616  DMRBPixX_->Fill(bpixid.second.runningMeanOfRes_);
1617  if (phase_ == SiPixelPI::phase::one) {
1618  pixelmap->fillBarrelBin("DMRsX", bpixid.first, bpixid.second.runningMeanOfRes_);
1619  fullPixelmapXDMR->fillTrackerMap(bpixid.first, bpixid.second.runningMeanOfRes_);
1620  }
1621 
1622  if (DEBUG) {
1623  auto myLocalTopo = PixelDMRS_x_ByLayer->getTheTopo();
1624  edm::LogPrint("DMRChecker") << myLocalTopo->print(bpixid.first) << std::endl;
1625  }
1626 
1627  PixelDMRS_x_ByLayer->fill(bpixid.first, bpixid.second.runningMeanOfRes_);
1628 
1629  // split DMR
1630  if (bpixid.second.rDirection > 0) {
1631  DMRBPixXSplit_[0]->Fill(bpixid.second.runningMeanOfRes_);
1632  } else {
1633  DMRBPixXSplit_[1]->Fill(bpixid.second.runningMeanOfRes_);
1634  }
1635 
1636  if (bpixid.second.hitCount < 2)
1637  DRnRBPixX_->Fill(-1);
1638  else
1639  DRnRBPixX_->Fill(sqrt(bpixid.second.runningNormVarOfRes_ / (bpixid.second.hitCount - 1)));
1640  }
1641 
1642  for (auto &bpixid : resDetailsBPixY_) {
1643  DMRBPixY_->Fill(bpixid.second.runningMeanOfRes_);
1644  if (phase_ == SiPixelPI::phase::one) {
1645  pixelmap->fillBarrelBin("DMRsY", bpixid.first, bpixid.second.runningMeanOfRes_);
1646  fullPixelmapYDMR->fillTrackerMap(bpixid.first, bpixid.second.runningMeanOfRes_);
1647  }
1648 
1649  PixelDMRS_y_ByLayer->fill(bpixid.first, bpixid.second.runningMeanOfRes_);
1650 
1651  // split DMR
1652  if (bpixid.second.rDirection > 0) {
1653  DMRBPixYSplit_[0]->Fill(bpixid.second.runningMeanOfRes_);
1654  } else {
1655  DMRBPixYSplit_[1]->Fill(bpixid.second.runningMeanOfRes_);
1656  }
1657 
1658  if (bpixid.second.hitCount < 2)
1659  DRnRBPixY_->Fill(-1);
1660  else
1661  DRnRBPixY_->Fill(sqrt(bpixid.second.runningNormVarOfRes_ / (bpixid.second.hitCount - 1)));
1662  }
1663 
1664  for (auto &fpixid : resDetailsFPixX_) {
1665  DMRFPixX_->Fill(fpixid.second.runningMeanOfRes_);
1666  if (phase_ == SiPixelPI::phase::one) {
1667  pixelmap->fillForwardBin("DMRsX", fpixid.first, fpixid.second.runningMeanOfRes_);
1668  fullPixelmapXDMR->fillTrackerMap(fpixid.first, fpixid.second.runningMeanOfRes_);
1669  }
1670  PixelDMRS_x_ByLayer->fill(fpixid.first, fpixid.second.runningMeanOfRes_);
1671 
1672  // split DMR
1673  if (fpixid.second.zDirection > 0) {
1674  DMRFPixXSplit_[0]->Fill(fpixid.second.runningMeanOfRes_);
1675  } else {
1676  DMRFPixXSplit_[1]->Fill(fpixid.second.runningMeanOfRes_);
1677  }
1678 
1679  if (fpixid.second.hitCount < 2)
1680  DRnRFPixX_->Fill(-1);
1681  else
1682  DRnRFPixX_->Fill(sqrt(fpixid.second.runningNormVarOfRes_ / (fpixid.second.hitCount - 1)));
1683  }
1684 
1685  for (auto &fpixid : resDetailsFPixY_) {
1686  DMRFPixY_->Fill(fpixid.second.runningMeanOfRes_);
1687  if (phase_ == SiPixelPI::phase::one) {
1688  pixelmap->fillForwardBin("DMRsY", fpixid.first, fpixid.second.runningMeanOfRes_);
1689  fullPixelmapXDMR->fillTrackerMap(fpixid.first, fpixid.second.runningMeanOfRes_);
1690  }
1691  PixelDMRS_y_ByLayer->fill(fpixid.first, fpixid.second.runningMeanOfRes_);
1692 
1693  // split DMR
1694  if (fpixid.second.zDirection > 0) {
1695  DMRFPixYSplit_[0]->Fill(fpixid.second.runningMeanOfRes_);
1696  } else {
1697  DMRFPixYSplit_[1]->Fill(fpixid.second.runningMeanOfRes_);
1698  }
1699 
1700  if (fpixid.second.hitCount < 2)
1701  DRnRFPixY_->Fill(-1);
1702  else
1703  DRnRFPixY_->Fill(sqrt(fpixid.second.runningNormVarOfRes_ / (fpixid.second.hitCount - 1)));
1704  }
1705 
1706  // strips
1707 
1708  for (auto &tibid : resDetailsTIB_) {
1709  DMRTIB_->Fill(tibid.second.runningMeanOfRes_);
1710 
1711  // split DMR
1712  if (tibid.second.rDirection > 0) {
1713  DMRTIBSplit_[0]->Fill(tibid.second.runningMeanOfRes_);
1714  } else {
1715  DMRTIBSplit_[1]->Fill(tibid.second.runningMeanOfRes_);
1716  }
1717 
1718  if (tibid.second.hitCount < 2)
1719  DRnRTIB_->Fill(-1);
1720  else
1721  DRnRTIB_->Fill(sqrt(tibid.second.runningNormVarOfRes_ / (tibid.second.hitCount - 1)));
1722  }
1723 
1724  for (auto &tobid : resDetailsTOB_) {
1725  DMRTOB_->Fill(tobid.second.runningMeanOfRes_);
1726 
1727  // split DMR
1728  if (tobid.second.rDirection > 0) {
1729  DMRTOBSplit_[0]->Fill(tobid.second.runningMeanOfRes_);
1730  } else {
1731  DMRTOBSplit_[1]->Fill(tobid.second.runningMeanOfRes_);
1732  }
1733 
1734  if (tobid.second.hitCount < 2)
1735  DRnRTOB_->Fill(-1);
1736  else
1737  DRnRTOB_->Fill(sqrt(tobid.second.runningNormVarOfRes_ / (tobid.second.hitCount - 1)));
1738  }
1739 
1740  for (auto &tidid : resDetailsTID_) {
1741  DMRTID_->Fill(tidid.second.runningMeanOfRes_);
1742 
1743  if (tidid.second.hitCount < 2)
1744  DRnRTID_->Fill(-1);
1745  else
1746  DRnRTID_->Fill(sqrt(tidid.second.runningNormVarOfRes_ / (tidid.second.hitCount - 1)));
1747  }
1748 
1749  for (auto &tecid : resDetailsTEC_) {
1750  DMRTEC_->Fill(tecid.second.runningMeanOfRes_);
1751 
1752  if (tecid.second.hitCount < 2)
1753  DRnRTEC_->Fill(-1);
1754  else
1755  DRnRTEC_->Fill(sqrt(tecid.second.runningNormVarOfRes_ / (tecid.second.hitCount - 1)));
1756  }
1757 
1758  edm::LogPrint("DMRChecker") << "n. of bpix modules " << resDetailsBPixX_.size() << std::endl;
1759  edm::LogPrint("DMRChecker") << "n. of fpix modules " << resDetailsFPixX_.size() << std::endl;
1760 
1761  if (phase_ == SiPixelPI::phase::zero) {
1762  pmap->save(true, 0, 0, "PixelHitMap.pdf", 600, 800);
1763  pmap->save(true, 0, 0, "PixelHitMap.png", 500, 750);
1764  }
1765 
1766  tmap->save(true, 0, 0, "StripHitMap.pdf");
1767  tmap->save(true, 0, 0, "StripHitMap.png");
1768 
1769  if (phase_ == SiPixelPI::phase::one) {
1770  gStyle->SetPalette(kRainBow);
1771  pixelmap->beautifyAllHistograms();
1772 
1773  TCanvas cBX("CanvXBarrel", "CanvXBarrel", 1200, 1000);
1774  pixelmap->drawBarrelMaps("DMRsX", cBX);
1775  cBX.SaveAs("pixelBarrelDMR_x.png");
1776 
1777  TCanvas cFX("CanvXForward", "CanvXForward", 1600, 1000);
1778  pixelmap->drawForwardMaps("DMRsX", cFX);
1779  cFX.SaveAs("pixelForwardDMR_x.png");
1780 
1781  TCanvas cBY("CanvYBarrel", "CanvYBarrel", 1200, 1000);
1782  pixelmap->drawBarrelMaps("DMRsY", cBY);
1783  cBY.SaveAs("pixelBarrelDMR_y.png");
1784 
1785  TCanvas cFY("CanvXForward", "CanvXForward", 1600, 1000);
1786  pixelmap->drawForwardMaps("DMRsY", cFY);
1787  cFY.SaveAs("pixelForwardDMR_y.png");
1788 
1789  TCanvas cFullPixelxDMR("CanvFullPixelX", "CanvFullPixelX", 3000, 2000);
1790  fullPixelmapXDMR->printTrackerMap(cFullPixelxDMR);
1791  cFullPixelxDMR.SaveAs("fullPixelDMR_x.png");
1792 
1793  TCanvas cFullPixelyDMR("CanvFullPixelX", "CanvFullPixelY", 3000, 2000);
1794  fullPixelmapXDMR->printTrackerMap(cFullPixelyDMR);
1795  cFullPixelyDMR.SaveAs("fullPixelDMR_y.png");
1796  }
1797 
1798  // take care now of the 1D histograms
1799  gStyle->SetOptStat("emr");
1800  PixelDMRS_x_ByLayer->beautify(2, 0);
1801  PixelDMRS_y_ByLayer->beautify(2, 0);
1802 
1803  TCanvas DMRxBarrel("DMRxBarrelCanv", "x-coordinate", 1400, 1200);
1804  DMRxBarrel.Divide(2, 2);
1805  PixelDMRS_x_ByLayer->draw(DMRxBarrel, true, "HISTS");
1806  adjustCanvases(DMRxBarrel, true);
1807  for (unsigned int c = 1; c <= 4; c++) {
1808  DMRxBarrel.cd(c)->Update();
1809  }
1810  PixelDMRS_x_ByLayer->stats();
1811 
1812  TCanvas DMRxForward("DMRxForwardCanv", "x-coordinate", 1400, 1200);
1813  DMRxForward.Divide(4, 3);
1814  PixelDMRS_x_ByLayer->draw(DMRxForward, false, "HISTS");
1815  adjustCanvases(DMRxForward, false);
1816  for (unsigned int c = 1; c <= 12; c++) {
1817  DMRxForward.cd(c)->Update();
1818  }
1819  PixelDMRS_x_ByLayer->stats();
1820 
1821  DMRxBarrel.SaveAs("DMR_x_Barrel_ByLayer.png");
1822  DMRxForward.SaveAs("DMR_x_Forward_ByRing.png");
1823 
1824  TCanvas DMRyBarrel("DMRyBarrelCanv", "y-coordinate", 1400, 1200);
1825  DMRyBarrel.Divide(2, 2);
1826  PixelDMRS_y_ByLayer->draw(DMRyBarrel, true, "HISTS");
1827  adjustCanvases(DMRyBarrel, true);
1828  for (unsigned int c = 1; c <= 4; c++) {
1829  DMRyBarrel.cd(c)->Update();
1830  }
1831  PixelDMRS_y_ByLayer->stats();
1832 
1833  TCanvas DMRyForward("DMRyForwardCanv", "y-coordinate", 1400, 1200);
1834  DMRyForward.Divide(4, 3);
1835  PixelDMRS_y_ByLayer->draw(DMRyForward, false, "HISTS");
1836  adjustCanvases(DMRyForward, false);
1837  for (unsigned int c = 1; c <= 12; c++) {
1838  DMRyForward.cd(c)->Update();
1839  }
1840  PixelDMRS_y_ByLayer->stats();
1841 
1842  DMRyBarrel.SaveAs("DMR_y_Barrel_ByLayer.png");
1843  DMRyForward.SaveAs("DMR_y_Forward_ByRing.png");
1844  }
1845 
1846  //*************************************************************
1847  // Adjust canvas for DMRs
1848  //*************************************************************
1849  void adjustCanvases(TCanvas &canvas, bool isBarrel) {
1850  unsigned int maxPads = isBarrel ? 4 : 12;
1851  for (unsigned int c = 1; c <= maxPads; c++) {
1852  canvas.cd(c);
1853  SiPixelPI::adjustCanvasMargins(canvas.cd(c), 0.06, 0.12, 0.12, 0.05);
1854  }
1855 
1856  auto ltx = TLatex();
1857  ltx.SetTextFont(62);
1858  ltx.SetTextSize(0.05);
1859  ltx.SetTextAlign(11);
1860 
1861  std::string toAppend = canvas.GetTitle();
1862 
1863  for (unsigned int c = 1; c <= maxPads; c++) {
1864  auto index = isBarrel ? c - 1 : c + 3;
1865  canvas.cd(c);
1866  ltx.DrawLatexNDC(gPad->GetLeftMargin(),
1867  1 - gPad->GetTopMargin() + 0.01,
1868  (PixelRegions::IDlabels.at(index) + " " + toAppend).c_str());
1869  }
1870  }
1871 
1872  //*************************************************************
1873  // check if the hit is 2D
1874  //*************************************************************
1875  bool isHit2D(const TrackingRecHit &hit) {
1876  bool countStereoHitAs2D_ = true;
1877  // we count SiStrip stereo modules as 2D if selected via countStereoHitAs2D_
1878  // (since they provide theta information)
1879  if (!hit.isValid() ||
1880  (hit.dimension() < 2 && !countStereoHitAs2D_ && !dynamic_cast<const SiStripRecHit1D *>(&hit))) {
1881  return false; // real RecHit1D - but SiStripRecHit1D depends on countStereoHitAs2D_
1882  } else {
1883  const DetId detId(hit.geographicalId());
1884  if (detId.det() == DetId::Tracker) {
1885  if (detId.subdetId() == kBPIX || detId.subdetId() == kFPIX) {
1886  return true; // pixel is always 2D
1887  } else { // should be SiStrip now
1888  const SiStripDetId stripId(detId);
1889  if (stripId.stereo())
1890  return countStereoHitAs2D_; // stereo modules
1891  else if (dynamic_cast<const SiStripRecHit1D *>(&hit) || dynamic_cast<const SiStripRecHit2D *>(&hit))
1892  return false; // rphi modules hit
1893  //the following two are not used any more since ages...
1894  else if (dynamic_cast<const SiStripMatchedRecHit2D *>(&hit))
1895  return true; // matched is 2D
1896  else if (dynamic_cast<const ProjectedSiStripRecHit2D *>(&hit)) {
1897  const ProjectedSiStripRecHit2D *pH = static_cast<const ProjectedSiStripRecHit2D *>(&hit);
1898  return (countStereoHitAs2D_ && this->isHit2D(pH->originalHit())); // depends on original...
1899  } else {
1900  edm::LogError("UnknownType") << "@SUB=DMRChecker::isHit2D"
1901  << "Tracker hit not in pixel, neither SiStripRecHit[12]D nor "
1902  << "SiStripMatchedRecHit2D nor ProjectedSiStripRecHit2D.";
1903  return false;
1904  }
1905  }
1906  } else { // not tracker??
1907  edm::LogWarning("DetectorMismatch") << "@SUB=DMRChecker::isHit2D"
1908  << "Hit not in tracker with 'official' dimension >=2.";
1909  return true; // dimension() >= 2 so accept that...
1910  }
1911  }
1912  // never reached...
1913  }
1914 
1915  //*************************************************************
1916  // Generic booker of split DMRs
1917  //*************************************************************
1918  std::array<TH1D *, 2> bookSplitDMRHistograms(TFileDirectory dir,
1919  std::string subdet,
1920  std::string vartype,
1921  bool isBarrel) {
1922  TH1F::SetDefaultSumw2(kTRUE);
1923 
1924  std::array<TH1D *, 2> out;
1925  std::array<std::string, 2> sign_name = {{"plus", "minus"}};
1926  std::array<std::string, 2> sign = {{">0", "<0"}};
1927  for (unsigned int i = 0; i < 2; i++) {
1928  const char *name_;
1929  const char *title_;
1930  const char *axisTitle_;
1931 
1932  if (isBarrel) {
1933  name_ = Form("DMR%s_%s_rDir%s", subdet.c_str(), vartype.c_str(), sign_name[i].c_str());
1934  title_ = Form("Split DMR of %s-%s (rDir%s)", subdet.c_str(), vartype.c_str(), sign[i].c_str());
1935  axisTitle_ = Form("mean of %s-residuals (rDir%s);modules", vartype.c_str(), sign[i].c_str());
1936  } else {
1937  name_ = Form("DMR%s_%s_zDir%s", subdet.c_str(), vartype.c_str(), sign_name[i].c_str());
1938  title_ = Form("Split DMR of %s-%s (zDir%s)", subdet.c_str(), vartype.c_str(), sign[i].c_str());
1939  axisTitle_ = Form("mean of %s-residuals (zDir%s);modules", vartype.c_str(), sign[i].c_str());
1940  }
1941 
1942  out[i] = dir.make<TH1D>(name_, fmt::sprintf("%s;%s", title_, axisTitle_).c_str(), 100., -200, 200);
1943  }
1944  return out;
1945  }
1946 
1947  //*************************************************************
1948  // Generic booker function
1949  //*************************************************************
1950  std::map<unsigned int, TH1D *> bookResidualsHistogram(
1951  TFileDirectory dir, unsigned int theNLayers, std::string resType, std::string varType, std::string detType) {
1952  TH1F::SetDefaultSumw2(kTRUE);
1953 
1954  std::pair<double, double> limits;
1955 
1956  if (varType.find("Res") != std::string::npos) {
1957  limits = std::make_pair(-1000., 1000);
1958  } else {
1959  limits = std::make_pair(-3., 3.);
1960  }
1961 
1962  std::map<unsigned int, TH1D *> h;
1963 
1964  for (unsigned int i = 1; i <= theNLayers; i++) {
1965  const char *name_;
1966  const char *title_;
1967  std::string xAxisTitle_;
1968 
1969  if (varType.find("Res") != std::string::npos) {
1970  xAxisTitle_ = fmt::sprintf("res_{%s'} [#mum]", resType);
1971  } else {
1972  xAxisTitle_ = fmt::sprintf("res_{%s'}/#sigma_{res_{%s`}}", resType, resType);
1973  }
1974 
1975  unsigned int side = -1;
1976  if (detType.find("FPix") != std::string::npos) {
1977  side = (i - 1) / 3 + 1;
1978  unsigned int plane = (i - 1) % 3 + 1;
1979 
1980  std::string theSide = "";
1981  if (side == 1) {
1982  theSide = "Z-";
1983  } else {
1984  theSide = "Z+";
1985  }
1986 
1987  name_ = Form("h_%s%s%s_side%i_disk%i", detType.c_str(), varType.c_str(), resType.c_str(), side, plane);
1988  title_ = Form("%s (%s, disk %i) track %s-%s;%s;hits",
1989  detType.c_str(),
1990  theSide.c_str(),
1991  plane,
1992  resType.c_str(),
1993  varType.c_str(),
1994  xAxisTitle_.c_str());
1995 
1996  } else {
1997  name_ = Form("h_%s%s%s_layer%i", detType.c_str(), varType.c_str(), resType.c_str(), i);
1998  title_ = Form("%s (layer %i) track %s-%s;%s;hits",
1999  detType.c_str(),
2000  i,
2001  resType.c_str(),
2002  varType.c_str(),
2003  xAxisTitle_.c_str());
2004 
2005  //edm::LogPrint("DMRChecker")<<"bookResidualsHistogram(): "<<i<<" layer:"<<i<<std::endl;
2006  }
2007 
2008  h[i] = dir.make<TH1D>(name_, title_, 100, limits.first, limits.second);
2009  }
2010 
2011  return h;
2012  }
2013 
2014  //*************************************************************
2015  // Generic filler function
2016  //*************************************************************
2017  void fillByIndex(std::map<unsigned int, TH1D *> &h, unsigned int index, double x) {
2018  if (h.count(index) != 0) {
2019  //if(TString(h[index]->GetName()).Contains("BPix"))
2020  //edm::LogPrint("DMRChecker")<<"fillByIndex() index: "<< index << " filling histogram: "<< h[index]->GetName() << std::endl;
2021 
2022  double min = h[index]->GetXaxis()->GetXmin();
2023  double max = h[index]->GetXaxis()->GetXmax();
2024  if (x < min)
2025  h[index]->Fill(min);
2026  else if (x >= max)
2027  h[index]->Fill(0.99999 * max);
2028  else
2029  h[index]->Fill(x);
2030  }
2031  }
2032 
2033  //*************************************************************
2034  // Implementation of the online variance algorithm
2035  // as in https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Online_algorithm
2036  //*************************************************************
2037  void updateOnlineMomenta(running::estimatorMap &myDetails, uint32_t theID, float the_data, float the_pull) {
2038  myDetails[theID].hitCount += 1;
2039 
2040  float delta = 0;
2041  float n_delta = 0;
2042 
2043  if (myDetails[theID].hitCount != 1) {
2044  delta = the_data - myDetails[theID].runningMeanOfRes_;
2045  n_delta = the_pull - myDetails[theID].runningNormMeanOfRes_;
2046  myDetails[theID].runningMeanOfRes_ += (delta / myDetails[theID].hitCount);
2047  myDetails[theID].runningNormMeanOfRes_ += (n_delta / myDetails[theID].hitCount);
2048  } else {
2049  myDetails[theID].runningMeanOfRes_ = the_data;
2050  myDetails[theID].runningNormMeanOfRes_ = the_pull;
2051  }
2052 
2053  float delta2 = the_data - myDetails[theID].runningMeanOfRes_;
2054  float n_delta2 = the_pull - myDetails[theID].runningNormMeanOfRes_;
2055 
2056  myDetails[theID].runningVarOfRes_ += delta * delta2;
2057  myDetails[theID].runningNormVarOfRes_ += n_delta * n_delta2;
2058  }
2059 
2060  //*************************************************************
2061  // Fill the histograms using the running::estimatorMap
2062  //**************************************************************
2063  void fillDMRs(const running::estimatorMap &myDetails,
2064  TH1D *DMR,
2065  TH1D *DRnR,
2066  std::array<TH1D *, 2> DMRSplit,
2067  std::unique_ptr<PixelRegions::PixelRegionContainers> regionalDMR) {
2068  for (const auto &element : myDetails) {
2069  // DMR
2070  DMR->Fill(element.second.runningMeanOfRes_);
2071 
2072  // DMR by layer
2073  if (regionalDMR.get()) {
2074  regionalDMR->fill(element.first, element.second.runningMeanOfRes_);
2075  }
2076 
2077  // split DMR
2078  if (element.second.rOrZDirection > 0) {
2079  DMRSplit[0]->Fill(element.second.runningMeanOfRes_);
2080  } else {
2081  DMRSplit[1]->Fill(element.second.runningMeanOfRes_);
2082  }
2083 
2084  // DRnR
2085  if (element.second.hitCount < 2) {
2086  DRnR->Fill(-1);
2087  } else {
2088  DRnR->Fill(sqrt(element.second.runningNormVarOfRes_ / (element.second.hitCount - 1)));
2089  }
2090  }
2091  }
2092 };
2093 
2094 //*************************************************************
2095 void DMRChecker::fillDescriptions(edm::ConfigurationDescriptions &descriptions)
2096 //*************************************************************
2097 {
2098  edm::ParameterSetDescription desc;
2099  desc.setComment("Generic track analyzer to check ALCARECO sample quantities / compute fast DMRs");
2100  desc.add<edm::InputTag>("TkTag", edm::InputTag("generalTracks"));
2101  desc.add<edm::InputTag>("TriggerResultsTag", edm::InputTag("TriggerResults", "", "HLT"));
2102  desc.add<edm::InputTag>("BeamSpotTag", edm::InputTag("offlineBeamSpot"));
2103  desc.add<edm::InputTag>("VerticesTag", edm::InputTag("offlinePrimaryVertices"));
2104  desc.add<bool>("isCosmics", false);
2105  descriptions.addWithDefaultLabel(desc);
2106 }
2107 
2108 DEFINE_FWK_MODULE(DMRChecker);
alignBH_cfg.fixed
fixed
Definition: alignBH_cfg.py:54
DMRChecker::hHitMinus
TH1D * hHitMinus
Definition: DMRChecker.cc:325
TFileService::kSharedResource
static const std::string kSharedResource
Definition: TFileService.h:76
DMRChecker::hTECResXPrime
TH1D * hTECResXPrime
Definition: DMRChecker.cc:291
DMRChecker::bookSplitDMRHistograms
std::array< TH1D *, 2 > bookSplitDMRHistograms(TFileDirectory dir, std::string subdet, std::string vartype, bool isBarrel)
Definition: DMRChecker.cc:1918
DMRChecker::hPhihp
TH1D * hPhihp
Definition: DMRChecker.cc:331
DMRChecker::resDetailsTEC_
running::estimatorMap resDetailsTEC_
Definition: DMRChecker.cc:502
edm::LogVerbatim
Log< level::Info, true > LogVerbatim
Definition: MessageLogger.h:134
StripSubdetector::TEC
static constexpr auto TEC
Definition: StripSubdetector.h:19
DMRChecker::hPhiOverlapMinus
TH1D * hPhiOverlapMinus
Definition: DMRChecker.cc:344
DMRChecker::trackerTopology_
const TrackerTopology * trackerTopology_
Definition: DMRChecker.cc:238
DMRChecker::hFPixZMinusResYPull
TH1D * hFPixZMinusResYPull
Definition: DMRChecker.cc:286
edm::ConfigurationDescriptions::addWithDefaultLabel
void addWithDefaultLabel(ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:87
jetUpdater_cfi.sort
sort
Definition: jetUpdater_cfi.py:30
ProducerED_cfi.InputTag
InputTag
Definition: ProducerED_cfi.py:5
deDxTools::esConsumes
ESGetTokenH3DDVariant esConsumes(std::string const &Record, edm::ConsumesCollector &)
Definition: DeDxTools.cc:283
DMRChecker::hHitCountVsXFPix
TH1D * hHitCountVsXFPix
Definition: DMRChecker.cc:299
DMRChecker::hHitCountVsYFPixPlus
TH1D * hHitCountVsYFPixPlus
Definition: DMRChecker.cc:313
TrackerTopology::pxbLayer
unsigned int pxbLayer(const DetId &id) const
Definition: TrackerTopology.h:146
DMRChecker::hFPixZPlusResXPrime
TH1D * hFPixZPlusResXPrime
Definition: DMRChecker.cc:270
DMRChecker::hHitCountVsXFPixPlus
TH1D * hHitCountVsXFPixPlus
Definition: DMRChecker.cc:311
DMRChecker::hHitCountVsYFPixMinus
TH1D * hHitCountVsYFPixMinus
Definition: DMRChecker.cc:314
PV3DBase::perp
T perp() const
Definition: PV3DBase.h:69
DMRChecker::eventRatesByRun_
TH1D * eventRatesByRun_
Definition: DMRChecker.cc:407
DMRChecker::hFPixZMinusResXPrime
TH1D * hFPixZMinusResXPrime
Definition: DMRChecker.cc:271
DMRChecker::hDeltaPhi
TH1D * hDeltaPhi
Definition: DMRChecker.cc:350
DMRChecker::modeByRun_
TH1D * modeByRun_
Definition: DMRChecker.cc:400
mps_fire.i
i
Definition: mps_fire.py:429
seconds
double seconds()
DMRChecker::tracksByRun_
TH1D * tracksByRun_
Definition: DMRChecker.cc:403
DMRChecker::hitsinFPixByRun_
TH1D * hitsinFPixByRun_
Definition: DMRChecker.cc:410
HLTBitAnalyser_cfi.hltresults
hltresults
Definition: HLTBitAnalyser_cfi.py:13
DMRChecker::fullPixelmapXDMR
std::unique_ptr< Phase1PixelSummaryMap > fullPixelmapXDMR
Definition: DMRChecker.cc:243
DMRChecker::vTrackProfiles_
std::vector< TH1 * > vTrackProfiles_
Definition: DMRChecker.cc:394
DMRChecker::hHitCountVsZFPixMinus
TH1D * hHitCountVsZFPixMinus
Definition: DMRChecker.cc:316
DMRChecker::hPtPlus
TH1D * hPtPlus
Definition: DMRChecker.cc:263
DMRChecker::book
T * book(const Args &...args) const
Definition: DMRChecker.cc:223
DMRChecker::hnhpxe
TH1D * hnhpxe
Definition: DMRChecker.cc:370
DMRChecker::resDetailsBPixX_
running::estimatorMap resDetailsBPixX_
Definition: DMRChecker.cc:492
DMRChecker::triggerMap_
std::map< std::string, std::pair< int, int > > triggerMap_
Definition: DMRChecker.cc:483
reco::Vertex::z
double z() const
z coordinate
Definition: Vertex.h:133
DMRChecker::hPhiEndcapMinus
TH1D * hPhiEndcapMinus
Definition: DMRChecker.cc:346
DMRChecker::hEta
TH1D * hEta
Definition: DMRChecker.cc:338
DMRChecker::fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &)
Definition: DMRChecker.cc:2095
PV3DBase::z
T z() const
Definition: PV3DBase.h:61
PixelRegions::IDlabels
const std::vector< std::string > IDlabels
Definition: PixelRegionContainers.h:62
DMRChecker::runHitsMap_
std::map< int, std::array< int, 6 > > runHitsMap_
Definition: DMRChecker.cc:486
DMRChecker::hdxyBS
TH1D * hdxyBS
Definition: DMRChecker.cc:384
edm::TriggerNames::triggerNames
Strings const & triggerNames() const
Definition: TriggerNames.cc:48
MagneticField::inTesla
virtual GlobalVector inTesla(const GlobalPoint &gp) const =0
Field value ad specified global point, in Tesla.
DMRChecker::hd0
TH1D * hd0
Definition: DMRChecker.cc:357
DMRChecker::endcapDisksPullsX
std::map< unsigned int, TH1D * > endcapDisksPullsX
Definition: DMRChecker.cc:459
DMRChecker::resDetailsTOB_
running::estimatorMap resDetailsTOB_
Definition: DMRChecker.cc:500
DMRChecker::hvz
TH1D * hvz
Definition: DMRChecker.cc:356
PV3DBase::phi
Geom::Phi< T > phi() const
Definition: PV3DBase.h:66
DMRChecker::resDetailsBPixY_
running::estimatorMap resDetailsBPixY_
Definition: DMRChecker.cc:493
Validation_hcalonly_cfi.sign
sign
Definition: Validation_hcalonly_cfi.py:32
GlobalPoint
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
DMRChecker::hTOBResXPrime
TH1D * hTOBResXPrime
Definition: DMRChecker.cc:289
reco::TrackCollection
std::vector< Track > TrackCollection
collection of Tracks
Definition: TrackFwd.h:14
SiPixelRawToDigiRegional_cfi.deltaPhi
deltaPhi
Definition: SiPixelRawToDigiRegional_cfi.py:9
MagneticField::inInverseGeV
GlobalVector inInverseGeV(const GlobalPoint &gp) const
Field value ad specified global point, in 1/Gev.
Definition: MagneticField.h:36
DMRChecker::htrkQuality
TH1I * htrkQuality
Definition: DMRChecker.cc:255
DMRChecker::hFPixZPlusResYPull
TH1D * hFPixZPlusResYPull
Definition: DMRChecker.cc:285
DMRChecker::hHit
TH1D * hHit
Definition: DMRChecker.cc:265
DMRChecker::firstEvent_
bool firstEvent_
Definition: DMRChecker.cc:466
DMRChecker::hPtMinus
TH1D * hPtMinus
Definition: DMRChecker.cc:264
pwdgSkimBPark_cfi.beamSpot
beamSpot
Definition: pwdgSkimBPark_cfi.py:5
muonDTDigis_cfi.pset
pset
Definition: muonDTDigis_cfi.py:27
DMRChecker::resDetailsFPixY_
running::estimatorMap resDetailsFPixY_
Definition: DMRChecker.cc:495
DMRChecker::hFPixResYPull
TH1D * hFPixResYPull
Definition: DMRChecker.cc:284
DMRChecker::hd0BS
TH1D * hd0BS
Definition: DMRChecker.cc:385
DMRChecker::hCharge
TH1D * hCharge
Definition: DMRChecker.cc:335
DMRChecker::hTECResXPull
TH1D * hTECResXPull
Definition: DMRChecker.cc:296
DMRChecker::hDeltaEta
TH1D * hDeltaEta
Definition: DMRChecker.cc:351
DMRChecker::pNBpixHitsVsVx
TProfile * pNBpixHitsVsVx
Definition: DMRChecker.cc:378
DMRChecker::pNBpixHitsVsVz
TProfile * pNBpixHitsVsVz
Definition: DMRChecker.cc:380
DMRChecker::hHitCountVsThetaFPix
TH1D * hHitCountVsThetaFPix
Definition: DMRChecker.cc:308
DMRChecker::DRnRFPixY_
TH1D * DRnRFPixY_
Definition: DMRChecker.cc:424
DMRChecker::TriggerResultsTag_
edm::InputTag TriggerResultsTag_
Definition: DMRChecker.cc:474
multiplicitycorr_cfi.xBins
xBins
Definition: multiplicitycorr_cfi.py:5
DMRChecker::hMultCand
TH1D * hMultCand
Definition: DMRChecker.cc:382
DMRChecker::hNtrkZoom
TH1D * hNtrkZoom
Definition: DMRChecker.cc:254
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:129
DMRChecker::fillByIndex
void fillByIndex(std::map< unsigned int, TH1D *> &h, unsigned int index, double x)
Definition: DMRChecker.cc:2017
DMRChecker::runInfoMap_
std::map< int, std::pair< int, int > > runInfoMap_
Definition: DMRChecker.cc:485
DMRChecker::endcapDisksResidualsX
std::map< unsigned int, TH1D * > endcapDisksResidualsX
Definition: DMRChecker.cc:458
accept
bool accept(const edm::Event &event, const edm::TriggerResults &triggerTable, const std::string &triggerPath)
Definition: TopDQMHelpers.h:31
DMRChecker::hHitComposition
TH1D * hHitComposition
Definition: DMRChecker.cc:376
DMRChecker::bookResidualsHistogram
std::map< unsigned int, TH1D * > bookResidualsHistogram(TFileDirectory dir, unsigned int theNLayers, std::string resType, std::string varType, std::string detType)
Definition: DMRChecker.cc:1950
DMRChecker::BeamSpotTag_
edm::InputTag BeamSpotTag_
Definition: DMRChecker.cc:475
DMRChecker::hPhiBarrel
TH1D * hPhiBarrel
Definition: DMRChecker.cc:342
DMRChecker::hHithp
TH1D * hHithp
Definition: DMRChecker.cc:329
DMRChecker::hHitCountVsZFPixPlus
TH1D * hHitCountVsZFPixPlus
Definition: DMRChecker.cc:315
DMRChecker::hEtaPlus
TH1D * hEtaPlus
Definition: DMRChecker.cc:339
DMRChecker::TkTag_
edm::InputTag TkTag_
Definition: DMRChecker.cc:473
DMRChecker::index
int index(const std::vector< OBJECT_TYPE *> &vec, const std::string &name)
Definition: DMRChecker.cc:211
DMRChecker::hvx
TH1D * hvx
Definition: DMRChecker.cc:354
HltBtagPostValidation_cff.c
c
Definition: HltBtagPostValidation_cff.py:35
DMRChecker::hHitCountVsZBPix
TH1D * hHitCountVsZBPix
Definition: DMRChecker.cc:302
DMRChecker::resDetailsTID_
running::estimatorMap resDetailsTID_
Definition: DMRChecker.cc:501
DMRChecker::hHitCountVsYFPix
TH1D * hHitCountVsYFPix
Definition: DMRChecker.cc:301
DMRChecker::trackRatesByRun_
TH1D * trackRatesByRun_
Definition: DMRChecker.cc:406
DMRChecker::hchi2ndofhp
TH1D * hchi2ndofhp
Definition: DMRChecker.cc:332
DMRChecker::DMRTID_
TH1D * DMRTID_
Definition: DMRChecker.cc:431
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
DMRChecker::timeMap_
std::map< int, float > timeMap_
Definition: DMRChecker.cc:488
DMRChecker::DRnRFPixX_
TH1D * DRnRFPixX_
Definition: DMRChecker.cc:423
DeadROC_duringRun.dir
dir
Definition: DeadROC_duringRun.py:23
PV3DBase::barePhi
T barePhi() const
Definition: PV3DBase.h:65
dumpRecoGeometry_cfg.varType
varType
Definition: dumpRecoGeometry_cfg.py:8
DMRChecker::hFPixZPlusResYPrime
TH1D * hFPixZPlusResYPrime
Definition: DMRChecker.cc:275
DMRChecker::hd0vspt
TH2D * hd0vspt
Definition: DMRChecker.cc:367
DMRChecker::hFPixZPlusResXPull
TH1D * hFPixZPlusResXPull
Definition: DMRChecker.cc:280
DMRChecker::hTOBResXPull
TH1D * hTOBResXPull
Definition: DMRChecker.cc:294
DMRChecker::DMRTIBSplit_
std::array< TH1D *, 2 > DMRTIBSplit_
Definition: DMRChecker.cc:448
DMRChecker::hPthp
TH1D * hPthp
Definition: DMRChecker.cc:328
dumpMFGeometry_cfg.delta
delta
Definition: dumpMFGeometry_cfg.py:25
DMRChecker::hHitCountVsPhiFPix
TH1D * hHitCountVsPhiFPix
Definition: DMRChecker.cc:309
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:222
DMRChecker::beginJob
void beginJob() override
Definition: DMRChecker.cc:1128
SiPixelPI::PhaseInfo::phase
const SiPixelPI::phase phase() const
Definition: SiPixelPayloadInspectorHelper.h:70
DMRChecker::hEtaMinus
TH1D * hEtaMinus
Definition: DMRChecker.cc:340
PixelPluginsPhase0_cfi.isBarrel
isBarrel
Definition: PixelPluginsPhase0_cfi.py:17
DMRChecker::hchi2Probhp
TH1D * hchi2Probhp
Definition: DMRChecker.cc:333
TFileDirectory::make
T * make(const Args &...args) const
make new ROOT object
Definition: TFileDirectory.h:53
DMRChecker::hPPlus
TH1D * hPPlus
Definition: DMRChecker.cc:259
DMRChecker::hFPixResYPrime
TH1D * hFPixResYPrime
Definition: DMRChecker.cc:274
running::estimatorMap
std::map< uint32_t, running::Estimators > estimatorMap
Definition: DMRChecker.cc:146
DMRChecker::fullPixelmapYDMR
std::unique_ptr< Phase1PixelSummaryMap > fullPixelmapYDMR
Definition: DMRChecker.cc:244
PV3DBase::x
T x() const
Definition: PV3DBase.h:59
PV3DBase::y
T y() const
Definition: PV3DBase.h:60
DMRChecker::hHitCountVsPhiBPix
TH1D * hHitCountVsPhiBPix
Definition: DMRChecker.cc:306
DMRChecker::DRnRBPixX_
TH1D * DRnRBPixX_
Definition: DMRChecker.cc:420
DMRChecker::DMRChecker
DMRChecker(const edm::ParameterSet &pset)
Definition: DMRChecker.cc:152
DMRChecker::hBPixResYPull
TH1D * hBPixResYPull
Definition: DMRChecker.cc:283
DMRChecker::magneticField_
const MagneticField * magneticField_
Definition: DMRChecker.cc:236
DMRChecker::hHitCountVsXFPixMinus
TH1D * hHitCountVsXFPixMinus
Definition: DMRChecker.cc:312
DMRChecker::hHitCountVsPhiFPixPlus
TH1D * hHitCountVsPhiFPixPlus
Definition: DMRChecker.cc:319
DMRChecker::hQoverPZoom
TH1D * hQoverPZoom
Definition: DMRChecker.cc:337
cscTnPEfficiencyTask_cfi.trigName
trigName
Definition: cscTnPEfficiencyTask_cfi.py:23
DMRChecker::hPhiEndcapPlus
TH1D * hPhiEndcapPlus
Definition: DMRChecker.cc:345
DMRChecker::PixelDMRS_x_ByLayer
std::unique_ptr< PixelRegions::PixelRegionContainers > PixelDMRS_x_ByLayer
Definition: DMRChecker.cc:246
mps_splice.entry
entry
Definition: mps_splice.py:68
DMRChecker::theTrackCollectionToken_
edm::EDGetTokenT< reco::TrackCollection > theTrackCollectionToken_
Definition: DMRChecker.cc:478
DMRChecker::DMRBPixY_
TH1D * DMRBPixY_
Definition: DMRChecker.cc:415
ALCARECOPromptCalibProdSiPixelAli0T_cff.mode
mode
Definition: ALCARECOPromptCalibProdSiPixelAli0T_cff.py:96
DMRChecker::beginRun
void beginRun(edm::Run const &run, edm::EventSetup const &setup) override
Definition: DMRChecker.cc:1073
DMRChecker::hHitCountVsThetaFPixPlus
TH1D * hHitCountVsThetaFPixPlus
Definition: DMRChecker.cc:318
DMRChecker::hFPixZMinusResXPull
TH1D * hFPixZMinusResXPull
Definition: DMRChecker.cc:281
DMRChecker::hHitCountVsZFPix
TH1D * hHitCountVsZFPix
Definition: DMRChecker.cc:303
DMRChecker::hdzBS
TH1D * hdzBS
Definition: DMRChecker.cc:386
DMRChecker::DMRTIB_
TH1D * DMRTIB_
Definition: DMRChecker.cc:428
TrackingRecHit::isValid
bool isValid() const
Definition: TrackingRecHit.h:141
DMRChecker::hP
TH1D * hP
Definition: DMRChecker.cc:258
DMRChecker::hNtrk
TH1D * hNtrk
Definition: DMRChecker.cc:253
DMRChecker::hnhTOB
TH1D * hnhTOB
Definition: DMRChecker.cc:373
DMRChecker::barrelLayersPullsX
std::map< unsigned int, TH1D * > barrelLayersPullsX
Definition: DMRChecker.cc:454
HcalObjRepresent::Fill
void Fill(HcalDetId &id, double val, std::vector< TH2F > &depth)
Definition: HcalObjRepresent.h:1053
TrackerGeometry::isThere
bool isThere(GeomDetEnumerators::SubDetector subdet) const
Definition: TrackerGeometry.cc:219
cmToUm
constexpr float cmToUm
Definition: DMRChecker.cc:127
DMRChecker::pmap
std::unique_ptr< TrackerMap > pmap
Definition: DMRChecker.cc:250
DMRChecker::DMRBPixXSplit_
std::array< TH1D *, 2 > DMRBPixXSplit_
Definition: DMRChecker.cc:442
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
DMRChecker::endJob
void endJob() override
Definition: DMRChecker.cc:1392
DMRChecker::DRnRTEC_
TH1D * DRnRTEC_
Definition: DMRChecker.cc:438
DMRChecker::hHitCountVsYBPix
TH1D * hHitCountVsYBPix
Definition: DMRChecker.cc:300
SiStripDetId::stereo
uint32_t stereo() const
Definition: SiStripDetId.h:168
DMRChecker::vertexToken_
edm::EDGetTokenT< reco::VertexCollection > vertexToken_
Definition: DMRChecker.cc:481
DMRChecker::vTrackHistos_
std::vector< TH1 * > vTrackHistos_
Definition: DMRChecker.cc:393
DMRChecker::beamspotToken_
edm::EDGetTokenT< reco::BeamSpot > beamspotToken_
Definition: DMRChecker.cc:480
DMRChecker::fieldByRun_
TH1D * fieldByRun_
Definition: DMRChecker.cc:401
PV3DBase::mag
T mag() const
Definition: PV3DBase.h:64
TrackerTopology::pxfDisk
unsigned int pxfDisk(const DetId &id) const
Definition: TrackerTopology.h:482
DMRChecker::hvy
TH1D * hvy
Definition: DMRChecker.cc:355
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
DMRChecker::hdzPV
TH1D * hdzPV
Definition: DMRChecker.cc:389
edm::Transition
Transition
Definition: Transition.h:12
DMRChecker::DMRTOB_
TH1D * DMRTOB_
Definition: DMRChecker.cc:429
DMRChecker::hPMinus
TH1D * hPMinus
Definition: DMRChecker.cc:260
DMRChecker::hPhiOverlapPlus
TH1D * hPhiOverlapPlus
Definition: DMRChecker.cc:343
DMRChecker::conditionsMap_
std::map< int, std::pair< int, float > > conditionsMap_
Definition: DMRChecker.cc:484
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
DMRChecker::updateOnlineMomenta
void updateOnlineMomenta(running::estimatorMap &myDetails, uint32_t theID, float the_data, float the_pull)
Definition: DMRChecker.cc:2037
DMRChecker::DMRFPixXSplit_
std::array< TH1D *, 2 > DMRFPixXSplit_
Definition: DMRChecker.cc:445
DMRChecker::tmap
std::unique_ptr< TrackerMap > tmap
Definition: DMRChecker.cc:249
DMRChecker::endcapDisksResidualsY
std::map< unsigned int, TH1D * > endcapDisksResidualsY
Definition: DMRChecker.cc:460
DMRChecker::DRnRTIB_
TH1D * DRnRTIB_
Definition: DMRChecker.cc:434
singleTopDQM_cfi.setup
setup
SETUP
Definition: singleTopDQM_cfi.py:37
DMRChecker::DMRBPixX_
TH1D * DMRBPixX_
Definition: DMRChecker.cc:414
reco::Vertex::x
double x() const
x coordinate
Definition: Vertex.h:129
StripSubdetector::TOB
static constexpr auto TOB
Definition: StripSubdetector.h:18
DMRChecker::trackerGeometry_
const TrackerGeometry * trackerGeometry_
Definition: DMRChecker.cc:237
DMRChecker::hEtahp
TH1D * hEtahp
Definition: DMRChecker.cc:330
SiPixelPI::adjustCanvasMargins
void adjustCanvasMargins(TVirtualPad *pad, float top, float bottom, float left, float right)
Definition: SiPixelPayloadInspectorHelper.h:509
DMRChecker::resDetailsFPixX_
running::estimatorMap resDetailsFPixX_
Definition: DMRChecker.cc:494
JetHT_cfg.trackCollection
trackCollection
Definition: JetHT_cfg.py:51
DMRChecker::resDetailsTIB_
running::estimatorMap resDetailsTIB_
Definition: DMRChecker.cc:499
edm::LogPrint
Log< level::Warning, true > LogPrint
Definition: MessageLogger.h:136
DMRChecker::hPt
TH1D * hPt
Definition: DMRChecker.cc:261
TrackerGeometry::idToDet
const TrackerGeomDet * idToDet(DetId) const override
Definition: TrackerGeometry.cc:193
hcalRecHitTable_cff.detId
detId
Definition: hcalRecHitTable_cff.py:12
DMRChecker::hlumi
TH1D * hlumi
Definition: DMRChecker.cc:391
reco::Vertex::y
double y() const
y coordinate
Definition: Vertex.h:131
DMRChecker::hrun
TH1D * hrun
Definition: DMRChecker.cc:390
DMRChecker::hFPixResXPrime
TH1D * hFPixResXPrime
Definition: DMRChecker.cc:269
qualities
const char * qualities[3]
Definition: beamSpotDipStandalone.cc:21
DMRChecker::hchi2ndof
TH1D * hchi2ndof
Definition: DMRChecker.cc:252
M_PI
#define M_PI
Definition: BXVectorInputProducer.cc:50
DMRChecker::DMRFPixY_
TH1D * DMRFPixY_
Definition: DMRChecker.cc:418
DMRChecker::barrelLayersResidualsX
std::map< unsigned int, TH1D * > barrelLayersResidualsX
Definition: DMRChecker.cc:453
DMRChecker::hnhTID
TH1D * hnhTID
Definition: DMRChecker.cc:372
DMRChecker::hPhi
TH1D * hPhi
Definition: DMRChecker.cc:341
DMRChecker::hHitCountVsPhiFPixMinus
TH1D * hHitCountVsPhiFPixMinus
Definition: DMRChecker.cc:322
DMRChecker::hFPixZMinusResYPrime
TH1D * hFPixZMinusResYPrime
Definition: DMRChecker.cc:276
edm::LogInfo
Log< level::Info, false > LogInfo
Definition: MessageLogger.h:131
SiStripDetId
Detector identifier class for the strip tracker.
Definition: SiStripDetId.h:18
DMRChecker::hd0PV
TH1D * hd0PV
Definition: DMRChecker.cc:388
DMRChecker::hnhTEC
TH1D * hnhTEC
Definition: DMRChecker.cc:374
DMRChecker::runInfoToken_
const edm::ESGetToken< RunInfo, RunInfoRcd > runInfoToken_
Definition: DMRChecker.cc:231
DMRChecker::hd0PVvseta
TH2D * hd0PVvseta
Definition: DMRChecker.cc:362
DetId
Definition: DetId.h:17
DMRChecker::hHitCountVsThetaFPixMinus
TH1D * hHitCountVsThetaFPixMinus
Definition: DMRChecker.cc:321
SiStripLatency::singleReadOutMode
int16_t singleReadOutMode() const
Definition: SiStripLatency.cc:122
TrackerTopology::pxfSide
unsigned int pxfSide(const DetId &id) const
Definition: TrackerTopology.h:194
DMRChecker::hHitPlus
TH1D * hHitPlus
Definition: DMRChecker.cc:324
MillePedeFileConverter_cfg.out
out
Definition: MillePedeFileConverter_cfg.py:31
StripSubdetector::TIB
static constexpr auto TIB
Definition: StripSubdetector.h:16
DMRChecker::latencyToken_
const edm::ESGetToken< SiStripLatency, SiStripLatencyRcd > latencyToken_
Definition: DMRChecker.cc:234
fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
DMRChecker::barrelLayersResidualsY
std::map< unsigned int, TH1D * > barrelLayersResidualsY
Definition: DMRChecker.cc:455
DMRChecker::tksByTrigger_
TH1D * tksByTrigger_
Definition: DMRChecker.cc:397
DMRChecker::barrelLayersPullsY
std::map< unsigned int, TH1D * > barrelLayersPullsY
Definition: DMRChecker.cc:456
DMRChecker::topoToken_
const edm::ESGetToken< TrackerTopology, TrackerTopologyRcd > topoToken_
Definition: DMRChecker.cc:233
DMRChecker::hBPixResYPrime
TH1D * hBPixResYPrime
Definition: DMRChecker.cc:273
DMRChecker::pixelmap
std::unique_ptr< Phase1PixelMaps > pixelmap
Definition: DMRChecker.cc:242
math::XYZPoint
XYZPointD XYZPoint
point in space with cartesian internal representation
Definition: Point3D.h:12
DMRChecker::phase_
SiPixelPI::phase phase_
Definition: DMRChecker.cc:468
DMRChecker::hTIBResXPrime
TH1D * hTIBResXPrime
Definition: DMRChecker.cc:288
DMRChecker::magFieldToken_
const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > magFieldToken_
Definition: DMRChecker.cc:232
DMRChecker::hltresultsToken_
edm::EDGetTokenT< edm::TriggerResults > hltresultsToken_
Definition: DMRChecker.cc:479
DMRChecker::hTIDResXPull
TH1D * hTIDResXPull
Definition: DMRChecker.cc:295
DMRChecker::pNBpixHitsVsVy
TProfile * pNBpixHitsVsVy
Definition: DMRChecker.cc:379
DMRChecker::hPhiMinus
TH1D * hPhiMinus
Definition: DMRChecker.cc:348
DMRChecker::hPhp
TH1D * hPhp
Definition: DMRChecker.cc:327
DMRChecker::endRun
void endRun(edm::Run const &, edm::EventSetup const &) override
Definition: DMRChecker.cc:1125
nano_mu_local_reco_cff.bool
bool
Definition: nano_mu_local_reco_cff.py:13
edm::TriggerNames::triggerName
std::string const & triggerName(unsigned int index) const
Definition: TriggerNames.cc:50
DMRChecker::DRnRTID_
TH1D * DRnRTID_
Definition: DMRChecker.cc:437
DMRChecker::DRnRTOB_
TH1D * DRnRTOB_
Definition: DMRChecker.cc:435
DMRChecker::hnhTIB
TH1D * hnhTIB
Definition: DMRChecker.cc:371
DMRChecker::hFPixResXPull
TH1D * hFPixResXPull
Definition: DMRChecker.cc:279
DMRChecker::hPhiPlus
TH1D * hPhiPlus
Definition: DMRChecker.cc:347
reco::TrackBase::algoNames
static const std::string algoNames[]
Definition: TrackBase.h:147
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
DMRChecker::hdz
TH1D * hdz
Definition: DMRChecker.cc:358
DMRChecker::isCosmics_
const bool isCosmics_
Definition: DMRChecker.cc:471
DMRChecker::DMRFPixYSplit_
std::array< TH1D *, 2 > DMRFPixYSplit_
Definition: DMRChecker.cc:446
DMRChecker::hQoverP
TH1D * hQoverP
Definition: DMRChecker.cc:336
DMRChecker::VerticesTag_
edm::InputTag VerticesTag_
Definition: DMRChecker.cc:476
DMRChecker::hd0vseta
TH2D * hd0vseta
Definition: DMRChecker.cc:366
DMRChecker::hdxyPV
TH1D * hdxyPV
Definition: DMRChecker.cc:387
edm
HLT enums.
Definition: AlignableModifier.h:19
ProjectedSiStripRecHit2D::originalHit
SiStripRecHit2D originalHit() const
Definition: ProjectedSiStripRecHit2D.h:56
DMRChecker::DMRFPixX_
TH1D * DMRFPixX_
Definition: DMRChecker.cc:417
DMRChecker::fs
edm::Service< TFileService > fs
Definition: DMRChecker.cc:240
DEBUG
#define DEBUG
Definition: DMRChecker.cc:120
edm::OwnVector::const_iterator
Definition: OwnVector.h:41
DMRChecker::hBPixResXPrime
TH1D * hBPixResXPrime
Definition: DMRChecker.cc:268
DMRChecker::adjustCanvases
void adjustCanvases(TCanvas &canvas, bool isBarrel)
Definition: DMRChecker.cc:1849
DMRChecker::DMRTOBSplit_
std::array< TH1D *, 2 > DMRTOBSplit_
Definition: DMRChecker.cc:449
StandaloneTrackerTopology::fromTrackerParametersXMLFile
TrackerTopology fromTrackerParametersXMLFile(const std::string &xmlFileName)
Definition: StandaloneTrackerTopology.cc:168
svgfig.canvas
def canvas(sub, attr)
Definition: svgfig.py:482
DMRChecker::hdxy
TH1D * hdxy
Definition: DMRChecker.cc:359
DMRChecker::htrkAlgo
TH1I * htrkAlgo
Definition: DMRChecker.cc:256
DMRChecker::PixelDMRS_y_ByLayer
std::unique_ptr< PixelRegions::PixelRegionContainers > PixelDMRS_y_ByLayer
Definition: DMRChecker.cc:247
DMRChecker::hHit2D
TH1D * hHit2D
Definition: DMRChecker.cc:266
x
float x
Definition: beamSpotDipStandalone.cc:55
DMRChecker::hHitCountVsThetaBPix
TH1D * hHitCountVsThetaBPix
Definition: DMRChecker.cc:305
DMRChecker::hBPixResXPull
TH1D * hBPixResXPull
Definition: DMRChecker.cc:278
DMRChecker::fillDMRs
void fillDMRs(const running::estimatorMap &myDetails, TH1D *DMR, TH1D *DRnR, std::array< TH1D *, 2 > DMRSplit, std::unique_ptr< PixelRegions::PixelRegionContainers > regionalDMR)
Definition: DMRChecker.cc:2063
DMRChecker::DMRTEC_
TH1D * DMRTEC_
Definition: DMRChecker.cc:432
DMRChecker::hHitCountVsXBPix
TH1D * hHitCountVsXBPix
Definition: DMRChecker.cc:298
DMRChecker::hnhpxb
TH1D * hnhpxb
Definition: DMRChecker.cc:369
DMRChecker::hTIDResXPrime
TH1D * hTIDResXPrime
Definition: DMRChecker.cc:290
gather_cfg.cout
cout
Definition: gather_cfg.py:144
DMRChecker::hd0PVvspt
TH2D * hd0PVvspt
Definition: DMRChecker.cc:363
DMRChecker::endcapDisksPullsY
std::map< unsigned int, TH1D * > endcapDisksPullsY
Definition: DMRChecker.cc:461
DMRChecker::geomToken_
const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord > geomToken_
Definition: DMRChecker.cc:230
DMRChecker::hd0vsphi
TH2D * hd0vsphi
Definition: DMRChecker.cc:365
hgcalLayerClustersEE_cfi.kappa
kappa
Definition: hgcalLayerClustersEE_cfi.py:19
DMRChecker::DRnRBPixY_
TH1D * DRnRBPixY_
Definition: DMRChecker.cc:421
DMRChecker::evtsByTrigger_
TH1D * evtsByTrigger_
Definition: DMRChecker.cc:398
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:128
F
static uInt32 F(BLOWFISH_CTX *ctx, uInt32 x)
Definition: blowfish.cc:163
DMRChecker::hMinPt
TH1D * hMinPt
Definition: DMRChecker.cc:262
PVValHelper::fillByIndex
void fillByIndex(std::vector< TH1F *> &h, unsigned int index, double x, std::string tag="")
Definition: PVValidationHelpers.cc:42
h
The Signals That Services Can Subscribe To This is based on ActivityRegistry h
Helper function to determine trigger accepts.
Definition: Activities.doc:4
kFPIX
const int kFPIX
Definition: DMRChecker.cc:126
DMRChecker::etaMax_
float etaMax_
Definition: DMRChecker.cc:469
T
long double T
Definition: Basic3DVectorLD.h:48
DMRChecker::hDeltaR
TH1D * hDeltaR
Definition: DMRChecker.cc:352
DMRChecker::hitsinBPixByRun_
TH1D * hitsinBPixByRun_
Definition: DMRChecker.cc:409
fireworks::subdets
static const std::string subdets[7]
Definition: TrackUtils.cc:60
StripSubdetector::TID
static constexpr auto TID
Definition: StripSubdetector.h:17
DMR
Definition: DMR.py:1
PixelRegions::attachedDets
static const std::vector< uint32_t > attachedDets(const PixelRegions::PixelId theId, const TrackerTopology *trackTopo, const SiPixelPI::phase &ph)
Definition: PixelRegionContainers.h:187
DMRChecker::hTIBResXPull
TH1D * hTIBResXPull
Definition: DMRChecker.cc:293
DMRChecker::analyze
void analyze(const edm::Event &event, const edm::EventSetup &setup) override
Definition: DMRChecker.cc:504
DMRChecker::hd0PVvsphi
TH2D * hd0PVvsphi
Definition: DMRChecker.cc:361
crab_NZS2018C_1.runRange
runRange
Definition: crab_NZS2018C_1.py:37
point
*vegas h *****************************************************used in the default bin number in original ***version of VEGAS is ***a higher bin number might help to derive a more precise ***grade subtle point
Definition: invegas.h:5
DMRChecker::DMRBPixYSplit_
std::array< TH1D *, 2 > DMRBPixYSplit_
Definition: DMRChecker.cc:443
event
Definition: event.py:1
edm::Run
Definition: Run.h:45
DMRChecker::isHit2D
bool isHit2D(const TrackingRecHit &hit)
Definition: DMRChecker.cc:1875
PV3DBase::theta
Geom::Theta< T > theta() const
Definition: PV3DBase.h:72
HLT_2023v12_cff.track
track
Definition: HLT_2023v12_cff.py:9604
Skims_PA_cff.name
name
Definition: Skims_PA_cff.py:17
kBPIX
const int kBPIX
Definition: DMRChecker.cc:125
SiPixelRecHit
Our base class.
Definition: SiPixelRecHit.h:23
DMRChecker::vTrack2DHistos_
std::vector< TH1 * > vTrack2DHistos_
Definition: DMRChecker.cc:395
DMRChecker::hNhighPurity
TH1D * hNhighPurity
Definition: DMRChecker.cc:257
DMRChecker::hitsByRun_
TH1D * hitsByRun_
Definition: DMRChecker.cc:404
Generated for CMSSW Reference Manual by doxygen 1.8.14