STrackMatchingComparator/macros/QuickTuplePlotter.C

0001 // ----------------------------------------------------------------------------
0002 // 'QuickTuplePlotter.C
0003 // Derek Anderson
0004 // 06.02.2023
0005 //
0006 // Use to quick plot some leaves from an ntuple.
0007 // ----------------------------------------------------------------------------
0008
0009 #include <vector>
0010 #include <iostream>
0011 #include "TH1.h"
0012 #include "TH2.h"
0013 #include "TFile.h"
0014 #include "TError.h"
0015 #include "TString.h"
0016 #include "TNtuple.h"
0017 #include "TDirectory.h"
0018
0019 using namespace std;
0020
0021
0022
0023 void QuickTuplePlotter() {
0024
0025   // lower verbosity
0026   gErrorIgnoreLevel = kError;
0027   cout << "\n  Beginning quick tuple plotting..." << endl;
0028
0029   // i/o parameters
0030   const TString sOutput  = "truthPhiCheck.allVsWeirdVsNormal.pt2040n100weird2pim.d10m7y2023.root";
0031   const TString sInput   = "input/embed_only/final_merge/sPhenixG4_forPtCheck_embedScanOn_embedOnly.pt2040n100pim.d8m5y2023.root";
0032   const TString sInTuple = "ntp_track";
0033
0034   // cuts to apply and labels
0035   const vector<TString> vecCutsToApply = {
0036     "(abs(vz)<10)&&(nintt>=1)&&(nmaps>2)&&(ntpc>35)&&(pt<100)&&(quality<10)",
0037     "(abs(vz)<10)&&(nintt>=1)&&(nmaps>2)&&(ntpc>35)&&(pt<100)&&(quality<10)&&((pt/gpt<0.2)||(pt/gpt>1.2))",
0038     "(abs(vz)<10)&&(nintt>=1)&&(nmaps>2)&&(ntpc>35)&&(pt<100)&&(quality<10)&&((pt/gpt>=0.2)&&(pt/gpt<=1.2))",
0039     "(abs(vz)<10)&&(nintt>=1)&&(nmaps>2)&&(ntpc>35)&&(pt<20)&&(quality<10)",
0040     "(abs(vz)<10)&&(nintt>=1)&&(nmaps>2)&&(ntpc>35)&&(pt<20)&&(quality<10)&&((pt/gpt<0.2)||(pt/gpt>1.2))",
0041     "(abs(vz)<10)&&(nintt>=1)&&(nmaps>2)&&(ntpc>35)&&(pt<20)&&(quality<10)&&((pt/gpt>=0.2)&&(pt/gpt<=1.2))",
0042     "(abs(vz)<10)&&(nintt>=1)&&(nmaps>2)&&(ntpc>35)&&(pt>20)&&(pt<100)&&(quality<10)",
0043     "(abs(vz)<10)&&(nintt>=1)&&(nmaps>2)&&(ntpc>35)&&(pt>20)&&(pt<100)&&(quality<10)&&((pt/gpt<0.2)||(pt/gpt>1.2))",
0044     "(abs(vz)<10)&&(nintt>=1)&&(nmaps>2)&&(ntpc>35)&&(pt>20)&&(pt<100)&&(quality<10)&&((pt/gpt>=0.2)&&(pt/gpt<=1.2))"
0045   };
0046   const vector<TString> vecCutLabels = {
0047     "All",
0048     "Weird",
0049     "Normal",
0050     "AllPtL20",
0051     "WeirdPtL20",
0052     "NormalPtL20",
0053     "AllPtG20",
0054     "WeirdPtG20",
0055     "NormalPtG20"
0056   };
0057
0058   // 1d things to draw and histogram names
0059   const vector<TString> vecToDraw1D = {
0060     "deltapt/pt",
0061     "pt/gpt",
0062     "gphi"
0063   };
0064   const vector<TString> vecHistNames1D = {
0065     "hDeltaPtOverPt",
0066     "hFracPt",
0067     "hTruthPhi"
0068   };
0069
0070   // 2d things to draw, histogram names, and options
0071   const vector<TString> vecToDraw2D = {
0072     "deltapt/pt:pt",
0073     "deltapt/pt:pt/gpt",
0074     "gphi:pt/gpt"
0075   };
0076   const vector<TString> vecHistNames2D = {
0077     "hDeltaPtOverPtVsPt",
0078     "hDeltaPtOverPtVsFracPt",
0079     "hTruthPhiVsFracPt"
0080   };
0081   const vector<TString> vecHistOpts2D = {
0082     "colz",
0083     "colz",
0084     "colz"
0085   };
0086
0087   // construct list of output histograms
0088   const Ssiz_t nToDraw1D    = vecToDraw1D.size();
0089   const Ssiz_t nToDraw2D    = vecToDraw2D.size();
0090   const Ssiz_t nCutsToApply = vecCutsToApply.size();
0091
0092   TString         sHistToDraw1D;
0093   TString         sHistToDraw2D;
0094   vector<TString> vecHistToDraw1D;
0095   vector<TString> vecHistToDraw2D;
0096   for (Ssiz_t iCutToApply = 0; iCutToApply < nCutsToApply; iCutToApply++) {
0097     for (Ssiz_t iToDraw1D = 0; iToDraw1D < nToDraw1D; iToDraw1D++) {
0098
0099       // construct 1d name
0100       sHistToDraw1D = vecHistNames1D[iToDraw1D].Data();
0101       sHistToDraw1D.Append("_");
0102       sHistToDraw1D.Append(vecCutLabels[iCutToApply].Data());
0103
0104       // add to list
0105       vecHistToDraw1D.push_back(sHistToDraw1D.Data());
0106     }
0107     for (Ssiz_t iToDraw2D = 0; iToDraw2D < nToDraw2D; iToDraw2D++) {
0108
0109       // construct 2d name
0110       sHistToDraw2D = vecHistNames2D[iToDraw2D].Data();
0111       sHistToDraw2D.Append("_");
0112       sHistToDraw2D.Append(vecCutLabels[iCutToApply].Data());
0113
0114       // add to list
0115       vecHistToDraw2D.push_back(sHistToDraw2D.Data());
0116     }
0117   }  // end cut loop
0118   cout << "    Constructed histogram lists." << endl;
0119
0120   // open files
0121   TFile *fOutput = new TFile(sOutput.Data(), "recreate");
0122   TFile *fInput  = new TFile(sInput.Data(),  "read");
0123   if (!fOutput || !fInput) {
0124     cerr << "PANIC: couldn't open a file!\n"
0125          << "       fOutput = " << fOutput << ", fInput = " << fInput << "\n"
0126          << endl;
0127     return;
0128   }
0129   cout << "    Opened files." << endl;
0130
0131   // grab input tuple
0132   TNtuple *ntToDrawFrom = (TNtuple*) fInput -> Get(sInTuple.Data());
0133   if (!ntToDrawFrom) {
0134     cerr << "PANIC: couldn't grab input tuple!\n" << endl;
0135     return;
0136   }
0137   cout << "    Grabbed input tuple.\n"
0138        << "    Beginning draw loop..."
0139        << endl;
0140
0141   // draw histograms
0142   Ssiz_t  iHistToDraw1D = 0;
0143   Ssiz_t  iHistToDraw2D = 0;
0144   TString sDrawArg1D    = "";
0145   TString sDrawArg2D    = "";
0146   for (Ssiz_t iCutToApply = 0; iCutToApply < nCutsToApply; iCutToApply++) {
0147     for (Ssiz_t iToDraw1D = 0; iToDraw1D < nToDraw1D; iToDraw1D++) {
0148
0149       // construct draw arg
0150       sDrawArg1D = vecToDraw1D[iToDraw1D].Data();
0151       sDrawArg1D.Append(">>");
0152       sDrawArg1D.Append(vecHistToDraw1D[iHistToDraw1D].Data());
0153       cout << "      Drawing '" << sDrawArg1D.Data() << "'..." << endl;
0154
0155       // draw to histogram
0156       ntToDrawFrom -> Draw(sDrawArg1D.Data(), vecCutsToApply[iCutToApply].Data());
0157       ++iHistToDraw1D;
0158     }
0159     for (Ssiz_t iToDraw2D = 0; iToDraw2D < nToDraw2D; iToDraw2D++) {
0160
0161       // construct draw arg
0162       sDrawArg2D = vecToDraw2D[iToDraw2D].Data();
0163       sDrawArg2D.Append(">>");
0164       sDrawArg2D.Append(vecHistToDraw2D[iHistToDraw2D].Data());
0165       cout << "      Drawing '" << sDrawArg2D.Data() << "'..." << endl;
0166
0167       // draw to histogram
0168       ntToDrawFrom -> Draw(sDrawArg2D.Data(), vecCutsToApply[iCutToApply].Data());
0169       ++iHistToDraw2D;
0170     }
0171   }  // end cut loop
0172   cout << "    Drew histograms from tuple." << endl;
0173
0174   // grab histograms and save
0175   const Ssiz_t nHistToDraw1D = vecHistToDraw1D.size();
0176   const Ssiz_t nHistToDraw2D = vecHistToDraw2D.size();
0177
0178   TH1D *hHistToDraw1D[nHistToDraw1D];
0179   TH2D *hHistToDraw2D[nHistToDraw2D];
0180   for (Ssiz_t iHist1D = 0; iHist1D < nHistToDraw1D; iHist1D++) {
0181
0182     // grab histogram
0183     fInput                 -> cd();
0184     hHistToDraw1D[iHist1D] = (TH1D*) gDirectory -> Get(vecHistToDraw1D[iHist1D].Data());
0185
0186     // save histogram
0187     fOutput                -> cd();
0188     hHistToDraw1D[iHist1D] -> Write();
0189   }
0190   for (Ssiz_t iHist2D = 0; iHist2D < nHistToDraw2D; iHist2D++) {
0191
0192     // grab histogram
0193     fInput                 -> cd();
0194     hHistToDraw2D[iHist2D] = (TH2D*) gDirectory -> Get(vecHistToDraw2D[iHist2D].Data());
0195
0196     // save histogram
0197     fOutput                -> cd();
0198     hHistToDraw2D[iHist2D] -> Write();
0199   }
0200   cout << "    Saved histograms." << endl;
0201
0202   // close files
0203   fOutput -> cd();
0204   fOutput -> Close();
0205   fInput  -> cd();
0206   fInput  -> Close();
0207   cout << "    Closed files." << endl;
0208
0209   // announce end and exit
0210   cout << "  Finished quick tuple plotting!\n" << endl;
0211   return;
0212
0213 }
0214
0215 // end ------------------------------------------------------------------------