NuMu2020_BasicPIDPlots_Plot.C File Reference

#include "TCanvas.h"
#include "TFile.h"
#include "TH1D.h"
#include "TFeldmanCousins.h"
#include "TGraph.h"
#include "TLine.h"
#include "TLatex.h"
#include "TLegend.h"
#include "TStyle.h"
#include "TSystem.h"
#include "CAFAna/Analysis/Calcs.h"
#include "CAFAna/Analysis/Exposures.h"
#include "CAFAna/Core/Spectrum.h"
#include "CAFAna/Prediction/PredictionNoExtrap.h"
#include "3FlavorAna/Ana2020/NuMu_PIDOptimisation/NuMu2020_BasicPIDPlots_header.h"
#include "OscLib/OscCalcPMNSOpt.h"
#include "Utilities/rootlogon.C"
#include <iostream>
#include <sstream>
#include <fstream>
#include <vector>
#include <string>
#include <TROOT.h>

Go to the source code of this file.

Classes
struct	LoadedHistograms_2020
struct	LoadedHistograms_2019

Functions
LoadedHistograms_2020	LoadFile_GetHists_2020 (TFile *InFile, std::string CutTier, bool isData)
LoadedHistograms_2019	LoadFile_GetHists_2019 (TFile *InFile, std::string CutTier, bool isData)
TH1D *	GetSpectToHist (TFile *MyF, std::string LoadName, std::string Axis, bool isData)
void	ProducePlots_2020 (LoadedHistograms_2020 NoTrue_2020, LoadedHistograms_2020 TrueNu_2020, LoadedHistograms_2020 TrNuMu_2020, LoadedHistograms_2020 AnNuMu_2020, LoadedHistograms_2019 NoTrue_2019, LoadedHistograms_2020 Data_2020, std::string CutTier)
void	ProducePlots_2019 (LoadedHistograms_2019 NoTrue_2019, LoadedHistograms_2019 TrueNu_2019, LoadedHistograms_2019 TrNuMu_2019, LoadedHistograms_2019 AnNuMu_2019, LoadedHistograms_2020 NoTrue_2020, LoadedHistograms_2019 Data_2019, std::string CutTier)
TH1D *	MakeRatio (TH1D *num, TH1D *denom, int Col, std::string FType)
void	SetRange (TH1D *MC, TH1D *Data, double XLow, double XHigh, double H_YLow, double H_YHigh)
void	FindAxisRange (double &XLow, double &XHigh, double &H_YLow, double &H_YHigh, double &R_YLow, double &R_YHigh, double MaxVal, bool &SetLogy, std::string Name)
void	MakeSplitCans (TH1D *MCHist, TH1D *DataHist, std::string PlotName)
void	PlotHistProp (TH1D *Hist, TLegend *L)
void	NuMu2020_BasicPIDPlots_Plot (bool isfhc, bool isfd, std::string period="full")
void	MakeSplitCans (TH1D *NoTrue, TH1D *TrueNu, TH1D *TrNuMu, TH1D *AnNuMu, TH1D *NoTrueAlt, TH1D *Data, std::string PlotName)

Variables
bool	bIsFHC = true
std::string	sIsFHC = ""
bool	bIsFD = true
std::string	sIsFD = ""
double	POTNorm = 1e20
double	LivNorm = 1e20
size_t	NPlot = 1
std::string	OutDir = "./"
TFile *	OutFile

Function Documentation

void FindAxisRange	(	double &	XLow,
		double &	XHigh,
		double &	H_YLow,
		double &	H_YHigh,
		double &	R_YLow,
		double &	R_YHigh,
		double	MaxVal,
		bool &	SetLogy,
		std::string	Name
	)

Definition at line 405 of file NuMu2020_BasicPIDPlots_Plot.C.

References bIsFD, and bIsFHC.

Referenced by MakeSplitCans().

                                                                                                                                                                  {

  XLow    = -1;  XHigh   = -1;
  H_YLow  = 0;   H_YHigh = MaxVal;
  R_YLow  = 0.5; R_YHigh = 1.5;
  SetLogy = false;
  if (!bIsFD) {
    SetLogy = true;
    H_YLow  = 10;
  }

  bool IsQuant = ( (Name.find("AllQuants") != std::string::npos) == true ? false:true);

  if ( (Name.find("Muon") != std::string::npos) ) { 
    if ( bIsFD &&  bIsFHC && Name.find("QualCont") != std::string::npos) { H_YLow = 0;   H_YHigh = 200; }
    if ( bIsFD && !bIsFHC && Name.find("QualCont") != std::string::npos) { H_YLow = 0;   H_YHigh = 120; }
    if ( bIsFD &&  bIsFHC && Name.find("Full")     != std::string::npos) { H_YLow = 0;   H_YHigh = 100; }
    if ( bIsFD && !bIsFHC && Name.find("Full")     != std::string::npos) { H_YLow = 0;   H_YHigh = 100; }
  }

  if ( (Name.find("RecoE") != std::string::npos) ) { 
    if ( bIsFD &&  bIsFHC && Name.find("QualCont") != std::string::npos) { H_YLow = 0;   H_YHigh = 30; }
    if ( bIsFD && !bIsFHC && Name.find("QualCont") != std::string::npos) { H_YLow = 0;   H_YHigh = 20; }
    if ( bIsFD &&  bIsFHC && Name.find("Full")     != std::string::npos) { H_YLow = 0;   H_YHigh = 15; }
    if ( bIsFD && !bIsFHC && Name.find("Full")     != std::string::npos) { H_YLow = 0;   H_YHigh = 10; }
}

  if ( (Name.find("ReMId") != std::string::npos) ) { 
    if ( bIsFD &&  bIsFHC ) { H_YLow = 0; H_YHigh = 100; }
    if ( bIsFD && !bIsFHC ) { H_YLow = 0; H_YHigh = 80;  }
  }

  /*
  std::cout << "\t\tParams are; Xlow " << XLow << ", XHigh: " << XHigh << ", H_YLow: " << H_YLow << ", H_YHigh: " << H_YHigh
            << ", R_YLow: " << R_YLow << ", R_YHigh " << R_YHigh << ", SetLogy " << SetLogy
            << std::endl;
  */
  return;
}

TH1D * GetSpectToHist	(	TFile *	MyF,
		std::string	LoadName,
		std::string	Axis,
		bool	isData
	)

Definition at line 318 of file NuMu2020_BasicPIDPlots_Plot.C.

