32 #include <boost/range/adaptor/indexed.hpp> 113 pmap = std::make_unique<TrackerMap>(
"Pixel");
114 pmap->onlyPixel(
true);
115 pmap->setTitle(
"Pixel Hit entries");
118 tmap = std::make_unique<TrackerMap>(
"Strip");
119 tmap->setTitle(
"Strip Hit entries");
122 pixelmap = std::make_unique<Phase1PixelMaps>(
"COLZ0 L");
123 pixelmap->bookBarrelHistograms(
"entriesBarrel",
"# hits",
"# pixel hits");
124 pixelmap->bookForwardHistograms(
"entriesForward",
"# hits",
"# pixel hits");
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) {
140 edm::LogError(
"GeneralPurposeTrackAnalyzer") <<
"@SUB=GeneralPurposeTrackAnalyzer::index" 141 <<
" could not find " <<
name;
145 template <
typename T,
typename... Args>
167 std::unique_ptr<TrackerMap>
tmap;
168 std::unique_ptr<TrackerMap>
pmap;
332 edm::LogInfo(
"GeneralPurposeTrackAnalyzer") <<
"Reconstructed " << tC.size() <<
" tracks" << std::endl;
342 for (
int itrig = 0; itrig != ntrigs; ++itrig) {
348 <<
trigName <<
" " <<
accept <<
" ,track size: " << tC.size() << std::endl;
360 int nHighPurityTracks = 0;
363 unsigned int nHit2D = 0;
364 std::bitset<16> rocsToMask;
365 for (
auto iHit =
track->recHitsBegin(); iHit !=
track->recHitsEnd(); ++iHit) {
371 const DetId &detId = (*iHit)->geographicalId();
377 if (pixhit->isValid()) {
378 unsigned int subid = detId.
subdetId();
379 int detid_db = detId.
rawId();
382 auto clustp = pixhit->cluster();
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));
390 rocsToMask.set(rocId);
394 pmap->fill(detid_db, 1);
397 pixelmap->fillBarrelBin(
"entriesBarrel", detid_db, 1);
399 pixelmap->fillForwardBin(
"entriesForward", detid_db, 1);
429 if ((*iHit)->isValid()) {
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());
445 if (
track->hitPattern().numberOfValidPixelBarrelHits() != 0) {
452 if (
track->hitPattern().numberOfValidPixelEndcapHits() != 0) {
455 if (
track->hitPattern().numberOfValidStripTIBHits() != 0) {
458 if (
track->hitPattern().numberOfValidStripTIDHits() != 0) {
461 if (
track->hitPattern().numberOfValidStripTOBHits() != 0) {
464 if (
track->hitPattern().numberOfValidStripTECHits() != 0) {
477 if (fabs(
track->eta()) < 0.8) {
480 if (
track->eta() > 0.8 &&
track->eta() < 1.4) {
483 if (
track->eta() < -0.8 &&
track->eta() > -1.4) {
486 if (
track->eta() > 1.4) {
489 if (
track->eta() < -1.4) {
538 static const int etaindex = this->
index(vTrackHistos_,
"h_tracketa");
540 static const int phiindex = this->
index(vTrackHistos_,
"h_trackphi");
542 static const int numOfValidHitsindex = this->
index(vTrackHistos_,
"h_trackNumberOfValidHits");
544 static const int numOfLostHitsindex = this->
index(vTrackHistos_,
"h_trackNumberOfLostHits");
549 double kappa = -
track->charge() * theLocalMagFieldInInverseGeV /
track->pt();
551 static const int kappaindex = this->
index(vTrackHistos_,
"h_curvature");
553 static const int kappaposindex = this->
index(vTrackHistos_,
"h_curvature_pos");
554 if (
track->charge() > 0)
556 static const int kappanegindex = this->
index(vTrackHistos_,
"h_curvature_neg");
557 if (
track->charge() < 0)
560 double chi2Prob = TMath::Prob(
track->chi2(),
track->ndof());
561 double normchi2 =
track->normalizedChi2();
563 static const int normchi2index = this->
index(vTrackHistos_,
"h_normchi2");
565 static const int chi2index = this->
index(vTrackHistos_,
"h_chi2");
567 static const int chi2Probindex = this->
index(vTrackHistos_,
"h_chi2Prob");
569 static const int ptindex = this->
index(vTrackHistos_,
"h_pt");
570 static const int pt2index = this->
index(vTrackHistos_,
"h_ptrebin");
573 if (
track->ptError() != 0.) {
574 static const int ptResolutionindex = this->
index(vTrackHistos_,
"h_ptResolution");
578 static const int d0phiindex = this->
index(vTrackProfiles_,
"p_d0_vs_phi");
580 static const int dzphiindex = this->
index(vTrackProfiles_,
"p_dz_vs_phi");
582 static const int d0etaindex = this->
index(vTrackProfiles_,
"p_d0_vs_eta");
584 static const int dzetaindex = this->
index(vTrackProfiles_,
"p_dz_vs_eta");
586 static const int chiProbphiindex = this->
index(vTrackProfiles_,
"p_chi2Prob_vs_phi");
588 static const int chiProbabsd0index = this->
index(vTrackProfiles_,
"p_chi2Prob_vs_d0");
590 static const int chiProbabsdzindex = this->
index(vTrackProfiles_,
"p_chi2Prob_vs_dz");
592 static const int chiphiindex = this->
index(vTrackProfiles_,
"p_chi2_vs_phi");
594 static const int normchiphiindex = this->
index(vTrackProfiles_,
"p_normchi2_vs_phi");
596 static const int chietaindex = this->
index(vTrackProfiles_,
"p_chi2_vs_eta");
598 static const int normchiptindex = this->
index(vTrackProfiles_,
"p_normchi2_vs_pt");
600 static const int normchipindex = this->
index(vTrackProfiles_,
"p_normchi2_vs_p");
602 static const int chiProbetaindex = this->
index(vTrackProfiles_,
"p_chi2Prob_vs_eta");
604 static const int normchietaindex = this->
index(vTrackProfiles_,
"p_normchi2_vs_eta");
606 static const int kappaphiindex = this->
index(vTrackProfiles_,
"p_kappa_vs_phi");
608 static const int kappaetaindex = this->
index(vTrackProfiles_,
"p_kappa_vs_eta");
610 static const int ptResphiindex = this->
index(vTrackProfiles_,
"p_ptResolution_vs_phi");
612 static const int ptResetaindex = this->
index(vTrackProfiles_,
"p_ptResolution_vs_eta");
616 static const int etaphiindex_2d = this->
index(vTrack2DHistos_,
"h2_phi_vs_eta");
618 static const int d0phiindex_2d = this->
index(vTrack2DHistos_,
"h2_d0_vs_phi");
620 static const int dzphiindex_2d = this->
index(vTrack2DHistos_,
"h2_dz_vs_phi");
622 static const int d0etaindex_2d = this->
index(vTrack2DHistos_,
"h2_d0_vs_eta");
624 static const int dzetaindex_2d = this->
index(vTrack2DHistos_,
"h2_dz_vs_eta");
626 static const int chiphiindex_2d = this->
index(vTrack2DHistos_,
"h2_chi2_vs_phi");
628 static const int chiProbphiindex_2d = this->
index(vTrack2DHistos_,
"h2_chi2Prob_vs_phi");
630 static const int chiProbabsd0index_2d = this->
index(vTrack2DHistos_,
"h2_chi2Prob_vs_d0");
632 static const int normchiphiindex_2d = this->
index(vTrack2DHistos_,
"h2_normchi2_vs_phi");
634 static const int chietaindex_2d = this->
index(vTrack2DHistos_,
"h2_chi2_vs_eta");
636 static const int chiProbetaindex_2d = this->
index(vTrack2DHistos_,
"h2_chi2Prob_vs_eta");
638 static const int normchietaindex_2d = this->
index(vTrack2DHistos_,
"h2_normchi2_vs_eta");
640 static const int kappaphiindex_2d = this->
index(vTrack2DHistos_,
"h2_kappa_vs_phi");
642 static const int kappaetaindex_2d = this->
index(vTrack2DHistos_,
"h2_kappa_vs_eta");
644 static const int normchi2kappa_2d = this->
index(vTrack2DHistos_,
"h2_normchi2_vs_kappa");
650 if (beamSpotHandle.
isValid()) {
663 double mindxy = 100.;
666 for (
auto pvtx = vertexHandle->cbegin(); pvtx != vertexHandle->cend(); ++pvtx) {
669 mindxy =
track->dxy(mypoint);
675 hd0PV->Fill(-mindxy);
693 edm::LogInfo(
"GeneralPurposeTrackAnalyzer") <<
"end of track loop" << std::endl;
697 hNtrk->Fill(tC.size());
702 edm::LogInfo(
"GeneralPurposeTrackAnalyzer") <<
"end of analysis" << std::endl;
720 <<
"run number:" <<
run.run() <<
" magnetic field: " << B_ <<
" [T]" << std::endl;
740 coord_.
init(trackerTopology, trackerGeometry, siPixelFedCablingMap);
752 edm::LogInfo(
"GeneralPurposeTrackAnalyzer") << __LINE__ << std::endl;
755 TH1D::SetDefaultSumw2(kTRUE);
763 hrun = book<TH1D>(
"h_run",
"run", 100000, 230000, 240000);
764 hlumi = book<TH1D>(
"h_lumi",
"lumi", 1000, 0, 1000);
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.);
771 book<TH1D>(
"h_NhighPurity",
"n. high purity tracks;Number of high purity tracks;events", 200, 0., 200.);
774 "tracking step;iterative tracking step;tracks",
780 "original tracking step;original iterative tracking step;tracks",
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++) {
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);
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);
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);
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);
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);
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);
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);
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);
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.);
841 "h_chi2_Prob_hp",
"#chi^{2} probability (high purity);#chi^{2}prob_{Track};Number of Tracks", 100, 0.0, 1.);
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);
851 book<TH2D>(
"h2_d0PVvsphi",
"hd0PVvsphi;track #phi;track d_{0}(PV) [cm]", 160, -
M_PI,
M_PI, 100, -1., 1.);
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.);
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);
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.);
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);
877 "h2_d0vsphi",
"Track d_{0} vs #phi; track #phi;track d_{0} [cm]", 160, -3.20, 3.20, 100, -100., 100.);
879 "h2_d0vseta",
"Track d_{0} vs #eta; track #eta;track d_{0} [cm]", 160, -3.20, 3.20, 100, -100., 100.);
881 book<TH2D>(
"h2_d0vspt",
"Track d_{0} vs p_{T};track p_{T};track d_{0} [cm]", 50, 0., 100., 100, -100, 100);
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.);
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.);
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.);
899 hHitComposition = book<TH1D>(
"h_hitcomposition",
"track hit composition;;# hits", 6, -0.5, 5.5);
902 book<TProfile>(
"p_NpixHits_vs_Vx",
"n. Barrel Pixel hits vs. v_{x};v_{x} (cm);n. BPix hits", 20, -20, 20);
905 book<TProfile>(
"p_NpixHits_vs_Vy",
"n. Barrel Pixel hits vs. v_{y};v_{y} (cm);n. BPix hits", 20, -20, 20);
908 book<TProfile>(
"p_NpixHits_vs_Vz",
"n. Barrel Pixel hits vs. v_{z};v_{z} (cm);n. BPix hits", 20, -100, 100);
910 std::string dets[6] = {
"PXB",
"PXF",
"TIB",
"TID",
"TOB",
"TEC"};
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.));
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));
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));
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));
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_));
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.));
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));
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));
982 edm::LogPrint(
"GeneralPurposeTrackAnalyzer") <<
"*******************************" << std::endl;
983 edm::LogPrint(
"GeneralPurposeTrackAnalyzer") <<
"Events run in total: " <<
ievt << std::endl;
985 edm::LogPrint(
"GeneralPurposeTrackAnalyzer") <<
"*******************************" << std::endl;
988 edm::LogPrint(
"GeneralPurposeTrackAnalyzer") <<
"firing triggers: " << nFiringTriggers << std::endl;
989 edm::LogPrint(
"GeneralPurposeTrackAnalyzer") <<
"*******************************" << std::endl;
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);
1000 double trkpercent = ((it.second).
second) * 100. / double(
itrks);
1001 double evtpercent = ((it.second).
first) * 100. / double(
ievt);
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 <<
"%)";
1021 std::vector<int> theRuns_;
1023 theRuns_.push_back(it.first);
1026 sort(theRuns_.begin(), theRuns_.end());
1027 int runRange = theRuns_.back() - theRuns_.front() + 1;
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;
1036 "Strip APV mode by run number;;APV mode (-1=deco,+1=peak)",
1038 theRuns_.front() - 0.5,
1039 theRuns_.back() + 0.5);
1042 "CMS B-field intensity by run number;;B-field intensity [T]",
1044 theRuns_.front() - 0.5,
1045 theRuns_.back() + 0.5);
1047 for (
const auto &the_r : theRuns_) {
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;
1063 pmap->save(
true, 0, 0,
"PixelHitMap.pdf", 600, 800);
1064 pmap->save(
true, 0, 0,
"PixelHitMap.png", 500, 750);
1067 tmap->save(
true, 0, 0,
"StripHitMap.pdf");
1068 tmap->save(
true, 0, 0,
"StripHitMap.png");
1070 gStyle->SetPalette(kRainBow);
1073 TCanvas cB(
"CanvBarrel",
"CanvBarrel", 1200, 1000);
1074 pixelmap->drawBarrelMaps(
"entriesBarrel", cB);
1075 cB.SaveAs(
"pixelBarrelEntries.png");
1077 TCanvas cF(
"CanvForward",
"CanvForward", 1600, 1000);
1078 pixelmap->drawForwardMaps(
"entriesForward", cF);
1079 cF.SaveAs(
"pixelForwardEntries.png");
1081 TCanvas cRocs = TCanvas(
"cRocs",
"cRocs", 1200, 1600);
1082 pixelrocsmap_->drawMaps(cRocs,
"Pixel on-track clusters occupancy");
1083 cRocs.SaveAs(
"Phase1PixelROCMaps_fullROCs.png");
1090 bool countStereoHitAs2D_ =
true;
1093 if (!
hit.isValid() ||
1097 const DetId detId(
hit.geographicalId());
1099 if (detId.subdetId() ==
kBPIX || detId.subdetId() ==
kFPIX) {
1104 return countStereoHitAs2D_;
1105 else if (dynamic_cast<const SiStripRecHit1D *>(&
hit) ||
dynamic_cast<const SiStripRecHit2D *
>(&
hit))
1108 else if (dynamic_cast<const SiStripMatchedRecHit2D *>(&
hit))
1110 else if (dynamic_cast<const ProjectedSiStripRecHit2D *>(&
hit)) {
1114 edm::LogError(
"UnknownType") <<
"@SUB=GeneralPurposeTrackAnalyzer::isHit2D" 1115 <<
"Tracker hit not in pixel, neither SiStripRecHit[12]D nor " 1116 <<
"SiStripMatchedRecHit2D nor ProjectedSiStripRecHit2D.";
1121 edm::LogWarning(
"DetectorMismatch") <<
"@SUB=GeneralPurposeTrackAnalyzer::isHit2D" 1122 <<
"Hit not in tracker with 'official' dimension >=2.";
1135 desc.setComment(
"Generic track analyzer to check ALCARECO sample quantities");
1140 desc.add<
bool>(
"isCosmics",
false);
1141 descriptions.
add(
"GeneralPurposeTrackAnalyzer",
desc);
static const std::string kSharedResource
void analyze(const edm::Event &event, const edm::EventSetup &setup) override
const edm::ESGetToken< SiStripLatency, SiStripLatencyRcd > latencyToken_
TProfile * pNBpixHitsVsVy
std::map< int, std::pair< int, float > > conditionsMap_
SiPixelCoordinates coord_
TH1D * hHitCountVsPhiFPix
double z() const
z coordinate
edm::EDGetTokenT< edm::TriggerResults > hltresultsToken_
edm::EDGetTokenT< reco::TrackCollection > theTrackCollectionToken_
Strings const & triggerNames() const
virtual GlobalVector inTesla(const GlobalPoint &gp) const =0
Field value ad specified global point, in Tesla.
#define DEFINE_FWK_MODULE(type)
Geom::Phi< T > phi() const
std::unique_ptr< TrackerMap > tmap
edm::InputTag VerticesTag_
Global3DPoint GlobalPoint
std::vector< Track > TrackCollection
collection of Tracks
GlobalVector inInverseGeV(const GlobalPoint &gp) const
Field value ad specified global point, in 1/Gev.
static void fillDescriptions(edm::ConfigurationDescriptions &)
std::unique_ptr< TrackerMap > pmap
std::string to_string(const V &value)
Log< level::Error, false > LogError
bool accept(const edm::Event &event, const edm::TriggerResults &triggerTable, const std::string &triggerPath)
void beginRun(edm::Run const &run, edm::EventSetup const &setup) override
const TrackerGeometry * trackerGeometry_
std::vector< TH1 * > vTrackHistos_
const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord > geomTokenBR_
U second(std::pair< T, U > const &p)
TH1D * hHitCountVsPhiBPix
std::vector< TH1 * > vTrackProfiles_
T const * product() const
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)
Abs< T >::type abs(const T &t)
TH1D * hHitCountVsThetaFPix
void init(const TrackerTopology *, const TrackerGeometry *, const SiPixelFedCablingMap *)
constexpr int subdetId() const
get the contents of the subdetector field (not cast into any detector's numbering enum) ...
int roc(const DetId &, const std::pair< int, int > &)
std::map< int, std::pair< int, int > > runInfoMap_
double x() const
x coordinate
std::vector< TH1 * > vTrack2DHistos_
Log< level::Warning, true > LogPrint
const TrackerGeomDet * idToDet(DetId) const override
double y() const
y coordinate
const char * qualities[3]
edm::EDGetTokenT< reco::BeamSpot > beamspotToken_
Log< level::Info, false > LogInfo
Detector identifier class for the strip tracker.
edm::InputTag BeamSpotTag_
const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > magFieldToken_
int16_t singleReadOutMode() const
constexpr uint32_t rawId() const
get the raw id
XYZPointD XYZPoint
point in space with cartesian internal representation
const edm::ESGetToken< TrackerTopology, TrackerTopologyRcd > trackerTopologyTokenBR_
void add(std::string const &label, ParameterSetDescription const &psetDescription)
std::string const & triggerName(unsigned int index) const
TProfile * pNBpixHitsVsVx
static const std::string algoNames[]
void endRun(edm::Run const &, edm::EventSetup const &) override
std::unique_ptr< Phase1PixelROCMaps > pixelrocsmap_
TH1D * hHitCountVsThetaBPix
SiStripRecHit2D originalHit() const
edm::Service< TFileService > fs
T * book(const Args &...args) const
T * make(const Args &...args) const
make new ROOT object
Log< level::Warning, false > LogWarning
std::unique_ptr< Phase1PixelMaps > pixelmap
bool isHit2D(const TrackingRecHit &hit)
edm::InputTag TriggerResultsTag_
~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
const edm::ESGetToken< SiPixelFedCablingMap, SiPixelFedCablingMapRcd > siPixelFedCablingMapTokenBR_
TProfile * pNBpixHitsVsVz
Geom::Theta< T > theta() const
const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord > geomToken_
int index(const std::vector< OBJECT_TYPE *> &vec, const TString &name)