dc/df5/SDeltaPtCutStudy_8h_source.html

// ----------------------------------------------------------------------------

// 'SDeltaPtCutStudy.h'

// Derek Anderson

// 06.29.2023

//

// Reads in the 'ntp_track' Ntuple

// generated by the SVtxEvaluator

// class and studies how deltapt/pt

// varies with quality cuts.

// ----------------------------------------------------------------------------


#ifndef SDELTAPTCUTSTUDY_H

#define SDELTAPTCUTSTUDY_H


// standard c includes

#include <array>

#include <cmath>

#include <vector>

#include <cassert>

#include <cstdlib>

#include <utility>

#include <iostream>

// root includes

#include <TH1.h>

#include <TH2.h>

#include <TF1.h>

#include <TPad.h>

#include <TFile.h>

#include <TLine.h>

#include <TGraph.h>

#include <TError.h>

#include <TString.h>

#include <TNtuple.h>

#include <TLegend.h>

#include <TCanvas.h>

#include <TVector.h>

#include <TPaveText.h>

#include <TDirectory.h>


using namespace std;


// SDeltaPtCutStudy definition ------------------------------------------------


class SDeltaPtCutStudy {


  // constants

  enum Const {

    NPad     = 2,

    NPar     = 3,

    NVtx     = 4,

    NRange   = 2,

    NTypes   = 3,

    NTrkCuts = 6

  };


  public:


    // ctor/dtor [*.cc]

    SDeltaPtCutStudy();

    ~SDeltaPtCutStudy();


    // main methods [*.cc]

    void Init();

    void Analyze();

    void End();


    // setters [*.io.h]

    void SetInputOutputFiles(const TString sInput, const TString sOutput);

    void SetInputTuples(const TString sTrack, const TString sTruth);

    void SetGeneralTrackCuts(const uint32_t nInttCut, const uint32_t nMvtxCut, const uint32_t nTpcCut, const double qualCut, const double vzCut, const double ptCut);

    void SetSigmaFitGuesses(const array<float, Const::NPar> hiGuess, const array<float, Const::NPar> loGuess);

    void SetNormAndFitRanges(const pair<float, float> norm, const pair<float, float> ptFit, const pair<float, float> deltaFit);

    void SetPlotRanges(const pair<float, float> ptRange, const pair<float, float> fracRange, const pair<float, float> deltaRange);

    void SetGeneralStyleParameters(const array<uint32_t, Const::NTypes> arrCol, const array<uint32_t, Const::NTypes> arrMar);

    void SetGeneralHistParameters(const uint32_t fill, const uint32_t line, const uint32_t width, const uint32_t font, const uint32_t align, const uint32_t center);

    void SetHistBaseNames(const TString sProj, const TString sDelta, const TString sTrue, const TString sReco, const TString sFrac, const TString sTrack);

    void SetPlotText(const vector<TString> plotText);

    void SetEffRebinParameters(const bool doRebin, const size_t nRebin = 2);

    void SetProjectionParameters(const vector<tuple<double, TString, uint32_t, uint32_t, uint32_t>> projParams);

    void SetFlatCutParameters(const vector<tuple<double, TString, uint32_t, uint32_t, bool>> flatParams);

    void SetPtDependCutParameters(const vector<tuple<double, TString, uint32_t, uint32_t, uint32_t, bool>> ptDependParams);


  private:


    // io methods [*.io.h]

    void OpenFiles();

    void GetTuples();

    void SaveOutput();

    void CloseFiles();


    // system methods [*.sys.h]

    void InitVectors();

    void InitTuples();

    void InitHists();


    // analysis methods [*.ana.h]

    void ApplyFlatDeltaPtCuts();

    void ApplyPtDependentDeltaPtCuts();

    void FillTruthHistograms();

    void CreateSigmaGraphs();

    void CalculateRejectionFactors();

    void CalculateEfficiencies();


    // plot methods [*.plot.h]

    void SetStyles();

    void MakePlots();


    // io parameters

    TFile*   fInput;

    TFile*   fOutput;

    TNtuple* ntTrack;

    TNtuple* ntTruth;

    TString  sInFile;

    TString  sOutFile;

    TString  sInTrack;

    TString  sInTruth;


    // general cut parameters

    uint32_t nInttTrkMin = 1;

    uint32_t nMVtxTrkMin = 2;

    uint32_t nTpcTrkMin  = 35;

    double   qualTrkMax  = 10.;

    double   vzTrkMax    = 10.;

    double   ptTrkMin    = 0.1;


    // sigma calculation parameters

    array<float, Const::NPar>   sigHiGuess    = {1., -1., 1.};

    array<float, Const::NPar>   sigLoGuess    = {1., -1., 1.};

    array<float, Const::NRange> normRange     = {0.2, 1.2};

    array<float, Const::NRange> ptFitRange    = {0.5, 40.};

    array<float, Const::NRange> deltaFitRange = {0.,  0.1};


    // projection parameters

    size_t           nProj = 0;

    vector<double>   ptProj;

    vector<TString>  sProjSuffix;

    vector<TString>  sPtProj;