References std::asin(), bIsFD, calc, ana::CenterTitles(), om::cout, allTimeWatchdog::endl, ana::kLivetime, LivNorm, ana::PredictionNoExtrap::LoadFrom(), ana::Spectrum::LoadFrom(), POTNorm, ana::ResetOscCalcToDefault(), and std::sqrt().

Referenced by LoadFile_GetHists_2019(), and LoadFile_GetHists_2020().

                                                                                    {
  MyF->cd(); 
  // --- Declare my histogram.
  TH1D* MyHist;
  // --- Am I looking at the NoExtrap MC?
  if ( !isData && bIsFD ) {
    std::unique_ptr<PredictionNoExtrap> TempSpec = PredictionNoExtrap::LoadFrom( MyF,  LoadName.c_str() ) ;

    // --- Set my Oscillation Cal
    osc::OscCalcPMNSOpt calc;
    ana::ResetOscCalcToDefault(&calc);
    calc.SetdCP   ( 0  );
    calc.SetDmsq32( 0.00248 );
    calc.SetTh23  ( asin(sqrt(0.565)) );
    MyHist = TempSpec -> Predict(&calc).ToTH1( POTNorm );
    //MyHist = TempSpec -> PredictUnoscillated().ToTH1( POTNorm ); std::cout << "\n\t\t!!!UNOSCILLATED SPECTRUM!!!" << std::endl;
  }
  // ---- If just looking at a spectra.
  else {
    std::unique_ptr<Spectrum> TempSpec = Spectrum::LoadFrom( MyF,  LoadName.c_str() ) ;
    if (bIsFD) MyHist = TempSpec -> ToTH1( LivNorm, kLivetime );
    else       MyHist = TempSpec -> ToTH1( POTNorm );
  }

  // --- Scale the RecoNuE plots.
  if (LoadName.find("RecoNuE") != std::string::npos) {
    //MyHist -> Scale( 0.1, "width" );
  }

  // --- Make my plots pretty, and return.
  CenterTitles      ( MyHist);
  MyHist->SetMinimum( 0     );
  MyHist->SetMaximum( MyHist->GetMaximum()*1.05 );
  MyHist->SetTitle  ( Axis.c_str() );

  std::cout << "\tLoadName is " << LoadName << ", integral is " << MyHist->Integral() << std::endl;

  return MyHist;
}

LoadedHistograms_2019 LoadFile_GetHists_2019	(	TFile *	InFile,
		std::string	CutTier,
		bool	isData
	)

Definition at line 296 of file NuMu2020_BasicPIDPlots_Plot.C.

References GetSpectToHist(), LoadedHistograms_2019::hNuRecoE, and string.

Referenced by NuMu2020_BasicPIDPlots_Plot().

                                                                                              {

  // --- Set my Y axis
  std::string YAxisStr = "Number of Events";

  // --- Declare the vector of LoadedHistograms_2020 which I am going to return...
  LoadedHistograms_2019 MyHists;
  // --- Grab my spectra...
  TH1D* hCosRejScoreP4 ;
  TH1D* hCVNmuon       ;
  MyHists.hNuRecoE       = GetSpectToHist( InFile, "RecoNuE"           +CutTier, ";Reco Nu E;"              +YAxisStr+"/0.1 GeV", isData);
  /*
  MyHists.hReMIdScore    = GetSpectToHist( InFile, "ReMIdScore"        +CutTier, ";ReMId Score;"            +YAxisStr, isData);
  MyHists.hProngScoremuon= GetSpectToHist( InFile, "ProngCVNMuonScore" +CutTier, ";Prong CVN Muon Score;"   +YAxisStr, isData);
  MyHists.hCosRejScoreP4 = GetSpectToHist( InFile, "Prod4CosRejScore"  +CutTier, ";Prod4 CosRej Score;"     +YAxisStr, isData);
  MyHists.hCVNmuon       = GetSpectToHist( InFile, "CVNMuonScore"      +CutTier, ";Prod3Train Muon Score;"  +YAxisStr, isData);
  */
  // --- Finally, return MyHists.
  return MyHists;
}

LoadedHistograms_2020 LoadFile_GetHists_2020	(	TFile *	InFile,
		std::string	CutTier,
		bool	isData
	)

Definition at line 272 of file NuMu2020_BasicPIDPlots_Plot.C.

References GetSpectToHist(), LoadedHistograms_2020::hNuRecoE, and string.

Referenced by NuMu2020_BasicPIDPlots_Plot().

                                                                                              {

  // --- Set my Y axis
  std::string YAxisStr = "Number of Events";

  // --- Declare the vector of LoadedHistograms_2020 which I am going to return...
  LoadedHistograms_2020 MyHists;
  // --- Grab my spectra...
  MyHists.hNuRecoE       = GetSpectToHist( InFile, "RecoNuE"           +CutTier, ";Reco Nu E;"              +YAxisStr+"/0.1 GeV", isData);
  /*
  MyHists.hReMIdScore    = GetSpectToHist( InFile, "ReMIdScore"        +CutTier, ";ReMId Score;"            +YAxisStr, isData);
  MyHists.hProngScoremuon= GetSpectToHist( InFile, "ProngCVNMuonScore" +CutTier, ";Prong CVN Muon Score;"   +YAxisStr, isData);
  MyHists.hCosRejScoreP4 = GetSpectToHist( InFile, "Prod4CosRejScore"  +CutTier, ";Prod4 CosRej Score;"     +YAxisStr, isData);
  MyHists.hCosRejScoreP5 = GetSpectToHist( InFile, "Prod5CosRejScore"  +CutTier, ";Prod5 CosRej Score;"     +YAxisStr, isData);
  MyHists.hOldPreselmuon = GetSpectToHist( InFile, "OldPreselMuonScore"+CutTier, ";Old Presel Muon Score;"  +YAxisStr, isData);
  MyHists.hOldPreselcosm = GetSpectToHist( InFile, "OldPreselCosmScore"+CutTier, ";Old Presel Cosmic Score;"+YAxisStr, isData);
  MyHists.hLoosePTPmuon  = GetSpectToHist( InFile, "LoosePtpMuonScore" +CutTier, ";Loose Pt/p Muon Score;"  +YAxisStr, isData);
  MyHists.hLoosePTPcosm  = GetSpectToHist( InFile, "LoosePtpCosmScore" +CutTier, ";Loose Pt/p Cosmic Score;"+YAxisStr, isData);
  */
  // --- Finally, return MyHists.
  return MyHists;
}

