CMS 3D CMS Logo

GeneralPurposeTrackAnalyzer.cc
Go to the documentation of this file.
1 // -*- C++ -*-
2 //
3 // Package: Alignment/OfflineValidation
4 // Class: GeneralPurposeTrackAnalyzer
5 //
9 //
10 // Original Author: Marco Musich
11 // Created: Mon, 13 Jun 2016 15:07:11 GMT
12 //
13 //
14 
15 // ROOT includes files
16 
17 #include "TMath.h"
18 #include "TFile.h"
19 #include "TH1D.h"
20 #include "TH1I.h"
21 #include "TH2D.h"
22 #include "TProfile.h"
23 
24 // system includes files
25 
26 #include <cmath>
27 #include <fstream>
28 #include <iostream>
29 #include <map>
30 #include <string>
31 #include <vector>
32 #include <boost/range/adaptor/indexed.hpp>
33 
34 // user include files
81 
82 // toggle to enable debugging
83 #define DEBUG 0
84 
87 
88 class GeneralPurposeTrackAnalyzer : public edm::one::EDAnalyzer<edm::one::WatchRuns, edm::one::SharedResources> {
89 public:
92  magFieldToken_(esConsumes<edm::Transition::BeginRun>()),
93  latencyToken_(esConsumes<edm::Transition::BeginRun>()),
94  geomTokenBR_(esConsumes<edm::Transition::BeginRun>()),
97  usesResource(TFileService::kSharedResource);
98 
99  TkTag_ = pset.getParameter<edm::InputTag>("TkTag");
100  theTrackCollectionToken_ = consumes<reco::TrackCollection>(TkTag_);
101 
102  TriggerResultsTag_ = pset.getParameter<edm::InputTag>("TriggerResultsTag");
103  hltresultsToken_ = consumes<edm::TriggerResults>(TriggerResultsTag_);
104 
105  BeamSpotTag_ = pset.getParameter<edm::InputTag>("BeamSpotTag");
106  beamspotToken_ = consumes<reco::BeamSpot>(BeamSpotTag_);
107 
108  VerticesTag_ = pset.getParameter<edm::InputTag>("VerticesTag");
109  vertexToken_ = consumes<reco::VertexCollection>(VerticesTag_);
110 
111  isCosmics_ = pset.getParameter<bool>("isCosmics");
112 
113  pmap = std::make_unique<TrackerMap>("Pixel");
114  pmap->onlyPixel(true);
115  pmap->setTitle("Pixel Hit entries");
116  pmap->setPalette(1);
117 
118  tmap = std::make_unique<TrackerMap>("Strip");
119  tmap->setTitle("Strip Hit entries");
120  tmap->setPalette(1);
121 
122  pixelmap = std::make_unique<Phase1PixelMaps>("COLZ0 L");
123  pixelmap->bookBarrelHistograms("entriesBarrel", "# hits", "# pixel hits");
124  pixelmap->bookForwardHistograms("entriesForward", "# hits", "# pixel hits");
125 
126  pixelrocsmap_ = std::make_unique<Phase1PixelROCMaps>("");
127  }
128 
129  ~GeneralPurposeTrackAnalyzer() override = default;
130 
132 
133  template <class OBJECT_TYPE>
134  int index(const std::vector<OBJECT_TYPE *> &vec, const TString &name) {
135  for (const auto &iter : vec | boost::adaptors::indexed(0)) {
136  if (iter.value() && iter.value()->GetName() == name) {
137  return iter.index();
138  }
139  }
140  edm::LogError("GeneralPurposeTrackAnalyzer") << "@SUB=GeneralPurposeTrackAnalyzer::index"
141  << " could not find " << name;
142  return -1;
143  }
144 
145  template <typename T, typename... Args>
146  T *book(const Args &...args) const {
147  T *t = fs->make<T>(args...);
148  return t;
149  }
150 
151 private:
152  // tokens for the event setup
156 
160 
162 
164 
166 
167  std::unique_ptr<TrackerMap> tmap;
168  std::unique_ptr<TrackerMap> pmap;
169 
170  std::unique_ptr<Phase1PixelMaps> pixelmap;
171  std::unique_ptr<Phase1PixelROCMaps> pixelrocsmap_;
172 
173  TH1D *hchi2ndof;
174  TH1D *hNtrk;
175  TH1D *hNtrkZoom;
176  TH1I *htrkQuality;
177  TH1I *htrkAlgo;
178  TH1I *htrkOriAlgo;
180  TH1D *hP;
181  TH1D *hPPlus;
182  TH1D *hPMinus;
183  TH1D *hPt;
184  TH1D *hMinPt;
185  TH1D *hPtPlus;
186  TH1D *hPtMinus;
187  TH1D *hHit;
188  TH1D *hHit2D;
189 
196 
199 
202 
203  TH1D *hHitPlus;
204  TH1D *hHitMinus;
205 
206  TH1D *hPhp;
207  TH1D *hPthp;
208  TH1D *hHithp;
209  TH1D *hEtahp;
210  TH1D *hPhihp;
211  TH1D *hchi2ndofhp;
212  TH1D *hchi2Probhp;
213 
214  TH1D *hCharge;
215  TH1D *hQoverP;
216  TH1D *hQoverPZoom;
217  TH1D *hEta;
218  TH1D *hEtaPlus;
219  TH1D *hEtaMinus;
220  TH1D *hPhi;
221  TH1D *hPhiBarrel;
226  TH1D *hPhiPlus;
227  TH1D *hPhiMinus;
228 
229  TH1D *hDeltaPhi;
230  TH1D *hDeltaEta;
231  TH1D *hDeltaR;
232 
233  TH1D *hvx;
234  TH1D *hvy;
235  TH1D *hvz;
236  TH1D *hd0;
237  TH1D *hdz;
238  TH1D *hdxy;
239 
240  TH2D *hd0PVvsphi;
241  TH2D *hd0PVvseta;
242  TH2D *hd0PVvspt;
243 
244  TH2D *hd0vsphi;
245  TH2D *hd0vseta;
246  TH2D *hd0vspt;
247 
248  TH1D *hnhpxb;
249  TH1D *hnhpxe;
250  TH1D *hnhTIB;
251  TH1D *hnhTID;
252  TH1D *hnhTOB;
253  TH1D *hnhTEC;
254 
256 
257  TProfile *pNBpixHitsVsVx;
258  TProfile *pNBpixHitsVsVy;
259  TProfile *pNBpixHitsVsVz;
260 
261  TH1D *hMultCand;
262 
263  TH1D *hdxyBS;
264  TH1D *hd0BS;
265  TH1D *hdzBS;
266  TH1D *hdxyPV;
267  TH1D *hd0PV;
268  TH1D *hdzPV;
269  TH1D *hrun;
270  TH1D *hlumi;
271 
272  std::vector<TH1 *> vTrackHistos_;
273  std::vector<TH1 *> vTrackProfiles_;
274  std::vector<TH1 *> vTrack2DHistos_;
275 
278 
279  TH1D *modeByRun_;
280  TH1D *fieldByRun_;
281 
282  int ievt;
283  int itrks;
284  int mode;
286  bool isPhase1_;
287  float etaMax_;
288 
290 
295 
297 
302 
303  std::map<std::string, std::pair<int, int> > triggerMap_;
304  std::map<int, std::pair<int, float> > conditionsMap_;
305  std::map<int, std::pair<int, int> > runInfoMap_;
306 
307  //*************************************************************
308  void analyze(const edm::Event &event, const edm::EventSetup &setup) override
309  //*************************************************************
310  {
311  ievt++;
312 
314 
315  // geometry setup
316  const TrackerGeometry *theGeometry = &setup.getData(geomToken_);
317 
318  // switch on the phase1
319  if ((theGeometry->isThere(GeomDetEnumerators::P1PXB)) || (theGeometry->isThere(GeomDetEnumerators::P1PXEC))) {
320  isPhase1_ = true;
321  } else {
322  isPhase1_ = false;
323  }
324 
325  const reco::TrackCollection tC = *(trackCollection.product());
326  itrks += tC.size();
327 
328  runInfoMap_[event.run()].first += 1;
329  runInfoMap_[event.run()].second += tC.size();
330 
331  if (DEBUG) {
332  edm::LogInfo("GeneralPurposeTrackAnalyzer") << "Reconstructed " << tC.size() << " tracks" << std::endl;
333  }
334  //int iCounter=0;
335 
337  if (hltresults.isValid()) {
338  const edm::TriggerNames &triggerNames_ = event.triggerNames(*hltresults);
339  int ntrigs = hltresults->size();
340  //const vector<std::string> &triggernames = triggerNames_.triggerNames();
341 
342  for (int itrig = 0; itrig != ntrigs; ++itrig) {
343  const std::string &trigName = triggerNames_.triggerName(itrig);
344  bool accept = hltresults->accept(itrig);
345  if (accept == 1) {
346  if (DEBUG) {
347  edm::LogInfo("GeneralPurposeTrackAnalyzer")
348  << trigName << " " << accept << " ,track size: " << tC.size() << std::endl;
349  }
350  triggerMap_[trigName].first += 1;
351  triggerMap_[trigName].second += tC.size();
352  // triggerInfo.push_back(pair <std::string, int> (trigName, accept));
353  }
354  }
355  }
356 
357  hrun->Fill(event.run());
358  hlumi->Fill(event.luminosityBlock());
359 
360  int nHighPurityTracks = 0;
361 
362  for (auto track = tC.cbegin(); track != tC.cend(); track++) {
363  unsigned int nHit2D = 0;
364  std::bitset<16> rocsToMask;
365  for (auto iHit = track->recHitsBegin(); iHit != track->recHitsEnd(); ++iHit) {
366  if (this->isHit2D(**iHit)) {
367  ++nHit2D;
368  }
369  // rest the ROCs for the map
370  rocsToMask.reset();
371  const DetId &detId = (*iHit)->geographicalId();
372  const GeomDet *geomDet(theGeometry->idToDet(detId));
373 
374  const SiPixelRecHit *pixhit = dynamic_cast<const SiPixelRecHit *>(*iHit);
375 
376  if (pixhit) {
377  if (pixhit->isValid()) {
378  unsigned int subid = detId.subdetId();
379  int detid_db = detId.rawId();
380 
381  // get the cluster
382  auto clustp = pixhit->cluster();
383 
384  if (clustp.isNull())
385  continue;
386  auto const &cluster = *clustp;
387  int row = cluster.x() - 0.5, col = cluster.y() - 0.5;
388  int rocId = coord_.roc(detId, std::make_pair(row, col));
389 
390  rocsToMask.set(rocId);
391  pixelrocsmap_->fillSelectedRocs(detid_db, rocsToMask, 1);
392 
393  if (!isPhase1_) {
394  pmap->fill(detid_db, 1);
395  } else {
396  if (subid == PixelSubdetector::PixelBarrel) {
397  pixelmap->fillBarrelBin("entriesBarrel", detid_db, 1);
398  } else {
399  pixelmap->fillForwardBin("entriesForward", detid_db, 1);
400  }
401  }
402 
403  LocalPoint lp = (*iHit)->localPosition();
404  //LocalError le = (*iHit)->localPositionError();
405 
406  GlobalPoint GP = geomDet->surface().toGlobal(lp);
407 
408  if ((subid == PixelSubdetector::PixelBarrel) || (subid == PixelSubdetector::PixelEndcap)) {
409  // 1 = PXB, 2 = PXF
410  if (subid == PixelSubdetector::PixelBarrel) {
411  hHitCountVsThetaBPix->Fill(GP.theta());
412  hHitCountVsPhiBPix->Fill(GP.phi());
413 
414  hHitCountVsZBPix->Fill(GP.z());
415  hHitCountVsXBPix->Fill(GP.x());
416  hHitCountVsYBPix->Fill(GP.y());
417 
418  } else if (subid == PixelSubdetector::PixelEndcap) {
419  hHitCountVsThetaFPix->Fill(GP.theta());
420  hHitCountVsPhiFPix->Fill(GP.phi());
421 
422  hHitCountVsZFPix->Fill(GP.z());
423  hHitCountVsXFPix->Fill(GP.x());
424  hHitCountVsYFPix->Fill(GP.y());
425  }
426  }
427  }
428  } else {
429  if ((*iHit)->isValid()) {
430  tmap->fill(detId.rawId(), 1);
431  }
432  }
433  }
434 
435  hHit2D->Fill(nHit2D);
436  hHit->Fill(track->numberOfValidHits());
437  hnhpxb->Fill(track->hitPattern().numberOfValidPixelBarrelHits());
438  hnhpxe->Fill(track->hitPattern().numberOfValidPixelEndcapHits());
439  hnhTIB->Fill(track->hitPattern().numberOfValidStripTIBHits());
440  hnhTID->Fill(track->hitPattern().numberOfValidStripTIDHits());
441  hnhTOB->Fill(track->hitPattern().numberOfValidStripTOBHits());
442  hnhTEC->Fill(track->hitPattern().numberOfValidStripTECHits());
443 
444  // fill hit composition histogram
445  if (track->hitPattern().numberOfValidPixelBarrelHits() != 0) {
446  hHitComposition->Fill(0., track->hitPattern().numberOfValidPixelBarrelHits());
447 
448  pNBpixHitsVsVx->Fill(track->vx(), track->hitPattern().numberOfValidPixelBarrelHits());
449  pNBpixHitsVsVy->Fill(track->vy(), track->hitPattern().numberOfValidPixelBarrelHits());
450  pNBpixHitsVsVz->Fill(track->vz(), track->hitPattern().numberOfValidPixelBarrelHits());
451  }
452  if (track->hitPattern().numberOfValidPixelEndcapHits() != 0) {
453  hHitComposition->Fill(1., track->hitPattern().numberOfValidPixelEndcapHits());
454  }
455  if (track->hitPattern().numberOfValidStripTIBHits() != 0) {
456  hHitComposition->Fill(2., track->hitPattern().numberOfValidStripTIBHits());
457  }
458  if (track->hitPattern().numberOfValidStripTIDHits() != 0) {
459  hHitComposition->Fill(3., track->hitPattern().numberOfValidStripTIDHits());
460  }
461  if (track->hitPattern().numberOfValidStripTOBHits() != 0) {
462  hHitComposition->Fill(4., track->hitPattern().numberOfValidStripTOBHits());
463  }
464  if (track->hitPattern().numberOfValidStripTECHits() != 0) {
465  hHitComposition->Fill(5., track->hitPattern().numberOfValidStripTECHits());
466  }
467 
468  hCharge->Fill(track->charge());
469  hQoverP->Fill(track->qoverp());
470  hQoverPZoom->Fill(track->qoverp());
471  hPt->Fill(track->pt());
472  hP->Fill(track->p());
473  hchi2ndof->Fill(track->normalizedChi2());
474  hEta->Fill(track->eta());
475  hPhi->Fill(track->phi());
476 
477  if (fabs(track->eta()) < 0.8) {
478  hPhiBarrel->Fill(track->phi());
479  }
480  if (track->eta() > 0.8 && track->eta() < 1.4) {
481  hPhiOverlapPlus->Fill(track->phi());
482  }
483  if (track->eta() < -0.8 && track->eta() > -1.4) {
484  hPhiOverlapMinus->Fill(track->phi());
485  }
486  if (track->eta() > 1.4) {
487  hPhiEndcapPlus->Fill(track->phi());
488  }
489  if (track->eta() < -1.4) {
490  hPhiEndcapMinus->Fill(track->phi());
491  }
492 
493  hd0->Fill(track->d0());
494  hdz->Fill(track->dz());
495  hdxy->Fill(track->dxy());
496  hvx->Fill(track->vx());
497  hvy->Fill(track->vy());
498  hvz->Fill(track->vz());
499 
500  htrkAlgo->Fill(static_cast<int>(track->algo()));
501  htrkOriAlgo->Fill(static_cast<int>(track->originalAlgo()));
502 
503  int myquality = -99;
504  if (track->quality(reco::TrackBase::undefQuality)) {
505  myquality = -1;
506  htrkQuality->Fill(myquality);
507  }
508  if (track->quality(reco::TrackBase::loose)) {
509  myquality = 0;
510  htrkQuality->Fill(myquality);
511  }
512  if (track->quality(reco::TrackBase::tight)) {
513  myquality = 1;
514  htrkQuality->Fill(myquality);
515  }
516  if (track->quality(reco::TrackBase::highPurity) && (!isCosmics_)) {
517  myquality = 2;
518  htrkQuality->Fill(myquality);
519  hPhp->Fill(track->p());
520  hPthp->Fill(track->pt());
521  hHithp->Fill(track->numberOfValidHits());
522  hEtahp->Fill(track->eta());
523  hPhihp->Fill(track->phi());
524  hchi2ndofhp->Fill(track->normalizedChi2());
525  hchi2Probhp->Fill(TMath::Prob(track->chi2(), track->ndof()));
526  nHighPurityTracks++;
527  }
528  if (track->quality(reco::TrackBase::confirmed)) {
529  myquality = 3;
530  htrkQuality->Fill(myquality);
531  }
532  if (track->quality(reco::TrackBase::goodIterative)) {
533  myquality = 4;
534  htrkQuality->Fill(myquality);
535  }
536 
537  // Fill 1D track histos
538  static const int etaindex = this->index(vTrackHistos_, "h_tracketa");
539  vTrackHistos_[etaindex]->Fill(track->eta());
540  static const int phiindex = this->index(vTrackHistos_, "h_trackphi");
541  vTrackHistos_[phiindex]->Fill(track->phi());
542  static const int numOfValidHitsindex = this->index(vTrackHistos_, "h_trackNumberOfValidHits");
543  vTrackHistos_[numOfValidHitsindex]->Fill(track->numberOfValidHits());
544  static const int numOfLostHitsindex = this->index(vTrackHistos_, "h_trackNumberOfLostHits");
545  vTrackHistos_[numOfLostHitsindex]->Fill(track->numberOfLostHits());
546 
547  GlobalPoint gPoint(track->vx(), track->vy(), track->vz());
548  double theLocalMagFieldInInverseGeV = magneticField_->inInverseGeV(gPoint).z();
549  double kappa = -track->charge() * theLocalMagFieldInInverseGeV / track->pt();
550 
551  static const int kappaindex = this->index(vTrackHistos_, "h_curvature");
552  vTrackHistos_[kappaindex]->Fill(kappa);
553  static const int kappaposindex = this->index(vTrackHistos_, "h_curvature_pos");
554  if (track->charge() > 0)
555  vTrackHistos_[kappaposindex]->Fill(fabs(kappa));
556  static const int kappanegindex = this->index(vTrackHistos_, "h_curvature_neg");
557  if (track->charge() < 0)
558  vTrackHistos_[kappanegindex]->Fill(fabs(kappa));
559 
560  double chi2Prob = TMath::Prob(track->chi2(), track->ndof());
561  double normchi2 = track->normalizedChi2();
562 
563  static const int normchi2index = this->index(vTrackHistos_, "h_normchi2");
564  vTrackHistos_[normchi2index]->Fill(normchi2);
565  static const int chi2index = this->index(vTrackHistos_, "h_chi2");
566  vTrackHistos_[chi2index]->Fill(track->chi2());
567  static const int chi2Probindex = this->index(vTrackHistos_, "h_chi2Prob");
568  vTrackHistos_[chi2Probindex]->Fill(chi2Prob);
569  static const int ptindex = this->index(vTrackHistos_, "h_pt");
570  static const int pt2index = this->index(vTrackHistos_, "h_ptrebin");
571  vTrackHistos_[ptindex]->Fill(track->pt());
572  vTrackHistos_[pt2index]->Fill(track->pt());
573  if (track->ptError() != 0.) {
574  static const int ptResolutionindex = this->index(vTrackHistos_, "h_ptResolution");
575  vTrackHistos_[ptResolutionindex]->Fill(track->ptError() / track->pt());
576  }
577  // Fill track profiles
578  static const int d0phiindex = this->index(vTrackProfiles_, "p_d0_vs_phi");
579  vTrackProfiles_[d0phiindex]->Fill(track->phi(), track->d0());
580  static const int dzphiindex = this->index(vTrackProfiles_, "p_dz_vs_phi");
581  vTrackProfiles_[dzphiindex]->Fill(track->phi(), track->dz());
582  static const int d0etaindex = this->index(vTrackProfiles_, "p_d0_vs_eta");
583  vTrackProfiles_[d0etaindex]->Fill(track->eta(), track->d0());
584  static const int dzetaindex = this->index(vTrackProfiles_, "p_dz_vs_eta");
585  vTrackProfiles_[dzetaindex]->Fill(track->eta(), track->dz());
586  static const int chiProbphiindex = this->index(vTrackProfiles_, "p_chi2Prob_vs_phi");
587  vTrackProfiles_[chiProbphiindex]->Fill(track->phi(), chi2Prob);
588  static const int chiProbabsd0index = this->index(vTrackProfiles_, "p_chi2Prob_vs_d0");
589  vTrackProfiles_[chiProbabsd0index]->Fill(fabs(track->d0()), chi2Prob);
590  static const int chiProbabsdzindex = this->index(vTrackProfiles_, "p_chi2Prob_vs_dz");
591  vTrackProfiles_[chiProbabsdzindex]->Fill(track->dz(), chi2Prob);
592  static const int chiphiindex = this->index(vTrackProfiles_, "p_chi2_vs_phi");
593  vTrackProfiles_[chiphiindex]->Fill(track->phi(), track->chi2());
594  static const int normchiphiindex = this->index(vTrackProfiles_, "p_normchi2_vs_phi");
595  vTrackProfiles_[normchiphiindex]->Fill(track->phi(), normchi2);
596  static const int chietaindex = this->index(vTrackProfiles_, "p_chi2_vs_eta");
597  vTrackProfiles_[chietaindex]->Fill(track->eta(), track->chi2());
598  static const int normchiptindex = this->index(vTrackProfiles_, "p_normchi2_vs_pt");
599  vTrackProfiles_[normchiptindex]->Fill(track->pt(), normchi2);
600  static const int normchipindex = this->index(vTrackProfiles_, "p_normchi2_vs_p");
601  vTrackProfiles_[normchipindex]->Fill(track->p(), normchi2);
602  static const int chiProbetaindex = this->index(vTrackProfiles_, "p_chi2Prob_vs_eta");
603  vTrackProfiles_[chiProbetaindex]->Fill(track->eta(), chi2Prob);
604  static const int normchietaindex = this->index(vTrackProfiles_, "p_normchi2_vs_eta");
605  vTrackProfiles_[normchietaindex]->Fill(track->eta(), normchi2);
606  static const int kappaphiindex = this->index(vTrackProfiles_, "p_kappa_vs_phi");
607  vTrackProfiles_[kappaphiindex]->Fill(track->phi(), kappa);
608  static const int kappaetaindex = this->index(vTrackProfiles_, "p_kappa_vs_eta");
609  vTrackProfiles_[kappaetaindex]->Fill(track->eta(), kappa);
610  static const int ptResphiindex = this->index(vTrackProfiles_, "p_ptResolution_vs_phi");
611  vTrackProfiles_[ptResphiindex]->Fill(track->phi(), track->ptError() / track->pt());
612  static const int ptResetaindex = this->index(vTrackProfiles_, "p_ptResolution_vs_eta");
613  vTrackProfiles_[ptResetaindex]->Fill(track->eta(), track->ptError() / track->pt());
614 
615  // Fill 2D track histos
616  static const int etaphiindex_2d = this->index(vTrack2DHistos_, "h2_phi_vs_eta");
617  vTrack2DHistos_[etaphiindex_2d]->Fill(track->eta(), track->phi());
618  static const int d0phiindex_2d = this->index(vTrack2DHistos_, "h2_d0_vs_phi");
619  vTrack2DHistos_[d0phiindex_2d]->Fill(track->phi(), track->d0());
620  static const int dzphiindex_2d = this->index(vTrack2DHistos_, "h2_dz_vs_phi");
621  vTrack2DHistos_[dzphiindex_2d]->Fill(track->phi(), track->dz());
622  static const int d0etaindex_2d = this->index(vTrack2DHistos_, "h2_d0_vs_eta");
623  vTrack2DHistos_[d0etaindex_2d]->Fill(track->eta(), track->d0());
624  static const int dzetaindex_2d = this->index(vTrack2DHistos_, "h2_dz_vs_eta");
625  vTrack2DHistos_[dzetaindex_2d]->Fill(track->eta(), track->dz());
626  static const int chiphiindex_2d = this->index(vTrack2DHistos_, "h2_chi2_vs_phi");
627  vTrack2DHistos_[chiphiindex_2d]->Fill(track->phi(), track->chi2());
628  static const int chiProbphiindex_2d = this->index(vTrack2DHistos_, "h2_chi2Prob_vs_phi");
629  vTrack2DHistos_[chiProbphiindex_2d]->Fill(track->phi(), chi2Prob);
630  static const int chiProbabsd0index_2d = this->index(vTrack2DHistos_, "h2_chi2Prob_vs_d0");
631  vTrack2DHistos_[chiProbabsd0index_2d]->Fill(fabs(track->d0()), chi2Prob);
632  static const int normchiphiindex_2d = this->index(vTrack2DHistos_, "h2_normchi2_vs_phi");
633  vTrack2DHistos_[normchiphiindex_2d]->Fill(track->phi(), normchi2);
634  static const int chietaindex_2d = this->index(vTrack2DHistos_, "h2_chi2_vs_eta");
635  vTrack2DHistos_[chietaindex_2d]->Fill(track->eta(), track->chi2());
636  static const int chiProbetaindex_2d = this->index(vTrack2DHistos_, "h2_chi2Prob_vs_eta");
637  vTrack2DHistos_[chiProbetaindex_2d]->Fill(track->eta(), chi2Prob);
638  static const int normchietaindex_2d = this->index(vTrack2DHistos_, "h2_normchi2_vs_eta");
639  vTrack2DHistos_[normchietaindex_2d]->Fill(track->eta(), normchi2);
640  static const int kappaphiindex_2d = this->index(vTrack2DHistos_, "h2_kappa_vs_phi");
641  vTrack2DHistos_[kappaphiindex_2d]->Fill(track->phi(), kappa);
642  static const int kappaetaindex_2d = this->index(vTrack2DHistos_, "h2_kappa_vs_eta");
643  vTrack2DHistos_[kappaetaindex_2d]->Fill(track->eta(), kappa);
644  static const int normchi2kappa_2d = this->index(vTrack2DHistos_, "h2_normchi2_vs_kappa");
645  vTrack2DHistos_[normchi2kappa_2d]->Fill(normchi2, kappa);
646 
647  //dxy with respect to the beamspot
649  edm::Handle<reco::BeamSpot> beamSpotHandle = event.getHandle(beamspotToken_);
650  if (beamSpotHandle.isValid()) {
651  beamSpot = *beamSpotHandle;
652  math::XYZPoint point(beamSpot.x0(), beamSpot.y0(), beamSpot.z0());
653  double dxy = track->dxy(point);
654  double dz = track->dz(point);
655  hdxyBS->Fill(dxy);
656  hd0BS->Fill(-dxy);
657  hdzBS->Fill(dz);
658  }
659 
660  //dxy with respect to the primary vertex
661  reco::Vertex pvtx;
662  edm::Handle<reco::VertexCollection> vertexHandle = event.getHandle(vertexToken_);
663  double mindxy = 100.;
664  double dz = 100;
665  if (vertexHandle.isValid() && !isCosmics_) {
666  for (auto pvtx = vertexHandle->cbegin(); pvtx != vertexHandle->cend(); ++pvtx) {
667  math::XYZPoint mypoint(pvtx->x(), pvtx->y(), pvtx->z());
668  if (abs(mindxy) > abs(track->dxy(mypoint))) {
669  mindxy = track->dxy(mypoint);
670  dz = track->dz(mypoint);
671  }
672  }
673 
674  hdxyPV->Fill(mindxy);
675  hd0PV->Fill(-mindxy);
676  hdzPV->Fill(dz);
677 
678  hd0PVvsphi->Fill(track->phi(), -mindxy);
679  hd0PVvseta->Fill(track->eta(), -mindxy);
680  hd0PVvspt->Fill(track->pt(), -mindxy);
681 
682  } else {
683  hdxyPV->Fill(100);
684  hd0PV->Fill(100);
685  hdzPV->Fill(100);
686 
687  hd0vsphi->Fill(track->phi(), -track->dxy());
688  hd0vseta->Fill(track->eta(), -track->dxy());
689  hd0vspt->Fill(track->pt(), -track->dxy());
690  }
691 
692  if (DEBUG) {
693  edm::LogInfo("GeneralPurposeTrackAnalyzer") << "end of track loop" << std::endl;
694  }
695  }
696 
697  hNtrk->Fill(tC.size());
698  hNtrkZoom->Fill(tC.size());
699  hNhighPurity->Fill(nHighPurityTracks);
700 
701  if (DEBUG) {
702  edm::LogInfo("GeneralPurposeTrackAnalyzer") << "end of analysis" << std::endl;
703  }
704  }
705 
706  //*************************************************************
707  void beginRun(edm::Run const &run, edm::EventSetup const &setup) override
708  //*************************************************************
709  {
710  // initialize runInfoMap_
711  runInfoMap_[run.run()].first = 0;
712  runInfoMap_[run.run()].second = 0;
713 
714  // Magnetic Field setup
715  magneticField_ = setup.getHandle(magFieldToken_);
716  float B_ = magneticField_.product()->inTesla(GlobalPoint(0, 0, 0)).mag();
717 
718  if (DEBUG) {
719  edm::LogInfo("GeneralPurposeTrackAnalyzer")
720  << "run number:" << run.run() << " magnetic field: " << B_ << " [T]" << std::endl;
721  }
722 
723  //SiStrip Latency
724  const SiStripLatency *apvlat = &setup.getData(latencyToken_);
725  if (apvlat->singleReadOutMode() == 1) {
726  mode = 1; // peak mode
727  } else if (apvlat->singleReadOutMode() == 0) {
728  mode = -1; // deco mode
729  }
730 
731  conditionsMap_[run.run()].first = mode;
732  conditionsMap_[run.run()].second = B_;
733 
734  // init the sipixel coordinates
735  const TrackerGeometry *trackerGeometry = &setup.getData(geomTokenBR_);
736  const TrackerTopology *trackerTopology = &setup.getData(trackerTopologyTokenBR_);
737  const SiPixelFedCablingMap *siPixelFedCablingMap = &setup.getData(siPixelFedCablingMapTokenBR_);
738 
739  // Pixel Phase-1 helper class
740  coord_.init(trackerTopology, trackerGeometry, siPixelFedCablingMap);
741  }
742 
743  //*************************************************************
744  void endRun(edm::Run const &, edm::EventSetup const &) override {}
745  //*************************************************************
746 
747  //*************************************************************
748  void beginJob() override
749  //*************************************************************
750  {
751  if (DEBUG) {
752  edm::LogInfo("GeneralPurposeTrackAnalyzer") << __LINE__ << std::endl;
753  }
754 
755  TH1D::SetDefaultSumw2(kTRUE);
756 
757  isPhase1_ = true;
758  etaMax_ = 3.0;
759 
760  ievt = 0;
761  itrks = 0;
762 
763  hrun = book<TH1D>("h_run", "run", 100000, 230000, 240000);
764  hlumi = book<TH1D>("h_lumi", "lumi", 1000, 0, 1000);
765 
766  hchi2ndof = book<TH1D>("h_chi2ndof", "chi2/ndf;#chi^{2}/ndf;tracks", 100, 0, 5.);
767  hCharge = book<TH1D>("h_charge", "charge;Charge of the track;tracks", 5, -2.5, 2.5);
768  hNtrk = book<TH1D>("h_Ntrk", "ntracks;Number of Tracks;events", 200, 0., 200.);
769  hNtrkZoom = book<TH1D>("h_NtrkZoom", "Number of tracks; number of tracks;events", 10, 0., 10.);
770  hNhighPurity =
771  book<TH1D>("h_NhighPurity", "n. high purity tracks;Number of high purity tracks;events", 200, 0., 200.);
772 
773  htrkAlgo = book<TH1I>("h_trkAlgo",
774  "tracking step;iterative tracking step;tracks",
776  0.,
777  double(reco::TrackBase::algoSize));
778 
779  htrkOriAlgo = book<TH1I>("h_trkOriAlgo",
780  "original tracking step;original iterative tracking step;tracks",
782  0.,
783  double(reco::TrackBase::algoSize));
784 
785  for (size_t ibin = 0; ibin < reco::TrackBase::algoSize - 1; ibin++) {
786  htrkAlgo->GetXaxis()->SetBinLabel(ibin + 1, (reco::TrackBase::algoNames[ibin]).c_str());
787  htrkOriAlgo->GetXaxis()->SetBinLabel(ibin + 1, (reco::TrackBase::algoNames[ibin]).c_str());
788  }
789 
790  htrkQuality = book<TH1I>("h_trkQuality", "track quality;track quality;tracks", 6, -1, 5);
791  std::string qualities[7] = {"undef", "loose", "tight", "highPurity", "confirmed", "goodIterative"};
792  for (int nbin = 1; nbin <= htrkQuality->GetNbinsX(); nbin++) {
793  htrkQuality->GetXaxis()->SetBinLabel(nbin, (qualities[nbin - 1]).c_str());
794  }
795 
796  hP = book<TH1D>("h_P", "Momentum;track momentum [GeV];tracks", 100, 0., 100.);
797  hQoverP = book<TH1D>("h_qoverp", "Track q/p; track q/p [GeV^{-1}];tracks", 100, -1., 1.);
798  hQoverPZoom = book<TH1D>("h_qoverpZoom", "Track q/p; track q/p [GeV^{-1}];tracks", 100, -0.1, 0.1);
799  hPt = book<TH1D>("h_Pt", "Transverse Momentum;track p_{T} [GeV];tracks", 100, 0., 100.);
800  hHit = book<TH1D>("h_nHits", "Number of hits;track n. hits;tracks", 50, -0.5, 49.5);
801  hHit2D = book<TH1D>("h_nHit2D", "Number of 2D hits; number of 2D hits;tracks", 20, 0, 20);
802 
803  hHitCountVsZBPix = book<TH1D>("h_HitCountVsZBpix", "Number of BPix hits vs z;hit global z;hits", 60, -30, 30);
804  hHitCountVsZFPix = book<TH1D>("h_HitCountVsZFpix", "Number of FPix hits vs z;hit global z;hits", 100, -100, 100);
805 
806  hHitCountVsXBPix = book<TH1D>("h_HitCountVsXBpix", "Number of BPix hits vs x;hit global x;hits", 20, -20, 20);
807  hHitCountVsXFPix = book<TH1D>("h_HitCountVsXFpix", "Number of FPix hits vs x;hit global x;hits", 20, -20, 20);
808 
809  hHitCountVsYBPix = book<TH1D>("h_HitCountVsYBpix", "Number of BPix hits vs y;hit global y;hits", 20, -20, 20);
810  hHitCountVsYFPix = book<TH1D>("h_HitCountVsYFpix", "Number of FPix hits vs y;hit global y;hits", 20, -20, 20);
811 
813  book<TH1D>("h_HitCountVsThetaBpix", "Number of BPix hits vs #theta;hit global #theta;hits", 20, 0., M_PI);
815  book<TH1D>("h_HitCountVsPhiBpix", "Number of BPix hits vs #phi;hit global #phi;hits", 20, -M_PI, M_PI);
816 
818  book<TH1D>("h_HitCountVsThetaFpix", "Number of FPix hits vs #theta;hit global #theta;hits", 40, 0., M_PI);
820  book<TH1D>("h_HitCountVsPhiFpix", "Number of FPix hits vs #phi;hit global #phi;hits", 20, -M_PI, M_PI);
821 
822  hEta = book<TH1D>("h_Eta", "Track pseudorapidity; track #eta;tracks", 100, -etaMax_, etaMax_);
823  hPhi = book<TH1D>("h_Phi", "Track azimuth; track #phi;tracks", 100, -M_PI, M_PI);
824 
825  hPhiBarrel = book<TH1D>("h_PhiBarrel", "hPhiBarrel (0<|#eta|<0.8);track #Phi;tracks", 100, -M_PI, M_PI);
827  book<TH1D>("h_PhiOverlapPlus", "hPhiOverlapPlus (0.8<#eta<1.4);track #phi;tracks", 100, -M_PI, M_PI);
829  book<TH1D>("h_PhiOverlapMinus", "hPhiOverlapMinus (-1.4<#eta<-0.8);track #phi;tracks", 100, -M_PI, M_PI);
830  hPhiEndcapPlus = book<TH1D>("h_PhiEndcapPlus", "hPhiEndcapPlus (#eta>1.4);track #phi;track", 100, -M_PI, M_PI);
831  hPhiEndcapMinus = book<TH1D>("h_PhiEndcapMinus", "hPhiEndcapMinus (#eta<1.4);track #phi;tracks", 100, -M_PI, M_PI);
832 
833  if (!isCosmics_) {
834  hPhp = book<TH1D>("h_P_hp", "Momentum (high purity);track momentum [GeV];tracks", 100, 0., 100.);
835  hPthp = book<TH1D>("h_Pt_hp", "Transverse Momentum (high purity);track p_{T} [GeV];tracks", 100, 0., 100.);
836  hHithp = book<TH1D>("h_nHit_hp", "Number of hits (high purity);track n. hits;tracks", 30, 0, 30);
837  hEtahp = book<TH1D>("h_Eta_hp", "Track pseudorapidity (high purity); track #eta;tracks", 100, -etaMax_, etaMax_);
838  hPhihp = book<TH1D>("h_Phi_hp", "Track azimuth (high purity); track #phi;tracks", 100, -M_PI, M_PI);
839  hchi2ndofhp = book<TH1D>("h_chi2ndof_hp", "chi2/ndf (high purity);#chi^{2}/ndf;tracks", 100, 0, 5.);
840  hchi2Probhp = book<TH1D>(
841  "h_chi2_Prob_hp", "#chi^{2} probability (high purity);#chi^{2}prob_{Track};Number of Tracks", 100, 0.0, 1.);
842 
843  hvx = book<TH1D>("h_vx", "Track v_{x} ; track v_{x} [cm];tracks", 100, -1.5, 1.5);
844  hvy = book<TH1D>("h_vy", "Track v_{y} ; track v_{y} [cm];tracks", 100, -1.5, 1.5);
845  hvz = book<TH1D>("h_vz", "Track v_{z} ; track v_{z} [cm];tracks", 100, -20., 20.);
846  hd0 = book<TH1D>("h_d0", "Track d_{0} ; track d_{0} [cm];tracks", 100, -1., 1.);
847  hdxy = book<TH1D>("h_dxy", "Track d_{xy}; track d_{xy} [cm]; tracks", 100, -0.5, 0.5);
848  hdz = book<TH1D>("h_dz", "Track d_{z} ; track d_{z} [cm]; tracks", 100, -20, 20);
849 
850  hd0PVvsphi =
851  book<TH2D>("h2_d0PVvsphi", "hd0PVvsphi;track #phi;track d_{0}(PV) [cm]", 160, -M_PI, M_PI, 100, -1., 1.);
852  hd0PVvseta =
853  book<TH2D>("h2_d0PVvseta", "hdPV0vseta;track #eta;track d_{0}(PV) [cm]", 160, -2.5, 2.5, 100, -1., 1.);
854  hd0PVvspt = book<TH2D>("h2_d0PVvspt", "hdPV0vspt;track p_{T};d_{0}(PV) [cm]", 50, 0., 100., 100, -1, 1.);
855 
856  hdxyBS = book<TH1D>("h_dxyBS", "hdxyBS; track d_{xy}(BS) [cm];tracks", 100, -0.1, 0.1);
857  hd0BS = book<TH1D>("h_d0BS", "hd0BS ; track d_{0}(BS) [cm];tracks", 100, -0.1, 0.1);
858  hdzBS = book<TH1D>("h_dzBS", "hdzBS ; track d_{z}(BS) [cm];tracks", 100, -12, 12);
859  hdxyPV = book<TH1D>("h_dxyPV", "hdxyPV; track d_{xy}(PV) [cm];tracks", 100, -0.1, 0.1);
860  hd0PV = book<TH1D>("h_d0PV", "hd0PV ; track d_{0}(PV) [cm];tracks", 100, -0.15, 0.15);
861  hdzPV = book<TH1D>("h_dzPV", "hdzPV ; track d_{z}(PV) [cm];tracks", 100, -0.1, 0.1);
862 
863  hnhTIB = book<TH1D>("h_nHitTIB", "nhTIB;# hits in TIB; tracks", 20, 0., 20.);
864  hnhTID = book<TH1D>("h_nHitTID", "nhTID;# hits in TID; tracks", 20, 0., 20.);
865  hnhTOB = book<TH1D>("h_nHitTOB", "nhTOB;# hits in TOB; tracks", 20, 0., 20.);
866  hnhTEC = book<TH1D>("h_nHitTEC", "nhTEC;# hits in TEC; tracks", 20, 0., 20.);
867 
868  } else {
869  hvx = book<TH1D>("h_vx", "Track v_{x};track v_{x} [cm];tracks", 100, -100., 100.);
870  hvy = book<TH1D>("h_vy", "Track v_{y};track v_{y} [cm];tracks", 100, -100., 100.);
871  hvz = book<TH1D>("h_vz", "Track v_{z};track v_{z} [cm];track", 100, -100., 100.);
872  hd0 = book<TH1D>("h_d0", "Track d_{0};track d_{0} [cm];track", 100, -100., 100.);
873  hdxy = book<TH1D>("h_dxy", "Track d_{xy};track d_{xy} [cm];tracks", 100, -100, 100);
874  hdz = book<TH1D>("h_dz", "Track d_{z};track d_{z} [cm];tracks", 100, -200, 200);
875 
876  hd0vsphi = book<TH2D>(
877  "h2_d0vsphi", "Track d_{0} vs #phi; track #phi;track d_{0} [cm]", 160, -3.20, 3.20, 100, -100., 100.);
878  hd0vseta = book<TH2D>(
879  "h2_d0vseta", "Track d_{0} vs #eta; track #eta;track d_{0} [cm]", 160, -3.20, 3.20, 100, -100., 100.);
880  hd0vspt =
881  book<TH2D>("h2_d0vspt", "Track d_{0} vs p_{T};track p_{T};track d_{0} [cm]", 50, 0., 100., 100, -100, 100);
882 
883  hdxyBS = book<TH1D>("h_dxyBS", "Track d_{xy}(BS);d_{xy}(BS) [cm];tracks", 100, -100., 100.);
884  hd0BS = book<TH1D>("h_d0BS", "Track d_{0}(BS);d_{0}(BS) [cm];tracks", 100, -100., 100.);
885  hdzBS = book<TH1D>("h_dzBS", "Track d_{z}(BS);d_{z}(BS) [cm];tracks", 100, -100., 100.);
886  hdxyPV = book<TH1D>("h_dxyPV", "Track d_{xy}(PV); d_{xy}(PV) [cm];tracks", 100, -100., 100.);
887  hd0PV = book<TH1D>("h_d0PV", "Track d_{0}(PV); d_{0}(PV) [cm];tracks", 100, -100., 100.);
888  hdzPV = book<TH1D>("h_dzPV", "Track d_{z}(PV); d_{z}(PV) [cm];tracks", 100, -100., 100.);
889 
890  hnhTIB = book<TH1D>("h_nHitTIB", "nhTIB;# hits in TIB; tracks", 30, 0., 30.);
891  hnhTID = book<TH1D>("h_nHitTID", "nhTID;# hits in TID; tracks", 30, 0., 30.);
892  hnhTOB = book<TH1D>("h_nHitTOB", "nhTOB;# hits in TOB; tracks", 30, 0., 30.);
893  hnhTEC = book<TH1D>("h_nHitTEC", "nhTEC;# hits in TEC; tracks", 30, 0., 30.);
894  }
895 
896  hnhpxb = book<TH1D>("h_nHitPXB", "nhpxb;# hits in Pixel Barrel; tracks", 10, 0., 10.);
897  hnhpxe = book<TH1D>("h_nHitPXE", "nhpxe;# hits in Pixel Endcap; tracks", 10, 0., 10.);
898 
899  hHitComposition = book<TH1D>("h_hitcomposition", "track hit composition;;# hits", 6, -0.5, 5.5);
900 
902  book<TProfile>("p_NpixHits_vs_Vx", "n. Barrel Pixel hits vs. v_{x};v_{x} (cm);n. BPix hits", 20, -20, 20);
903 
905  book<TProfile>("p_NpixHits_vs_Vy", "n. Barrel Pixel hits vs. v_{y};v_{y} (cm);n. BPix hits", 20, -20, 20);
906 
908  book<TProfile>("p_NpixHits_vs_Vz", "n. Barrel Pixel hits vs. v_{z};v_{z} (cm);n. BPix hits", 20, -100, 100);
909 
910  std::string dets[6] = {"PXB", "PXF", "TIB", "TID", "TOB", "TEC"};
911 
912  for (int i = 1; i <= hHitComposition->GetNbinsX(); i++) {
913  hHitComposition->GetXaxis()->SetBinLabel(i, (dets[i - 1]).c_str());
914  }
915 
916  // vector of track histograms
917 
918  // clang-format off
919 
920  vTrackHistos_.push_back(book<TH1F>("h_tracketa", "Track #eta;#eta_{Track};Number of Tracks", 90, -etaMax_, etaMax_));
921  vTrackHistos_.push_back(book<TH1F>("h_trackphi", "Track #phi;#phi_{Track};Number of Tracks", 90, -M_PI, M_PI));
922  vTrackHistos_.push_back(book<TH1F>("h_trackNumberOfValidHits", "Track # of valid hits;# of valid hits _{Track};Number of Tracks", 40, 0., 40.));
923  vTrackHistos_.push_back(book<TH1F>("h_trackNumberOfLostHits", "Track # of lost hits;# of lost hits _{Track};Number of Tracks", 10, 0., 10.));
924  vTrackHistos_.push_back(book<TH1F>("h_curvature", "Curvature #kappa;#kappa_{Track};Number of Tracks", 100, -.05, .05));
925  vTrackHistos_.push_back(book<TH1F>("h_curvature_pos", "Curvature |#kappa| Positive Tracks;|#kappa_{pos Track}|;Number of Tracks", 100, .0, .05));
926  vTrackHistos_.push_back(book<TH1F>("h_curvature_neg", "Curvature |#kappa| Negative Tracks;|#kappa_{neg Track}|;Number of Tracks", 100, .0, .05));
927  vTrackHistos_.push_back(book<TH1F>("h_diff_curvature","Curvature |#kappa| Tracks Difference;|#kappa_{Track}|;# Pos Tracks - # Neg Tracks",100, .0, .05));
928  vTrackHistos_.push_back(book<TH1F>("h_chi2", "Track #chi^{2};#chi^{2}_{Track};Number of Tracks", 500, -0.01, 500.));
929  vTrackHistos_.push_back(book<TH1F>("h_chi2Prob", "#chi^{2} probability;Track Prob(#chi^{2},ndof);Number of Tracks", 100, 0.0, 1.));
930  vTrackHistos_.push_back(book<TH1F>("h_normchi2", "#chi^{2}/ndof;#chi^{2}/ndof;Number of Tracks", 100, -0.01, 10.));
931  //variable binning for chi2/ndof vs. pT
932  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.};
933  vTrackHistos_.push_back(book<TH1F>("h_pt", "Track p_{T};p_{T}^{track} [GeV];Number of Tracks", 250, 0., 250));
934  vTrackHistos_.push_back(book<TH1F>("h_ptrebin", "Track p_{T};p_{T}^{track} [GeV];Number of Tracks", 18, xBins));
935  vTrackHistos_.push_back(book<TH1F>("h_ptResolution", "#delta_{p_{T}}/p_{T}^{track};#delta_{p_{T}}/p_{T}^{track};Number of Tracks", 100, 0., 0.5));
936 
937  vTrackProfiles_.push_back(book<TProfile>("p_d0_vs_phi", "Transverse Impact Parameter vs. #phi;#phi_{Track};#LT d_{0} #GT [cm]", 100, -M_PI, M_PI));
938  vTrackProfiles_.push_back(book<TProfile>("p_dz_vs_phi", "Longitudinal Impact Parameter vs. #phi;#phi_{Track};#LT d_{z} #GT [cm]", 100, -M_PI, M_PI));
939  vTrackProfiles_.push_back(book<TProfile>("p_d0_vs_eta", "Transverse Impact Parameter vs. #eta;#eta_{Track};#LT d_{0} #GT [cm]", 100, -etaMax_, etaMax_));
940  vTrackProfiles_.push_back(book<TProfile>("p_dz_vs_eta", "Longitudinal Impact Parameter vs. #eta;#eta_{Track};#LT d_{z} #GT [cm]", 100, -etaMax_, etaMax_));
941  vTrackProfiles_.push_back(book<TProfile>("p_chi2_vs_phi", "#chi^{2} vs. #phi;#phi_{Track};#LT #chi^{2} #GT", 100, -M_PI, M_PI));
942  vTrackProfiles_.push_back(book<TProfile>("p_chi2Prob_vs_phi", "#chi^{2} probablility vs. #phi;#phi_{Track};#LT #chi^{2} probability#GT", 100, -M_PI, M_PI));
943  vTrackProfiles_.push_back(book<TProfile>("p_chi2Prob_vs_d0", "#chi^{2} probablility vs. |d_{0}|;|d_{0}|[cm];#LT #chi^{2} probability#GT", 100, 0, 80));
944  vTrackProfiles_.push_back(book<TProfile>("p_chi2Prob_vs_dz", "#chi^{2} probablility vs. dz;d_{z} [cm];#LT #chi^{2} probability#GT", 100, -30, 30));
945  vTrackProfiles_.push_back(book<TProfile>("p_normchi2_vs_phi", "#chi^{2}/ndof vs. #phi;#phi_{Track};#LT #chi^{2}/ndof #GT", 100, -M_PI, M_PI));
946  vTrackProfiles_.push_back(book<TProfile>("p_chi2_vs_eta", "#chi^{2} vs. #eta;#eta_{Track};#LT #chi^{2} #GT", 100, -etaMax_, etaMax_));
947  vTrackProfiles_.push_back(book<TProfile>("p_normchi2_vs_pt", "norm #chi^{2} vs. p_{T}_{Track}; p_{T}_{Track};#LT #chi^{2}/ndof #GT", 18, xBins));
948  vTrackProfiles_.push_back(book<TProfile>("p_normchi2_vs_p", "#chi^{2}/ndof vs. p_{Track};p_{Track};#LT #chi^{2}/ndof #GT", 18, xBins));
949  vTrackProfiles_.push_back(book<TProfile>("p_chi2Prob_vs_eta","#chi^{2} probability vs. #eta;#eta_{Track};#LT #chi^{2} probability #GT",100,-etaMax_,etaMax_));
950  vTrackProfiles_.push_back(book<TProfile>("p_normchi2_vs_eta", "#chi^{2}/ndof vs. #eta;#eta_{Track};#LT #chi^{2}/ndof #GT", 100, -etaMax_, etaMax_));
951  vTrackProfiles_.push_back(book<TProfile>("p_kappa_vs_phi", "#kappa vs. #phi;#phi_{Track};#kappa", 100, -M_PI, M_PI));
952  vTrackProfiles_.push_back(book<TProfile>("p_kappa_vs_eta", "#kappa vs. #eta;#eta_{Track};#kappa", 100, -etaMax_, etaMax_));
953  vTrackProfiles_.push_back(book<TProfile>("p_ptResolution_vs_phi","#delta_{p_{T}}/p_{T}^{track};#phi^{track};#delta_{p_{T}}/p_{T}^{track}",100,-M_PI,M_PI));
954  vTrackProfiles_.push_back(book<TProfile>("p_ptResolution_vs_eta","#delta_{p_{T}}/p_{T}^{track};#eta^{track};#delta_{p_{T}}/p_{T}^{track}",100,-etaMax_,etaMax_));
955 
956  vTrack2DHistos_.push_back(book<TH2F>("h2_phi_vs_eta", "Track #phi vs. #eta;#eta_{Track};#phi_{Track}",50, -etaMax_, etaMax_, 50, -M_PI, M_PI));
957  vTrack2DHistos_.push_back(book<TH2F>("h2_d0_vs_phi", "Transverse Impact Parameter vs. #phi;#phi_{Track};d_{0} [cm]", 100, -M_PI, M_PI, 100, -1., 1.));
958  vTrack2DHistos_.push_back(book<TH2F>("h2_dz_vs_phi", "Longitudinal Impact Parameter vs. #phi;#phi_{Track};d_{z} [cm]",100, -M_PI, M_PI, 100, -100., 100.));
959  vTrack2DHistos_.push_back(book<TH2F>("h2_d0_vs_eta", "Transverse Impact Parameter vs. #eta;#eta_{Track};d_{0} [cm]", 100, -etaMax_, etaMax_, 100, -1., 1.));
960  vTrack2DHistos_.push_back(book<TH2F>("h2_dz_vs_eta", "Longitudinal Impact Parameter vs. #eta;#eta_{Track};d_{z} [cm]", 100, -etaMax_, etaMax_, 100, -100., 100.));
961  vTrack2DHistos_.push_back(book<TH2F>("h2_chi2_vs_phi", "#chi^{2} vs. #phi;#phi_{Track};#chi^{2}", 100, -M_PI, M_PI, 500, 0., 500.));
962  vTrack2DHistos_.push_back(book<TH2F>("h2_chi2Prob_vs_phi", "#chi^{2} probability vs. #phi;#phi_{Track};#chi^{2} probability", 100, -M_PI, M_PI, 100, 0., 1.));
963  vTrack2DHistos_.push_back(book<TH2F>("h2_chi2Prob_vs_d0", "#chi^{2} probability vs. |d_{0}|;|d_{0}| [cm];#chi^{2} probability", 100, 0, 80, 100, 0., 1.));
964  vTrack2DHistos_.push_back(book<TH2F>("h2_normchi2_vs_phi", "#chi^{2}/ndof vs. #phi;#phi_{Track};#chi^{2}/ndof", 100, -M_PI, M_PI, 100, 0., 10.));
965  vTrack2DHistos_.push_back(book<TH2F>("h2_chi2_vs_eta", "#chi^{2} vs. #eta;#eta_{Track};#chi^{2}", 100, -etaMax_, etaMax_, 500, 0., 500.));
966  vTrack2DHistos_.push_back(book<TH2F>("h2_chi2Prob_vs_eta", "#chi^{2} probaility vs. #eta;#eta_{Track};#chi^{2} probability", 100, -etaMax_, etaMax_, 100, 0., 1.));
967  vTrack2DHistos_.push_back(book<TH2F>("h2_normchi2_vs_eta", "#chi^{2}/ndof vs. #eta;#eta_{Track};#chi^{2}/ndof", 100, -etaMax_, etaMax_, 100, 0., 10.));
968  vTrack2DHistos_.push_back(book<TH2F>("h2_kappa_vs_phi", "#kappa vs. #phi;#phi_{Track};#kappa", 100, -M_PI, M_PI, 100, .0, .05));
969  vTrack2DHistos_.push_back(book<TH2F>("h2_kappa_vs_eta", "#kappa vs. #eta;#eta_{Track};#kappa", 100, -etaMax_, etaMax_, 100, .0, .05));
970  vTrack2DHistos_.push_back(book<TH2F>("h2_normchi2_vs_kappa", "#kappa vs. #chi^{2}/ndof;#chi^{2}/ndof;#kappa", 100, 0., 10, 100, -.03, .03));
971 
972  // clang-format on
973 
974  firstEvent_ = true;
975 
976  } //beginJob
977 
978  //*************************************************************
979  void endJob() override
980  //*************************************************************
981  {
982  edm::LogPrint("GeneralPurposeTrackAnalyzer") << "*******************************" << std::endl;
983  edm::LogPrint("GeneralPurposeTrackAnalyzer") << "Events run in total: " << ievt << std::endl;
984  edm::LogPrint("GeneralPurposeTrackAnalyzer") << "n. tracks: " << itrks << std::endl;
985  edm::LogPrint("GeneralPurposeTrackAnalyzer") << "*******************************" << std::endl;
986 
987  int nFiringTriggers = triggerMap_.size();
988  edm::LogPrint("GeneralPurposeTrackAnalyzer") << "firing triggers: " << nFiringTriggers << std::endl;
989  edm::LogPrint("GeneralPurposeTrackAnalyzer") << "*******************************" << std::endl;
990 
991  tksByTrigger_ =
992  book<TH1D>("tksByTrigger", "tracks by HLT path;;% of # traks", nFiringTriggers, -0.5, nFiringTriggers - 0.5);
994  book<TH1D>("evtsByTrigger", "events by HLT path;;% of # events", nFiringTriggers, -0.5, nFiringTriggers - 0.5);
995 
996  int i = 0;
997  for (const auto &it : triggerMap_) {
998  i++;
999 
1000  double trkpercent = ((it.second).second) * 100. / double(itrks);
1001  double evtpercent = ((it.second).first) * 100. / double(ievt);
1002 
1003  std::cout.precision(4);
1004 
1005  edm::LogPrint("GeneralPurposeTrackAnalyzer")
1006  << "HLT path: " << std::setw(60) << std::left << it.first << " | events firing: " << std::right
1007  << std::setw(8) << (it.second).first << " (" << std::setw(8) << std::fixed << std::setprecision(4)
1008  << evtpercent << "%)"
1009  << " | tracks collected: " << std::setw(10) << (it.second).second << " (" << std::setw(8) << std::fixed
1010  << std::setprecision(4) << trkpercent << "%)";
1011 
1012  tksByTrigger_->SetBinContent(i, trkpercent);
1013  tksByTrigger_->GetXaxis()->SetBinLabel(i, (it.first).c_str());
1014 
1015  evtsByTrigger_->SetBinContent(i, evtpercent);
1016  evtsByTrigger_->GetXaxis()->SetBinLabel(i, (it.first).c_str());
1017  }
1018 
1019  int nRuns = conditionsMap_.size();
1020 
1021  std::vector<int> theRuns_;
1022  for (const auto &it : conditionsMap_) {
1023  theRuns_.push_back(it.first);
1024  }
1025 
1026  sort(theRuns_.begin(), theRuns_.end());
1027  int runRange = theRuns_.back() - theRuns_.front() + 1;
1028 
1029  edm::LogPrint("GeneralPurposeTrackAnalyzer") << "*******************************" << std::endl;
1030  edm::LogPrint("GeneralPurposeTrackAnalyzer") << "first run: " << theRuns_.front() << std::endl;
1031  edm::LogPrint("GeneralPurposeTrackAnalyzer") << "last run: " << theRuns_.back() << std::endl;
1032  edm::LogPrint("GeneralPurposeTrackAnalyzer") << "considered runs: " << nRuns << std::endl;
1033  edm::LogPrint("GeneralPurposeTrackAnalyzer") << "*******************************" << std::endl;
1034 
1035  modeByRun_ = book<TH1D>("modeByRun",
1036  "Strip APV mode by run number;;APV mode (-1=deco,+1=peak)",
1037  runRange,
1038  theRuns_.front() - 0.5,
1039  theRuns_.back() + 0.5);
1040 
1041  fieldByRun_ = book<TH1D>("fieldByRun",
1042  "CMS B-field intensity by run number;;B-field intensity [T]",
1043  runRange,
1044  theRuns_.front() - 0.5,
1045  theRuns_.back() + 0.5);
1046 
1047  for (const auto &the_r : theRuns_) {
1048  if (conditionsMap_.find(the_r)->second.first != 0) {
1049  edm::LogPrint("GeneralPurposeTrackAnalyzer")
1050  << "run:" << the_r << " | isPeak: " << std::setw(4) << conditionsMap_.find(the_r)->second.first
1051  << "| B-field: " << conditionsMap_.find(the_r)->second.second << " [T]"
1052  << "| events: " << std::setw(10) << runInfoMap_.find(the_r)->second.first << ", tracks " << std::setw(10)
1053  << runInfoMap_.find(the_r)->second.second << std::endl;
1054  }
1055 
1056  modeByRun_->SetBinContent((the_r - theRuns_.front()) + 1, conditionsMap_.find(the_r)->second.first);
1057  fieldByRun_->SetBinContent((the_r - theRuns_.front()) + 1, conditionsMap_.find(the_r)->second.second);
1058  modeByRun_->GetXaxis()->SetBinLabel((the_r - theRuns_.front()) + 1, std::to_string(the_r).c_str());
1059  fieldByRun_->GetXaxis()->SetBinLabel((the_r - theRuns_.front()) + 1, std::to_string(the_r).c_str());
1060  }
1061 
1062  if (!isPhase1_) {
1063  pmap->save(true, 0, 0, "PixelHitMap.pdf", 600, 800);
1064  pmap->save(true, 0, 0, "PixelHitMap.png", 500, 750);
1065  }
1066 
1067  tmap->save(true, 0, 0, "StripHitMap.pdf");
1068  tmap->save(true, 0, 0, "StripHitMap.png");
1069 
1070  gStyle->SetPalette(kRainBow);
1071  pixelmap->beautifyAllHistograms();
1072 
1073  TCanvas cB("CanvBarrel", "CanvBarrel", 1200, 1000);
1074  pixelmap->drawBarrelMaps("entriesBarrel", cB);
1075  cB.SaveAs("pixelBarrelEntries.png");
1076 
1077  TCanvas cF("CanvForward", "CanvForward", 1600, 1000);
1078  pixelmap->drawForwardMaps("entriesForward", cF);
1079  cF.SaveAs("pixelForwardEntries.png");
1080 
1081  TCanvas cRocs = TCanvas("cRocs", "cRocs", 1200, 1600);
1082  pixelrocsmap_->drawMaps(cRocs, "Pixel on-track clusters occupancy");
1083  cRocs.SaveAs("Phase1PixelROCMaps_fullROCs.png");
1084  }
1085 
1086  //*************************************************************
1088  //*************************************************************
1089  {
1090  bool countStereoHitAs2D_ = true;
1091  // we count SiStrip stereo modules as 2D if selected via countStereoHitAs2D_
1092  // (since they provide theta information)
1093  if (!hit.isValid() ||
1094  (hit.dimension() < 2 && !countStereoHitAs2D_ && !dynamic_cast<const SiStripRecHit1D *>(&hit))) {
1095  return false; // real RecHit1D - but SiStripRecHit1D depends on countStereoHitAs2D_
1096  } else {
1097  const DetId detId(hit.geographicalId());
1098  if (detId.det() == DetId::Tracker) {
1099  if (detId.subdetId() == kBPIX || detId.subdetId() == kFPIX) {
1100  return true; // pixel is always 2D
1101  } else { // should be SiStrip now
1102  const SiStripDetId stripId(detId);
1103  if (stripId.stereo())
1104  return countStereoHitAs2D_; // stereo modules
1105  else if (dynamic_cast<const SiStripRecHit1D *>(&hit) || dynamic_cast<const SiStripRecHit2D *>(&hit))
1106  return false; // rphi modules hit
1107  //the following two are not used any more since ages...
1108  else if (dynamic_cast<const SiStripMatchedRecHit2D *>(&hit))
1109  return true; // matched is 2D
1110  else if (dynamic_cast<const ProjectedSiStripRecHit2D *>(&hit)) {
1111  const ProjectedSiStripRecHit2D *pH = static_cast<const ProjectedSiStripRecHit2D *>(&hit);
1112  return (countStereoHitAs2D_ && this->isHit2D(pH->originalHit())); // depends on original...
1113  } else {
1114  edm::LogError("UnknownType") << "@SUB=GeneralPurposeTrackAnalyzer::isHit2D"
1115  << "Tracker hit not in pixel, neither SiStripRecHit[12]D nor "
1116  << "SiStripMatchedRecHit2D nor ProjectedSiStripRecHit2D.";
1117  return false;
1118  }
1119  }
1120  } else { // not tracker??
1121  edm::LogWarning("DetectorMismatch") << "@SUB=GeneralPurposeTrackAnalyzer::isHit2D"
1122  << "Hit not in tracker with 'official' dimension >=2.";
1123  return true; // dimension() >= 2 so accept that...
1124  }
1125  }
1126  // never reached...
1127  }
1128 };
1129 
1130 //*************************************************************
1132 //*************************************************************
1133 {
1135  desc.setComment("Generic track analyzer to check ALCARECO sample quantities");
1136  desc.add<edm::InputTag>("TkTag", edm::InputTag("generalTracks"));
1137  desc.add<edm::InputTag>("TriggerResultsTag", edm::InputTag("TriggerResults", "", "HLT"));
1138  desc.add<edm::InputTag>("BeamSpotTag", edm::InputTag("offlineBeamSpot"));
1139  desc.add<edm::InputTag>("VerticesTag", edm::InputTag("offlinePrimaryVertices"));
1140  desc.add<bool>("isCosmics", false);
1141  descriptions.add("GeneralPurposeTrackAnalyzer", desc);
1142 }
1143 
static const std::string kSharedResource
Definition: TFileService.h:76
void analyze(const edm::Event &event, const edm::EventSetup &setup) override
const edm::ESGetToken< SiStripLatency, SiStripLatencyRcd > latencyToken_
std::map< int, std::pair< int, float > > conditionsMap_
double z() const
z coordinate
Definition: Vertex.h:133
edm::EDGetTokenT< edm::TriggerResults > hltresultsToken_
edm::EDGetTokenT< reco::TrackCollection > theTrackCollectionToken_
T z() const
Definition: PV3DBase.h:61
Strings const & triggerNames() const
Definition: TriggerNames.cc:48
virtual GlobalVector inTesla(const GlobalPoint &gp) const =0
Field value ad specified global point, in Tesla.
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
Geom::Phi< T > phi() const
Definition: PV3DBase.h:66
std::unique_ptr< TrackerMap > tmap
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
std::vector< Track > TrackCollection
collection of Tracks
Definition: TrackFwd.h:14
GlobalVector inInverseGeV(const GlobalPoint &gp) const
Field value ad specified global point, in 1/Gev.
Definition: MagneticField.h:36
static void fillDescriptions(edm::ConfigurationDescriptions &)
std::unique_ptr< TrackerMap > pmap
std::string to_string(const V &value)
Definition: OMSAccess.h:71
Log< level::Error, false > LogError
bool accept(const edm::Event &event, const edm::TriggerResults &triggerTable, const std::string &triggerPath)
Definition: TopDQMHelpers.h:31
void beginRun(edm::Run const &run, edm::EventSetup const &setup) override
const int kFPIX
const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord > geomTokenBR_
U second(std::pair< T, U > const &p)
T x() const
Definition: PV3DBase.h:59
T y() const
Definition: PV3DBase.h:60
T const * product() const
Definition: ESHandle.h:86
edm::ESHandle< MagneticField > magneticField_
std::map< std::string, std::pair< int, int > > triggerMap_
edm::EDGetTokenT< reco::VertexCollection > vertexToken_
void Fill(HcalDetId &id, double val, std::vector< TH2F > &depth)
bool isThere(GeomDetEnumerators::SubDetector subdet) const
GeneralPurposeTrackAnalyzer(const edm::ParameterSet &pset)
uint32_t stereo() const
Definition: SiStripDetId.h:168
T mag() const
Definition: PV3DBase.h:64
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
Transition
Definition: Transition.h:12
void init(const TrackerTopology *, const TrackerGeometry *, const SiPixelFedCablingMap *)
constexpr int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:48
int roc(const DetId &, const std::pair< int, int > &)
std::map< int, std::pair< int, int > > runInfoMap_
double x() const
x coordinate
Definition: Vertex.h:129
Log< level::Warning, true > LogPrint
const TrackerGeomDet * idToDet(DetId) const override
double y() const
y coordinate
Definition: Vertex.h:131
const char * qualities[3]
#define M_PI
edm::EDGetTokenT< reco::BeamSpot > beamspotToken_
Log< level::Info, false > LogInfo
Detector identifier class for the strip tracker.
Definition: SiStripDetId.h:18
const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > magFieldToken_
Definition: DetId.h:17
int16_t singleReadOutMode() const
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:57
XYZPointD XYZPoint
point in space with cartesian internal representation
Definition: Point3D.h:12
const edm::ESGetToken< TrackerTopology, TrackerTopologyRcd > trackerTopologyTokenBR_
void add(std::string const &label, ParameterSetDescription const &psetDescription)
std::string const & triggerName(unsigned int index) const
Definition: TriggerNames.cc:50
static const std::string algoNames[]
Definition: TrackBase.h:147
void endRun(edm::Run const &, edm::EventSetup const &) override
bool isValid() const
Definition: HandleBase.h:70
std::unique_ptr< Phase1PixelROCMaps > pixelrocsmap_
HLT enums.
SiStripRecHit2D originalHit() const
col
Definition: cuy.py:1009
T * book(const Args &...args) const
T * make(const Args &...args) const
make new ROOT object
Definition: TFileService.h:64
Log< level::Warning, false > LogWarning
std::unique_ptr< Phase1PixelMaps > pixelmap
const int kBPIX
long double T
bool isHit2D(const TrackingRecHit &hit)
~GeneralPurposeTrackAnalyzer() override=default
*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
const edm::ESGetToken< SiPixelFedCablingMap, SiPixelFedCablingMapRcd > siPixelFedCablingMapTokenBR_
Definition: event.py:1
Definition: Run.h:45
Geom::Theta< T > theta() const
Definition: PV3DBase.h:72
Our base class.
Definition: SiPixelRecHit.h:23
const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord > geomToken_
int index(const std::vector< OBJECT_TYPE *> &vec, const TString &name)