    vector<uint32_t> fColProj;

    vector<uint32_t> fMarProj;

    vector<uint32_t> fColFit;


    // flat delta-pt cut parameters

    size_t           nDPtCuts   = 0;

    size_t           iCutToDraw = 0;

    vector<double>   ptDeltaMax;

    vector<TString>  sDPtSuffix;

    vector<uint32_t> fColCut;

    vector<uint32_t> fMarCut;


    // pt-dependent delta-pt cut parameters

    size_t           nSigCuts   = 0;

    size_t           iSigToDraw = 0;

    vector<double>   ptDeltaSig;

    vector<TString>  sSigSuffix;

    vector<uint32_t> fColSig;

    vector<uint32_t> fMarSig;

    vector<uint32_t> fColSigFit;


    // histogram base names

    TString sPtProjBase   = "DeltaPtProj";

    TString sPtDeltaBase  = "DeltaPt";

    TString sPtTrueBase   = "PtTrue";

    TString sPtRecoBase   = "PtReco";

    TString sPtFracBase   = "PtFrac";

    TString sPtTrkTruBase = "PtTrkTruth";


    // plot text

    size_t          nTxt = 0;

    vector<TString> sInfo;


    // plot range parameters

    array<float, Const::NRange> rPtRange    = {0., 60.};

    array<float, Const::NRange> rFracRange  = {0., 4.};

    array<float, Const::NRange> rDeltaRange = {0., 0.1};


    // general histogram style parameters

    uint32_t fFil       = 0;

    uint32_t fLin       = 1;

    uint32_t fWid       = 1;

    uint32_t fTxt       = 42;

    uint32_t fAln       = 12;

    uint32_t fCnt       = 1;

    uint32_t fColTrue   = 923;

    uint32_t fColPure   = 923;

    uint32_t fColTrk    = 809;

    uint32_t fMarTrue   = 20;

    uint32_t fMarPure   = 20;

    uint32_t fMarTrk    = 46;

    size_t   nEffRebin  = 5;

    bool     doEffRebin = true;


    // track tuple addresses

    float trk_event;

    float trk_seed;

    float trk_trackID;

    float trk_crossing;

    float trk_px;

    float trk_py;

    float trk_pz;

    float trk_pt;

    float trk_eta;

    float trk_phi;

    float trk_deltapt;

    float trk_deltaeta;

    float trk_deltaphi;

    float trk_charge;

    float trk_quality;

    float trk_chisq;

    float trk_ndf;

    float trk_nhits;

    float trk_nmaps;

    float trk_nintt;

    float trk_ntpc;

    float trk_nmms;

    float trk_ntpc1;

    float trk_ntpc11;

    float trk_ntpc2;

    float trk_ntpc3;

    float trk_nlmaps;

    float trk_nlintt;

    float trk_nltpc;

    float trk_nlmms;

    float trk_layers;

    float trk_vertexID;

    float trk_vx;

    float trk_vy;

    float trk_vz;

    float trk_dca2d;

    float trk_dca2dsigma;

    float trk_dca3dxy;

    float trk_dca3dxysigma;

    float trk_dca3dz;

    float trk_dca3dzsigma;

    float trk_pcax;

    float trk_pcay;

    float trk_pcaz;

    float trk_gtrackID;

    float trk_gflavor;

    float trk_gnhits;

    float trk_gnmaps;

    float trk_gnintt;

    float trk_gntpc;

    float trk_gnmms;

    float trk_gnlmaps;

    float trk_gnlintt;

    float trk_gnltpc;

    float trk_gnlmms;

    float trk_gpx;

    float trk_gpy;

    float trk_gpz;

    float trk_gpt;

    float trk_geta;

    float trk_gphi;

    float trk_gvx;

    float trk_gvy;

    float trk_gvz;

    float trk_gvt;

    float trk_gfpx;

    float trk_gfpy;

    float trk_gfpz;

    float trk_gfx;

    float trk_gfy;

    float trk_gfz;

    float trk_gembed;

    float trk_gprimary;

    float trk_nfromtruth;

    float trk_nwrong;

    float trk_ntrumaps;

    float trk_ntruintt;

    float trk_ntrutpc;

    float trk_ntrumms;

    float trk_ntrutpc1;

    float trk_ntrutpc11;

    float trk_ntrutpc2;

    float trk_ntrutpc3;

    float trk_layersfromtruth;

    float trk_nhittpcall;

    float trk_nhittpcin;

    float trk_nhittpcmid;

    float trk_nhittpcout;

    float trk_nclusall;

    float trk_nclustpc;

    float trk_nclusintt;

    float trk_nclusmaps;

    float trk_nclusmms;


    // truth tuple addresses

    float tru_event;

    float tru_seed;

    float tru_gntracks;

    float tru_gtrackID;

    float tru_gflavor;

    float tru_gnhits;

    float tru_gnmaps;

    float tru_gnintt;

    float tru_gnmms;

    float tru_gnintt1;

    float tru_gnintt2;

    float tru_gnintt3;

    float tru_gnintt4;

    float tru_gnintt5;

    float tru_gnintt6;