TH1D* MakeRatio	(	TH1D *	num,
		TH1D *	denom,
		int	Col,
		std::string	FType
	)

Definition at line 359 of file NuMu2020_BasicPIDPlots_Plot.C.

References ana::CenterTitles(), and art::to_string().

                                                                       {
  // Declare a new histogram.
  TH1D* ratHist = new TH1D( TString(PlotName)+TString("_ratio_")+TString(std::to_string(Col)),
                            TString(";")+TString(num->GetXaxis()->GetTitle())+TString(";Ratio"),
                            num->GetNbinsX(),
                            num->GetXaxis()->GetXmin(),
                            num->GetXaxis()->GetXmax()
                            );
  // Don't want any exponents?
  ratHist->GetYaxis()->SetNoExponent();
  ratHist->GetXaxis()->SetNoExponent();
  // Divide the two input histograms...
  ratHist->Divide( num , denom );
  // Set Line and Marker colors / styles.
  ratHist->SetLineColor  ( Col );
  ratHist->SetMarkerColor( Col );
  ratHist->SetMarkerStyle( 20 );
  ratHist->SetMarkerSize ( 0  );
  // Figure out what the range should be...
  ratHist->GetYaxis()->SetRangeUser( 0.8, 1.2 );
  // Return my shiny new ratio plot!
  CenterTitles(ratHist);
  return ratHist;
}

void MakeSplitCans	(	TH1D *	MCHist,
		TH1D *	DataHist,
		std::string	PlotName
	)

Referenced by ProducePlots_2019(), and ProducePlots_2020().

void MakeSplitCans	(	TH1D *	NoTrue,
		TH1D *	TrueNu,
		TH1D *	TrNuMu,
		TH1D *	AnNuMu,
		TH1D *	NoTrueAlt,
		TH1D *	Data,
		std::string	PlotName
	)

Definition at line 457 of file NuMu2020_BasicPIDPlots_Plot.C.

