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