    float tru_gnintt7;

    float tru_gnintt8;

    float tru_gntpc;

    float tru_gnlmaps;

    float tru_gnlintt;

    float tru_gnltpc;

    float tru_gnlmms;

    float tru_gpx;

    float tru_gpy;

    float tru_gpz;

    float tru_gpt;

    float tru_geta;

    float tru_gphi;

    float tru_gvx;

    float tru_gvy;

    float tru_gvz;

    float tru_gvt;

    float tru_gfpx;

    float tru_gfpy;

    float tru_gfpz;

    float tru_gfx;

    float tru_gfy;

    float tru_gfz;

    float tru_gembed;

    float tru_gprimary;

    float tru_trackID;

    float tru_px;

    float tru_py;

    float tru_pz;

    float tru_pt;

    float tru_eta;

    float tru_phi;

    float tru_deltapt;

    float tru_deltaeta;

    float tru_deltaphi;

    float tru_charge;

    float tru_quality;

    float tru_chisq;

    float tru_ndf;

    float tru_nhits;

    float tru_layers;

    float tru_nmaps;

    float tru_nintt;

    float tru_ntpc;

    float tru_nmms;

    float tru_ntpc1;

    float tru_ntpc11;

    float tru_ntpc2;

    float tru_ntpc3;

    float tru_nlmaps;

    float tru_nlintt;

    float tru_nltpc;

    float tru_nlmms;

    float tru_vertexID;

    float tru_vx;

    float tru_vy;

    float tru_vz;

    float tru_dca2d;

    float tru_dca2dsigma;

    float tru_dca3dxy;

    float tru_dca3dxysigma;

    float tru_dca3dz;

    float tru_dca3dzsigma;

    float tru_pcax;

    float tru_pcay;

    float tru_pcaz;

    float tru_nfromtruth;

    float tru_nwrong;

    float tru_ntrumaps;

    float tru_ntruintt;

    float tru_ntrutpc;

    float tru_ntrumms;

    float tru_ntrutpc1;

    float tru_ntrutpc11;

    float tru_ntrutpc2;

    float tru_ntrutpc3;

    float tru_layersfromtruth;

    float tru_nhittpcall;

    float tru_nhittpcin;

    float tru_nhittpcmid;

    float tru_nhittpcout;

    float tru_nclusall;

    float tru_nclustpc;

    float tru_nclusintt;

    float tru_nclusmaps;

    float tru_nclusmms;


    // for sigma calculation

    vector<double>         muProj;

    vector<double>         sigProj;

    vector<vector<double>> muHiProj;

    vector<vector<double>> muLoProj;


    // for flat delta-pt cut rejection

    vector<uint64_t> nNormCut;

    vector<uint64_t> nNormSig;

    vector<uint64_t> nWeirdCut;

    vector<uint64_t> nWeirdSig;

    vector<double>   rejCut;

    vector<double>   rejSig;


    // for tuple loops

    uint64_t nTrks;

    uint64_t nTrus;


    // general 1d histograms

    TH1D* hEff;

    TH1D* hPtTruth;

    TH1D* hPtDelta;

    TH1D* hPtTrack;

    TH1D* hPtFrac;

    TH1D* hPtTrkTru;


    // 1d projection & cut-dependent histograms

    vector<TH1D*> hPtDeltaProj;

    vector<TH1D*> hPtDeltaCut;

    vector<TH1D*> hPtDeltaSig;

    vector<TH1D*> hPtTrackCut;

    vector<TH1D*> hPtTrackSig;

    vector<TH1D*> hPtFracCut;

    vector<TH1D*> hPtFracSig;

    vector<TH1D*> hPtTrkTruCut;

    vector<TH1D*> hPtTrkTruSig;

    vector<TH1D*> hEffCut;

    vector<TH1D*> hEffSig;


    // general 2d histograms

    TH2D* hPtDeltaVsFrac;

    TH2D* hPtDeltaVsTrue;

    TH2D* hPtDeltaVsTrack;

    TH2D* hPtTrueVsTrack;


    // 2d cut-dependent histograms

    vector<TH2D*> hPtDeltaVsFracCut;

    vector<TH2D*> hPtDeltaVsFracSig;

    vector<TH2D*> hPtDeltaVsTrueCut;

    vector<TH2D*> hPtDeltaVsTrueSig;

    vector<TH2D*> hPtDeltaVsTrackCut;

    vector<TH2D*> hPtDeltaVsTrackSig;

    vector<TH2D*> hPtTrueVsTrackCut;

    vector<TH2D*> hPtTrueVsTrackSig;


    // functions

    vector<TF1*> fPtDeltaProj;

    vector<TF1*> fMuHiProj;

    vector<TF1*> fMuLoProj;


    // general graphs

    TGraph* grMuProj;

    TGraph* grSigProj;

    TGraph* grRejCut;

    TGraph* grRejSig;


    // cut-dependent graphs

    vector<TGraph*> grMuHiProj;

    vector<TGraph*> grMuLoProj;


};  // end SDeltaPtCutStudy definition


#endif


// end ------------------------------------------------------------------------