References AddEntry(), bIsFD, bIsFHC, cd(), CornerLabel(), om::cout, Draw(), allTimeWatchdog::endl, FindAxisRange(), GetXaxis(), GetYaxis(), OutDir, OutFile, SaveAs(), SetBorderSize(), SetFillColor(), SetFillStyle(), SetLineColor(), SetLogy(), SetMarkerColor(), SetMarkerStyle(), SetRange(), SetTextSize(), std::sqrt(), string, and Write().

                                                                                                                              {
  // ------ What histograms am I passing to the function ------
  // NoTrue    --> The Monte Carlo histogram with no truth cuts applied
  // TrueNu    --> The Monte Carlo histogram with a true neutrino cut applied
  // TrNuMu    --> The Monte Carlo histogram with a true muon neutrino CC cut applied
  // AnNuMu    --> The Monte Carlo histogram with a true anti-muon neutrino CC cut applied
  // NoTrueAlt --> The Monte Carlo histogram with no truth cuts applied [ For the other Prod file ]
  // Data      --> The Data histogram [ For FD this is empty ].
  // ----------------------------------------------------------
  std::cout << "---> In MakeSplitCans .... " << PlotName << std::endl;
  
  // --- Find some integrals, mainly for the RecoNuE plots.
  double Int_NoTrue, Int_TrueNu, Int_TrNuMu, Int_AnNuMu, Int_NoTrueAlt;
  double Dip_NoTrue, Dip_TrueNu, Dip_TrNuMu, Dip_AnNuMu, Dip_NoTrueAlt;
  Int_NoTrue = Int_TrueNu = Int_TrNuMu = Int_AnNuMu = Int_NoTrueAlt = 0;
  Dip_NoTrue = Dip_TrueNu = Dip_TrNuMu = Dip_AnNuMu = Dip_NoTrueAlt = 0;
  int MinBin, MaxBin;
  MinBin = MaxBin = 0;
  // If RecoNuE do the integrals.
  if ((PlotName.find("RecoE") != std::string::npos) ) {
    Int_NoTrue =    NoTrue   ->Integral();
    Int_TrueNu =    TrueNu   ->Integral();
    Int_TrNuMu =    TrNuMu   ->Integral();
    Int_AnNuMu =    AnNuMu   ->Integral();
    Int_NoTrueAlt = NoTrueAlt->Integral();
    
    MinBin = NoTrue -> GetXaxis() -> FindBin( 1.0 );
    MaxBin = NoTrue -> GetXaxis() -> FindBin( 2.0 );
    std::cout << "\t MinBin = " << MinBin << ". \t MaxBin = " << MaxBin << std::endl;

    Dip_NoTrue =    NoTrue   ->Integral( MinBin, MaxBin );
    Dip_TrueNu =    TrueNu   ->Integral( MinBin, MaxBin );
    Dip_TrNuMu =    TrNuMu   ->Integral( MinBin, MaxBin );
    Dip_AnNuMu =    AnNuMu   ->Integral( MinBin, MaxBin );
    Dip_NoTrueAlt = NoTrueAlt->Integral( MinBin, MaxBin );

    std::cout << "\n\t NoTrue Full:    " << Int_NoTrue    << ", Dip: " << Dip_NoTrue
              << "\n\t TrueNu Full:    " << Int_TrueNu    << ", Dip: " << Dip_TrueNu
              << "\n\t TrNuMu Full:    " << Int_TrNuMu    << ", Dip: " << Dip_TrNuMu
              << "\n\t AnNuMu Full:    " << Int_AnNuMu    << ", Dip: " << Dip_AnNuMu
              << "\n\t NoTrueAlt Full: " << Int_NoTrueAlt << ", Dip: " << Dip_NoTrueAlt
              << std::endl;

    double FOM_Full = Int_TrNuMu / sqrt( Int_NoTrue );
    double FOM_Dip  = Dip_TrNuMu / sqrt( Dip_NoTrue );    
    if (!bIsFHC) {
      FOM_Full      = Int_AnNuMu / sqrt( Int_NoTrue );
      FOM_Dip       = Dip_AnNuMu / sqrt( Dip_NoTrue );
    }
    std::cout << "\t FOM_Full = " << FOM_Full << ". \n\t FOM_Dip = " << FOM_Dip << std::endl;
  }

  // Add the wrong sign NuMu to the correct sign one.
  if (bIsFHC) TrNuMu->Add( AnNuMu );
  else        AnNuMu->Add( TrNuMu );

  // --- Set my histogram colours...
  NoTrue   -> SetLineColor( 2 ); NoTrue -> SetFillColor( 2 ); NoTrue -> SetFillStyle( 3003 );
  //TrueNu -> SetLineColor( 2 ); TrueNu -> SetFillColor( 2 ); TrueNu -> SetFillStyle( 1001 );
  TrNuMu   -> SetLineColor( 4 ); TrNuMu -> SetFillColor( 4 ); TrNuMu -> SetFillStyle( 1001 );
  AnNuMu   -> SetLineColor( 6 ); AnNuMu -> SetFillColor( 6 ); AnNuMu -> SetFillStyle( 1001 );
  NoTrueAlt-> SetLineColor( 1 ); NoTrueAlt -> SetMarkerColor( 1 ); NoTrueAlt -> SetMarkerStyle( 20 ); 
  if (!bIsFD) { Data -> SetMarkerColor( 1 ); Data -> SetMarkerStyle( 3 ); }

  // --- What axis ranges do I want to use?
  double XL, XH, H_YL, H_YH, R_YL, R_YH;
  bool SetLogy;
  FindAxisRange( XL, XH, H_YL, H_YH, R_YL, R_YH, 1.5*NoTrue->GetMaximum(), SetLogy, PlotName );
  // --- And set the ranges...
  SetRange( NoTrue, Data, XL, XH, H_YL, H_YH ); 

  // --- Now, let's make a histogram with just the plot.
  std::string HistCanNa = PlotName;
  TCanvas* HistCan = new TCanvas( HistCanNa.c_str(), HistCanNa.c_str() );

  // --- And now start drawing things!!!
  NoTrue    -> Draw("hist");
  //TrueNu    -> Draw("same");
  if (bIsFHC) { TrNuMu -> Draw("same"); AnNuMu -> Draw("same"); }
  else        { AnNuMu -> Draw("same"); TrNuMu -> Draw("same"); }
  NoTrueAlt -> Draw("same");
  if (!bIsFD) Data -> Draw( "same" );

  // --- Add whether FHC or RHC
  if (bIsFHC ) CornerLabel( "Neutrino beam" );
  else         CornerLabel( "Antineutrino beam" );

  // Do I want the canvas to be loagarithmic?
  if ( SetLogy ) {
    TrNuMu    -> GetYaxis() -> SetRangeUser( H_YL, H_YH );
    AnNuMu    -> GetYaxis() -> SetRangeUser( H_YL, H_YH );
    NoTrueAlt -> GetYaxis() -> SetRangeUser( H_YL, H_YH );
    HistCan   -> SetLogy();
  }

  // --- Where do I want my legend...
  double HistLeg_X1 = 0.45, HistLeg_Y1 = 0.55, HistLeg_X2 = 0.85, HistLeg_Y2 = 0.88;
  // Do I want the legend on the left instead?
  if ( (PlotName.find("CosRej") != std::string::npos) ) {
    HistLeg_X1 = 0.10;
    HistLeg_X2 = 0.56;
  }
  // --- Make the legend where I've decided...
  TLegend *HistLeg = new TLegend( HistLeg_X1, HistLeg_Y1, HistLeg_X2, HistLeg_Y2 );
  HistLeg -> SetFillStyle (0); 
  HistLeg -> SetBorderSize(0);
  HistLeg -> SetTextSize  (NoTrue ->GetXaxis()->GetTitleSize() );
  // And now fill it.
  HistLeg   -> AddEntry( NoTrue    , "Monte Carlo");
  //HistLeg   -> AddEntry( TrueNu    , "True Nu Cut");  
  if (bIsFHC) { HistLeg -> AddEntry( TrNuMu, "NuMu CC Cut"     ); HistLeg -> AddEntry( AnNuMu, "Anti-NuMu CC Cut"); }
  else        { HistLeg -> AddEntry( AnNuMu, "Anti-NuMu CC Cut"); HistLeg -> AddEntry( TrNuMu, "NuMu CC Cut"     ); }
  HistLeg   -> AddEntry( NoTrueAlt , "Alt Monte Carlo");
  if (!bIsFD) { HistLeg -> AddEntry( Data, "Data"); }
  // And draw the legend
  HistLeg -> Draw();

  // --- Now I can save my things...
  HistCan -> SaveAs( TString(OutDir)+TString(HistCan->GetName())+TString(".pdf") );
  //HistCan -> SaveAs( TString(OutDir)+TString(HistCan->GetName())+TString(".png") );
  OutFile -> cd();
  HistCan -> Write( HistCan->GetName() );


  // -----------------------------------------------------------
  // --- Now for the ratio part of the plots....
  // ---     Provided that I'm looking at the ND...
  // -----------------------------------------------------------
  /*
  if (!bIsFD) {
    // Make my ratio plot
    TH1D* Ratio = MakeRatio( MCHist, Data, 2, PlotName );

    std::string RatCanNa = PlotName+"_ratio";
    TCanvas *RatCan = new TCanvas( RatCanNa.c_str(), RatCanNa.c_str() );
    // --- If looking at cosmics then I want the plot to be log y
    Ratio -> GetYaxis() -> SetTitle("Ratio");
    Ratio -> Draw();
    // --- Add a reference line
    double x[2] = { Ratio->GetXaxis()->GetXmin(), Ratio->GetXaxis()->GetXmax() };
    double y[2] = { 1, 1 };
    TGraph *line = new TGraph( 2, x, y );
    line->SetLineColor(kGray);
    line->SetLineWidth( 3 );
    line->SetLineStyle( 2 );
    line->Draw("l same");
    // --- Finally, draw! 
    Ratio -> Draw("axis same");
    
    // ------------------------------
    // --- Now merge the two canvases
    std::string MergeCanNa = PlotName+"_merged";
    TCanvas *MergeCan = new TCanvas( MergeCanNa.c_str(), MergeCanNa.c_str() );
    MergeCan->Divide(1,2);
    HistCan -> SetRightMargin(.03); HistCan -> SetLeftMargin(.07); HistCan -> SetTopMargin(.10); HistCan -> SetBottomMargin(.00); 
    RatCan  -> SetRightMargin(.03); RatCan  -> SetLeftMargin(.07); RatCan  -> SetTopMargin(.00); RatCan  -> SetBottomMargin(.12); 

    // And now the axes...
    double Lb1 = 0.07;
    MCHist -> GetYaxis() -> SetTitleSize( Lb1 ); MCHist -> GetYaxis() -> SetLabelSize( Lb1 ); MCHist -> GetYaxis() -> SetTitleOffset( 0.45 );
    Ratio  -> GetYaxis() -> SetTitleSize( Lb1 ); Ratio  -> GetYaxis() -> SetLabelSize( Lb1 ); Ratio  -> GetYaxis() -> SetTitleOffset( 0.45 );
    Ratio  -> GetXaxis() -> SetTitleSize( Lb1 ); Ratio  -> GetXaxis() -> SetLabelSize( Lb1 );

    MergeCan->cd(1);
    HistCan->DrawClonePad();
    MergeCan->cd(2);
    RatCan ->DrawClonePad();

    // Finally, save the merged canvas.
    MergeCan -> SaveAs( TString(OutDir)+TString(MergeCanNa)+TString(".pdf" ) );
    //MergeCan -> SaveAs( TString(OutDir)+TString(MergeCanNa)+TString(".png" ) );
    OutFile  -> cd();
    MergeCan -> Write ( MergeCanNa.c_str() );
  }
  */
  // --- Return.
  return;
}

