Back to home page

sPhenix code displayed by LXR
 
 

    

File indexing completed on 2025-08-06 08:11:53 

0001 // ----------------------------------------------------------------------------
0002 // 'MakeNewMatcherPlots.cxx'
0003 // Derek Anderson
0004 // 08.24.2023
0005 //
0006 // Short macro to make plots from the
0007 // output of the SvtxEvaluator module.
0008 // ----------------------------------------------------------------------------
0009 
0010 #include <string>
0011 #include <vector>
0012 #include <utility>
0013 #include <iostream>
0014 #include "TH1.h"
0015 #include "TH2.h"
0016 #include "TFile.h"
0017 #include "TError.h"
0018 #include "TChain.h"
0019 #include "TNtuple.h"
0020 
0021 using namespace std;
0022 
0023 // global constants
0024 static const size_t NSectors = 12;
0025 
0026 
0027 
0028 // main body of macro ---------------------------------------------------------
0029 
0030 
0031 void MakeOldEvaluatorPlots() {
0032 
0033   // io parameters
0034   const string         sOutput("oldEvalPlots_oneMatchPerParticle_embedScanOn_forZVtxCutComp_oddFrac05150.pt10n1evt500pim.d1m2y2024.root");
0035   const string         sTupleTrue("ntp_gtrack");
0036   const string         sTupleReco("ntp_track");
0037   const vector<string> vecInTrue = {
0038     "input/merged/sPhenixG4_oneMatchPerParticle_oldEval_forCrossCheck.pt10num1evt500pim.d25m1y2024.root"
0039   };
0040   const vector<string> vecInReco = {
0041     "input/merged/sPhenixG4_oneMatchPerParticle_oldEval_forCrossCheck.pt10num1evt500pim.d25m1y2024.root"
0042   };
0043 
0044   // cut options
0045   const bool useOnlyPrimTrks(true);
0046   const bool doZVtxCut(true);
0047   const bool doPhiCut(false);
0048 
0049   // weird track parameters
0050   const pair<float, float> oddPtFrac = {0.5,  1.5};
0051   const pair<float, float> zVtxRange = {-1.,  1.};
0052 
0053   // phi cut parameters
0054   const float sigCutVal(0.75);
0055   const array<pair<float, float>, NSectors> phiSectors = {
0056     make_pair(-2.92, 0.12),
0057     make_pair(-2.38, 0.05),
0058     make_pair(-1.93, 0.18),
0059     make_pair(-1.33, 0.07),
0060     make_pair(-0.90, 0.24),
0061     make_pair(-0.29, 0.09),
0062     make_pair(0.23,  0.11),
0063     make_pair(0.73,  0.10),
0064     make_pair(1.28,  0.10),
0065     make_pair(1.81,  0.08),
0066     make_pair(2.23,  0.18),
0067     make_pair(2.80,  0.17)
0068   };
0069 
0070   // lower verbosity
0071   gErrorIgnoreLevel = kError;
0072   cout << "\n  Staring old evaluator plot script..." << endl;
0073 
0074   // open files
0075   TFile* fOutput = new TFile(sOutput.data(), "recreate");
0076   if (!fOutput) {
0077      cerr << "PANIC: couldn't open output file!\n"
0078           << "       fOutput = " << fOutput << "\n"
0079           << endl;
0080     return;
0081   }
0082   cout << "    Opened files." << endl;
0083 
0084   // grab input trees
0085   TChain* tInTrue = new TChain(sTupleTrue.data());
0086   TChain* tInReco = new TChain(sTupleReco.data());
0087   for (const string sInTrue : vecInTrue) {
0088     const int added = tInTrue -> Add(sInTrue.data());
0089     if (added != 1) {
0090       cerr << "WARNING: was not able to add ntuple from file \'" << sInTrue << "\'!\n"
0091            << "         return value = " << added
0092            << endl;
0093     }
0094   }
0095   for (const string sInReco : vecInReco) {
0096     const int added = tInReco -> Add(sInReco.data());
0097     if (added != 1) {
0098       cerr << "WARNING: was not able to add ntuple from file \'" << sInReco << "\'!\n"
0099            << "         return value = " << added
0100            << endl;
0101     }
0102   }
0103   cout << "    Grabbed input trees." << endl;
0104 
0105   // declare input leaves
0106   Float_t tru_event;
0107   Float_t tru_seed;
0108   Float_t tru_gntracks;
0109   Float_t tru_gnchghad;
0110   Float_t tru_gtrackID;
0111   Float_t tru_gflavor;
0112   Float_t tru_gnhits;
0113   Float_t tru_gnmaps;
0114   Float_t tru_gnintt;
0115   Float_t tru_gnmms;
0116   Float_t tru_gnintt1;
0117   Float_t tru_gnintt2;
0118   Float_t tru_gnintt3;
0119   Float_t tru_gnintt4;
0120   Float_t tru_gnintt5;
0121   Float_t tru_gnintt6;
0122   Float_t tru_gnintt7;
0123   Float_t tru_gnintt8;
0124   Float_t tru_gntpc;
0125   Float_t tru_gnlmaps;
0126   Float_t tru_gnlintt;
0127   Float_t tru_gnltpc;
0128   Float_t tru_gnlmms;
0129   Float_t tru_gpx;
0130   Float_t tru_gpy;
0131   Float_t tru_gpz;
0132   Float_t tru_gpt;
0133   Float_t tru_geta;
0134   Float_t tru_gphi;
0135   Float_t tru_gvx;
0136   Float_t tru_gvy;
0137   Float_t tru_gvz;
0138   Float_t tru_gvt;
0139   Float_t tru_gfpx;
0140   Float_t tru_gfpy;
0141   Float_t tru_gfpz;
0142   Float_t tru_gfx;
0143   Float_t tru_gfy;
0144   Float_t tru_gfz;
0145   Float_t tru_gembed;
0146   Float_t tru_gprimary;
0147   Float_t tru_trackID;
0148   Float_t tru_px;
0149   Float_t tru_py;
0150   Float_t tru_pz;
0151   Float_t tru_pt;
0152   Float_t tru_eta;
0153   Float_t tru_phi;
0154   Float_t tru_deltapt;
0155   Float_t tru_deltaeta;
0156   Float_t tru_deltaphi;
0157   Float_t tru_siqr;
0158   Float_t tru_siphi;
0159   Float_t tru_sithe;
0160   Float_t tru_six0;
0161   Float_t tru_siy0;
0162   Float_t tru_tpqr;
0163   Float_t tru_tpphi;
0164   Float_t tru_tpthe;
0165   Float_t tru_tpx0;
0166   Float_t tru_tpy0;
0167   Float_t tru_charge;
0168   Float_t tru_quality;
0169   Float_t tru_chisq;
0170   Float_t tru_ndf;
0171   Float_t tru_nhits;
0172   Float_t tru_layers;
0173   Float_t tru_nmaps;
0174   Float_t tru_nintt;
0175   Float_t tru_ntpc;
0176   Float_t tru_nmms;
0177   Float_t tru_ntpc1;
0178   Float_t tru_ntpc11;
0179   Float_t tru_ntpc2;
0180   Float_t tru_ntpc3;
0181   Float_t tru_nlmaps;
0182   Float_t tru_nlintt;
0183   Float_t tru_nltpc;
0184   Float_t tru_nlmms;
0185   Float_t tru_vertexID;
0186   Float_t tru_vx;
0187   Float_t tru_vy;
0188   Float_t tru_vz;
0189   Float_t tru_dca2d;
0190   Float_t tru_dca2dsigma;
0191   Float_t tru_dca3dxy;
0192   Float_t tru_dca3dxysigma;
0193   Float_t tru_dca3dz;
0194   Float_t tru_dca3dzsigma;
0195   Float_t tru_pcax;
0196   Float_t tru_pcay;
0197   Float_t tru_pcaz;
0198   Float_t tru_nfromtruth;
0199   Float_t tru_nwrong;
0200   Float_t tru_ntrumaps;
0201   Float_t tru_nwrongmaps;
0202   Float_t tru_ntruintt;
0203   Float_t tru_nwrongintt;
0204   Float_t tru_ntrutpc;
0205   Float_t tru_nwrongtpc;
0206   Float_t tru_ntrumms;
0207   Float_t tru_nwrongmms;
0208   Float_t tru_ntrutpc1;
0209   Float_t tru_nwrongtpc1;
0210   Float_t tru_ntrutpc11;
0211   Float_t tru_nwrongtpc11;
0212   Float_t tru_ntrutpc2;
0213   Float_t tru_nwrongtpc2;
0214   Float_t tru_ntrutpc3;
0215   Float_t tru_nwrongtpc3;
0216   Float_t tru_layersfromtruth;
0217   Float_t tru_npedge;
0218   Float_t tru_nredge;
0219   Float_t tru_nbig;
0220   Float_t tru_novlp;
0221   Float_t tru_merr;
0222   Float_t tru_msize;
0223   Float_t tru_nhittpcall;
0224   Float_t tru_nhittpcin;
0225   Float_t tru_nhittpcmid;
0226   Float_t tru_nhittpcout;
0227   Float_t tru_nclusall;
0228   Float_t tru_nclustpc;
0229   Float_t tru_nclusintt;
0230   Float_t tru_nclusmaps;
0231   Float_t tru_nclusmms;
0232 
0233   Float_t rec_event;
0234   Float_t rec_seed;
0235   Float_t rec_trackID;
0236   Float_t rec_crossing;
0237   Float_t rec_px;
0238   Float_t rec_py;
0239   Float_t rec_pz;
0240   Float_t rec_pt;
0241   Float_t rec_eta;
0242   Float_t rec_phi;
0243   Float_t rec_deltapt;
0244   Float_t rec_deltaeta;
0245   Float_t rec_deltaphi;
0246   Float_t rec_siqr;
0247   Float_t rec_siphi;
0248   Float_t rec_sithe;
0249   Float_t rec_six0;
0250   Float_t rec_siy0;
0251   Float_t rec_tpqr;
0252   Float_t rec_tpphi;
0253   Float_t rec_tpthe;
0254   Float_t rec_tpx0;
0255   Float_t rec_tpy0;
0256   Float_t rec_charge;
0257   Float_t rec_quality;
0258   Float_t rec_chisq;
0259   Float_t rec_ndf;
0260   Float_t rec_nhits;
0261   Float_t rec_nmaps;
0262   Float_t rec_nintt;
0263   Float_t rec_ntpc;
0264   Float_t rec_nmms;
0265   Float_t rec_ntpc1;
0266   Float_t rec_ntpc11;
0267   Float_t rec_ntpc2;
0268   Float_t rec_ntpc3;
0269   Float_t rec_nlmaps;
0270   Float_t rec_nlintt;
0271   Float_t rec_nltpc;
0272   Float_t rec_nlmms;
0273   Float_t rec_layers;
0274   Float_t rec_vertexID;
0275   Float_t rec_vx;
0276   Float_t rec_vy;
0277   Float_t rec_vz;
0278   Float_t rec_dca2d;
0279   Float_t rec_dca2dsigma;
0280   Float_t rec_dca3dxy;
0281   Float_t rec_dca3dxysigma;
0282   Float_t rec_dca3dz;
0283   Float_t rec_dca3dzsigma;
0284   Float_t rec_pcax;
0285   Float_t rec_pcay;
0286   Float_t rec_pcaz;
0287   Float_t rec_gtrackID;
0288   Float_t rec_gflavor;
0289   Float_t rec_gnhits;
0290   Float_t rec_gnmaps;
0291   Float_t rec_gnintt;
0292   Float_t rec_gntpc;
0293   Float_t rec_gnmms;
0294   Float_t rec_gnlmaps;
0295   Float_t rec_gnlintt;
0296   Float_t rec_gnltpc;
0297   Float_t rec_gnlmms;
0298   Float_t rec_gpx;
0299   Float_t rec_gpy;
0300   Float_t rec_gpz;
0301   Float_t rec_gpt;
0302   Float_t rec_geta;
0303   Float_t rec_gphi;
0304   Float_t rec_gvx;
0305   Float_t rec_gvy;
0306   Float_t rec_gvz;
0307   Float_t rec_gvt;
0308   Float_t rec_gfpx;
0309   Float_t rec_gfpy;
0310   Float_t rec_gfpz;
0311   Float_t rec_gfx;
0312   Float_t rec_gfy;
0313   Float_t rec_gfz;
0314   Float_t rec_gembed;
0315   Float_t rec_gprimary;
0316   Float_t rec_nfromtruth;
0317   Float_t rec_nwrong;
0318   Float_t rec_ntrumaps;
0319   Float_t rec_nwrongmaps;
0320   Float_t rec_ntruintt;
0321   Float_t rec_nwrongintt;
0322   Float_t rec_ntrutpc;
0323   Float_t rec_nwrongtpc;
0324   Float_t rec_ntrumms;
0325   Float_t rec_nwrongmms;
0326   Float_t rec_ntrutpc1;
0327   Float_t rec_nwrongtpc1;
0328   Float_t rec_ntrutpc11;
0329   Float_t rec_nwrongtpc11;
0330   Float_t rec_ntrutpc2;
0331   Float_t rec_nwrongtpc2;
0332   Float_t rec_ntrutpc3;
0333   Float_t rec_nwrongtpc3;
0334   Float_t rec_layersfromtruth;
0335   Float_t rec_npedge;
0336   Float_t rec_nredge;
0337   Float_t rec_nbig;
0338   Float_t rec_novlp;
0339   Float_t rec_merr;
0340   Float_t rec_msize;
0341   Float_t rec_nhittpcall;
0342   Float_t rec_nhittpcin;
0343   Float_t rec_nhittpcmid;
0344   Float_t rec_nhittpcout;
0345   Float_t rec_nclusall;
0346   Float_t rec_nclustpc;
0347   Float_t rec_nclusintt;
0348   Float_t rec_nclusmaps;
0349   Float_t rec_nclusmms;
0350 
0351   // Set branch addresses.
0352   tInTrue -> SetBranchAddress("event",           &tru_event);
0353   tInTrue -> SetBranchAddress("seed",            &tru_seed);
0354   tInTrue -> SetBranchAddress("gntracks",        &tru_gntracks);
0355   tInTrue -> SetBranchAddress("gnchghad",        &tru_gnchghad);
0356   tInTrue -> SetBranchAddress("gtrackID",        &tru_gtrackID);
0357   tInTrue -> SetBranchAddress("gflavor",         &tru_gflavor);
0358   tInTrue -> SetBranchAddress("gnhits",          &tru_gnhits);
0359   tInTrue -> SetBranchAddress("gnmaps",          &tru_gnmaps);
0360   tInTrue -> SetBranchAddress("gnintt",          &tru_gnintt);
0361   tInTrue -> SetBranchAddress("gnmms",           &tru_gnmms);
0362   tInTrue -> SetBranchAddress("gnintt1",         &tru_gnintt1);
0363   tInTrue -> SetBranchAddress("gnintt2",         &tru_gnintt2);
0364   tInTrue -> SetBranchAddress("gnintt3",         &tru_gnintt3);
0365   tInTrue -> SetBranchAddress("gnintt4",         &tru_gnintt4);
0366   tInTrue -> SetBranchAddress("gnintt5",         &tru_gnintt5);
0367   tInTrue -> SetBranchAddress("gnintt6",         &tru_gnintt6);
0368   tInTrue -> SetBranchAddress("gnintt7",         &tru_gnintt7);
0369   tInTrue -> SetBranchAddress("gnintt8",         &tru_gnintt8);
0370   tInTrue -> SetBranchAddress("gntpc",           &tru_gntpc);
0371   tInTrue -> SetBranchAddress("gnlmaps",         &tru_gnlmaps);
0372   tInTrue -> SetBranchAddress("gnlintt",         &tru_gnlintt);
0373   tInTrue -> SetBranchAddress("gnltpc",          &tru_gnltpc);
0374   tInTrue -> SetBranchAddress("gnlmms",          &tru_gnlmms);
0375   tInTrue -> SetBranchAddress("gpx",             &tru_gpx);
0376   tInTrue -> SetBranchAddress("gpy",             &tru_gpy);
0377   tInTrue -> SetBranchAddress("gpz",             &tru_gpz);
0378   tInTrue -> SetBranchAddress("gpt",             &tru_gpt);
0379   tInTrue -> SetBranchAddress("geta",            &tru_geta);
0380   tInTrue -> SetBranchAddress("gphi",            &tru_gphi);
0381   tInTrue -> SetBranchAddress("gvx",             &tru_gvx);
0382   tInTrue -> SetBranchAddress("gvy",             &tru_gvy);
0383   tInTrue -> SetBranchAddress("gvz",             &tru_gvz);
0384   tInTrue -> SetBranchAddress("gvt",             &tru_gvt);
0385   tInTrue -> SetBranchAddress("gfpx",            &tru_gfpx);
0386   tInTrue -> SetBranchAddress("gfpy",            &tru_gfpy);
0387   tInTrue -> SetBranchAddress("gfpz",            &tru_gfpz);
0388   tInTrue -> SetBranchAddress("gfx",             &tru_gfx);
0389   tInTrue -> SetBranchAddress("gfy",             &tru_gfy);
0390   tInTrue -> SetBranchAddress("gfz",             &tru_gfz);
0391   tInTrue -> SetBranchAddress("gembed",          &tru_gembed);
0392   tInTrue -> SetBranchAddress("gprimary",        &tru_gprimary);
0393   tInTrue -> SetBranchAddress("trackID",         &tru_trackID);
0394   tInTrue -> SetBranchAddress("px",              &tru_px);
0395   tInTrue -> SetBranchAddress("py",              &tru_py);
0396   tInTrue -> SetBranchAddress("pz",              &tru_pz);
0397   tInTrue -> SetBranchAddress("pt",              &tru_pt);
0398   tInTrue -> SetBranchAddress("eta",             &tru_eta);
0399   tInTrue -> SetBranchAddress("phi",             &tru_phi);
0400   tInTrue -> SetBranchAddress("deltapt",         &tru_deltapt);
0401   tInTrue -> SetBranchAddress("deltaeta",        &tru_deltaeta);
0402   tInTrue -> SetBranchAddress("deltaphi",        &tru_deltaphi);
0403   tInTrue -> SetBranchAddress("siqr",            &tru_siqr);
0404   tInTrue -> SetBranchAddress("siphi",           &tru_siphi);
0405   tInTrue -> SetBranchAddress("sithe",           &tru_sithe);
0406   tInTrue -> SetBranchAddress("six0",            &tru_six0);
0407   tInTrue -> SetBranchAddress("siy0",            &tru_siy0);
0408   tInTrue -> SetBranchAddress("tpqr",            &tru_tpqr);
0409   tInTrue -> SetBranchAddress("tpphi",           &tru_tpphi);
0410   tInTrue -> SetBranchAddress("tpthe",           &tru_tpthe);
0411   tInTrue -> SetBranchAddress("tpx0",            &tru_tpx0);
0412   tInTrue -> SetBranchAddress("tpy0",            &tru_tpy0);
0413   tInTrue -> SetBranchAddress("charge",          &tru_charge);
0414   tInTrue -> SetBranchAddress("quality",         &tru_quality);
0415   tInTrue -> SetBranchAddress("chisq",           &tru_chisq);
0416   tInTrue -> SetBranchAddress("ndf",             &tru_ndf);
0417   tInTrue -> SetBranchAddress("nhits",           &tru_nhits);
0418   tInTrue -> SetBranchAddress("layers",          &tru_layers);
0419   tInTrue -> SetBranchAddress("nmaps",           &tru_nmaps);
0420   tInTrue -> SetBranchAddress("nintt",           &tru_nintt);
0421   tInTrue -> SetBranchAddress("ntpc",            &tru_ntpc);
0422   tInTrue -> SetBranchAddress("nmms",            &tru_nmms);
0423   tInTrue -> SetBranchAddress("ntpc1",           &tru_ntpc1);
0424   tInTrue -> SetBranchAddress("ntpc11",          &tru_ntpc11);
0425   tInTrue -> SetBranchAddress("ntpc2",           &tru_ntpc2);
0426   tInTrue -> SetBranchAddress("ntpc3",           &tru_ntpc3);
0427   tInTrue -> SetBranchAddress("nlmaps",          &tru_nlmaps);
0428   tInTrue -> SetBranchAddress("nlintt",          &tru_nlintt);
0429   tInTrue -> SetBranchAddress("nltpc",           &tru_nltpc);
0430   tInTrue -> SetBranchAddress("nlmms",           &tru_nlmms);
0431   tInTrue -> SetBranchAddress("vertexID",        &tru_vertexID);
0432   tInTrue -> SetBranchAddress("vx",              &tru_vx);
0433   tInTrue -> SetBranchAddress("vy",              &tru_vy);
0434   tInTrue -> SetBranchAddress("vz",              &tru_vz);
0435   tInTrue -> SetBranchAddress("dca2d",           &tru_dca2d);
0436   tInTrue -> SetBranchAddress("dca2dsigma",      &tru_dca2dsigma);
0437   tInTrue -> SetBranchAddress("dca3dxy",         &tru_dca3dxy);
0438   tInTrue -> SetBranchAddress("dca3dxysigma",    &tru_dca3dxysigma);
0439   tInTrue -> SetBranchAddress("dca3dz",          &tru_dca3dz);
0440   tInTrue -> SetBranchAddress("dca3dzsigma",     &tru_dca3dzsigma);
0441   tInTrue -> SetBranchAddress("pcax",            &tru_pcax);
0442   tInTrue -> SetBranchAddress("pcay",            &tru_pcay);
0443   tInTrue -> SetBranchAddress("pcaz",            &tru_pcaz);
0444   tInTrue -> SetBranchAddress("nfromtruth",      &tru_nfromtruth);
0445   tInTrue -> SetBranchAddress("nwrong",          &tru_nwrong);
0446   tInTrue -> SetBranchAddress("ntrumaps",        &tru_ntrumaps);
0447   tInTrue -> SetBranchAddress("nwrongmaps",      &tru_nwrongmaps);
0448   tInTrue -> SetBranchAddress("ntruintt",        &tru_ntruintt);
0449   tInTrue -> SetBranchAddress("nwrongintt",      &tru_nwrongintt);
0450   tInTrue -> SetBranchAddress("ntrutpc",         &tru_ntrutpc);
0451   tInTrue -> SetBranchAddress("nwrongtpc",       &tru_nwrongtpc);
0452   tInTrue -> SetBranchAddress("ntrumms",         &tru_ntrumms);
0453   tInTrue -> SetBranchAddress("nwrongmms",       &tru_nwrongmms);
0454   tInTrue -> SetBranchAddress("ntrutpc1",        &tru_ntrutpc1);
0455   tInTrue -> SetBranchAddress("nwrongtpc1",      &tru_nwrongtpc1);
0456   tInTrue -> SetBranchAddress("ntrutpc11",       &tru_ntrutpc11);
0457   tInTrue -> SetBranchAddress("nwrongtpc11",     &tru_nwrongtpc11);
0458   tInTrue -> SetBranchAddress("ntrutpc2",        &tru_ntrutpc2);
0459   tInTrue -> SetBranchAddress("nwrongtpc2",      &tru_nwrongtpc2);
0460   tInTrue -> SetBranchAddress("ntrutpc3",        &tru_ntrutpc3);
0461   tInTrue -> SetBranchAddress("nwrongtpc3",      &tru_nwrongtpc3);
0462   tInTrue -> SetBranchAddress("layersfromtruth", &tru_layersfromtruth);
0463   tInTrue -> SetBranchAddress("npedge",          &tru_npedge);
0464   tInTrue -> SetBranchAddress("nredge",          &tru_nredge);
0465   tInTrue -> SetBranchAddress("nbig",            &tru_nbig);
0466   tInTrue -> SetBranchAddress("novlp",           &tru_novlp);
0467   tInTrue -> SetBranchAddress("merr",            &tru_merr);
0468   tInTrue -> SetBranchAddress("msize",           &tru_msize);
0469   tInTrue -> SetBranchAddress("nhittpcall",      &tru_nhittpcall);
0470   tInTrue -> SetBranchAddress("nhittpcin",       &tru_nhittpcin);
0471   tInTrue -> SetBranchAddress("nhittpcmid",      &tru_nhittpcmid);
0472   tInTrue -> SetBranchAddress("nhittpcout",      &tru_nhittpcout);
0473   tInTrue -> SetBranchAddress("nclusall",        &tru_nclusall);
0474   tInTrue -> SetBranchAddress("nclustpc",        &tru_nclustpc);
0475   tInTrue -> SetBranchAddress("nclusintt",       &tru_nclusintt);
0476   tInTrue -> SetBranchAddress("nclusmaps",       &tru_nclusmaps);
0477   tInTrue -> SetBranchAddress("nclusmms",        &tru_nclusmms);
0478 
0479   tInReco -> SetBranchAddress("event",           &rec_event);
0480   tInReco -> SetBranchAddress("seed",            &rec_seed);
0481   tInReco -> SetBranchAddress("trackID",         &rec_trackID);
0482   tInReco -> SetBranchAddress("crossing",        &rec_crossing);
0483   tInReco -> SetBranchAddress("px",              &rec_px);
0484   tInReco -> SetBranchAddress("py",              &rec_py);
0485   tInReco -> SetBranchAddress("pz",              &rec_pz);
0486   tInReco -> SetBranchAddress("pt",              &rec_pt);
0487   tInReco -> SetBranchAddress("eta",             &rec_eta);
0488   tInReco -> SetBranchAddress("phi",             &rec_phi);
0489   tInReco -> SetBranchAddress("deltapt",         &rec_deltapt);
0490   tInReco -> SetBranchAddress("deltaeta",        &rec_deltaeta);
0491   tInReco -> SetBranchAddress("deltaphi",        &rec_deltaphi);
0492   tInReco -> SetBranchAddress("siqr",            &rec_siqr);
0493   tInReco -> SetBranchAddress("siphi",           &rec_siphi);
0494   tInReco -> SetBranchAddress("sithe",           &rec_sithe);
0495   tInReco -> SetBranchAddress("six0",            &rec_six0);
0496   tInReco -> SetBranchAddress("siy0",            &rec_siy0);
0497   tInReco -> SetBranchAddress("tpqr",            &rec_tpqr);
0498   tInReco -> SetBranchAddress("tpphi",           &rec_tpphi);
0499   tInReco -> SetBranchAddress("tpthe",           &rec_tpthe);
0500   tInReco -> SetBranchAddress("tpx0",            &rec_tpx0);
0501   tInReco -> SetBranchAddress("tpy0",            &rec_tpy0);
0502   tInReco -> SetBranchAddress("charge",          &rec_charge);
0503   tInReco -> SetBranchAddress("quality",         &rec_quality);
0504   tInReco -> SetBranchAddress("chisq",           &rec_chisq);
0505   tInReco -> SetBranchAddress("ndf",             &rec_ndf);
0506   tInReco -> SetBranchAddress("nhits",           &rec_nhits);
0507   tInReco -> SetBranchAddress("nmaps",           &rec_nmaps);
0508   tInReco -> SetBranchAddress("nintt",           &rec_nintt);
0509   tInReco -> SetBranchAddress("ntpc",            &rec_ntpc);
0510   tInReco -> SetBranchAddress("nmms",            &rec_nmms);
0511   tInReco -> SetBranchAddress("ntpc1",           &rec_ntpc1);
0512   tInReco -> SetBranchAddress("ntpc11",          &rec_ntpc11);
0513   tInReco -> SetBranchAddress("ntpc2",           &rec_ntpc2);
0514   tInReco -> SetBranchAddress("ntpc3",           &rec_ntpc3);
0515   tInReco -> SetBranchAddress("nlmaps",          &rec_nlmaps);
0516   tInReco -> SetBranchAddress("nlintt",          &rec_nlintt);
0517   tInReco -> SetBranchAddress("nltpc",           &rec_nltpc);
0518   tInReco -> SetBranchAddress("nlmms",           &rec_nlmms);
0519   tInReco -> SetBranchAddress("layers",          &rec_layers);
0520   tInReco -> SetBranchAddress("vertexID",        &rec_vertexID);
0521   tInReco -> SetBranchAddress("vx",              &rec_vx);
0522   tInReco -> SetBranchAddress("vy",              &rec_vy);
0523   tInReco -> SetBranchAddress("vz",              &rec_vz);
0524   tInReco -> SetBranchAddress("dca2d",           &rec_dca2d);
0525   tInReco -> SetBranchAddress("dca2dsigma",      &rec_dca2dsigma);
0526   tInReco -> SetBranchAddress("dca3dxy",         &rec_dca3dxy);
0527   tInReco -> SetBranchAddress("dca3dxysigma",    &rec_dca3dxysigma);
0528   tInReco -> SetBranchAddress("dca3dz",          &rec_dca3dz);
0529   tInReco -> SetBranchAddress("dca3dzsigma",     &rec_dca3dzsigma);
0530   tInReco -> SetBranchAddress("pcax",            &rec_pcax);
0531   tInReco -> SetBranchAddress("pcay",            &rec_pcay);
0532   tInReco -> SetBranchAddress("pcaz",            &rec_pcaz);
0533   tInReco -> SetBranchAddress("gtrackID",        &rec_gtrackID);
0534   tInReco -> SetBranchAddress("gflavor",         &rec_gflavor);
0535   tInReco -> SetBranchAddress("gnhits",          &rec_gnhits);
0536   tInReco -> SetBranchAddress("gnmaps",          &rec_gnmaps);
0537   tInReco -> SetBranchAddress("gnintt",          &rec_gnintt);
0538   tInReco -> SetBranchAddress("gntpc",           &rec_gntpc);
0539   tInReco -> SetBranchAddress("gnmms",           &rec_gnmms);
0540   tInReco -> SetBranchAddress("gnlmaps",         &rec_gnlmaps);
0541   tInReco -> SetBranchAddress("gnlintt",         &rec_gnlintt);
0542   tInReco -> SetBranchAddress("gnltpc",          &rec_gnltpc);
0543   tInReco -> SetBranchAddress("gnlmms",          &rec_gnlmms);
0544   tInReco -> SetBranchAddress("gpx",             &rec_gpx);
0545   tInReco -> SetBranchAddress("gpy",             &rec_gpy);
0546   tInReco -> SetBranchAddress("gpz",             &rec_gpz);
0547   tInReco -> SetBranchAddress("gpt",             &rec_gpt);
0548   tInReco -> SetBranchAddress("geta",            &rec_geta);
0549   tInReco -> SetBranchAddress("gphi",            &rec_gphi);
0550   tInReco -> SetBranchAddress("gvx",             &rec_gvx);
0551   tInReco -> SetBranchAddress("gvy",             &rec_gvy);
0552   tInReco -> SetBranchAddress("gvz",             &rec_gvz);
0553   tInReco -> SetBranchAddress("gvt",             &rec_gvt);
0554   tInReco -> SetBranchAddress("gfpx",            &rec_gfpx);
0555   tInReco -> SetBranchAddress("gfpy",            &rec_gfpy);
0556   tInReco -> SetBranchAddress("gfpz",            &rec_gfpz);
0557   tInReco -> SetBranchAddress("gfx",             &rec_gfx);
0558   tInReco -> SetBranchAddress("gfy",             &rec_gfy);
0559   tInReco -> SetBranchAddress("gfz",             &rec_gfz);
0560   tInReco -> SetBranchAddress("gembed",          &rec_gembed);
0561   tInReco -> SetBranchAddress("gprimary",        &rec_gprimary);
0562   tInReco -> SetBranchAddress("nfromtruth",      &rec_nfromtruth);
0563   tInReco -> SetBranchAddress("nwrong",          &rec_nwrong);
0564   tInReco -> SetBranchAddress("ntrumaps",        &rec_ntrumaps);
0565   tInReco -> SetBranchAddress("nwrongmaps",      &rec_nwrongmaps);
0566   tInReco -> SetBranchAddress("ntruintt",        &rec_ntruintt);
0567   tInReco -> SetBranchAddress("nwrongintt",      &rec_nwrongintt);
0568   tInReco -> SetBranchAddress("ntrutpc",         &rec_ntrutpc);
0569   tInReco -> SetBranchAddress("nwrongtpc",       &rec_nwrongtpc);
0570   tInReco -> SetBranchAddress("ntrumms",         &rec_ntrumms);
0571   tInReco -> SetBranchAddress("nwrongmms",       &rec_nwrongmms);
0572   tInReco -> SetBranchAddress("ntrutpc1",        &rec_ntrutpc1);
0573   tInReco -> SetBranchAddress("nwrongtpc1",      &rec_nwrongtpc1);
0574   tInReco -> SetBranchAddress("ntrutpc11",       &rec_ntrutpc11);
0575   tInReco -> SetBranchAddress("nwrongtpc11",     &rec_nwrongtpc11);
0576   tInReco -> SetBranchAddress("ntrutpc2",        &rec_ntrutpc2);
0577   tInReco -> SetBranchAddress("nwrongtpc2",      &rec_nwrongtpc2);
0578   tInReco -> SetBranchAddress("ntrutpc3",        &rec_ntrutpc3);
0579   tInReco -> SetBranchAddress("nwrongtpc3",      &rec_nwrongtpc3);
0580   tInReco -> SetBranchAddress("layersfromtruth", &rec_layersfromtruth);
0581   tInReco -> SetBranchAddress("npedge",          &rec_npedge);
0582   tInReco -> SetBranchAddress("nredge",          &rec_nredge);
0583   tInReco -> SetBranchAddress("nbig",            &rec_nbig);
0584   tInReco -> SetBranchAddress("novlp",           &rec_novlp);
0585   tInReco -> SetBranchAddress("merr",            &rec_merr);
0586   tInReco -> SetBranchAddress("msize",           &rec_msize);
0587   tInReco -> SetBranchAddress("nhittpcall",      &rec_nhittpcall);
0588   tInReco -> SetBranchAddress("nhittpcin",       &rec_nhittpcin);
0589   tInReco -> SetBranchAddress("nhittpcmid",      &rec_nhittpcmid);
0590   tInReco -> SetBranchAddress("nhittpcout",      &rec_nhittpcout);
0591   tInReco -> SetBranchAddress("nclusall",        &rec_nclusall);
0592   tInReco -> SetBranchAddress("nclustpc",        &rec_nclustpc);
0593   tInReco -> SetBranchAddress("nclusintt",       &rec_nclusintt);
0594   tInReco -> SetBranchAddress("nclusmaps",       &rec_nclusmaps);
0595   tInReco -> SetBranchAddress("nclusmms",        &rec_nclusmms);
0596   cout << "    Set input branches." << endl;
0597 
0598   // histogram indices
0599   enum Var {
0600     NTot,
0601     NIntt,
0602     NMvtx,
0603     NTpc,
0604     RTot,
0605     RIntt,
0606     RMvtx,
0607     RTpc,
0608     Phi,
0609     Eta,
0610     Pt,
0611     Frac
0612   };
0613   enum Type {
0614     Truth,
0615     Track,
0616     Weird,
0617     Normal
0618   };
0619   enum Comp {
0620     VsTruthPt,
0621     VsNumTpc
0622   };
0623 
0624   // output histogram base names
0625   const vector<vector<string>> vecHistBase = {
0626     {"hTruthNumTot",  "hTrackNumTot",  "hWeirdNumTot",  "hNormNumTot"},
0627     {"hTruthNumIntt", "hTrackNumIntt", "hWeirdNumIntt", "hNormNumIntt"},
0628     {"hTruthNumMvtx", "hTrackNumMvtx", "hWeirdNumMvtx", "hNormNumMvtx"},
0629     {"hTruthNumTpc",  "hTrackNumTpc",  "hWeirdNumTpc",  "hNormNumTpc"},
0630     {"hTruthRatTot",  "hTrackRatTot",  "hWeirdRatTot",  "hNormRatTot"},
0631     {"hTruthRatIntt", "hTrackRatIntt", "hWeirdRatIntt", "hNormRatIntt"},
0632     {"hTruthRatMvtx", "hTrackRatMvtx", "hWeirdRatMvtx", "hNormRatMvtx"},
0633     {"hTruthRatTpc",  "hTrackRatTpc",  "hWeirdRatTpc",  "hNormRatTpc"},
0634     {"hTruthPhi",     "hTrackPhi",     "hWeirdPhi",     "hNormPhi"},
0635     {"hTruthEta",     "hTrackEta",     "hWeirdEta",     "hNormEta"},
0636     {"hTruthPt",      "hTrackPt",      "hWeirdPt",      "hNormPt"},
0637     {"hTruthFrac",    "hTrackFrac",    "hWeirdFrac",    "hNormFrac"}
0638   };
0639   const size_t nHistRows  = vecHistBase.size();
0640   const size_t nHistTypes = vecHistBase[0].size();
0641 
0642   // 2D histogram name modifiers
0643   const vector<string> vecVsHistModifiers = {
0644     "VsTruthPt",
0645     "VsNumTpc"
0646   };
0647   const size_t nVsHistMods = vecVsHistModifiers.size();
0648 
0649   // axis titles
0650   const string         sCount("counts");
0651   const vector<string> vecBaseAxisVars = {
0652     "N^{tot} = N_{hit}^{mvtx} + N_{hit}^{intt} + N_{clust}^{tpc}",
0653     "N_{hit}^{intt}",
0654     "N_{hit}^{mvtx}",
0655     "N_{clust}^{tpc}",
0656     "N_{reco}^{tot} / N_{true}^{tot}",
0657     "N_{reco}^{intt} / N_{true}^{intt}",
0658     "N_{reco}^{mvtx} / N_{true}^{mvtx}",
0659     "N_{reco}^{tpc} / N_{true}^{tpc}",
0660     "#varphi",
0661     "#eta",
0662     "p_{T} [GeV/c]",
0663     "p_{T}^{reco} / p_{T}^{true}"
0664   };
0665   const vector<string> vecVsAxisVars = {
0666     "p_{T}^{true} [GeV/c]",
0667     "N_{clust}^{tpc}"
0668   };
0669 
0670   // output histogram no. of bins
0671   const uint32_t nNumBins  = 101;
0672   const uint32_t nRatBins  = 120;
0673   const uint32_t nEtaBins  = 80;
0674   const uint32_t nPhiBins  = 360;
0675   const uint32_t nPtBins   = 101;
0676   const uint32_t nFracBins = 110;
0677 
0678   // output histogram bin ranges
0679   const pair<float, float> xNumBins  = {-0.5,  100.5};
0680   const pair<float, float> xRatBins  = {-0.5,  5.5};
0681   const pair<float, float> xEtaBins  = {-2.,   2.};
0682   const pair<float, float> xPhiBins  = {-3.15, 3.15};
0683   const pair<float, float> xPtBins   = {-1.,   100.};
0684   const pair<float, float> xFracBins = {-0.5,  10.5};
0685 
0686   // output histogram base binning definitions
0687   vector<tuple<uint32_t, pair<float, float>>> vecBaseHistBins = {
0688     make_tuple(nNumBins,  xNumBins),
0689     make_tuple(nNumBins,  xNumBins),
0690     make_tuple(nNumBins,  xNumBins),
0691     make_tuple(nNumBins,  xNumBins),
0692     make_tuple(nRatBins,  xRatBins),
0693     make_tuple(nRatBins,  xRatBins),
0694     make_tuple(nRatBins,  xRatBins),
0695     make_tuple(nRatBins,  xRatBins),
0696     make_tuple(nPhiBins,  xPhiBins),
0697     make_tuple(nEtaBins,  xEtaBins),
0698     make_tuple(nPtBins,   xPtBins),
0699     make_tuple(nFracBins, xFracBins)
0700   };
0701 
0702   // output 2D histogram x-axis binning
0703   vector<tuple<uint32_t, pair<float, float>>> vecVsHistBins = {
0704     make_tuple(nPtBins,  xPtBins),
0705     make_tuple(nNumBins, xNumBins)
0706   };
0707 
0708   // make 1D histograms
0709   vector<vector<TH1D*>> vecHist1D(nHistRows);
0710   for (size_t iHistRow = 0; iHistRow < nHistRows; iHistRow++) {
0711     for (const string sHistBase : vecHistBase[iHistRow]) {
0712       vecHist1D[iHistRow].push_back(
0713         new TH1D(
0714           sHistBase.data(),
0715           "",
0716           get<0>(vecBaseHistBins[iHistRow]),
0717           get<1>(vecBaseHistBins[iHistRow]).first,
0718           get<1>(vecBaseHistBins[iHistRow]).second
0719         )
0720       );
0721     }  // end type loop
0722   }  // end row loop
0723 
0724   // make 2D histograms
0725   vector<vector<vector<TH2D*>>> vecHist2D(nHistRows, vector<vector<TH2D*>>(nHistTypes));
0726   for (size_t iHistRow = 0; iHistRow < nHistRows; iHistRow++) {
0727     for (size_t iHistType = 0; iHistType < nHistTypes; iHistType++) {
0728       for (size_t iVsHistMod = 0; iVsHistMod < nVsHistMods; iVsHistMod++) {
0729         const string sHistName2D = vecHistBase[iHistRow][iHistType] + vecVsHistModifiers[iVsHistMod];
0730         vecHist2D[iHistRow][iHistType].push_back(
0731           new TH2D(
0732             sHistName2D.data(),
0733             "",
0734             get<0>(vecVsHistBins[iVsHistMod]),
0735             get<1>(vecVsHistBins[iVsHistMod]).first,
0736             get<1>(vecVsHistBins[iVsHistMod]).second,
0737             get<0>(vecBaseHistBins[iHistRow]),
0738             get<1>(vecBaseHistBins[iHistRow]).first,
0739             get<1>(vecBaseHistBins[iHistRow]).second
0740           )
0741         );
0742       }  // end modifier loop
0743     }  // end type loop
0744   }  // end row loop
0745 
0746   // set errors
0747   for (auto histRow1D : vecHist1D) {
0748     for (auto hist1D : histRow1D) {
0749       hist1D -> Sumw2();
0750     }
0751   }
0752 
0753   for (auto histRow2D : vecHist2D) {
0754     for (auto histType2D : histRow2D) {
0755       for (auto hist2D: histType2D) {
0756         hist2D -> Sumw2();
0757       }
0758     }
0759   }
0760 
0761   // grab no. of entries
0762   const int64_t nTrueEntries = tInTrue -> GetEntries();
0763   const int64_t nRecoEntries = tInReco -> GetEntries(); 
0764   cout << "    Beginning truth particle loop: " << nTrueEntries << " to process" << endl;
0765 
0766   // loop over truth particles
0767   int64_t nTrueBytes = 0;
0768   for (int64_t iTrueEntry = 0; iTrueEntry < nTrueEntries; iTrueEntry++) {
0769 
0770     // grab truth particle entry
0771     const int64_t trueBytes = tInTrue -> GetEntry(iTrueEntry);
0772     if (trueBytes < 0) {
0773       cerr << "PANIC: issue with entry " << iTrueEntry << "! Aborting loop!\n" << endl;
0774       break;
0775     } else {
0776       nTrueBytes += trueBytes;
0777     }
0778 
0779     const int64_t iTrueProg = iTrueEntry + 1;
0780     if (iTrueProg == nTrueEntries) {
0781       cout << "      Processing entry " << iTrueProg << "/" << nTrueEntries << "..." << endl;
0782     } else {
0783       cout << "      Processing entry " << iTrueProg << "/" << nTrueEntries << "...\r" << flush;
0784     }
0785 
0786     // skip nan's
0787     if (isnan(tru_trackID)) continue;
0788 
0789     // run calculations
0790     const double tru_gntot = tru_gnintt + tru_gnmaps + tru_gntpc;
0791 
0792     // check if near sector
0793     bool isNearSector = false;
0794     if (doPhiCut) {
0795       for (size_t iSector = 0; iSector < NSectors; iSector++) {
0796         const float cutVal = sigCutVal * phiSectors[iSector].second;
0797         const float minPhi = phiSectors[iSector].first - cutVal;
0798         const float maxPhi = phiSectors[iSector].first + cutVal;
0799         const bool  isNear = ((tru_gphi >= minPhi) && (tru_gphi <= maxPhi));
0800         if (isNear) {
0801           isNearSector = true;
0802           break;
0803         }
0804       }  // end sector loop
0805     }  // end if (doPhiCut)
0806 
0807     // apply cuts
0808     const bool isPrimary   = (tru_gprimary == 1);
0809     const bool isInZVtxCut = ((tru_gvz > zVtxRange.first) && (tru_gvz < zVtxRange.second));
0810     if (useOnlyPrimTrks && !isPrimary)   continue;
0811     if (doZVtxCut       && !isInZVtxCut) continue;
0812     if (doPhiCut        && isNearSector) continue;
0813 
0814     // fill truth 1D histograms
0815     vecHist1D[Var::NTot][Type::Truth]  -> Fill(tru_gntot);
0816     vecHist1D[Var::NIntt][Type::Truth] -> Fill(tru_gnintt);
0817     vecHist1D[Var::NMvtx][Type::Truth] -> Fill(tru_gnmaps);
0818     vecHist1D[Var::NTpc][Type::Truth]  -> Fill(tru_gntpc);
0819     vecHist1D[Var::RTot][Type::Truth]  -> Fill(1.);
0820     vecHist1D[Var::RIntt][Type::Truth] -> Fill(1.);
0821     vecHist1D[Var::RMvtx][Type::Truth] -> Fill(1.);
0822     vecHist1D[Var::RTpc][Type::Truth]  -> Fill(1.);
0823     vecHist1D[Var::Phi][Type::Truth]   -> Fill(tru_gphi);
0824     vecHist1D[Var::Eta][Type::Truth]   -> Fill(tru_geta);
0825     vecHist1D[Var::Pt][Type::Truth]    -> Fill(tru_gpt);
0826     vecHist1D[Var::Frac][Type::Truth]  -> Fill(1.);
0827 
0828     // fill truth 2D histograms
0829     vecHist2D[Var::NTot][Type::Truth][Comp::VsTruthPt]  -> Fill(tru_gpt, tru_gntot);
0830     vecHist2D[Var::NIntt][Type::Truth][Comp::VsTruthPt] -> Fill(tru_gpt, tru_gnintt);
0831     vecHist2D[Var::NMvtx][Type::Truth][Comp::VsTruthPt] -> Fill(tru_gpt, tru_gnmaps);
0832     vecHist2D[Var::NTpc][Type::Truth][Comp::VsTruthPt]  -> Fill(tru_gpt, tru_gntpc);
0833     vecHist2D[Var::RTot][Type::Truth][Comp::VsTruthPt]  -> Fill(tru_gpt, 1.);
0834     vecHist2D[Var::RIntt][Type::Truth][Comp::VsTruthPt] -> Fill(tru_gpt, 1.);
0835     vecHist2D[Var::RMvtx][Type::Truth][Comp::VsTruthPt] -> Fill(tru_gpt, 1.);
0836     vecHist2D[Var::RTpc][Type::Truth][Comp::VsTruthPt]  -> Fill(tru_gpt, 1.);
0837     vecHist2D[Var::Phi][Type::Truth][Comp::VsTruthPt]   -> Fill(tru_gpt, tru_gphi);
0838     vecHist2D[Var::Eta][Type::Truth][Comp::VsTruthPt]   -> Fill(tru_gpt, tru_geta);
0839     vecHist2D[Var::Pt][Type::Truth][Comp::VsTruthPt]    -> Fill(tru_gpt, tru_gpt);
0840     vecHist2D[Var::Frac][Type::Truth][Comp::VsTruthPt]  -> Fill(tru_gpt, 1.);
0841 
0842     vecHist2D[Var::NTot][Type::Truth][Comp::VsNumTpc]  -> Fill(tru_gntpc, tru_gntot);
0843     vecHist2D[Var::NIntt][Type::Truth][Comp::VsNumTpc] -> Fill(tru_gntpc, tru_gnintt);
0844     vecHist2D[Var::NMvtx][Type::Truth][Comp::VsNumTpc] -> Fill(tru_gntpc, tru_gnmaps);
0845     vecHist2D[Var::NTpc][Type::Truth][Comp::VsNumTpc]  -> Fill(tru_gntpc, tru_gntpc);
0846     vecHist2D[Var::RTot][Type::Truth][Comp::VsNumTpc]  -> Fill(tru_gntpc, 1.);
0847     vecHist2D[Var::RIntt][Type::Truth][Comp::VsNumTpc] -> Fill(tru_gntpc, 1.);
0848     vecHist2D[Var::RMvtx][Type::Truth][Comp::VsNumTpc] -> Fill(tru_gntpc, 1.);
0849     vecHist2D[Var::RTpc][Type::Truth][Comp::VsNumTpc]  -> Fill(tru_gntpc, 1.);
0850     vecHist2D[Var::Phi][Type::Truth][Comp::VsNumTpc]   -> Fill(tru_gntpc, tru_gphi);
0851     vecHist2D[Var::Eta][Type::Truth][Comp::VsNumTpc]   -> Fill(tru_gntpc, tru_geta);
0852     vecHist2D[Var::Pt][Type::Truth][Comp::VsNumTpc]    -> Fill(tru_gntpc, tru_gpt);
0853     vecHist2D[Var::Frac][Type::Truth][Comp::VsNumTpc]  -> Fill(tru_gntpc, 1.);
0854   }  // end truth particle loop
0855 
0856   // announce next entry loop
0857   cout << "    Finished truth particle loop.\n"
0858        << "    Beginning reconstructed track loop: " << nRecoEntries << " to process"
0859        << endl;
0860 
0861   // loop over reco tracks
0862   int64_t nRecoBytes = 0;
0863   for (int64_t iRecoEntry = 0; iRecoEntry < nRecoEntries; iRecoEntry++) {
0864 
0865     // grab reco track entry
0866     const int64_t recoBytes = tInReco -> GetEntry(iRecoEntry);
0867     if (recoBytes < 0) {
0868       cerr << "PANIC: issue with entry " << iRecoEntry << "! Aborting loop!\n" << endl;
0869       break;
0870     } else {
0871       nRecoBytes += recoBytes;
0872     }
0873 
0874     const int64_t iRecoProg = iRecoEntry + 1;
0875     if (iRecoProg == nRecoEntries) {
0876       cout << "      Processing entry " << iRecoProg << "/" << nRecoEntries << "..." << endl;
0877     } else {
0878       cout << "      Processing entry " << iRecoProg << "/" << nRecoEntries << "...\r" << flush;
0879     }
0880 
0881     // skip nan's
0882     if (isnan(rec_gpt)) continue;
0883 
0884     // run calculations
0885     const double rec_ntot   = rec_nintt + rec_nmaps + rec_ntpc;
0886     const double rec_gntot  = rec_gnintt + rec_gnmaps + rec_gntpc;
0887     const double rec_rtot   = rec_ntot / rec_gntot;
0888     const double rec_rintt  = rec_nintt / rec_gnintt;
0889     const double rec_rmaps  = rec_nmaps / rec_gnmaps;
0890     const double rec_rtpc   = rec_ntpc / rec_gntpc;
0891     const double rec_ptfrac = rec_pt / rec_gpt;
0892 
0893     // check if near sector
0894     bool isNearSector = false;
0895     if (doPhiCut) {
0896       for (size_t iSector = 0; iSector < NSectors; iSector++) {
0897        const float cutVal = sigCutVal * phiSectors[iSector].second;
0898         const float minPhi = phiSectors[iSector].first - cutVal;
0899         const float maxPhi = phiSectors[iSector].first + cutVal;
0900         const bool  isNear = ((rec_phi >= minPhi) && (rec_phi <= maxPhi));
0901         if (isNear) {
0902           isNearSector = true;
0903           break;
0904         }
0905       }  // end sector loop
0906     }  // end if (doPhiCut)
0907 
0908     // apply cuts
0909     const bool isPrimary   = (rec_gprimary == 1);
0910     const bool isInZVtxCut = ((rec_gvz > zVtxRange.first) && (rec_gvz < zVtxRange.second));
0911     if (useOnlyPrimTrks && !isPrimary)   continue;
0912     if (doZVtxCut       && !isInZVtxCut) continue;
0913     if (doPhiCut        && isNearSector) continue;
0914 
0915     // fill all matched reco 1D histograms
0916     vecHist1D[Var::NTot][Type::Track]  -> Fill(rec_ntot);
0917     vecHist1D[Var::NIntt][Type::Track] -> Fill(rec_nintt);
0918     vecHist1D[Var::NMvtx][Type::Track] -> Fill(rec_nmaps);
0919     vecHist1D[Var::NTpc][Type::Track]  -> Fill(rec_ntpc);
0920     vecHist1D[Var::RTot][Type::Track]  -> Fill(rec_rtot);
0921     vecHist1D[Var::RIntt][Type::Track] -> Fill(rec_rintt);
0922     vecHist1D[Var::RMvtx][Type::Track] -> Fill(rec_rmaps);
0923     vecHist1D[Var::RTpc][Type::Track]  -> Fill(rec_rtpc);
0924     vecHist1D[Var::Phi][Type::Track]   -> Fill(rec_phi);
0925     vecHist1D[Var::Eta][Type::Track]   -> Fill(rec_eta);
0926     vecHist1D[Var::Pt][Type::Track]    -> Fill(rec_pt);
0927     vecHist1D[Var::Frac][Type::Track]  -> Fill(rec_ptfrac);
0928 
0929     // fill all matched reco 2D histograms
0930     vecHist2D[Var::NTot][Type::Track][Comp::VsTruthPt]  -> Fill(rec_gpt, rec_ntot);
0931     vecHist2D[Var::NIntt][Type::Track][Comp::VsTruthPt] -> Fill(rec_gpt, rec_nintt);
0932     vecHist2D[Var::NMvtx][Type::Track][Comp::VsTruthPt] -> Fill(rec_gpt, rec_nmaps);
0933     vecHist2D[Var::NTpc][Type::Track][Comp::VsTruthPt]  -> Fill(rec_gpt, rec_ntpc);
0934     vecHist2D[Var::RTot][Type::Track][Comp::VsTruthPt]  -> Fill(rec_gpt, rec_rtot);
0935     vecHist2D[Var::RIntt][Type::Track][Comp::VsTruthPt] -> Fill(rec_gpt, rec_rintt);
0936     vecHist2D[Var::RMvtx][Type::Track][Comp::VsTruthPt] -> Fill(rec_gpt, rec_rmaps);
0937     vecHist2D[Var::RTpc][Type::Track][Comp::VsTruthPt]  -> Fill(rec_gpt, rec_rtpc);
0938     vecHist2D[Var::Phi][Type::Track][Comp::VsTruthPt]   -> Fill(rec_gpt, rec_phi);
0939     vecHist2D[Var::Eta][Type::Track][Comp::VsTruthPt]   -> Fill(rec_gpt, rec_eta);
0940     vecHist2D[Var::Pt][Type::Track][Comp::VsTruthPt]    -> Fill(rec_gpt, rec_pt);
0941     vecHist2D[Var::Frac][Type::Track][Comp::VsTruthPt]  -> Fill(rec_gpt, rec_ptfrac);
0942 
0943     vecHist2D[Var::NTot][Type::Track][Comp::VsNumTpc]  -> Fill(rec_gntpc, rec_ntot);
0944     vecHist2D[Var::NIntt][Type::Track][Comp::VsNumTpc] -> Fill(rec_gntpc, rec_nintt);
0945     vecHist2D[Var::NMvtx][Type::Track][Comp::VsNumTpc] -> Fill(rec_gntpc, rec_nmaps);
0946     vecHist2D[Var::NTpc][Type::Track][Comp::VsNumTpc]  -> Fill(rec_gntpc, rec_ntpc);
0947     vecHist2D[Var::RTot][Type::Track][Comp::VsNumTpc]  -> Fill(rec_gntpc, rec_rtpc);
0948     vecHist2D[Var::RIntt][Type::Track][Comp::VsNumTpc] -> Fill(rec_gntpc, rec_rintt);
0949     vecHist2D[Var::RMvtx][Type::Track][Comp::VsNumTpc] -> Fill(rec_gntpc, rec_rmaps);
0950     vecHist2D[Var::RTpc][Type::Track][Comp::VsNumTpc]  -> Fill(rec_gntpc, rec_rtpc);
0951     vecHist2D[Var::Phi][Type::Track][Comp::VsNumTpc]   -> Fill(rec_gntpc, rec_phi);
0952     vecHist2D[Var::Eta][Type::Track][Comp::VsNumTpc]   -> Fill(rec_gntpc, rec_eta);
0953     vecHist2D[Var::Pt][Type::Track][Comp::VsNumTpc]    -> Fill(rec_gntpc, rec_pt);
0954     vecHist2D[Var::Frac][Type::Track][Comp::VsNumTpc]  -> Fill(rec_gntpc, rec_ptfrac);
0955 
0956     // fill weird and normal matched reco 1D histograms
0957     const bool isNormalTrack = ((rec_ptfrac >= oddPtFrac.first) && (rec_ptfrac <= oddPtFrac.second));
0958     if (isNormalTrack) {
0959       vecHist1D[Var::NTot][Type::Normal]  -> Fill(rec_ntot);
0960       vecHist1D[Var::NIntt][Type::Normal] -> Fill(rec_nintt);
0961       vecHist1D[Var::NMvtx][Type::Normal] -> Fill(rec_nmaps);
0962       vecHist1D[Var::NTpc][Type::Normal]  -> Fill(rec_ntpc);
0963       vecHist1D[Var::RTot][Type::Normal]  -> Fill(rec_rtot);
0964       vecHist1D[Var::RIntt][Type::Normal] -> Fill(rec_rintt);
0965       vecHist1D[Var::RMvtx][Type::Normal] -> Fill(rec_rmaps);
0966       vecHist1D[Var::RTpc][Type::Normal]  -> Fill(rec_rtpc);
0967       vecHist1D[Var::Phi][Type::Normal]   -> Fill(rec_phi);
0968       vecHist1D[Var::Eta][Type::Normal]   -> Fill(rec_eta);
0969       vecHist1D[Var::Pt][Type::Normal]    -> Fill(rec_pt);
0970       vecHist1D[Var::Frac][Type::Normal]  -> Fill(rec_ptfrac);
0971 
0972       vecHist2D[Var::NTot][Type::Normal][Comp::VsTruthPt]  -> Fill(rec_gpt, rec_ntot);
0973       vecHist2D[Var::NIntt][Type::Normal][Comp::VsTruthPt] -> Fill(rec_gpt, rec_nintt);
0974       vecHist2D[Var::NMvtx][Type::Normal][Comp::VsTruthPt] -> Fill(rec_gpt, rec_nmaps);
0975       vecHist2D[Var::NTpc][Type::Normal][Comp::VsTruthPt]  -> Fill(rec_gpt, rec_ntpc);
0976       vecHist2D[Var::RTot][Type::Normal][Comp::VsTruthPt]  -> Fill(rec_gpt, rec_rtot);
0977       vecHist2D[Var::RIntt][Type::Normal][Comp::VsTruthPt] -> Fill(rec_gpt, rec_rintt);
0978       vecHist2D[Var::RMvtx][Type::Normal][Comp::VsTruthPt] -> Fill(rec_gpt, rec_rmaps);
0979       vecHist2D[Var::RTpc][Type::Normal][Comp::VsTruthPt]  -> Fill(rec_gpt, rec_rtpc);
0980       vecHist2D[Var::Phi][Type::Normal][Comp::VsTruthPt]   -> Fill(rec_gpt, rec_phi);
0981       vecHist2D[Var::Eta][Type::Normal][Comp::VsTruthPt]   -> Fill(rec_gpt, rec_eta);
0982       vecHist2D[Var::Pt][Type::Normal][Comp::VsTruthPt]    -> Fill(rec_gpt, rec_pt);
0983       vecHist2D[Var::Frac][Type::Normal][Comp::VsTruthPt]  -> Fill(rec_gpt, rec_ptfrac);
0984 
0985       vecHist2D[Var::NTot][Type::Normal][Comp::VsNumTpc]  -> Fill(rec_gntpc, rec_ntot);
0986       vecHist2D[Var::NIntt][Type::Normal][Comp::VsNumTpc] -> Fill(rec_gntpc, rec_nintt);
0987       vecHist2D[Var::NMvtx][Type::Normal][Comp::VsNumTpc] -> Fill(rec_gntpc, rec_nmaps);
0988       vecHist2D[Var::NTpc][Type::Normal][Comp::VsNumTpc]  -> Fill(rec_gntpc, rec_ntpc);
0989       vecHist2D[Var::RTot][Type::Normal][Comp::VsNumTpc]  -> Fill(rec_gntpc, rec_rtot);
0990       vecHist2D[Var::RIntt][Type::Normal][Comp::VsNumTpc] -> Fill(rec_gntpc, rec_rintt);
0991       vecHist2D[Var::RMvtx][Type::Normal][Comp::VsNumTpc] -> Fill(rec_gntpc, rec_rmaps);
0992       vecHist2D[Var::RTpc][Type::Normal][Comp::VsNumTpc]  -> Fill(rec_gntpc, rec_rtpc);
0993       vecHist2D[Var::Phi][Type::Normal][Comp::VsNumTpc]   -> Fill(rec_gntpc, rec_phi);
0994       vecHist2D[Var::Eta][Type::Normal][Comp::VsNumTpc]   -> Fill(rec_gntpc, rec_eta);
0995       vecHist2D[Var::Pt][Type::Normal][Comp::VsNumTpc]    -> Fill(rec_gntpc, rec_pt);
0996       vecHist2D[Var::Frac][Type::Normal][Comp::VsNumTpc]  -> Fill(rec_gntpc, rec_ptfrac);
0997     } else {
0998       vecHist1D[Var::NTot][Type::Weird]  -> Fill(rec_ntot);
0999       vecHist1D[Var::NIntt][Type::Weird] -> Fill(rec_nintt);
1000       vecHist1D[Var::NMvtx][Type::Weird] -> Fill(rec_nmaps);
1001       vecHist1D[Var::NTpc][Type::Weird]  -> Fill(rec_ntpc);
1002       vecHist1D[Var::RTot][Type::Weird]  -> Fill(rec_rtot);
1003       vecHist1D[Var::RIntt][Type::Weird] -> Fill(rec_rintt);
1004       vecHist1D[Var::RMvtx][Type::Weird] -> Fill(rec_rmaps);
1005       vecHist1D[Var::RTpc][Type::Weird]  -> Fill(rec_rtpc);
1006       vecHist1D[Var::Phi][Type::Weird]   -> Fill(rec_phi);
1007       vecHist1D[Var::Eta][Type::Weird]   -> Fill(rec_eta);
1008       vecHist1D[Var::Pt][Type::Weird]    -> Fill(rec_pt);
1009       vecHist1D[Var::Frac][Type::Weird]  -> Fill(rec_ptfrac);
1010 
1011       vecHist2D[Var::NTot][Type::Weird][Comp::VsTruthPt]  -> Fill(rec_gpt, rec_ntot);
1012       vecHist2D[Var::NIntt][Type::Weird][Comp::VsTruthPt] -> Fill(rec_gpt, rec_nintt);
1013       vecHist2D[Var::NMvtx][Type::Weird][Comp::VsTruthPt] -> Fill(rec_gpt, rec_nmaps);
1014       vecHist2D[Var::NTpc][Type::Weird][Comp::VsTruthPt]  -> Fill(rec_gpt, rec_ntpc);
1015       vecHist2D[Var::RTot][Type::Weird][Comp::VsTruthPt]  -> Fill(rec_gpt, rec_rtot);
1016       vecHist2D[Var::RIntt][Type::Weird][Comp::VsTruthPt] -> Fill(rec_gpt, rec_rintt);
1017       vecHist2D[Var::RMvtx][Type::Weird][Comp::VsTruthPt] -> Fill(rec_gpt, rec_rmaps);
1018       vecHist2D[Var::RTpc][Type::Weird][Comp::VsTruthPt]  -> Fill(rec_gpt, rec_rtpc);
1019       vecHist2D[Var::Phi][Type::Weird][Comp::VsTruthPt]   -> Fill(rec_gpt, rec_phi);
1020       vecHist2D[Var::Eta][Type::Weird][Comp::VsTruthPt]   -> Fill(rec_gpt, rec_eta);
1021       vecHist2D[Var::Pt][Type::Weird][Comp::VsTruthPt]    -> Fill(rec_gpt, rec_pt);
1022       vecHist2D[Var::Frac][Type::Weird][Comp::VsTruthPt]  -> Fill(rec_gpt, rec_ptfrac);
1023 
1024       vecHist2D[Var::NTot][Type::Weird][Comp::VsNumTpc]  -> Fill(rec_gntpc, rec_ntot);
1025       vecHist2D[Var::NIntt][Type::Weird][Comp::VsNumTpc] -> Fill(rec_gntpc, rec_nintt);
1026       vecHist2D[Var::NMvtx][Type::Weird][Comp::VsNumTpc] -> Fill(rec_gntpc, rec_nmaps);
1027       vecHist2D[Var::NTpc][Type::Weird][Comp::VsNumTpc]  -> Fill(rec_gntpc, rec_ntpc);
1028       vecHist2D[Var::RTot][Type::Weird][Comp::VsNumTpc]  -> Fill(rec_gntpc, rec_rtpc);
1029       vecHist2D[Var::RIntt][Type::Weird][Comp::VsNumTpc] -> Fill(rec_gntpc, rec_rintt);
1030       vecHist2D[Var::RMvtx][Type::Weird][Comp::VsNumTpc] -> Fill(rec_gntpc, rec_rmaps);
1031       vecHist2D[Var::RTpc][Type::Weird][Comp::VsNumTpc]  -> Fill(rec_gntpc, rec_rtpc);
1032       vecHist2D[Var::Phi][Type::Weird][Comp::VsNumTpc]   -> Fill(rec_gntpc, rec_phi);
1033       vecHist2D[Var::Eta][Type::Weird][Comp::VsNumTpc]   -> Fill(rec_gntpc, rec_eta);
1034       vecHist2D[Var::Pt][Type::Weird][Comp::VsNumTpc]    -> Fill(rec_gntpc, rec_pt);
1035       vecHist2D[Var::Frac][Type::Weird][Comp::VsNumTpc]  -> Fill(rec_gntpc, rec_ptfrac);
1036     }
1037   }  // end reco track loop
1038   cout << "    Finished reconstructed track loop."  << endl;
1039 
1040   // set axis titles
1041   size_t iVar = 0;
1042   for (auto histRow1D : vecHist1D) {
1043     for (auto hist1D : histRow1D) {
1044       hist1D -> GetXaxis() -> SetTitle(vecBaseAxisVars.at(iVar).data());
1045       hist1D -> GetYaxis() -> SetTitle(sCount.data());
1046     }
1047     ++iVar;
1048   }
1049   iVar = 0;
1050 
1051   size_t iComp = 0;
1052   for (auto histRow2D : vecHist2D) {
1053     for (auto histType2D : histRow2D) {
1054       iComp = 0;
1055       for (auto hist2D : histType2D) {
1056         hist2D -> GetXaxis() -> SetTitle(vecVsAxisVars.at(iComp).data());
1057         hist2D -> GetYaxis() -> SetTitle(vecBaseAxisVars.at(iVar).data());
1058         hist2D -> GetZaxis() -> SetTitle(sCount.data());
1059         ++iComp;
1060       }
1061     }
1062     ++iVar;
1063   }
1064   cout << "    Set axis titles." << endl;
1065 
1066   // save histograms
1067   fOutput -> cd();
1068   for (auto histRow1D : vecHist1D) {
1069     for (auto hist1D : histRow1D) {
1070       hist1D -> Write();
1071     }
1072   }
1073   for (auto histRow2D : vecHist2D) {
1074     for (auto histType2D : histRow2D) {
1075       for (auto hist2D: histType2D) {
1076         hist2D -> Write();
1077       }
1078     }
1079   }
1080   cout << "    Saved histograms." << endl;
1081 
1082   // close files
1083   fOutput -> cd();
1084   fOutput -> Close();
1085 
1086   // exit
1087   cout << "  Finished old evaluator plot script!\n" << endl;
1088   return;
1089 
1090 }
1091 
1092 // end ------------------------------------------------------------------------
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!