void NuMu2020_BasicPIDPlots_Plot	(	bool	isfhc,
		bool	isfd,
		std::string	period = "full"
	)

Definition at line 101 of file NuMu2020_BasicPIDPlots_Plot.C.

References ana::BasicPIDPlots2019_Cuts(), ana::BasicPIDPlots_Cuts(), bIsFD, bIsFHC, om::cout, cut, allTimeWatchdog::endl, isfd, ana::kAna2019FHCLivetime, ana::kAna2019FHCPOT, ana::kAna2019RHCLivetime, ana::kAna2019RHCPOT, LivNorm, LoadFile_GetHists_2019(), LoadFile_GetHists_2020(), DCS_db_parser::period, POTNorm, sIsFD, sIsFHC, and string.

                                                                                     {

  // ---- First off, lets set the styles...
  gStyle->SetOptStat(0);
  gROOT->SetStyle("novaStyle");

  // --- Set my global variables and print them out to the screen...
  bIsFHC  = isfhc ; sIsFHC  = "fhc" ; if (!isfhc ) {sIsFHC  = "rhc" ; }
  bIsFD   = isfd  ; sIsFD   = "fd"  ; if (!isfd  ) {sIsFD   = "nd"  ;}
  std::cout << "\n================================= \n"
            << "\n\t bIsFHC  --> " << bIsFHC  << " --> " << sIsFHC
            << "\n\t bIsFD   --> " << bIsFD   << " --> " << sIsFD
            << "\n\t Period  --> " << period
            << "\n================================= \n"
            << std::endl;

  // --- What do I normalise to? Just take the Ana19 numbers...
  if      (  bIsFHC ) { POTNorm = kAna2019FHCPOT; LivNorm = kAna2019FHCLivetime; } // FHC
  else if ( !bIsFHC ) { POTNorm = kAna2019RHCPOT; LivNorm = kAna2019RHCLivetime; } // RHC

  // --- Get my cut vector sorted...
  std::vector<std::pair<Cut, std::string> > My2020_Mont = BasicPIDPlots_Cuts    ( bIsFHC, bIsFD, false );
  std::vector<std::pair<Cut, std::string> > My2020_Data = BasicPIDPlots_Cuts    ( bIsFHC, bIsFD, true  );
  std::vector<std::pair<Cut, std::string> > My2019_Mont = BasicPIDPlots2019_Cuts( bIsFHC, bIsFD, false );
  std::vector<std::pair<Cut, std::string> > My2019_Data = BasicPIDPlots2019_Cuts( bIsFHC, bIsFD, true  );
  // --- Get my cut vector size sorted...
  size_t NumCut2020_Mont = My2020_Mont.size();
  size_t NumCut2020_Data = My2020_Data.size();
  size_t NumCut2019_Mont = My2019_Mont.size();
  size_t NumCut2019_Data = My2019_Data.size();
  // --- Write the size of the cuts
  std::cout << "\nThe sizes of the Cut vectors are;"
            << "\n\t NumCut2020_Mont: " << NumCut2020_Mont << "\t NumCut2020_Data: " << NumCut2020_Data
            << "\n\t NumCut2019_Mont: " << NumCut2019_Mont << "\t NumCut2019_Data: " << NumCut2019_Data
            << std::endl;

  // --- Where do my input files live?
  std::string BaseCAFFileDir="/nova/ana/users/karlwarb/Analysis2020/PIDOpt/BasicPlot/200128/";
  
  // --- What are my input files called?
  std::string InputMont_2020 = BaseCAFFileDir+"BasicPIDPlots_2020_"+sIsFD+"_mc_"  +sIsFHC+"_"+period+".root";
  std::string InputData_2020 = BaseCAFFileDir+"BasicPIDPlots_2020_"+sIsFD+"_cosm_"+sIsFHC+"_"+period+".root";
  std::string InputMont_2019 = BaseCAFFileDir+"BasicPIDPlots_2019_"+sIsFD+"_mc_"  +sIsFHC+"_"+period+".root";
  std::string InputData_2019 = BaseCAFFileDir+"BasicPIDPlots_2019_"+sIsFD+"_cosm_"+sIsFHC+"_"+period+".root";
  // --- Open the files.
  std::cout << "\n Going to load input files: "
            << "\n\t" << InputMont_2020 << "\n\t" << InputData_2020
            << "\n\t" << InputMont_2019 << "\n\t" << InputData_2019 << std::endl;
  TFile *MontFile_2020 = TFile::Open( InputMont_2020.c_str() );
  TFile *MontFile_2019 = TFile::Open( InputMont_2019.c_str() );
  TFile *DataFile_2020 = TFile::Open( InputData_2020.c_str() );
  TFile *DataFile_2019 = TFile::Open( InputData_2019.c_str() );

  // --- Declare my various Loaded Histograms...
  // 2020 MC
  std::vector< LoadedHistograms_2020 > LH_MC_NoTrue_2020;
  std::vector< LoadedHistograms_2020 > LH_MC_TrueNu_2020;
  std::vector< LoadedHistograms_2020 > LH_MC_TrNuMu_2020;
  std::vector< LoadedHistograms_2020 > LH_MC_AnNuMu_2020;
  // 2020 Data
  std::vector< LoadedHistograms_2020 > LH_Data_2020;
  // 2019 MC
  std::vector< LoadedHistograms_2019 > LH_MC_NoTrue_2019;
  std::vector< LoadedHistograms_2019 > LH_MC_TrueNu_2019;
  std::vector< LoadedHistograms_2019 > LH_MC_TrNuMu_2019;
  std::vector< LoadedHistograms_2019 > LH_MC_AnNuMu_2019;
  // 2019 Data
  std::vector< LoadedHistograms_2019 > LH_Data_2019;

  // --- Now to load all of my histograms!
  // --- 2020 MC...
  std::cout << "\nLets load the 2020 Monte Carlo." << std::endl;
  for (size_t cut=0; cut<NumCut2020_Mont; ++cut) {
    // --- What is the Cut + Quant combination?
    std::string CutName = My2020_Mont[cut].second;
    //std::cout << "\n\nNow to look at " << CutName << std::endl;
    // --- Load the Monte Carlo histograms.
    if      (CutName.find("AntiNuMu") != std::string::npos) LH_MC_AnNuMu_2020.push_back( LoadFile_GetHists_2020( MontFile_2020, CutName, false ) );
    else if (CutName.find("TrueNuMu") != std::string::npos) LH_MC_TrNuMu_2020.push_back( LoadFile_GetHists_2020( MontFile_2020, CutName, false ) );
    else if (CutName.find("TrueNu"  ) != std::string::npos) LH_MC_TrueNu_2020.push_back( LoadFile_GetHists_2020( MontFile_2020, CutName, false ) );
    else if (CutName.find("NoTrue"  ) != std::string::npos) LH_MC_NoTrue_2020.push_back( LoadFile_GetHists_2020( MontFile_2020, CutName, false ) );
  }
  // --- 2020 Data
  std::cout << "\nLets load the 2020 Data." << std::endl;
  for (size_t cut=0; cut<NumCut2020_Data; ++cut) {
    // --- What is the Cut + Quant combination?
    std::string CutName = My2020_Data[cut].second;
    //std::cout << "\n\nNow to look at " << CutName << std::endl;
    // --- Load the Data histograms.
    LH_Data_2020.push_back( LoadFile_GetHists_2020( DataFile_2020, CutName, true ) );
  }

  // --- 2019 MC...
  std::cout << "\nLets load the 2019 Monte Carlo." << std::endl;
  for (size_t cut=0; cut<NumCut2019_Mont; ++cut) {
    // --- What is the Cut + Quant combination?
    std::string CutName = My2019_Mont[cut].second;
    //std::cout << "\n\nNow to look at " << CutName << std::endl;
    // --- Load the Monte Carlo histograms.
    if      (CutName.find("AntiNuMu") != std::string::npos) LH_MC_AnNuMu_2019.push_back( LoadFile_GetHists_2019( MontFile_2019, CutName, false ) );
    else if (CutName.find("TrueNuMu") != std::string::npos) LH_MC_TrNuMu_2019.push_back( LoadFile_GetHists_2019( MontFile_2019, CutName, false ) );
    else if (CutName.find("TrueNu"  ) != std::string::npos) LH_MC_TrueNu_2019.push_back( LoadFile_GetHists_2019( MontFile_2019, CutName, false ) );
    else if (CutName.find("NoTrue"  ) != std::string::npos) LH_MC_NoTrue_2019.push_back( LoadFile_GetHists_2019( MontFile_2019, CutName, false ) );
  }
  // --- 2019 Data
  std::cout << "\nLets load the 2019 Data." << std::endl;
  for (size_t cut=0; cut<NumCut2019_Data; ++cut) {
    // --- What is the Cut + Quant combination?
    std::string CutName = My2019_Data[cut].second;
    //std::cout << "\n\nNow to look at " << CutName << std::endl;
    // --- Load the Data histograms.
    LH_Data_2019.push_back( LoadFile_GetHists_2019( DataFile_2019, CutName, true ) );
  }
  // --- Check the sizes of all of my LoadedHistogram vectors...
  std::cout << "\nThe size of my various LH vectors are as follows;"
            << "\n\t LH_MC_NoTrue_2020 " << LH_MC_NoTrue_2020.size() 
            << "\n\t LH_MC_TrueNu_2020 " << LH_MC_TrueNu_2020.size()
            << "\n\t LH_MC_TrNuMu_2020 " << LH_MC_TrNuMu_2020.size()
            << "\n\t LH_MC_AnNuMu_2020 " << LH_MC_AnNuMu_2020.size()
            << "\n\t LH_MC_NoTrue_2019 " << LH_MC_NoTrue_2019.size()
            << "\n\t LH_MC_TrueNu_2019 " << LH_MC_TrueNu_2019.size()
            << "\n\t LH_MC_TrNuMu_2019 " << LH_MC_TrNuMu_2019.size()
            << "\n\t LH_MC_AnNuMu_2019 " << LH_MC_AnNuMu_2019.size()
            << "\n\t LH_Data_2020      " << LH_Data_2020     .size()
            << "\n\t LH_Data_2019      " << LH_Data_2019     .size()
            << std::endl;

  // --- Now that I've loaded everything, I need to make my plots!
  /*
  std::cout << "\n\n Now to plot things..." << std::endl;
  for (size_t CutInd=0; CutInd<LH_MC_NoTrue_2020.size(); ++CutInd) {
    
    // Set the 2020 Cut Factor
    unsigned int cut   = CutInd*4;
    // Set the 2019 Cut Factor.
    unsigned int   cut19 =  CutInd   *4, CutInd19 = CutInd;
    if (CutInd==2){cut19 = (CutInd-1)*4; CutInd19 = CutInd-1;}
    // Check that the elements are set correctly.
    
    //std::cout << "\t What elements should I plot?"
    //        << "\n\t\t 2020 MC:   "<<My2020_Mont[cut     ].second<<", "<<My2020_Mont[cut+1  ].second<<", "<<My2020_Mont[cut  +2].second<<", "<<My2020_Mont[cut  +3].second
    //        << "\n\t\t 2020 Data: "<<My2020_Data[CutInd  ].second
    //        << "\n\t\t 2019 MC:   "<<My2019_Mont[cut19   ].second<<", "<<My2019_Mont[cut19+1].second<<", "<<My2019_Mont[cut19+2].second<<", "<<My2019_Mont[cut19+3].second
    //        << "\n\t\t 2019 Data: "<<My2019_Data[CutInd19].second
    //        << std::endl;
    
    // --- Now to figure out how to make my plots... 
    // Want the "CutInd" elements of each LH vector, and the "cut" element of the CutName vector 
    ProducePlots_2020( LH_MC_NoTrue_2020[ CutInd    ], // 2020 - NoTrue
                       LH_MC_TrueNu_2020[ CutInd    ], // 2020 - TrueNu
                       LH_MC_TrNuMu_2020[ CutInd    ], // 2020 - TrNuMu
                       LH_MC_AnNuMu_2020[ CutInd    ], // 2020 - AnNuMu
                       LH_MC_NoTrue_2019[ CutInd19  ], // 2019 - NoTrue
                       LH_Data_2020     [ CutInd    ], // 2020 - Data
                       My2020_Mont[cut].second      ); // CutTier.
    if (CutInd!=2) {
      ProducePlots_2019( LH_MC_NoTrue_2019[ CutInd19 ], // 2019 - NoTrue
                         LH_MC_TrueNu_2019[ CutInd19 ], // 2019 - TrueNu
                         LH_MC_TrNuMu_2019[ CutInd19 ], // 2019 - TrNuMu
                         LH_MC_AnNuMu_2019[ CutInd19 ], // 2019 - AnNuMu
                         LH_MC_NoTrue_2020[ CutInd   ], // 2020 - NoTrue
                         LH_Data_2019     [ CutInd19 ], // 2019 - Data
                         My2019_Mont[cut19].second   ); // CutTier.
    }
  }
  */
  // --- Finally, return.
  return;
} // DoThePlots

void PlotHistProp	(	TH1D *	Hist,
		TLegend *	L
	)

Definition at line 446 of file NuMu2020_BasicPIDPlots_Plot.C.

References AddEntry().

                                            {
  double Mean_Nom = Hist->GetMean();
  double RMS_Nom  = Hist->GetRMS();
  double Int_Nom  = Hist->Integral();
  L -> AddEntry( Hist, Form("Mean: %.3f", Mean_Nom), "" );
  L -> AddEntry( Hist, Form("RMS: %.3f" , RMS_Nom ), "" );
  L -> AddEntry( Hist, Form("Int: %.3f" , Int_Nom ), "" );
  return;
}

void ProducePlots_2019	(	LoadedHistograms_2019	NoTrue_2019,
		LoadedHistograms_2019	TrueNu_2019,
		LoadedHistograms_2019	TrNuMu_2019,
		LoadedHistograms_2019	AnNuMu_2019,
		LoadedHistograms_2020	NoTrue_2020,
		LoadedHistograms_2019	Data_2019,
		std::string	CutTier
	)

Definition at line 687 of file NuMu2020_BasicPIDPlots_Plot.C.

References om::cout, allTimeWatchdog::endl, LoadedHistograms_2020::hNuRecoE, LoadedHistograms_2019::hNuRecoE, MakeSplitCans(), OutDir, OutFile, sIsFD, sIsFHC, and string.

                                                                                                                  {

  // --- Make my output directory.
  OutDir  = "Plots-2019-"+sIsFD+"-"+sIsFHC+"/";
  std::string OutName = OutDir+"BasicPIDPlots-"+sIsFD+"-"+sIsFHC+".root";
  gSystem -> MakeDirectory( OutDir.c_str() );
  OutFile = TFile::Open( OutName.c_str(), "RECREATE" );

  // --- Make a quick string to combine some important nomenclature
  std::string EndCan = sIsFD+"_"+sIsFHC+CutTier+"_2019";
  
  std::cout << "\n In ProducePlots_2019. I passed the cut " << CutTier << std::endl;

  // --- Now let's start making all of the plots!!!!
  // -----------------------------------------------
  MakeSplitCans( NoTrue_2019.hNuRecoE       , TrueNu_2019.hNuRecoE     , TrNuMu_2019.hNuRecoE       , AnNuMu_2019.hNuRecoE       , 
                 NoTrue_2020.hNuRecoE       , Data_2019.hNuRecoE       , "hNuRecoE_"           +EndCan );

  return;
}

void ProducePlots_2020	(	LoadedHistograms_2020	NoTrue_2020,
		LoadedHistograms_2020	TrueNu_2020,
		LoadedHistograms_2020	TrNuMu_2020,
		LoadedHistograms_2020	AnNuMu_2020,
		LoadedHistograms_2019	NoTrue_2019,
		LoadedHistograms_2020	Data_2020,
		std::string	CutTier
	)

Definition at line 637 of file NuMu2020_BasicPIDPlots_Plot.C.

References om::cout, allTimeWatchdog::endl, LoadedHistograms_2020::hNuRecoE, LoadedHistograms_2019::hNuRecoE, MakeSplitCans(), OutDir, OutFile, sIsFD, sIsFHC, and string.

                                                                                                                  {

  // --- Make my output directory.
  OutDir  = "Plots-2020-"+sIsFD+"-"+sIsFHC+"/";
  std::string OutName = OutDir+"BasicPIDPlots-"+sIsFD+"-"+sIsFHC+".root";
  gSystem -> MakeDirectory( OutDir.c_str() );
  OutFile = TFile::Open( OutName.c_str(), "RECREATE" );

  // --- Make a quick string to combine some important nomenclature
  std::string EndCan = sIsFD+"_"+sIsFHC+CutTier+"_2020";
  
  std::cout << "\n In ProducePlots_2020. I passed the cut " << CutTier << std::endl;

  // --- Now let's start making all of the plots!!!!
  // -----------------------------------------------
  MakeSplitCans( NoTrue_2020.hNuRecoE       , TrueNu_2020.hNuRecoE       , TrNuMu_2020.hNuRecoE       , AnNuMu_2020.hNuRecoE       , 
                 NoTrue_2019.hNuRecoE       , Data_2020  .hNuRecoE       , "hNuRecoE_"           +EndCan );
  /*
  MakeSplitCans( NoTrue_2020.hReMIdScore    , TrueNu_2020.hReMIdScore    , TrNuMu_2020.hReMIdScore    , AnNuMu_2020.hReMIdScore    ,
                 NoTrue_2019.hReMIdScore    , Data_2020  .hReMIdScore    , "hReMIdScore_"        +EndCan );

  MakeSplitCans( NoTrue_2020.hProngScoremuon, TrueNu_2020.hProngScoremuon, TrNuMu_2020.hProngScoremuon, AnNuMu_2020.hProngScoremuon,
                 NoTrue_2019.hProngScoremuon, Data_2020  .hProngScoremuon, "hProngCVNMuonScore_" +EndCan );

  MakeSplitCans( NoTrue_2020.hOldPreselmuon , TrueNu_2020.hOldPreselmuon , TrNuMu_2020.hOldPreselmuon , AnNuMu_2020.hOldPreselmuon ,
                 NoTrue_2019.hCVNmuon       , Data_2020  .hOldPreselmuon , "hOldPreselMuonScore_"+EndCan );

  MakeSplitCans( NoTrue_2020.hLoosePTPmuon  , TrueNu_2020.hLoosePTPmuon  , TrNuMu_2020.hLoosePTPmuon  , AnNuMu_2020.hLoosePTPmuon  ,
                 NoTrue_2019.hCVNmuon       , Data_2020  .hLoosePTPmuon  , "hLoosePtpMuonScore_" +EndCan );
  if (bIsFD) {    
    // CosRej
    MakeSplitCans( NoTrue_2020.hCosRejScoreP4 , TrueNu_2020.hCosRejScoreP4 , TrNuMu_2020.hCosRejScoreP4 , AnNuMu_2020.hCosRejScoreP4 ,
                   NoTrue_2019.hCosRejScoreP4 , Data_2020  .hCosRejScoreP4 , "hProd4CosRejScore_"  +EndCan );

    MakeSplitCans( NoTrue_2020.hCosRejScoreP5 , TrueNu_2020.hCosRejScoreP5 , TrNuMu_2020.hCosRejScoreP5 , AnNuMu_2020.hCosRejScoreP5 ,
                   NoTrue_2019.hCosRejScoreP4 , Data_2020  .hCosRejScoreP5 , "hProd5CosRejScore_"  +EndCan );
    // Cosmic Score
    MakeSplitCans( NoTrue_2020.hOldPreselcosm , TrueNu_2020.hOldPreselcosm , TrNuMu_2020.hOldPreselcosm , AnNuMu_2020.hOldPreselcosm ,
                   NoTrue_2019.hCVNmuon       , Data_2020  .hOldPreselcosm , "hOldPreselCosmScore_"+EndCan );

    MakeSplitCans( NoTrue_2020.hLoosePTPcosm  , TrueNu_2020.hLoosePTPcosm  , TrNuMu_2020.hLoosePTPcosm  , AnNuMu_2020.hLoosePTPcosm  ,
                   NoTrue_2019.hCVNmuon       , Data_2020  .hLoosePTPcosm  , "hLoosePtpCosmScore_" +EndCan );
  }
  */
  return;
}

void SetRange	(	TH1D *	MC,
		TH1D *	Data,
		double	XLow,
		double	XHigh,
		double	H_YLow,
		double	H_YHigh
	)

Definition at line 385 of file NuMu2020_BasicPIDPlots_Plot.C.

References bIsFD, GetXaxis(), and GetYaxis().

Referenced by MakeSplitCans().

                                               { // What Y values do I want?
  // --- First off, set the X ranges.
  if ( (XLow != -1) && (XHigh != -1) ) {
    MC                -> GetXaxis() -> SetRangeUser( XLow, XHigh );
    if (!bIsFD) Data  -> GetXaxis() -> SetRangeUser( XLow, XHigh );
  }

  // --- And, the Y axes, but check that they aren't -1!
  // Hists
  if ( (H_YLow != -1) && (H_YHigh != -1) ) {
    MC               -> GetYaxis() -> SetRangeUser( H_YLow, H_YHigh );
    if (!bIsFD) Data -> GetYaxis() -> SetRangeUser( H_YLow, H_YHigh );
  }
  // --- Return
  return;
}

Variable Documentation

bool bIsFD = true

Definition at line 62 of file NuMu2020_BasicPIDPlots_Plot.C.

Referenced by FindAxisRange(), GetSpectToHist(), MakeSplitCans(), NuMu2020_BasicPIDPlots_Plot(), and SetRange().

bool bIsFHC = true

Definition at line 61 of file NuMu2020_BasicPIDPlots_Plot.C.

Referenced by FindAxisRange(), MakeSplitCans(), and NuMu2020_BasicPIDPlots_Plot().

double LivNorm = 1e20

Definition at line 65 of file NuMu2020_BasicPIDPlots_Plot.C.

Referenced by GetSpectToHist(), and NuMu2020_BasicPIDPlots_Plot().

size_t NPlot = 1

Definition at line 67 of file NuMu2020_BasicPIDPlots_Plot.C.

std::string OutDir = "./"

Definition at line 69 of file NuMu2020_BasicPIDPlots_Plot.C.

Referenced by make_ehade_histogram(), make_prediction_extrap(), make_prediction_noextrap(), MakeSplitCans(), NuMu2020_MakePIDPlots(), ProducePlots_2019(), and ProducePlots_2020().

TFile* OutFile

Definition at line 70 of file NuMu2020_BasicPIDPlots_Plot.C.

Referenced by CalcCutValsPlot(), CutFlow_Cosmic(), CutFlow_Data(), CutFlow_MC(), CutFlow_NearDet(), EnergyCont_macro(), FD_Data_PosComp(), hadEFrac_nd_data_mc_systs(), hyperon_macro(), hyperon_nom_macro(), make_dataMC(), make_quantiles_histogram_2020(), MakeCutFlow(), MakeCutFlowPlots(), MakeSplitCans(), ND_DataMC_Comp_Systs(), neutKEsyst(), neutronE_macro(), NuMu2019_BasicPIDPlots_FD(), NuMu2019_BasicPIDPlots_ND(), NuMu2019_BasicPIDPlots_Spectrum(), NuMu2020_BasicPIDPlots_FD(), NuMu2020_BasicPIDPlots_ND(), NuMu2020_BasicPIDPlots_Spectrum(), Plot_Evals_BDTMLP_Algs(), PositionComparison(), ProducePlots(), ProducePlots_2019(), and ProducePlots_2020().

double POTNorm = 1e20

Definition at line 64 of file NuMu2020_BasicPIDPlots_Plot.C.

Referenced by GetSpectToHist(), and NuMu2020_BasicPIDPlots_Plot().

std::string sIsFD = ""

Definition at line 62 of file NuMu2020_BasicPIDPlots_Plot.C.

Referenced by NuMu2020_BasicPIDPlots_Plot(), NuMu2020_MakePIDPlots(), NuMu2020_TrimCAFs(), ProducePlots_2019(), and ProducePlots_2020().

std::string sIsFHC = ""

Definition at line 61 of file NuMu2020_BasicPIDPlots_Plot.C.

Referenced by NuMu2020_BasicPIDPlots_Plot(), NuMu2020_MakePIDPlots(), ProducePlots_2019(), and ProducePlots_2020().