void ThreeBeamEnu() { /////////////////////////////////////// /////////////////////////////////////// /////////////////////////////////////// // Configure macro gStyle->SetOptStat(0); Int_t le10rebin = 4; Int_t pMErebin = 4; Int_t pHErebin = 4; Int_t le10rebinAft = 4; Int_t pMErebinAft = 6; Int_t pHErebinAft = 8; Float_t enuAxisLow = 0.0; Float_t enuAxisHigh = 15.0; Float_t ratioAxisLow = 0.3; Float_t ratioAxisHigh = 2.0; Bool_t cutOnShwEnergy = true; // To select zero hadronic energy sample use lowEshwCut=highEshwCut=0. // Otherwise note that the projections with reco_eshw use a 2D histogram // with reco_eshw in bins of 50MeV from 0-60 GeV. // eg: lowEshwCut = 0.001 // highEshwCut = 0.999 Float_t lowEshwCut = 0.0; Float_t highEshwCut = 0.0; Bool_t showQEevents = true; Bool_t showRESevents = true; Bool_t showDISevents = true; Bool_t showNCevents = true; // Select kinematics samples with following integer: // 0 - whole kinematic plane // 1 - 'safe' DIS (W2>4 Q2>1) // 2 - low Q2 DIS (W2>4 Q2<=1) // 3 - QEL/Delta (W2<1.69) // 4 - transition (W2>1.69 W2<=4) Int_t selectKinSample = 0; Bool_t showSlidingCut = true; // Ratios can look a little crazy for the sliding cuts so rebin with this... Int_t ratioRebin = 2; Double_t le10mcPots = 8.156000e18; Double_t pMEmcPots = 3.861990e18; Double_t pHEmcPots = 7.205415e17; Double_t le10dataPots = 7.1175790e19; Double_t pMEdataPots = 1.127720e18; Double_t pHEdataPots = 1.597130e18; /////////////////////////////////////// /////////////////////////////////////// /////////////////////////////////////// // Read in histograms // LE-10 TFile* le10mcFile = new TFile("ana_LE-10mc_12parFit_wCCpid_ehad0.root","READ"); le10mcFile->cd(); TH2F* le10mcEnu; if(selectKinSample==0) le10mcEnu = (TH2F*)le10mcFile->Get("enuVeshwB4[0]"); if(selectKinSample==1) le10mcEnu = (TH2F*)le10mcFile->Get("enuVeshwB4[1]"); if(selectKinSample==2) le10mcEnu = (TH2F*)le10mcFile->Get("enuVeshwB4[2]"); if(selectKinSample==3) le10mcEnu = (TH2F*)le10mcFile->Get("enuVeshwB4[3]"); if(selectKinSample==4) le10mcEnu = (TH2F*)le10mcFile->Get("enuVeshwB4[4]"); TH2F* le10mcEnuRw; if(selectKinSample==0) le10mcEnuRw = (TH2F*)le10mcFile->Get("enuVeshwB4Rw[0]"); if(selectKinSample==1) le10mcEnuRw = (TH2F*)le10mcFile->Get("enuVeshwB4Rw[1]"); if(selectKinSample==2) le10mcEnuRw = (TH2F*)le10mcFile->Get("enuVeshwB4Rw[2]"); if(selectKinSample==3) le10mcEnuRw = (TH2F*)le10mcFile->Get("enuVeshwB4Rw[3]"); if(selectKinSample==4) le10mcEnuRw = (TH2F*)le10mcFile->Get("enuVeshwB4Rw[4]"); TFile* le10QEmcFile = new TFile("ana_LE-10mc_12parFit_wCCpid_ehad0_justQE.root","READ"); le10QEmcFile->cd(); TH2F* le10QEmcEnuRw; if(selectKinSample==0) le10QEmcEnuRw = (TH2F*)le10QEmcFile->Get("enuVeshwB4Rw[0]"); if(selectKinSample==1) le10QEmcEnuRw = (TH2F*)le10QEmcFile->Get("enuVeshwB4Rw[1]"); if(selectKinSample==2) le10QEmcEnuRw = (TH2F*)le10QEmcFile->Get("enuVeshwB4Rw[2]"); if(selectKinSample==3) le10QEmcEnuRw = (TH2F*)le10QEmcFile->Get("enuVeshwB4Rw[3]"); if(selectKinSample==4) le10QEmcEnuRw = (TH2F*)le10QEmcFile->Get("enuVeshwB4Rw[4]"); TFile* le10RESmcFile = new TFile("ana_LE-10mc_12parFit_wCCpid_ehad0_justRES.root","READ"); le10RESmcFile->cd(); TH2F* le10RESmcEnuRw; if(selectKinSample==0) le10RESmcEnuRw = (TH2F*)le10RESmcFile->Get("enuVeshwB4Rw[0]"); if(selectKinSample==1) le10RESmcEnuRw = (TH2F*)le10RESmcFile->Get("enuVeshwB4Rw[1]"); if(selectKinSample==2) le10RESmcEnuRw = (TH2F*)le10RESmcFile->Get("enuVeshwB4Rw[2]"); if(selectKinSample==3) le10RESmcEnuRw = (TH2F*)le10RESmcFile->Get("enuVeshwB4Rw[3]"); if(selectKinSample==4) le10RESmcEnuRw = (TH2F*)le10RESmcFile->Get("enuVeshwB4Rw[4]"); TFile* le10DISmcFile = new TFile("ana_LE-10mc_12parFit_wCCpid_ehad0_justDIS.root","READ"); le10DISmcFile->cd(); TH2F* le10DISmcEnuRw; if(selectKinSample==0) le10DISmcEnuRw = (TH2F*)le10DISmcFile->Get("enuVeshwB4Rw[0]"); if(selectKinSample==1) le10DISmcEnuRw = (TH2F*)le10DISmcFile->Get("enuVeshwB4Rw[1]"); if(selectKinSample==2) le10DISmcEnuRw = (TH2F*)le10DISmcFile->Get("enuVeshwB4Rw[2]"); if(selectKinSample==3) le10DISmcEnuRw = (TH2F*)le10DISmcFile->Get("enuVeshwB4Rw[3]"); if(selectKinSample==4) le10DISmcEnuRw = (TH2F*)le10DISmcFile->Get("enuVeshwB4Rw[4]"); TFile* le10NCmcFile = new TFile("ana_LE-10mc_12parFit_wCCpid_ehad0_justNC.root","READ"); le10NCmcFile->cd(); TH2F* le10NCmcEnuRw; if(selectKinSample==0) le10NCmcEnuRw = (TH2F*)le10NCmcFile->Get("enuVeshwB4Rw[0]"); if(selectKinSample==1) le10NCmcEnuRw = (TH2F*)le10NCmcFile->Get("enuVeshwB4Rw[1]"); if(selectKinSample==2) le10NCmcEnuRw = (TH2F*)le10NCmcFile->Get("enuVeshwB4Rw[2]"); if(selectKinSample==3) le10NCmcEnuRw = (TH2F*)le10NCmcFile->Get("enuVeshwB4Rw[3]"); if(selectKinSample==4) le10NCmcEnuRw = (TH2F*)le10NCmcFile->Get("enuVeshwB4Rw[4]"); TFile* le10dataFile = new TFile("ana_LE-10data_12parFit_wCCpid_ehad0.root","READ"); le10dataFile->cd(); TH2F* le10dataEnu; if(selectKinSample==0) le10dataEnu = (TH2F*)le10dataFile->Get("enuVeshwB4[0]"); if(selectKinSample==1) le10dataEnu = (TH2F*)le10dataFile->Get("enuVeshwB4[1]"); if(selectKinSample==2) le10dataEnu = (TH2F*)le10dataFile->Get("enuVeshwB4[2]"); if(selectKinSample==3) le10dataEnu = (TH2F*)le10dataFile->Get("enuVeshwB4[3]"); if(selectKinSample==4) le10dataEnu = (TH2F*)le10dataFile->Get("enuVeshwB4[4]"); // pME TFile* pMEmcFile = new TFile("ana_pMEmc_12parFit_wCCpid_ehad0.root","READ"); pMEmcFile->cd(); TH2F* pMEmcEnu; if(selectKinSample==0) pMEmcEnu = (TH2F*)pMEmcFile->Get("enuVeshwB4[0]"); if(selectKinSample==1) pMEmcEnu = (TH2F*)pMEmcFile->Get("enuVeshwB4[1]"); if(selectKinSample==2) pMEmcEnu = (TH2F*)pMEmcFile->Get("enuVeshwB4[2]"); if(selectKinSample==3) pMEmcEnu = (TH2F*)pMEmcFile->Get("enuVeshwB4[3]"); if(selectKinSample==4) pMEmcEnu = (TH2F*)pMEmcFile->Get("enuVeshwB4[4]"); TH2F* pMEmcEnuRw; if(selectKinSample==0) pMEmcEnuRw = (TH2F*)pMEmcFile->Get("enuVeshwB4Rw[0]"); if(selectKinSample==1) pMEmcEnuRw = (TH2F*)pMEmcFile->Get("enuVeshwB4Rw[1]"); if(selectKinSample==2) pMEmcEnuRw = (TH2F*)pMEmcFile->Get("enuVeshwB4Rw[2]"); if(selectKinSample==3) pMEmcEnuRw = (TH2F*)pMEmcFile->Get("enuVeshwB4Rw[3]"); if(selectKinSample==4) pMEmcEnuRw = (TH2F*)pMEmcFile->Get("enuVeshwB4Rw[4]"); TFile* pMEQEmcFile = new TFile("ana_pMEmc_12parFit_wCCpid_ehad0_justQE.root","READ"); pMEQEmcFile->cd(); TH2F* pMEQEmcEnuRw; if(selectKinSample==0) pMEQEmcEnuRw = (TH2F*)pMEQEmcFile->Get("enuVeshwB4Rw[0]"); if(selectKinSample==1) pMEQEmcEnuRw = (TH2F*)pMEQEmcFile->Get("enuVeshwB4Rw[1]"); if(selectKinSample==2) pMEQEmcEnuRw = (TH2F*)pMEQEmcFile->Get("enuVeshwB4Rw[2]"); if(selectKinSample==3) pMEQEmcEnuRw = (TH2F*)pMEQEmcFile->Get("enuVeshwB4Rw[3]"); if(selectKinSample==4) pMEQEmcEnuRw = (TH2F*)pMEQEmcFile->Get("enuVeshwB4Rw[4]"); TFile* pMERESmcFile = new TFile("ana_pMEmc_12parFit_wCCpid_ehad0_justRES.root","READ"); pMERESmcFile->cd(); TH2F* pMERESmcEnuRw; if(selectKinSample==0) pMERESmcEnuRw = (TH2F*)pMERESmcFile->Get("enuVeshwB4Rw[0]"); if(selectKinSample==1) pMERESmcEnuRw = (TH2F*)pMERESmcFile->Get("enuVeshwB4Rw[1]"); if(selectKinSample==2) pMERESmcEnuRw = (TH2F*)pMERESmcFile->Get("enuVeshwB4Rw[2]"); if(selectKinSample==3) pMERESmcEnuRw = (TH2F*)pMERESmcFile->Get("enuVeshwB4Rw[3]"); if(selectKinSample==4) pMERESmcEnuRw = (TH2F*)pMERESmcFile->Get("enuVeshwB4Rw[4]"); TFile* pMEDISmcFile = new TFile("ana_pMEmc_12parFit_wCCpid_ehad0_justDIS.root","READ"); pMEDISmcFile->cd(); TH2F* pMEDISmcEnuRw; if(selectKinSample==0) pMEDISmcEnuRw = (TH2F*)pMEDISmcFile->Get("enuVeshwB4Rw[0]"); if(selectKinSample==1) pMEDISmcEnuRw = (TH2F*)pMEDISmcFile->Get("enuVeshwB4Rw[1]"); if(selectKinSample==2) pMEDISmcEnuRw = (TH2F*)pMEDISmcFile->Get("enuVeshwB4Rw[2]"); if(selectKinSample==3) pMEDISmcEnuRw = (TH2F*)pMEDISmcFile->Get("enuVeshwB4Rw[3]"); if(selectKinSample==4) pMEDISmcEnuRw = (TH2F*)pMEDISmcFile->Get("enuVeshwB4Rw[4]"); TFile* pMENCmcFile = new TFile("ana_pMEmc_12parFit_wCCpid_ehad0_justNC.root","READ"); pMENCmcFile->cd(); TH2F* pMENCmcEnuRw; if(selectKinSample==0) pMENCmcEnuRw = (TH2F*)pMENCmcFile->Get("enuVeshwB4Rw[0]"); if(selectKinSample==1) pMENCmcEnuRw = (TH2F*)pMENCmcFile->Get("enuVeshwB4Rw[1]"); if(selectKinSample==2) pMENCmcEnuRw = (TH2F*)pMENCmcFile->Get("enuVeshwB4Rw[2]"); if(selectKinSample==3) pMENCmcEnuRw = (TH2F*)pMENCmcFile->Get("enuVeshwB4Rw[3]"); if(selectKinSample==4) pMENCmcEnuRw = (TH2F*)pMENCmcFile->Get("enuVeshwB4Rw[4]"); TFile* pMEdataFile = new TFile("ana_pMEdata_12parFit_wCCpid_ehad0.root","READ"); pMEdataFile->cd(); TH2F* pMEdataEnu; if(selectKinSample==0) pMEdataEnu = (TH2F*)pMEdataFile->Get("enuVeshwB4[0]"); if(selectKinSample==1) pMEdataEnu = (TH2F*)pMEdataFile->Get("enuVeshwB4[1]"); if(selectKinSample==2) pMEdataEnu = (TH2F*)pMEdataFile->Get("enuVeshwB4[2]"); if(selectKinSample==3) pMEdataEnu = (TH2F*)pMEdataFile->Get("enuVeshwB4[3]"); if(selectKinSample==4) pMEdataEnu = (TH2F*)pMEdataFile->Get("enuVeshwB4[4]"); // pHE TFile* pHEmcFile = new TFile("ana_pHEmc_12parFit_wCCpid_ehad0.root","READ"); pHEmcFile->cd(); TH2F* pHEmcEnu; if(selectKinSample==0) pHEmcEnu = (TH2F*)pHEmcFile->Get("enuVeshwB4[0]"); if(selectKinSample==1) pHEmcEnu = (TH2F*)pHEmcFile->Get("enuVeshwB4[1]"); if(selectKinSample==2) pHEmcEnu = (TH2F*)pHEmcFile->Get("enuVeshwB4[2]"); if(selectKinSample==3) pHEmcEnu = (TH2F*)pHEmcFile->Get("enuVeshwB4[3]"); if(selectKinSample==4) pHEmcEnu = (TH2F*)pHEmcFile->Get("enuVeshwB4[4]"); TH2F* pHEmcEnuRw; if(selectKinSample==0) pHEmcEnuRw = (TH2F*)pHEmcFile->Get("enuVeshwB4Rw[0]"); if(selectKinSample==1) pHEmcEnuRw = (TH2F*)pHEmcFile->Get("enuVeshwB4Rw[1]"); if(selectKinSample==2) pHEmcEnuRw = (TH2F*)pHEmcFile->Get("enuVeshwB4Rw[2]"); if(selectKinSample==3) pHEmcEnuRw = (TH2F*)pHEmcFile->Get("enuVeshwB4Rw[3]"); if(selectKinSample==4) pHEmcEnuRw = (TH2F*)pHEmcFile->Get("enuVeshwB4Rw[4]"); TFile* pHEQEmcFile = new TFile("ana_pHEmc_12parFit_wCCpid_ehad0_justQE.root","READ"); pHEQEmcFile->cd(); TH2F* pHEQEmcEnuRw; if(selectKinSample==0) pHEQEmcEnuRw = (TH2F*)pHEQEmcFile->Get("enuVeshwB4Rw[0]"); if(selectKinSample==1) pHEQEmcEnuRw = (TH2F*)pHEQEmcFile->Get("enuVeshwB4Rw[1]"); if(selectKinSample==2) pHEQEmcEnuRw = (TH2F*)pHEQEmcFile->Get("enuVeshwB4Rw[2]"); if(selectKinSample==3) pHEQEmcEnuRw = (TH2F*)pHEQEmcFile->Get("enuVeshwB4Rw[3]"); if(selectKinSample==4) pHEQEmcEnuRw = (TH2F*)pHEQEmcFile->Get("enuVeshwB4Rw[4]"); TFile* pHERESmcFile = new TFile("ana_pHEmc_12parFit_wCCpid_ehad0_justRES.root","READ"); pHERESmcFile->cd(); TH2F* pHERESmcEnuRw; if(selectKinSample==0) pHERESmcEnuRw = (TH2F*)pHERESmcFile->Get("enuVeshwB4Rw[0]"); if(selectKinSample==1) pHERESmcEnuRw = (TH2F*)pHERESmcFile->Get("enuVeshwB4Rw[1]"); if(selectKinSample==2) pHERESmcEnuRw = (TH2F*)pHERESmcFile->Get("enuVeshwB4Rw[2]"); if(selectKinSample==3) pHERESmcEnuRw = (TH2F*)pHERESmcFile->Get("enuVeshwB4Rw[3]"); if(selectKinSample==4) pHERESmcEnuRw = (TH2F*)pHERESmcFile->Get("enuVeshwB4Rw[4]"); TFile* pHEDISmcFile = new TFile("ana_pHEmc_12parFit_wCCpid_ehad0_justDIS.root","READ"); pHEDISmcFile->cd(); TH2F* pHEDISmcEnuRw; if(selectKinSample==0) pHEDISmcEnuRw = (TH2F*)pHEDISmcFile->Get("enuVeshwB4Rw[0]"); if(selectKinSample==1) pHEDISmcEnuRw = (TH2F*)pHEDISmcFile->Get("enuVeshwB4Rw[1]"); if(selectKinSample==2) pHEDISmcEnuRw = (TH2F*)pHEDISmcFile->Get("enuVeshwB4Rw[2]"); if(selectKinSample==3) pHEDISmcEnuRw = (TH2F*)pHEDISmcFile->Get("enuVeshwB4Rw[3]"); if(selectKinSample==4) pHEDISmcEnuRw = (TH2F*)pHEDISmcFile->Get("enuVeshwB4Rw[4]"); TFile* pHENCmcFile = new TFile("ana_pHEmc_12parFit_wCCpid_ehad0_justNC.root","READ"); pHENCmcFile->cd(); TH2F* pHENCmcEnuRw; if(selectKinSample==0) pHENCmcEnuRw = (TH2F*)pHENCmcFile->Get("enuVeshwB4Rw[0]"); if(selectKinSample==1) pHENCmcEnuRw = (TH2F*)pHENCmcFile->Get("enuVeshwB4Rw[1]"); if(selectKinSample==2) pHENCmcEnuRw = (TH2F*)pHENCmcFile->Get("enuVeshwB4Rw[2]"); if(selectKinSample==3) pHENCmcEnuRw = (TH2F*)pHENCmcFile->Get("enuVeshwB4Rw[3]"); if(selectKinSample==4) pHENCmcEnuRw = (TH2F*)pHENCmcFile->Get("enuVeshwB4Rw[4]"); TFile* pHEdataFile = new TFile("ana_pHEdata_12parFit_wCCpid_ehad0.root","READ"); pHEdataFile->cd(); TH2F* pHEdataEnu; if(selectKinSample==0) pHEdataEnu = (TH2F*)pHEdataFile->Get("enuVeshwB4[0]"); if(selectKinSample==1) pHEdataEnu = (TH2F*)pHEdataFile->Get("enuVeshwB4[1]"); if(selectKinSample==2) pHEdataEnu = (TH2F*)pHEdataFile->Get("enuVeshwB4[2]"); if(selectKinSample==3) pHEdataEnu = (TH2F*)pHEdataFile->Get("enuVeshwB4[3]"); if(selectKinSample==4) pHEdataEnu = (TH2F*)pHEdataFile->Get("enuVeshwB4[4]"); ///////////////////////////////////// ///////////////////////////////////// ///////////////////////////////////// // Make 'Base' Plots Int_t baseFirstBin = le10mcEnu->GetXaxis()->FindBin(0.001); Int_t baseLastBin = le10mcEnu->GetXaxis()->FindBin(59.999); TH1D* le10mcEnuPY = le10mcEnu->ProjectionY("le10mcEnuPY",baseFirstBin,baseLastBin); le10mcEnuPY->Sumw2(); le10mcEnuPY->Rebin(le10rebin); le10mcEnuPY->Scale(1.0e19/le10mcPots); TH1D* le10mcEnuRwPY = le10mcEnuRw->ProjectionY("le10mcEnuRwPY",baseFirstBin,baseLastBin); le10mcEnuRwPY->Sumw2(); le10mcEnuRwPY->Rebin(le10rebin); le10mcEnuRwPY->Scale(1.0e19/le10mcPots); TH1D* le10dataEnuPY = le10dataEnu->ProjectionY("le10dataEnuPY",baseFirstBin,baseLastBin); le10dataEnuPY->Sumw2(); le10dataEnuPY->Rebin(le10rebin); le10dataEnuPY->Scale(1.0e19/le10dataPots); TH1D* le10QEmcEnuRwPY = le10QEmcEnuRw->ProjectionY("le10QEmcEnuRwPY",baseFirstBin,baseLastBin); le10QEmcEnuRwPY->Sumw2(); le10QEmcEnuRwPY->Rebin(le10rebin); le10QEmcEnuRwPY->Scale(1.0e19/le10mcPots); TH1D* le10RESmcEnuRwPY = le10RESmcEnuRw->ProjectionY("le10RESmcEnuRwPY",baseFirstBin,baseLastBin); le10RESmcEnuRwPY->Sumw2(); le10RESmcEnuRwPY->Rebin(le10rebin); le10RESmcEnuRwPY->Scale(1.0e19/le10mcPots); TH1D* le10DISmcEnuRwPY = le10DISmcEnuRw->ProjectionY("le10DISmcEnuRwPY",baseFirstBin,baseLastBin); le10DISmcEnuRwPY->Sumw2(); le10DISmcEnuRwPY->Rebin(le10rebin); le10DISmcEnuRwPY->Scale(1.0e19/le10mcPots); TH1D* le10NCmcEnuRwPY = le10NCmcEnuRw->ProjectionY("le10NCmcEnuRwPY",baseFirstBin,baseLastBin); le10NCmcEnuRwPY->Sumw2(); le10NCmcEnuRwPY->Rebin(le10rebin); le10NCmcEnuRwPY->Scale(1.0e19/le10mcPots); TH1D* pMEmcEnuPY = pMEmcEnu->ProjectionY("pMEmcEnuPY",baseFirstBin,baseLastBin); pMEmcEnuPY->Sumw2(); pMEmcEnuPY->Rebin(pMErebin); pMEmcEnuPY->Scale(1.0e19/pMEmcPots); TH1D* pMEmcEnuRwPY = pMEmcEnuRw->ProjectionY("pMEmcEnuRwPY",baseFirstBin,baseLastBin); pMEmcEnuRwPY->Sumw2(); pMEmcEnuRwPY->Rebin(pMErebin); pMEmcEnuRwPY->Scale(1.0e19/pMEmcPots); TH1D* pMEdataEnuPY = pMEdataEnu->ProjectionY("pMEdataEnuPY",baseFirstBin,baseLastBin); pMEdataEnuPY->Sumw2(); pMEdataEnuPY->Rebin(pMErebin); pMEdataEnuPY->Scale(1.0e19/pMEdataPots); TH1D* pMEQEmcEnuRwPY = pMEQEmcEnuRw->ProjectionY("pMEQEmcEnuRwPY",baseFirstBin,baseLastBin); pMEQEmcEnuRwPY->Sumw2(); pMEQEmcEnuRwPY->Rebin(pMErebin); pMEQEmcEnuRwPY->Scale(1.0e19/pMEmcPots); TH1D* pMERESmcEnuRwPY = pMERESmcEnuRw->ProjectionY("pMERESmcEnuRwPY",baseFirstBin,baseLastBin); pMERESmcEnuRwPY->Sumw2(); pMERESmcEnuRwPY->Rebin(pMErebin); pMERESmcEnuRwPY->Scale(1.0e19/pMEmcPots); TH1D* pMEDISmcEnuRwPY = pMEDISmcEnuRw->ProjectionY("pMEDISmcEnuRwPY",baseFirstBin,baseLastBin); pMEDISmcEnuRwPY->Sumw2(); pMEDISmcEnuRwPY->Rebin(pMErebin); pMEDISmcEnuRwPY->Scale(1.0e19/pMEmcPots); TH1D* pMENCmcEnuRwPY = pMENCmcEnuRw->ProjectionY("pMENCmcEnuRwPY",baseFirstBin,baseLastBin); pMENCmcEnuRwPY->Sumw2(); pMENCmcEnuRwPY->Rebin(pMErebin); pMENCmcEnuRwPY->Scale(1.0e19/pMEmcPots); TH1D* pHEmcEnuPY = pHEmcEnu->ProjectionY("pHEmcEnuPY",baseFirstBin,baseLastBin); pHEmcEnuPY->Sumw2(); pHEmcEnuPY->Rebin(pHErebin); pHEmcEnuPY->Scale(1.0e19/pHEmcPots); TH1D* pHEmcEnuRwPY = pHEmcEnuRw->ProjectionY("pHEmcEnuRwPY",baseFirstBin,baseLastBin); pHEmcEnuRwPY->Sumw2(); pHEmcEnuRwPY->Rebin(pHErebin); pHEmcEnuRwPY->Scale(1.0e19/pHEmcPots); TH1D* pHEdataEnuPY = pHEdataEnu->ProjectionY("pHEdataEnuPY",baseFirstBin,baseLastBin); pHEdataEnuPY->Sumw2(); pHEdataEnuPY->Rebin(pHErebin); pHEdataEnuPY->Scale(1.0e19/pHEdataPots); TH1D* pHEQEmcEnuRwPY = pHEQEmcEnuRw->ProjectionY("pHEQEmcEnuRwPY",baseFirstBin,baseLastBin); pHEQEmcEnuRwPY->Sumw2(); pHEQEmcEnuRwPY->Rebin(pHErebin); pHEQEmcEnuRwPY->Scale(1.0e19/pHEmcPots); TH1D* pHERESmcEnuRwPY = pHERESmcEnuRw->ProjectionY("pHERESmcEnuRwPY",baseFirstBin,baseLastBin); pHERESmcEnuRwPY->Sumw2(); pHERESmcEnuRwPY->Rebin(pHErebin); pHERESmcEnuRwPY->Scale(1.0e19/pHEmcPots); TH1D* pHEDISmcEnuRwPY = pHEDISmcEnuRw->ProjectionY("pHEDISmcEnuRwPY",baseFirstBin,baseLastBin); pHEDISmcEnuRwPY->Sumw2(); pHEDISmcEnuRwPY->Rebin(pHErebin); pHEDISmcEnuRwPY->Scale(1.0e19/pHEmcPots); TH1D* pHENCmcEnuRwPY = pHENCmcEnuRw->ProjectionY("pHENCmcEnuRwPY",baseFirstBin,baseLastBin); pHENCmcEnuRwPY->Sumw2(); pHENCmcEnuRwPY->Rebin(pHErebin); pHENCmcEnuRwPY->Scale(1.0e19/pHEmcPots); TCanvas* c1 = new TCanvas("c1","Base Plots"); TLegend* leg1 = new TLegend(0.45,0.45,0.85,0.88); TPad* pad1 = new TPad("pad1","pad1",0.01,0.40,0.33,0.98,0); TPad* pad2 = new TPad("pad2","pad2",0.34,0.40,0.66,0.98,0); TPad* pad3 = new TPad("pad3","pad3",0.67,0.40,0.99,0.98,0); TPad* pad4 = new TPad("pad4","pad4",0.01,0.02,0.33,0.39,0); TPad* pad5 = new TPad("pad5","pad5",0.34,0.02,0.66,0.39,0); TPad* pad6 = new TPad("pad6","pad6",0.67,0.02,0.99,0.39,0); pad1->Draw(); pad2->Draw(); pad3->Draw(); pad4->Draw(); pad5->Draw(); pad6->Draw(); pad1->cd(); Float_t axMax1 = le10mcEnuPY->GetBinContent(le10mcEnuPY->GetMaximumBin()); if((le10mcEnuRwPY->GetBinContent(le10mcEnuRwPY->GetMaximumBin()))>axMax1) axMax1 = le10mcEnuRwPY->GetBinContent(le10mcEnuRwPY->GetMaximumBin()); if((le10dataEnuPY->GetBinContent(le10dataEnuPY->GetMaximumBin()))>axMax1) axMax1 = le10dataEnuPY->GetBinContent(le10dataEnuPY->GetMaximumBin()); le10mcEnuPY->GetYaxis()->SetRangeUser(0.0,axMax1*1.1); le10mcEnuPY->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); le10mcEnuPY->SetTitle("CC-like Events (LE-10 Beam) ; Reconstructed E_{#nu} ; Per 1e19 PoTs"); le10mcEnuPY->SetLineColor(4); le10mcEnuPY->Draw("hist"); le10mcEnuRwPY->SetLineColor(2); le10mcEnuRwPY->Draw("sames && hist && err"); le10dataEnuPY->Draw("sames"); leg1->SetFillColor(0); leg1->AddEntry(le10dataEnuPY,"Data"); leg1->AddEntry(le10mcEnuPY,"Nominal MC"); leg1->AddEntry(le10mcEnuRwPY,"Tuned MC"); le10QEmcEnuRwPY->SetFillStyle(3001); le10QEmcEnuRwPY->SetFillColor(7); le10QEmcEnuRwPY->SetLineColor(7); if(showQEevents) { le10QEmcEnuRwPY->Draw("hist && sames"); leg1->AddEntry(le10QEmcEnuRwPY,"True #nu_{#mu} CC QEL"); } le10RESmcEnuRwPY->SetFillStyle(3002); le10RESmcEnuRwPY->SetFillColor(3); le10RESmcEnuRwPY->SetLineColor(3); if(showRESevents) { le10RESmcEnuRwPY->Draw("hist && sames"); leg1->AddEntry(le10RESmcEnuRwPY,"True #nu_{#mu} CC RES"); } le10DISmcEnuRwPY->SetFillStyle(3003); le10DISmcEnuRwPY->SetFillColor(30); le10DISmcEnuRwPY->SetLineColor(30); if(showDISevents) { le10DISmcEnuRwPY->Draw("hist && sames"); leg1->AddEntry(le10DISmcEnuRwPY,"True #nu_{#mu} CC DIS"); } le10NCmcEnuRwPY->SetFillStyle(3001); le10NCmcEnuRwPY->SetFillColor(6); le10NCmcEnuRwPY->SetLineColor(6); if(showNCevents) { le10NCmcEnuRwPY->Draw("hist && sames"); leg1->AddEntry(le10NCmcEnuRwPY,"True #nu_{#mu} NC"); } leg1->Draw(); pad2->cd(); Float_t axMax2 = pMEmcEnuPY->GetBinContent(pMEmcEnuPY->GetMaximumBin()); if((pMEmcEnuRwPY->GetBinContent(pMEmcEnuRwPY->GetMaximumBin()))>axMax2) axMax2 = pMEmcEnuRwPY->GetBinContent(pMEmcEnuRwPY->GetMaximumBin()); if((pMEdataEnuPY->GetBinContent(pMEdataEnuPY->GetMaximumBin()))>axMax2) axMax2 = pMEdataEnuPY->GetBinContent(pMEdataEnuPY->GetMaximumBin()); pMEmcEnuPY->GetYaxis()->SetRangeUser(0.0,axMax2*1.1); pMEmcEnuPY->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); pMEmcEnuPY->SetTitle("CC-like Events (pME Beam) ; Reconstructed E_{#nu} ; Per 1e19 PoTs"); pMEmcEnuPY->SetLineColor(4); pMEmcEnuPY->Draw("hist"); pMEmcEnuRwPY->SetLineColor(2); pMEmcEnuRwPY->Draw("sames && hist && err"); pMEdataEnuPY->Draw("sames"); pMEQEmcEnuRwPY->SetFillStyle(3001); pMEQEmcEnuRwPY->SetFillColor(7); pMEQEmcEnuRwPY->SetLineColor(7); if(showQEevents) { pMEQEmcEnuRwPY->Draw("hist && sames"); } pMERESmcEnuRwPY->SetFillStyle(3002); pMERESmcEnuRwPY->SetFillColor(3); pMERESmcEnuRwPY->SetLineColor(3); if(showRESevents) { pMERESmcEnuRwPY->Draw("hist && sames"); } pMEDISmcEnuRwPY->SetFillStyle(3003); pMEDISmcEnuRwPY->SetFillColor(30); pMEDISmcEnuRwPY->SetLineColor(30); if(showDISevents) { pMEDISmcEnuRwPY->Draw("hist && sames"); } pMENCmcEnuRwPY->SetFillStyle(3001); pMENCmcEnuRwPY->SetFillColor(6); pMENCmcEnuRwPY->SetLineColor(6); if(showNCevents) { pMENCmcEnuRwPY->Draw("hist && sames"); } pad3->cd(); Float_t axMax3 = pHEmcEnuPY->GetBinContent(pHEmcEnuPY->GetMaximumBin()); if((pHEmcEnuRwPY->GetBinContent(pHEmcEnuRwPY->GetMaximumBin()))>axMax3) axMax3 = pHEmcEnuRwPY->GetBinContent(pHEmcEnuRwPY->GetMaximumBin()); if((pHEdataEnuPY->GetBinContent(pHEdataEnuPY->GetMaximumBin()))>axMax3) axMax3 = pHEdataEnuPY->GetBinContent(pHEdataEnuPY->GetMaximumBin()); pHEmcEnuPY->GetYaxis()->SetRangeUser(0.0,axMax3*1.1); pHEmcEnuPY->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); pHEmcEnuPY->SetTitle("CC-like Events (pHE Beam) ; Reconstructed E_{#nu} ; Per 1e19 PoTs"); pHEmcEnuPY->SetLineColor(4); pHEmcEnuPY->Draw("hist"); pHEmcEnuRwPY->SetLineColor(2); pHEmcEnuRwPY->Draw("sames && hist && err"); pHEdataEnuPY->Draw("sames"); pHEQEmcEnuRwPY->SetFillStyle(3001); pHEQEmcEnuRwPY->SetFillColor(7); pHEQEmcEnuRwPY->SetLineColor(7); if(showQEevents) { pHEQEmcEnuRwPY->Draw("hist && sames"); } pHERESmcEnuRwPY->SetFillStyle(3002); pHERESmcEnuRwPY->SetFillColor(3); pHERESmcEnuRwPY->SetLineColor(3); if(showRESevents) { pHERESmcEnuRwPY->Draw("hist && sames"); } pHEDISmcEnuRwPY->SetFillStyle(3003); pHEDISmcEnuRwPY->SetFillColor(30); pHEDISmcEnuRwPY->SetLineColor(30); if(showDISevents) { pHEDISmcEnuRwPY->Draw("hist && sames"); } pHENCmcEnuRwPY->SetFillStyle(3001); pHENCmcEnuRwPY->SetFillColor(6); pHENCmcEnuRwPY->SetLineColor(6); if(showNCevents) { pHENCmcEnuRwPY->Draw("hist && sames"); } pad4->cd(); TH1D* le10ratio1 = (TH1D*)le10dataEnuPY->Clone(); le10ratio1->SetNameTitle("le10ratio1","le10ratio1"); TH1D* le10ratio1Rw = (TH1D*)le10dataEnuPY->Clone(); le10ratio1Rw->SetNameTitle("le10ratio1Rw","le10ratio1Rw"); le10ratio1->Divide(le10ratio1,le10mcEnuPY,1,1); le10ratio1->SetLineColor(4); le10ratio1->SetTitle(" ; ; Data / MC"); le10ratio1->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); le10ratio1->GetYaxis()->SetRangeUser(ratioAxisLow,ratioAxisHigh); le10ratio1->Draw("hist"); le10ratio1Rw->Divide(le10ratio1Rw,le10mcEnuRwPY,1,1); le10ratio1Rw->SetLineColor(2); le10ratio1Rw->Draw("hist && sames"); TF1* ratLine = new TF1("ratLine","1",-1000,1000); ratLine->SetLineColor(14); ratLine->SetLineStyle(2); ratLine->Draw("sames"); pad5->cd(); TH1D* pMEratio1 = (TH1D*)pMEdataEnuPY->Clone(); pMEratio1->SetNameTitle("pMEratio1","pMEratio1"); TH1D* pMEratio1Rw = (TH1D*)pMEdataEnuPY->Clone(); pMEratio1Rw->SetNameTitle("pMEratio1Rw","pMEratio1Rw"); pMEratio1->Divide(pMEratio1,pMEmcEnuPY,1,1); pMEratio1->SetLineColor(4); pMEratio1->SetTitle(" ; ; Data / MC"); pMEratio1->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); pMEratio1->GetYaxis()->SetRangeUser(ratioAxisLow,ratioAxisHigh); pMEratio1->Draw("hist"); pMEratio1Rw->Divide(pMEratio1Rw,pMEmcEnuRwPY,1,1); pMEratio1Rw->SetLineColor(2); pMEratio1Rw->Draw("hist && sames"); ratLine->Draw("sames"); pad6->cd(); TH1D* pHEratio1 = (TH1D*)pHEdataEnuPY->Clone(); pHEratio1->SetNameTitle("pHEratio1","pHEratio1"); TH1D* pHEratio1Rw = (TH1D*)pHEdataEnuPY->Clone(); pHEratio1Rw->SetNameTitle("pHEratio1Rw","pHEratio1Rw"); pHEratio1->Divide(pHEratio1,pHEmcEnuPY,1,1); pHEratio1->SetLineColor(4); pHEratio1->SetTitle(" ; ; Data / MC"); pHEratio1->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); pHEratio1->GetYaxis()->SetRangeUser(ratioAxisLow,ratioAxisHigh); pHEratio1->Draw("hist"); pHEratio1Rw->Divide(pHEratio1Rw,pHEmcEnuRwPY,1,1); pHEratio1Rw->SetLineColor(2); pHEratio1Rw->Draw("hist && sames"); ratLine->Draw("sames"); c1->Update(); ///////////////////////////////////// ///////////////////////////////////// ///////////////////////////////////// if(cutOnShwEnergy && highEshwCut>0.0){ // Make Ehad Cut Plots Int_t cutFirstBin = le10mcEnu->GetXaxis()->FindBin(lowEshwCut); Int_t cutLastBin = le10mcEnu->GetXaxis()->FindBin(highEshwCut); TH1D* le10mcEnuPY2 = le10mcEnu->ProjectionY("le10mcEnuPY2",cutFirstBin,cutLastBin); le10mcEnuPY2->Sumw2(); le10mcEnuPY2->Rebin(le10rebinAft); le10mcEnuPY2->Scale(1.0e19/le10mcPots); TH1D* le10mcEnuRwPY2 = le10mcEnuRw->ProjectionY("le10mcEnuRwPY2",cutFirstBin,cutLastBin); le10mcEnuRwPY2->Sumw2(); le10mcEnuRwPY2->Rebin(le10rebinAft); le10mcEnuRwPY2->Scale(1.0e19/le10mcPots); TH1D* le10dataEnuPY2 = le10dataEnu->ProjectionY("le10dataEnuPY2",cutFirstBin,cutLastBin); le10dataEnuPY2->Sumw2(); le10dataEnuPY2->Rebin(le10rebinAft); le10dataEnuPY2->Scale(1.0e19/le10dataPots); TH1D* le10QEmcEnuRwPY2 = le10QEmcEnuRw->ProjectionY("le10QEmcEnuRwPY2",cutFirstBin,cutLastBin); le10QEmcEnuRwPY2->Sumw2(); le10QEmcEnuRwPY2->Rebin(le10rebinAft); le10QEmcEnuRwPY2->Scale(1.0e19/le10mcPots); TH1D* le10RESmcEnuRwPY2 = le10RESmcEnuRw->ProjectionY("le10RESmcEnuRwPY2",cutFirstBin,cutLastBin); le10RESmcEnuRwPY2->Sumw2(); le10RESmcEnuRwPY2->Rebin(le10rebinAft); le10RESmcEnuRwPY2->Scale(1.0e19/le10mcPots); TH1D* le10DISmcEnuRwPY2 = le10DISmcEnuRw->ProjectionY("le10DISmcEnuRwPY2",cutFirstBin,cutLastBin); le10DISmcEnuRwPY2->Sumw2(); le10DISmcEnuRwPY2->Rebin(le10rebinAft); le10DISmcEnuRwPY2->Scale(1.0e19/le10mcPots); TH1D* le10NCmcEnuRwPY2 = le10NCmcEnuRw->ProjectionY("le10NCmcEnuRwPY2",cutFirstBin,cutLastBin); le10NCmcEnuRwPY2->Sumw2(); le10NCmcEnuRwPY2->Rebin(le10rebinAft); le10NCmcEnuRwPY2->Scale(1.0e19/le10mcPots); TH1D* pMEmcEnuPY2 = pMEmcEnu->ProjectionY("pMEmcEnuPY2",cutFirstBin,cutLastBin); pMEmcEnuPY2->Sumw2(); pMEmcEnuPY2->Rebin(pMErebinAft); pMEmcEnuPY2->Scale(1.0e19/pMEmcPots); TH1D* pMEmcEnuRwPY2 = pMEmcEnuRw->ProjectionY("pMEmcEnuRwPY2",cutFirstBin,cutLastBin); pMEmcEnuRwPY2->Sumw2(); pMEmcEnuRwPY2->Rebin(pMErebinAft); pMEmcEnuRwPY2->Scale(1.0e19/pMEmcPots); TH1D* pMEdataEnuPY2 = pMEdataEnu->ProjectionY("pMEdataEnuPY2",cutFirstBin,cutLastBin); pMEdataEnuPY2->Sumw2(); pMEdataEnuPY2->Rebin(pMErebinAft); pMEdataEnuPY2->Scale(1.0e19/pMEdataPots); TH1D* pMEQEmcEnuRwPY2 = pMEQEmcEnuRw->ProjectionY("pMEQEmcEnuRwPY2",cutFirstBin,cutLastBin); pMEQEmcEnuRwPY2->Sumw2(); pMEQEmcEnuRwPY2->Rebin(pMErebinAft); pMEQEmcEnuRwPY2->Scale(1.0e19/pMEmcPots); TH1D* pMERESmcEnuRwPY2 = pMERESmcEnuRw->ProjectionY("pMERESmcEnuRwPY2",cutFirstBin,cutLastBin); pMERESmcEnuRwPY2->Sumw2(); pMERESmcEnuRwPY2->Rebin(pMErebinAft); pMERESmcEnuRwPY2->Scale(1.0e19/pMEmcPots); TH1D* pMEDISmcEnuRwPY2 = pMEDISmcEnuRw->ProjectionY("pMEDISmcEnuRwPY2",cutFirstBin,cutLastBin); pMEDISmcEnuRwPY2->Sumw2(); pMEDISmcEnuRwPY2->Rebin(pMErebinAft); pMEDISmcEnuRwPY2->Scale(1.0e19/pMEmcPots); TH1D* pMENCmcEnuRwPY2 = pMENCmcEnuRw->ProjectionY("pMENCmcEnuRwPY2",cutFirstBin,cutLastBin); pMENCmcEnuRwPY2->Sumw2(); pMENCmcEnuRwPY2->Rebin(pMErebinAft); pMENCmcEnuRwPY2->Scale(1.0e19/pMEmcPots); TH1D* pHEmcEnuPY2 = pHEmcEnu->ProjectionY("pHEmcEnuPY2",cutFirstBin,cutLastBin); pHEmcEnuPY2->Sumw2(); pHEmcEnuPY2->Rebin(pHErebinAft); pHEmcEnuPY2->Scale(1.0e19/pHEmcPots); TH1D* pHEmcEnuRwPY2 = pHEmcEnuRw->ProjectionY("pHEmcEnuRwPY2",cutFirstBin,cutLastBin); pHEmcEnuRwPY2->Sumw2(); pHEmcEnuRwPY2->Rebin(pHErebinAft); pHEmcEnuRwPY2->Scale(1.0e19/pHEmcPots); TH1D* pHEdataEnuPY2 = pHEdataEnu->ProjectionY("pHEdataEnuPY2",cutFirstBin,cutLastBin); pHEdataEnuPY2->Sumw2(); pHEdataEnuPY2->Rebin(pHErebinAft); pHEdataEnuPY2->Scale(1.0e19/pHEdataPots); TH1D* pHEQEmcEnuRwPY2 = pHEQEmcEnuRw->ProjectionY("pHEQEmcEnuRwPY2",cutFirstBin,cutLastBin); pHEQEmcEnuRwPY2->Sumw2(); pHEQEmcEnuRwPY2->Rebin(pHErebinAft); pHEQEmcEnuRwPY2->Scale(1.0e19/pHEmcPots); TH1D* pHERESmcEnuRwPY2 = pHERESmcEnuRw->ProjectionY("pHERESmcEnuRwPY2",cutFirstBin,cutLastBin); pHERESmcEnuRwPY2->Sumw2(); pHERESmcEnuRwPY2->Rebin(pHErebinAft); pHERESmcEnuRwPY2->Scale(1.0e19/pHEmcPots); TH1D* pHEDISmcEnuRwPY2 = pHEDISmcEnuRw->ProjectionY("pHEDISmcEnuRwPY2",cutFirstBin,cutLastBin); pHEDISmcEnuRwPY2->Sumw2(); pHEDISmcEnuRwPY2->Rebin(pHErebinAft); pHEDISmcEnuRwPY2->Scale(1.0e19/pHEmcPots); TH1D* pHENCmcEnuRwPY2 = pHENCmcEnuRw->ProjectionY("pHENCmcEnuRwPY2",cutFirstBin,cutLastBin); pHENCmcEnuRwPY2->Sumw2(); pHENCmcEnuRwPY2->Rebin(pHErebinAft); pHENCmcEnuRwPY2->Scale(1.0e19/pHEmcPots); TCanvas* c2 = new TCanvas("c2","Had. Energy Cut Plots"); TLegend* leg2 = new TLegend(0.45,0.45,0.85,0.88); TPad* pad7 = new TPad("pad7","pad7",0.01,0.40,0.33,0.98,0); TPad* pad8 = new TPad("pad8","pad8",0.34,0.40,0.66,0.98,0); TPad* pad9 = new TPad("pad9","pad9",0.67,0.40,0.99,0.98,0); TPad* pad10 = new TPad("pad10","pad10",0.01,0.02,0.33,0.39,0); TPad* pad11 = new TPad("pad11","pad11",0.34,0.02,0.66,0.39,0); TPad* pad12 = new TPad("pad12","pad12",0.67,0.02,0.99,0.39,0); pad7->Draw(); pad8->Draw(); pad9->Draw(); pad10->Draw(); pad11->Draw(); pad12->Draw(); pad7->cd(); Float_t axMax4 = le10mcEnuPY2->GetBinContent(le10mcEnuPY2->GetMaximumBin()); if((le10mcEnuRwPY2->GetBinContent(le10mcEnuRwPY2->GetMaximumBin()))>axMax4) axMax4 = le10mcEnuRwPY2->GetBinContent(le10mcEnuRwPY2->GetMaximumBin()); if((le10dataEnuPY2->GetBinContent(le10dataEnuPY2->GetMaximumBin()))>axMax4) axMax4 = le10dataEnuPY2->GetBinContent(le10dataEnuPY2->GetMaximumBin()); le10mcEnuPY2->GetYaxis()->SetRangeUser(0.0,axMax4*1.1); le10mcEnuPY2->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); le10mcEnuPY2->SetTitle("E_{had} Cut CC-like Events (LE-10 Beam) ; Reconstructed E_{#nu} ; Per 1e19 PoTs"); le10mcEnuPY2->SetLineColor(4); le10mcEnuPY2->Draw("hist"); le10mcEnuRwPY2->SetLineColor(2); le10mcEnuRwPY2->Draw("sames && hist && err"); le10dataEnuPY2->Draw("sames"); leg2->SetFillColor(0); leg2->AddEntry(le10dataEnuPY2,"Data"); leg2->AddEntry(le10mcEnuPY2,"Nominal MC"); leg2->AddEntry(le10mcEnuRwPY2,"Tuned MC"); le10QEmcEnuRwPY2->SetFillStyle(3001); le10QEmcEnuRwPY2->SetFillColor(7); le10QEmcEnuRwPY2->SetLineColor(7); if(showQEevents) { le10QEmcEnuRwPY2->Draw("hist && sames"); leg2->AddEntry(le10QEmcEnuRwPY2,"True #nu_{#mu} CC QEL"); } le10RESmcEnuRwPY2->SetFillStyle(3002); le10RESmcEnuRwPY2->SetFillColor(3); le10RESmcEnuRwPY2->SetLineColor(3); if(showRESevents) { le10RESmcEnuRwPY2->Draw("hist && sames"); leg2->AddEntry(le10RESmcEnuRwPY2,"True #nu_{#mu} CC RES"); } le10DISmcEnuRwPY2->SetFillStyle(3003); le10DISmcEnuRwPY2->SetFillColor(30); le10DISmcEnuRwPY2->SetLineColor(30); if(showDISevents) { le10DISmcEnuRwPY2->Draw("hist && sames"); leg2->AddEntry(le10DISmcEnuRwPY2,"True #nu_{#mu} CC DIS"); } le10NCmcEnuRwPY2->SetFillStyle(3001); le10NCmcEnuRwPY2->SetFillColor(6); le10NCmcEnuRwPY2->SetLineColor(6); if(showNCevents) { le10NCmcEnuRwPY2->Draw("hist && sames"); leg2->AddEntry(le10NCmcEnuRwPY2,"True #nu_{#mu} NC"); } leg2->Draw(); pad8->cd(); Float_t axMax5 = pMEmcEnuPY2->GetBinContent(pMEmcEnuPY2->GetMaximumBin()); if((pMEmcEnuRwPY2->GetBinContent(pMEmcEnuRwPY2->GetMaximumBin()))>axMax5) axMax5 = pMEmcEnuRwPY2->GetBinContent(pMEmcEnuRwPY2->GetMaximumBin()); if((pMEdataEnuPY2->GetBinContent(pMEdataEnuPY2->GetMaximumBin()))>axMax5) axMax5 = pMEdataEnuPY2->GetBinContent(pMEdataEnuPY2->GetMaximumBin()); pMEmcEnuPY2->GetYaxis()->SetRangeUser(0.0,axMax5*1.1); pMEmcEnuPY2->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); pMEmcEnuPY2->SetTitle("E_{had} Cut CC-like Events (pME Beam) ; Reconstructed E_{#nu} ; Per 1e19 PoTs"); pMEmcEnuPY2->SetLineColor(4); pMEmcEnuPY2->Draw("hist"); pMEmcEnuRwPY2->SetLineColor(2); pMEmcEnuRwPY2->Draw("sames && hist && err"); pMEdataEnuPY2->Draw("sames"); pMEQEmcEnuRwPY2->SetFillStyle(3001); pMEQEmcEnuRwPY2->SetFillColor(7); pMEQEmcEnuRwPY2->SetLineColor(7); if(showQEevents) { pMEQEmcEnuRwPY2->Draw("hist && sames"); } pMERESmcEnuRwPY2->SetFillStyle(3002); pMERESmcEnuRwPY2->SetFillColor(3); pMERESmcEnuRwPY2->SetLineColor(3); if(showRESevents) { pMERESmcEnuRwPY2->Draw("hist && sames"); } pMEDISmcEnuRwPY2->SetFillStyle(3003); pMEDISmcEnuRwPY2->SetFillColor(30); pMEDISmcEnuRwPY2->SetLineColor(30); if(showDISevents) { pMEDISmcEnuRwPY2->Draw("hist && sames"); } pMENCmcEnuRwPY2->SetFillStyle(3001); pMENCmcEnuRwPY2->SetFillColor(6); pMENCmcEnuRwPY2->SetLineColor(6); if(showNCevents) { pMENCmcEnuRwPY2->Draw("hist && sames"); } pad9->cd(); Float_t axMax6 = pHEmcEnuPY2->GetBinContent(pHEmcEnuPY2->GetMaximumBin()); if((pHEmcEnuRwPY2->GetBinContent(pHEmcEnuRwPY2->GetMaximumBin()))>axMax6) axMax6 = pHEmcEnuRwPY2->GetBinContent(pHEmcEnuRwPY2->GetMaximumBin()); if((pHEdataEnuPY2->GetBinContent(pHEdataEnuPY2->GetMaximumBin()))>axMax6) axMax6 = pHEdataEnuPY2->GetBinContent(pHEdataEnuPY2->GetMaximumBin()); pHEmcEnuPY2->GetYaxis()->SetRangeUser(0.0,axMax6*1.1); pHEmcEnuPY2->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); pHEmcEnuPY2->SetTitle("E_{had} Cut CC-like Events (pHE Beam) ; Reconstructed E_{#nu} ; Per 1e19 PoTs"); pHEmcEnuPY2->SetLineColor(4); pHEmcEnuPY2->Draw("hist"); pHEmcEnuRwPY2->SetLineColor(2); pHEmcEnuRwPY2->Draw("sames && hist && err"); pHEdataEnuPY2->Draw("sames"); pHEQEmcEnuRwPY2->SetFillStyle(3001); pHEQEmcEnuRwPY2->SetFillColor(7); pHEQEmcEnuRwPY2->SetLineColor(7); if(showQEevents) { pHEQEmcEnuRwPY2->Draw("hist && sames"); } pHERESmcEnuRwPY2->SetFillStyle(3002); pHERESmcEnuRwPY2->SetFillColor(3); pHERESmcEnuRwPY2->SetLineColor(3); if(showRESevents) { pHERESmcEnuRwPY2->Draw("hist && sames"); } pHEDISmcEnuRwPY2->SetFillStyle(3003); pHEDISmcEnuRwPY2->SetFillColor(30); pHEDISmcEnuRwPY2->SetLineColor(30); if(showDISevents) { pHEDISmcEnuRwPY2->Draw("hist && sames"); } pHENCmcEnuRwPY2->SetFillStyle(3001); pHENCmcEnuRwPY2->SetFillColor(6); pHENCmcEnuRwPY2->SetLineColor(6); if(showNCevents) { pHENCmcEnuRwPY2->Draw("hist && sames"); } pad10->cd(); TH1D* le10ratio2 = (TH1D*)le10dataEnuPY2->Clone(); le10ratio2->SetNameTitle("le10ratio2","le10ratio2"); TH1D* le10ratio2Rw = (TH1D*)le10dataEnuPY2->Clone(); le10ratio2Rw->SetNameTitle("le10ratio2Rw","le10ratio2Rw"); le10ratio2->Divide(le10ratio2,le10mcEnuPY2,1,1); le10ratio2->SetLineColor(4); le10ratio2->SetTitle(" ; ; Data / MC"); le10ratio2->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); le10ratio2->GetYaxis()->SetRangeUser(ratioAxisLow,ratioAxisHigh); le10ratio2->Draw("hist"); le10ratio2Rw->Divide(le10ratio2Rw,le10mcEnuRwPY2,1,1); le10ratio2Rw->SetLineColor(2); le10ratio2Rw->Draw("hist && sames"); TF1* ratLine2 = new TF1("ratLine2","1",-1000,1000); ratLine2->SetLineColor(14); ratLine2->SetLineStyle(2); ratLine2->Draw("sames"); pad11->cd(); TH1D* pMEratio2 = (TH1D*)pMEdataEnuPY2->Clone(); pMEratio2->SetNameTitle("pMEratio2","pMEratio2"); TH1D* pMEratio2Rw = (TH1D*)pMEdataEnuPY2->Clone(); pMEratio2Rw->SetNameTitle("pMEratio2Rw","pMEratio2Rw"); pMEratio2->Divide(pMEratio2,pMEmcEnuPY2,1,1); pMEratio2->SetLineColor(4); pMEratio2->SetTitle(" ; ; Data / MC"); pMEratio2->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); pMEratio2->GetYaxis()->SetRangeUser(ratioAxisLow,ratioAxisHigh); pMEratio2->Draw("hist"); pMEratio2Rw->Divide(pMEratio2Rw,pMEmcEnuRwPY2,1,1); pMEratio2Rw->SetLineColor(2); pMEratio2Rw->Draw("hist && sames"); ratLine2->Draw("sames"); pad12->cd(); TH1D* pHEratio2 = (TH1D*)pHEdataEnuPY2->Clone(); pHEratio2->SetNameTitle("pHEratio2","pHEratio2"); TH1D* pHEratio2Rw = (TH1D*)pHEdataEnuPY2->Clone(); pHEratio2Rw->SetNameTitle("pHEratio2Rw","pHEratio2Rw"); pHEratio2->Divide(pHEratio2,pHEmcEnuPY2,1,1); pHEratio2->SetLineColor(4); pHEratio2->SetTitle(" ; ; Data / MC"); pHEratio2->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); pHEratio2->GetYaxis()->SetRangeUser(ratioAxisLow,ratioAxisHigh); pHEratio2->Draw("hist"); pHEratio2Rw->Divide(pHEratio2Rw,pHEmcEnuRwPY2,1,1); pHEratio2Rw->SetLineColor(2); pHEratio2Rw->Draw("hist && sames"); ratLine2->Draw("sames"); c2->Update(); } if(cutOnShwEnergy && highEshwCut==0.0 && lowEshwCut==0){ // Read in histograms // LE-10 le10mcFile->cd(); TH1F* le10mcEnuAft; if(selectKinSample==0) le10mcEnuAft = (TH1F*)le10mcFile->Get("enuAft[0]"); if(selectKinSample==1) le10mcEnuAft = (TH1F*)le10mcFile->Get("enuAft[1]"); if(selectKinSample==2) le10mcEnuAft = (TH1F*)le10mcFile->Get("enuAft[2]"); if(selectKinSample==3) le10mcEnuAft = (TH1F*)le10mcFile->Get("enuAft[3]"); if(selectKinSample==4) le10mcEnuAft = (TH1F*)le10mcFile->Get("enuAft[4]"); TH1F* le10mcEnuAftRw; if(selectKinSample==0) le10mcEnuAftRw = (TH1F*)le10mcFile->Get("enuAftRw[0]"); if(selectKinSample==1) le10mcEnuAftRw = (TH1F*)le10mcFile->Get("enuAftRw[1]"); if(selectKinSample==2) le10mcEnuAftRw = (TH1F*)le10mcFile->Get("enuAftRw[2]"); if(selectKinSample==3) le10mcEnuAftRw = (TH1F*)le10mcFile->Get("enuAftRw[3]"); if(selectKinSample==4) le10mcEnuAftRw = (TH1F*)le10mcFile->Get("enuAftRw[4]"); le10mcEnuAft->Sumw2(); le10mcEnuAft->Rebin(le10rebinAft); le10mcEnuAft->Scale(1.0e19/le10mcPots); le10mcEnuAftRw->Sumw2(); le10mcEnuAftRw->Rebin(le10rebinAft); le10mcEnuAftRw->Scale(1.0e19/le10mcPots); le10QEmcFile->cd(); TH1F* le10QEmcEnuAftRw; if(selectKinSample==0) le10QEmcEnuAftRw = (TH1F*)le10QEmcFile->Get("enuAftRw[0]"); if(selectKinSample==1) le10QEmcEnuAftRw = (TH1F*)le10QEmcFile->Get("enuAftRw[1]"); if(selectKinSample==2) le10QEmcEnuAftRw = (TH1F*)le10QEmcFile->Get("enuAftRw[2]"); if(selectKinSample==3) le10QEmcEnuAftRw = (TH1F*)le10QEmcFile->Get("enuAftRw[3]"); if(selectKinSample==4) le10QEmcEnuAftRw = (TH1F*)le10QEmcFile->Get("enuAftRw[4]"); le10QEmcEnuAftRw->Sumw2(); le10QEmcEnuAftRw->Rebin(le10rebinAft); le10QEmcEnuAftRw->Scale(1.0e19/le10mcPots); le10RESmcFile->cd(); TH1F* le10RESmcEnuAftRw; if(selectKinSample==0) le10RESmcEnuAftRw = (TH1F*)le10RESmcFile->Get("enuAftRw[0]"); if(selectKinSample==1) le10RESmcEnuAftRw = (TH1F*)le10RESmcFile->Get("enuAftRw[1]"); if(selectKinSample==2) le10RESmcEnuAftRw = (TH1F*)le10RESmcFile->Get("enuAftRw[2]"); if(selectKinSample==3) le10RESmcEnuAftRw = (TH1F*)le10RESmcFile->Get("enuAftRw[3]"); if(selectKinSample==4) le10RESmcEnuAftRw = (TH1F*)le10RESmcFile->Get("enuAftRw[4]"); le10RESmcEnuAftRw->Sumw2(); le10RESmcEnuAftRw->Rebin(le10rebinAft); le10RESmcEnuAftRw->Scale(1.0e19/le10mcPots); le10DISmcFile->cd(); TH1F* le10DISmcEnuAftRw; if(selectKinSample==0) le10DISmcEnuAftRw = (TH1F*)le10DISmcFile->Get("enuAftRw[0]"); if(selectKinSample==1) le10DISmcEnuAftRw = (TH1F*)le10DISmcFile->Get("enuAftRw[1]"); if(selectKinSample==2) le10DISmcEnuAftRw = (TH1F*)le10DISmcFile->Get("enuAftRw[2]"); if(selectKinSample==3) le10DISmcEnuAftRw = (TH1F*)le10DISmcFile->Get("enuAftRw[3]"); if(selectKinSample==4) le10DISmcEnuAftRw = (TH1F*)le10DISmcFile->Get("enuAftRw[4]"); le10DISmcEnuAftRw->Sumw2(); le10DISmcEnuAftRw->Rebin(le10rebinAft); le10DISmcEnuAftRw->Scale(1.0e19/le10mcPots); le10NCmcFile->cd(); TH1F* le10NCmcEnuAftRw; if(selectKinSample==0) le10NCmcEnuAftRw = (TH1F*)le10NCmcFile->Get("enuAftRw[0]"); if(selectKinSample==1) le10NCmcEnuAftRw = (TH1F*)le10NCmcFile->Get("enuAftRw[1]"); if(selectKinSample==2) le10NCmcEnuAftRw = (TH1F*)le10NCmcFile->Get("enuAftRw[2]"); if(selectKinSample==3) le10NCmcEnuAftRw = (TH1F*)le10NCmcFile->Get("enuAftRw[3]"); if(selectKinSample==4) le10NCmcEnuAftRw = (TH1F*)le10NCmcFile->Get("enuAftRw[4]"); le10NCmcEnuAftRw->Sumw2(); le10NCmcEnuAftRw->Rebin(le10rebinAft); le10NCmcEnuAftRw->Scale(1.0e19/le10mcPots); le10dataFile->cd(); TH1F* le10dataEnuAft; if(selectKinSample==0) le10dataEnuAft = (TH1F*)le10dataFile->Get("enuAft[0]"); if(selectKinSample==1) le10dataEnuAft = (TH1F*)le10dataFile->Get("enuAft[1]"); if(selectKinSample==2) le10dataEnuAft = (TH1F*)le10dataFile->Get("enuAft[2]"); if(selectKinSample==3) le10dataEnuAft = (TH1F*)le10dataFile->Get("enuAft[3]"); if(selectKinSample==4) le10dataEnuAft = (TH1F*)le10dataFile->Get("enuAft[4]"); le10dataEnuAft->Sumw2(); le10dataEnuAft->Rebin(le10rebinAft); le10dataEnuAft->Scale(1.0e19/le10dataPots); // pME pMEmcFile->cd(); TH1F* pMEmcEnuAft; if(selectKinSample==0) pMEmcEnuAft = (TH1F*)pMEmcFile->Get("enuAft[0]"); if(selectKinSample==1) pMEmcEnuAft = (TH1F*)pMEmcFile->Get("enuAft[1]"); if(selectKinSample==2) pMEmcEnuAft = (TH1F*)pMEmcFile->Get("enuAft[2]"); if(selectKinSample==3) pMEmcEnuAft = (TH1F*)pMEmcFile->Get("enuAft[3]"); if(selectKinSample==4) pMEmcEnuAft = (TH1F*)pMEmcFile->Get("enuAft[4]"); TH1F* pMEmcEnuAftRw; if(selectKinSample==0) pMEmcEnuAftRw = (TH1F*)pMEmcFile->Get("enuAftRw[0]"); if(selectKinSample==1) pMEmcEnuAftRw = (TH1F*)pMEmcFile->Get("enuAftRw[1]"); if(selectKinSample==2) pMEmcEnuAftRw = (TH1F*)pMEmcFile->Get("enuAftRw[2]"); if(selectKinSample==3) pMEmcEnuAftRw = (TH1F*)pMEmcFile->Get("enuAftRw[3]"); if(selectKinSample==4) pMEmcEnuAftRw = (TH1F*)pMEmcFile->Get("enuAftRw[4]"); pMEmcEnuAft->Sumw2(); pMEmcEnuAft->Rebin(pMErebinAft); pMEmcEnuAft->Scale(1.0e19/pMEmcPots); pMEmcEnuAftRw->Sumw2(); pMEmcEnuAftRw->Rebin(pMErebinAft); pMEmcEnuAftRw->Scale(1.0e19/pMEmcPots); pMEQEmcFile->cd(); TH1F* pMEQEmcEnuAftRw; if(selectKinSample==0) pMEQEmcEnuAftRw = (TH1F*)pMEQEmcFile->Get("enuAftRw[0]"); if(selectKinSample==1) pMEQEmcEnuAftRw = (TH1F*)pMEQEmcFile->Get("enuAftRw[1]"); if(selectKinSample==2) pMEQEmcEnuAftRw = (TH1F*)pMEQEmcFile->Get("enuAftRw[2]"); if(selectKinSample==3) pMEQEmcEnuAftRw = (TH1F*)pMEQEmcFile->Get("enuAftRw[3]"); if(selectKinSample==4) pMEQEmcEnuAftRw = (TH1F*)pMEQEmcFile->Get("enuAftRw[4]"); pMEQEmcEnuAftRw->Sumw2(); pMEQEmcEnuAftRw->Rebin(pMErebinAft); pMEQEmcEnuAftRw->Scale(1.0e19/pMEmcPots); pMERESmcFile->cd(); TH1F* pMERESmcEnuAftRw; if(selectKinSample==0) pMERESmcEnuAftRw = (TH1F*)pMERESmcFile->Get("enuAftRw[0]"); if(selectKinSample==1) pMERESmcEnuAftRw = (TH1F*)pMERESmcFile->Get("enuAftRw[1]"); if(selectKinSample==2) pMERESmcEnuAftRw = (TH1F*)pMERESmcFile->Get("enuAftRw[2]"); if(selectKinSample==3) pMERESmcEnuAftRw = (TH1F*)pMERESmcFile->Get("enuAftRw[3]"); if(selectKinSample==4) pMERESmcEnuAftRw = (TH1F*)pMERESmcFile->Get("enuAftRw[4]"); pMERESmcEnuAftRw->Sumw2(); pMERESmcEnuAftRw->Rebin(pMErebinAft); pMERESmcEnuAftRw->Scale(1.0e19/pMEmcPots); pMEDISmcFile->cd(); TH1F* pMEDISmcEnuAftRw; if(selectKinSample==0) pMEDISmcEnuAftRw = (TH1F*)pMEDISmcFile->Get("enuAftRw[0]"); if(selectKinSample==1) pMEDISmcEnuAftRw = (TH1F*)pMEDISmcFile->Get("enuAftRw[1]"); if(selectKinSample==2) pMEDISmcEnuAftRw = (TH1F*)pMEDISmcFile->Get("enuAftRw[2]"); if(selectKinSample==3) pMEDISmcEnuAftRw = (TH1F*)pMEDISmcFile->Get("enuAftRw[3]"); if(selectKinSample==4) pMEDISmcEnuAftRw = (TH1F*)pMEDISmcFile->Get("enuAftRw[4]"); pMEDISmcEnuAftRw->Sumw2(); pMEDISmcEnuAftRw->Rebin(pMErebinAft); pMEDISmcEnuAftRw->Scale(1.0e19/pMEmcPots); pMENCmcFile->cd(); TH1F* pMENCmcEnuAftRw; if(selectKinSample==0) pMENCmcEnuAftRw = (TH1F*)pMENCmcFile->Get("enuAftRw[0]"); if(selectKinSample==1) pMENCmcEnuAftRw = (TH1F*)pMENCmcFile->Get("enuAftRw[1]"); if(selectKinSample==2) pMENCmcEnuAftRw = (TH1F*)pMENCmcFile->Get("enuAftRw[2]"); if(selectKinSample==3) pMENCmcEnuAftRw = (TH1F*)pMENCmcFile->Get("enuAftRw[3]"); if(selectKinSample==4) pMENCmcEnuAftRw = (TH1F*)pMENCmcFile->Get("enuAftRw[4]"); pMENCmcEnuAftRw->Sumw2(); pMENCmcEnuAftRw->Rebin(pMErebinAft); pMENCmcEnuAftRw->Scale(1.0e19/pMEmcPots); pMEdataFile->cd(); TH1F* pMEdataEnuAft; if(selectKinSample==0) pMEdataEnuAft = (TH1F*)pMEdataFile->Get("enuAft[0]"); if(selectKinSample==1) pMEdataEnuAft = (TH1F*)pMEdataFile->Get("enuAft[1]"); if(selectKinSample==2) pMEdataEnuAft = (TH1F*)pMEdataFile->Get("enuAft[2]"); if(selectKinSample==3) pMEdataEnuAft = (TH1F*)pMEdataFile->Get("enuAft[3]"); if(selectKinSample==4) pMEdataEnuAft = (TH1F*)pMEdataFile->Get("enuAft[4]"); pMEdataEnuAft->Sumw2(); pMEdataEnuAft->Rebin(pMErebinAft); pMEdataEnuAft->Scale(1.0e19/pMEdataPots); // pHE pHEmcFile->cd(); TH1F* pHEmcEnuAft; if(selectKinSample==0) pHEmcEnuAft = (TH1F*)pHEmcFile->Get("enuAft[0]"); if(selectKinSample==1) pHEmcEnuAft = (TH1F*)pHEmcFile->Get("enuAft[1]"); if(selectKinSample==2) pHEmcEnuAft = (TH1F*)pHEmcFile->Get("enuAft[2]"); if(selectKinSample==3) pHEmcEnuAft = (TH1F*)pHEmcFile->Get("enuAft[3]"); if(selectKinSample==4) pHEmcEnuAft = (TH1F*)pHEmcFile->Get("enuAft[4]"); TH1F* pHEmcEnuAftRw; if(selectKinSample==0) pHEmcEnuAftRw = (TH1F*)pHEmcFile->Get("enuAftRw[0]"); if(selectKinSample==1) pHEmcEnuAftRw = (TH1F*)pHEmcFile->Get("enuAftRw[1]"); if(selectKinSample==2) pHEmcEnuAftRw = (TH1F*)pHEmcFile->Get("enuAftRw[2]"); if(selectKinSample==3) pHEmcEnuAftRw = (TH1F*)pHEmcFile->Get("enuAftRw[3]"); if(selectKinSample==4) pHEmcEnuAftRw = (TH1F*)pHEmcFile->Get("enuAftRw[4]"); pHEmcEnuAft->Sumw2(); pHEmcEnuAft->Rebin(pHErebinAft); pHEmcEnuAft->Scale(1.0e19/pHEmcPots); pHEmcEnuAftRw->Sumw2(); pHEmcEnuAftRw->Rebin(pHErebinAft); pHEmcEnuAftRw->Scale(1.0e19/pHEmcPots); pHEQEmcFile->cd(); TH1F* pHEQEmcEnuAftRw; if(selectKinSample==0) pHEQEmcEnuAftRw = (TH1F*)pHEQEmcFile->Get("enuAftRw[0]"); if(selectKinSample==1) pHEQEmcEnuAftRw = (TH1F*)pHEQEmcFile->Get("enuAftRw[1]"); if(selectKinSample==2) pHEQEmcEnuAftRw = (TH1F*)pHEQEmcFile->Get("enuAftRw[2]"); if(selectKinSample==3) pHEQEmcEnuAftRw = (TH1F*)pHEQEmcFile->Get("enuAftRw[3]"); if(selectKinSample==4) pHEQEmcEnuAftRw = (TH1F*)pHEQEmcFile->Get("enuAftRw[4]"); pHEQEmcEnuAftRw->Sumw2(); pHEQEmcEnuAftRw->Rebin(pHErebinAft); pHEQEmcEnuAftRw->Scale(1.0e19/pHEmcPots); pHERESmcFile->cd(); TH1F* pHERESmcEnuAftRw; if(selectKinSample==0) pHERESmcEnuAftRw = (TH1F*)pHERESmcFile->Get("enuAftRw[0]"); if(selectKinSample==1) pHERESmcEnuAftRw = (TH1F*)pHERESmcFile->Get("enuAftRw[1]"); if(selectKinSample==2) pHERESmcEnuAftRw = (TH1F*)pHERESmcFile->Get("enuAftRw[2]"); if(selectKinSample==3) pHERESmcEnuAftRw = (TH1F*)pHERESmcFile->Get("enuAftRw[3]"); if(selectKinSample==4) pHERESmcEnuAftRw = (TH1F*)pHERESmcFile->Get("enuAftRw[4]"); pHERESmcEnuAftRw->Sumw2(); pHERESmcEnuAftRw->Rebin(pHErebinAft); pHERESmcEnuAftRw->Scale(1.0e19/pHEmcPots); pHEDISmcFile->cd(); TH1F* pHEDISmcEnuAftRw; if(selectKinSample==0) pHEDISmcEnuAftRw = (TH1F*)pHEDISmcFile->Get("enuAftRw[0]"); if(selectKinSample==1) pHEDISmcEnuAftRw = (TH1F*)pHEDISmcFile->Get("enuAftRw[1]"); if(selectKinSample==2) pHEDISmcEnuAftRw = (TH1F*)pHEDISmcFile->Get("enuAftRw[2]"); if(selectKinSample==3) pHEDISmcEnuAftRw = (TH1F*)pHEDISmcFile->Get("enuAftRw[3]"); if(selectKinSample==4) pHEDISmcEnuAftRw = (TH1F*)pHEDISmcFile->Get("enuAftRw[4]"); pHEDISmcEnuAftRw->Sumw2(); pHEDISmcEnuAftRw->Rebin(pHErebinAft); pHEDISmcEnuAftRw->Scale(1.0e19/pHEmcPots); pHENCmcFile->cd(); TH1F* pHENCmcEnuAftRw; if(selectKinSample==0) pHENCmcEnuAftRw = (TH1F*)pHENCmcFile->Get("enuAftRw[0]"); if(selectKinSample==1) pHENCmcEnuAftRw = (TH1F*)pHENCmcFile->Get("enuAftRw[1]"); if(selectKinSample==2) pHENCmcEnuAftRw = (TH1F*)pHENCmcFile->Get("enuAftRw[2]"); if(selectKinSample==3) pHENCmcEnuAftRw = (TH1F*)pHENCmcFile->Get("enuAftRw[3]"); if(selectKinSample==4) pHENCmcEnuAftRw = (TH1F*)pHENCmcFile->Get("enuAftRw[4]"); pHENCmcEnuAftRw->Sumw2(); pHENCmcEnuAftRw->Rebin(pHErebinAft); pHENCmcEnuAftRw->Scale(1.0e19/pHEmcPots); pHEdataFile->cd(); TH1F* pHEdataEnuAft; if(selectKinSample==0) pHEdataEnuAft = (TH1F*)pHEdataFile->Get("enuAft[0]"); if(selectKinSample==1) pHEdataEnuAft = (TH1F*)pHEdataFile->Get("enuAft[1]"); if(selectKinSample==2) pHEdataEnuAft = (TH1F*)pHEdataFile->Get("enuAft[2]"); if(selectKinSample==3) pHEdataEnuAft = (TH1F*)pHEdataFile->Get("enuAft[3]"); if(selectKinSample==4) pHEdataEnuAft = (TH1F*)pHEdataFile->Get("enuAft[4]"); pHEdataEnuAft->Sumw2(); pHEdataEnuAft->Rebin(pHErebinAft); pHEdataEnuAft->Scale(1.0e19/pHEdataPots); TCanvas* c3 = new TCanvas("c3","E_{had}=0 Plots"); TLegend* leg3 = new TLegend(0.45,0.45,0.85,0.88); TPad* pad13 = new TPad("pad13","pad13",0.01,0.40,0.33,0.98,0); TPad* pad14 = new TPad("pad14","pad14",0.34,0.40,0.66,0.98,0); TPad* pad15 = new TPad("pad15","pad15",0.67,0.40,0.99,0.98,0); TPad* pad16 = new TPad("pad16","pad16",0.01,0.02,0.33,0.39,0); TPad* pad17 = new TPad("pad17","pad17",0.34,0.02,0.66,0.39,0); TPad* pad18 = new TPad("pad18","pad18",0.67,0.02,0.99,0.39,0); pad13->Draw(); pad14->Draw(); pad15->Draw(); pad16->Draw(); pad17->Draw(); pad18->Draw(); pad13->cd(); Float_t axMax7 = le10mcEnuAft->GetBinContent(le10mcEnuAft->GetMaximumBin()); if((le10mcEnuAftRw->GetBinContent(le10mcEnuAftRw->GetMaximumBin()))>axMax7) axMax7 = le10mcEnuAftRw->GetBinContent(le10mcEnuAftRw->GetMaximumBin()); if((le10dataEnuAft->GetBinContent(le10dataEnuAft->GetMaximumBin()))>axMax7) axMax7 = le10dataEnuAft->GetBinContent(le10dataEnuAft->GetMaximumBin()); le10mcEnuAft->GetYaxis()->SetRangeUser(0.0,axMax7*1.1); le10mcEnuAft->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); le10mcEnuAft->SetTitle("E_{had}=0 CC-like Events (LE-10 Beam) ; Reconstructed E_{#nu} ; Per 1e19 PoTs"); le10mcEnuAft->SetLineColor(4); le10mcEnuAft->Draw("hist"); le10mcEnuAftRw->SetLineColor(2); le10mcEnuAftRw->Draw("sames && hist && err"); le10dataEnuAft->Draw("sames"); leg3->SetFillColor(0); leg3->AddEntry(le10dataEnuAft,"Data"); leg3->AddEntry(le10mcEnuAft,"Nominal MC"); leg3->AddEntry(le10mcEnuAftRw,"Tuned MC"); le10QEmcEnuAftRw->SetFillStyle(3001); le10QEmcEnuAftRw->SetFillColor(7); le10QEmcEnuAftRw->SetLineColor(7); if(showQEevents) { le10QEmcEnuAftRw->Draw("hist && sames"); leg3->AddEntry(le10QEmcEnuAftRw,"True #nu_{#mu} CC QEL"); } le10RESmcEnuAftRw->SetFillStyle(3002); le10RESmcEnuAftRw->SetFillColor(3); le10RESmcEnuAftRw->SetLineColor(3); if(showRESevents) { le10RESmcEnuAftRw->Draw("hist && sames"); leg3->AddEntry(le10RESmcEnuAftRw,"True #nu_{#mu} CC RES"); } le10DISmcEnuAftRw->SetFillStyle(3003); le10DISmcEnuAftRw->SetFillColor(30); le10DISmcEnuAftRw->SetLineColor(30); if(showDISevents) { le10DISmcEnuAftRw->Draw("hist && sames"); leg3->AddEntry(le10DISmcEnuAftRw,"True #nu_{#mu} CC DIS"); } le10NCmcEnuAftRw->SetFillStyle(3001); le10NCmcEnuAftRw->SetFillColor(6); le10NCmcEnuAftRw->SetLineColor(6); if(showNCevents) { le10NCmcEnuAftRw->Draw("hist && sames"); leg3->AddEntry(le10NCmcEnuAftRw,"True #nu_{#mu} NC"); } leg3->Draw(); pad14->cd(); Float_t axMax8 = pMEmcEnuAft->GetBinContent(pMEmcEnuAft->GetMaximumBin()); if((pMEmcEnuAftRw->GetBinContent(pMEmcEnuAftRw->GetMaximumBin()))>axMax8) axMax8 = pMEmcEnuAftRw->GetBinContent(pMEmcEnuAftRw->GetMaximumBin()); if((pMEdataEnuAft->GetBinContent(pMEdataEnuAft->GetMaximumBin()))>axMax8) axMax8 = pMEdataEnuAft->GetBinContent(pMEdataEnuAft->GetMaximumBin()); pMEmcEnuAft->GetYaxis()->SetRangeUser(0.0,axMax8*1.1); pMEmcEnuAft->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); pMEmcEnuAft->SetTitle("E_{had}=0 CC-like Events (pME Beam) ; Reconstructed E_{#nu} ; Per 1e19 PoTs"); pMEmcEnuAft->SetLineColor(4); pMEmcEnuAft->Draw("hist"); pMEmcEnuAftRw->SetLineColor(2); pMEmcEnuAftRw->Draw("sames && hist && err"); pMEdataEnuAft->Draw("sames"); pMEQEmcEnuAftRw->SetFillStyle(3001); pMEQEmcEnuAftRw->SetFillColor(7); pMEQEmcEnuAftRw->SetLineColor(7); if(showQEevents) { pMEQEmcEnuAftRw->Draw("hist && sames"); } pMERESmcEnuAftRw->SetFillStyle(3002); pMERESmcEnuAftRw->SetFillColor(3); pMERESmcEnuAftRw->SetLineColor(3); if(showRESevents) { pMERESmcEnuAftRw->Draw("hist && sames"); } pMEDISmcEnuAftRw->SetFillStyle(3003); pMEDISmcEnuAftRw->SetFillColor(30); pMEDISmcEnuAftRw->SetLineColor(30); if(showDISevents) { pMEDISmcEnuAftRw->Draw("hist && sames"); } pMENCmcEnuAftRw->SetFillStyle(3001); pMENCmcEnuAftRw->SetFillColor(6); pMENCmcEnuAftRw->SetLineColor(6); if(showNCevents) { pMENCmcEnuAftRw->Draw("hist && sames"); } pad15->cd(); Float_t axMax9 = pHEmcEnuAft->GetBinContent(pHEmcEnuAft->GetMaximumBin()); if((pHEmcEnuAftRw->GetBinContent(pHEmcEnuAftRw->GetMaximumBin()))>axMax9) axMax9 = pHEmcEnuAftRw->GetBinContent(pHEmcEnuAftRw->GetMaximumBin()); if((pHEdataEnuAft->GetBinContent(pHEdataEnuAft->GetMaximumBin()))>axMax9) axMax9 = pHEdataEnuAft->GetBinContent(pHEdataEnuAft->GetMaximumBin()); pHEmcEnuAft->GetYaxis()->SetRangeUser(0.0,axMax9*1.1); pHEmcEnuAft->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); pHEmcEnuAft->SetTitle("E_{had}=0 CC-like Events (pHE Beam) ; Reconstructed E_{#nu} ; Per 1e19 PoTs"); pHEmcEnuAft->SetLineColor(4); pHEmcEnuAft->Draw("hist"); pHEmcEnuAftRw->SetLineColor(2); pHEmcEnuAftRw->Draw("sames && hist && err"); pHEdataEnuAft->Draw("sames"); pHEQEmcEnuAftRw->SetFillStyle(3001); pHEQEmcEnuAftRw->SetFillColor(7); pHEQEmcEnuAftRw->SetLineColor(7); if(showQEevents) { pHEQEmcEnuAftRw->Draw("hist && sames"); } pHERESmcEnuAftRw->SetFillStyle(3002); pHERESmcEnuAftRw->SetFillColor(3); pHERESmcEnuAftRw->SetLineColor(3); if(showRESevents) { pHERESmcEnuAftRw->Draw("hist && sames"); } pHEDISmcEnuAftRw->SetFillStyle(3003); pHEDISmcEnuAftRw->SetFillColor(30); pHEDISmcEnuAftRw->SetLineColor(30); if(showDISevents) { pHEDISmcEnuAftRw->Draw("hist && sames"); } pHENCmcEnuAftRw->SetFillStyle(3001); pHENCmcEnuAftRw->SetFillColor(6); pHENCmcEnuAftRw->SetLineColor(6); if(showNCevents) { pHENCmcEnuAftRw->Draw("hist && sames"); } pad16->cd(); TH1D* le10ratio3 = (TH1D*)le10dataEnuAft->Clone(); le10ratio3->SetNameTitle("le10ratio3","le10ratio3"); TH1D* le10ratio3Rw = (TH1D*)le10dataEnuAft->Clone(); le10ratio3Rw->SetNameTitle("le10ratio3Rw","le10ratio3Rw"); le10ratio3->Divide(le10ratio3,le10mcEnuAft,1,1); le10ratio3->SetLineColor(4); le10ratio3->SetTitle(" ; ; Data / MC"); le10ratio3->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); le10ratio3->GetYaxis()->SetRangeUser(ratioAxisLow,ratioAxisHigh); le10ratio3->Draw("hist"); le10ratio3Rw->Divide(le10ratio3Rw,le10mcEnuAftRw,1,1); le10ratio3Rw->SetLineColor(2); le10ratio3Rw->Draw("hist && sames"); TF1* ratLine3 = new TF1("ratLine3","1",-1000,1000); ratLine3->SetLineColor(14); ratLine3->SetLineStyle(2); ratLine3->Draw("sames"); pad17->cd(); TH1D* pMEratio3 = (TH1D*)pMEdataEnuAft->Clone(); pMEratio3->SetNameTitle("pMEratio3","pMEratio3"); TH1D* pMEratio3Rw = (TH1D*)pMEdataEnuAft->Clone(); pMEratio3Rw->SetNameTitle("pMEratio3Rw","pMEratio3Rw"); pMEratio3->Divide(pMEratio3,pMEmcEnuAft,1,1); pMEratio3->SetLineColor(4); pMEratio3->SetTitle(" ; ; Data / MC"); pMEratio3->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); pMEratio3->GetYaxis()->SetRangeUser(ratioAxisLow,ratioAxisHigh); pMEratio3->Draw("hist"); pMEratio3Rw->Divide(pMEratio3Rw,pMEmcEnuAftRw,1,1); pMEratio3Rw->SetLineColor(2); pMEratio3Rw->Draw("hist && sames"); ratLine3->Draw("sames"); pad18->cd(); TH1D* pHEratio3 = (TH1D*)pHEdataEnuAft->Clone(); pHEratio3->SetNameTitle("pHEratio3","pHEratio3"); TH1D* pHEratio3Rw = (TH1D*)pHEdataEnuAft->Clone(); pHEratio3Rw->SetNameTitle("pHEratio3Rw","pHEratio3Rw"); pHEratio3->Divide(pHEratio3,pHEmcEnuAft,1,1); pHEratio3->SetLineColor(4); pHEratio3->SetTitle(" ; ; Data / MC"); pHEratio3->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); pHEratio3->GetYaxis()->SetRangeUser(ratioAxisLow,ratioAxisHigh); pHEratio3->Draw("hist"); pHEratio3Rw->Divide(pHEratio3Rw,pHEmcEnuAftRw,1,1); pHEratio3Rw->SetLineColor(2); pHEratio3Rw->Draw("hist && sames"); ratLine3->Draw("sames"); c3->Update(); } if(showSlidingCut){ TFile* le10mcFile2 = new TFile("ana_LE-10mc_12parFit_wCCpid_ehad0.root","READ"); le10mcFile2->cd(); TH1F* le10mcEnuAft2; if(selectKinSample==0) le10mcEnuAft2 = (TH1F*)le10mcFile2->Get("enuAft[0]"); if(selectKinSample==1) le10mcEnuAft2 = (TH1F*)le10mcFile2->Get("enuAft[1]"); if(selectKinSample==2) le10mcEnuAft2 = (TH1F*)le10mcFile2->Get("enuAft[2]"); if(selectKinSample==3) le10mcEnuAft2 = (TH1F*)le10mcFile2->Get("enuAft[3]"); if(selectKinSample==4) le10mcEnuAft2 = (TH1F*)le10mcFile2->Get("enuAft[4]"); TH1F* le10mcEnuAft2Rw; if(selectKinSample==0) le10mcEnuAft2Rw = (TH1F*)le10mcFile2->Get("enuAftRw[0]"); if(selectKinSample==1) le10mcEnuAft2Rw = (TH1F*)le10mcFile2->Get("enuAftRw[1]"); if(selectKinSample==2) le10mcEnuAft2Rw = (TH1F*)le10mcFile2->Get("enuAftRw[2]"); if(selectKinSample==3) le10mcEnuAft2Rw = (TH1F*)le10mcFile2->Get("enuAftRw[3]"); if(selectKinSample==4) le10mcEnuAft2Rw = (TH1F*)le10mcFile2->Get("enuAftRw[4]"); le10mcEnuAft2->Sumw2(); le10mcEnuAft2->Rebin(le10rebinAft); le10mcEnuAft2->Scale(1.0e19/le10mcPots); le10mcEnuAft2Rw->Sumw2(); le10mcEnuAft2Rw->Rebin(le10rebinAft); le10mcEnuAft2Rw->Scale(1.0e19/le10mcPots); TFile* le10QEmcFile2 = new TFile("ana_LE-10mc_12parFit_wCCpid_ehad0_justQE.root","READ"); le10QEmcFile2->cd(); TH1F* le10QEmcEnuAft2Rw; if(selectKinSample==0) le10QEmcEnuAft2Rw = (TH1F*)le10QEmcFile2->Get("enuAftRw[0]"); if(selectKinSample==1) le10QEmcEnuAft2Rw = (TH1F*)le10QEmcFile2->Get("enuAftRw[1]"); if(selectKinSample==2) le10QEmcEnuAft2Rw = (TH1F*)le10QEmcFile2->Get("enuAftRw[2]"); if(selectKinSample==3) le10QEmcEnuAft2Rw = (TH1F*)le10QEmcFile2->Get("enuAftRw[3]"); if(selectKinSample==4) le10QEmcEnuAft2Rw = (TH1F*)le10QEmcFile2->Get("enuAftRw[4]"); le10QEmcEnuAft2Rw->Sumw2(); le10QEmcEnuAft2Rw->Rebin(le10rebinAft); le10QEmcEnuAft2Rw->Scale(1.0e19/le10mcPots); TFile* le10RESmcFile2 = new TFile("ana_LE-10mc_12parFit_wCCpid_ehad0_justRES.root","READ"); le10RESmcFile2->cd(); TH1F* le10RESmcEnuAft2Rw; if(selectKinSample==0) le10RESmcEnuAft2Rw = (TH1F*)le10RESmcFile2->Get("enuAftRw[0]"); if(selectKinSample==1) le10RESmcEnuAft2Rw = (TH1F*)le10RESmcFile2->Get("enuAftRw[1]"); if(selectKinSample==2) le10RESmcEnuAft2Rw = (TH1F*)le10RESmcFile2->Get("enuAftRw[2]"); if(selectKinSample==3) le10RESmcEnuAft2Rw = (TH1F*)le10RESmcFile2->Get("enuAftRw[3]"); if(selectKinSample==4) le10RESmcEnuAft2Rw = (TH1F*)le10RESmcFile2->Get("enuAftRw[4]"); le10RESmcEnuAft2Rw->Sumw2(); le10RESmcEnuAft2Rw->Rebin(le10rebinAft); le10RESmcEnuAft2Rw->Scale(1.0e19/le10mcPots); TFile* le10DISmcFile2 = new TFile("ana_LE-10mc_12parFit_wCCpid_ehad0_justDIS.root","READ"); le10DISmcFile2->cd(); TH1F* le10DISmcEnuAft2Rw; if(selectKinSample==0) le10DISmcEnuAft2Rw = (TH1F*)le10DISmcFile2->Get("enuAftRw[0]"); if(selectKinSample==1) le10DISmcEnuAft2Rw = (TH1F*)le10DISmcFile2->Get("enuAftRw[1]"); if(selectKinSample==2) le10DISmcEnuAft2Rw = (TH1F*)le10DISmcFile2->Get("enuAftRw[2]"); if(selectKinSample==3) le10DISmcEnuAft2Rw = (TH1F*)le10DISmcFile2->Get("enuAftRw[3]"); if(selectKinSample==4) le10DISmcEnuAft2Rw = (TH1F*)le10DISmcFile2->Get("enuAftRw[4]"); le10DISmcEnuAft2Rw->Sumw2(); le10DISmcEnuAft2Rw->Rebin(le10rebinAft); le10DISmcEnuAft2Rw->Scale(1.0e19/le10mcPots); TFile* le10NCmcFile2 = new TFile("ana_LE-10mc_12parFit_wCCpid_ehad0_justNC.root","READ"); le10NCmcFile2->cd(); TH1F* le10NCmcEnuAft2Rw; if(selectKinSample==0) le10NCmcEnuAft2Rw = (TH1F*)le10NCmcFile2->Get("enuAftRw[0]"); if(selectKinSample==1) le10NCmcEnuAft2Rw = (TH1F*)le10NCmcFile2->Get("enuAftRw[1]"); if(selectKinSample==2) le10NCmcEnuAft2Rw = (TH1F*)le10NCmcFile2->Get("enuAftRw[2]"); if(selectKinSample==3) le10NCmcEnuAft2Rw = (TH1F*)le10NCmcFile2->Get("enuAftRw[3]"); if(selectKinSample==4) le10NCmcEnuAft2Rw = (TH1F*)le10NCmcFile2->Get("enuAftRw[4]"); le10NCmcEnuAft2Rw->Sumw2(); le10NCmcEnuAft2Rw->Rebin(le10rebinAft); le10NCmcEnuAft2Rw->Scale(1.0e19/le10mcPots); TFile* le10dataFile2 = new TFile("ana_LE-10data_12parFit_wCCpid_ehad0.root","READ"); le10dataFile2->cd(); TH1F* le10dataEnuAft2; if(selectKinSample==0) le10dataEnuAft2 = (TH1F*)le10dataFile2->Get("enuAft[0]"); if(selectKinSample==1) le10dataEnuAft2 = (TH1F*)le10dataFile2->Get("enuAft[1]"); if(selectKinSample==2) le10dataEnuAft2 = (TH1F*)le10dataFile2->Get("enuAft[2]"); if(selectKinSample==3) le10dataEnuAft2 = (TH1F*)le10dataFile2->Get("enuAft[3]"); if(selectKinSample==4) le10dataEnuAft2 = (TH1F*)le10dataFile2->Get("enuAft[4]"); le10dataEnuAft2->Sumw2(); le10dataEnuAft2->Rebin(le10rebinAft); le10dataEnuAft2->Scale(1.0e19/le10dataPots); Int_t firstBin = le10mcEnu->GetXaxis()->FindBin(0.001); Int_t lastBin50 = le10mcEnu->GetXaxis()->FindBin(0.049); TH1D* le10mcEnu50 = le10mcEnu->ProjectionY("le10mcEnu50",firstBin,lastBin50); TH1D* le10mcEnuRw50 = le10mcEnuRw->ProjectionY("le10mcEnuRw50",firstBin,lastBin50); TH1D* le10QEmcEnuRw50 = le10QEmcEnuRw->ProjectionY("le10QEmcEnuRw50",firstBin,lastBin50); TH1D* le10RESmcEnuRw50 = le10RESmcEnuRw->ProjectionY("le10RESmcEnuRw50",firstBin,lastBin50); TH1D* le10DISmcEnuRw50 = le10DISmcEnuRw->ProjectionY("le10DISmcEnuRw50",firstBin,lastBin50); TH1D* le10NCmcEnuRw50 = le10NCmcEnuRw->ProjectionY("le10NCmcEnuRw50",firstBin,lastBin50); TH1D* le10dataEnu50 = le10dataEnu->ProjectionY("le10dataEnu50",firstBin,lastBin50); le10mcEnu50->Sumw2(); le10mcEnu50->Rebin(le10rebinAft); le10mcEnu50->Scale(1.0e19/le10mcPots); le10mcEnuRw50->Sumw2(); le10mcEnuRw50->Rebin(le10rebinAft); le10mcEnuRw50->Scale(1.0e19/le10mcPots); le10QEmcEnuRw50->Sumw2(); le10QEmcEnuRw50->Rebin(le10rebinAft); le10QEmcEnuRw50->Scale(1.0e19/le10mcPots); le10RESmcEnuRw50->Sumw2(); le10RESmcEnuRw50->Rebin(le10rebinAft); le10RESmcEnuRw50->Scale(1.0e19/le10mcPots); le10DISmcEnuRw50->Sumw2(); le10DISmcEnuRw50->Rebin(le10rebinAft); le10DISmcEnuRw50->Scale(1.0e19/le10mcPots); le10NCmcEnuRw50->Sumw2(); le10NCmcEnuRw50->Rebin(le10rebinAft); le10NCmcEnuRw50->Scale(1.0e19/le10mcPots); le10dataEnu50->Sumw2(); le10dataEnu50->Rebin(le10rebinAft); le10dataEnu50->Scale(1.0e19/le10dataPots); Int_t lastBin100 = le10mcEnu->GetXaxis()->FindBin(0.099); TH1D* le10mcEnu100 = le10mcEnu->ProjectionY("le10mcEnu100",firstBin,lastBin100); TH1D* le10mcEnuRw100 = le10mcEnuRw->ProjectionY("le10mcEnuRw100",firstBin,lastBin100); TH1D* le10QEmcEnuRw100 = le10QEmcEnuRw->ProjectionY("le10QEmcEnuRw100",firstBin,lastBin100); TH1D* le10RESmcEnuRw100 = le10RESmcEnuRw->ProjectionY("le10RESmcEnuRw100",firstBin,lastBin100); TH1D* le10DISmcEnuRw100 = le10DISmcEnuRw->ProjectionY("le10DISmcEnuRw100",firstBin,lastBin100); TH1D* le10NCmcEnuRw100 = le10NCmcEnuRw->ProjectionY("le10NCmcEnuRw100",firstBin,lastBin100); TH1D* le10dataEnu100 = le10dataEnu->ProjectionY("le10dataEnu100",firstBin,lastBin100); le10mcEnu100->Sumw2(); le10mcEnu100->Rebin(le10rebinAft); le10mcEnu100->Scale(1.0e19/le10mcPots); le10mcEnuRw100->Sumw2(); le10mcEnuRw100->Rebin(le10rebinAft); le10mcEnuRw100->Scale(1.0e19/le10mcPots); le10QEmcEnuRw100->Sumw2(); le10QEmcEnuRw100->Rebin(le10rebinAft); le10QEmcEnuRw100->Scale(1.0e19/le10mcPots); le10RESmcEnuRw100->Sumw2(); le10RESmcEnuRw100->Rebin(le10rebinAft); le10RESmcEnuRw100->Scale(1.0e19/le10mcPots); le10DISmcEnuRw100->Sumw2(); le10DISmcEnuRw100->Rebin(le10rebinAft); le10DISmcEnuRw100->Scale(1.0e19/le10mcPots); le10NCmcEnuRw100->Sumw2(); le10NCmcEnuRw100->Rebin(le10rebinAft); le10NCmcEnuRw100->Scale(1.0e19/le10mcPots); le10dataEnu100->Sumw2(); le10dataEnu100->Rebin(le10rebinAft); le10dataEnu100->Scale(1.0e19/le10dataPots); Int_t lastBin150 = le10mcEnu->GetXaxis()->FindBin(0.149); TH1D* le10mcEnu150 = le10mcEnu->ProjectionY("le10mcEnu150",firstBin,lastBin150); TH1D* le10mcEnuRw150 = le10mcEnuRw->ProjectionY("le10mcEnuRw150",firstBin,lastBin150); TH1D* le10QEmcEnuRw150 = le10QEmcEnuRw->ProjectionY("le10QEmcEnuRw150",firstBin,lastBin150); TH1D* le10RESmcEnuRw150 = le10RESmcEnuRw->ProjectionY("le10RESmcEnuRw150",firstBin,lastBin150); TH1D* le10DISmcEnuRw150 = le10DISmcEnuRw->ProjectionY("le10DISmcEnuRw150",firstBin,lastBin150); TH1D* le10NCmcEnuRw150 = le10NCmcEnuRw->ProjectionY("le10NCmcEnuRw150",firstBin,lastBin150); TH1D* le10dataEnu150 = le10dataEnu->ProjectionY("le10dataEnu150",firstBin,lastBin150); le10mcEnu150->Sumw2(); le10mcEnu150->Rebin(le10rebinAft); le10mcEnu150->Scale(1.0e19/le10mcPots); le10mcEnuRw150->Sumw2(); le10mcEnuRw150->Rebin(le10rebinAft); le10mcEnuRw150->Scale(1.0e19/le10mcPots); le10QEmcEnuRw150->Sumw2(); le10QEmcEnuRw150->Rebin(le10rebinAft); le10QEmcEnuRw150->Scale(1.0e19/le10mcPots); le10RESmcEnuRw150->Sumw2(); le10RESmcEnuRw150->Rebin(le10rebinAft); le10RESmcEnuRw150->Scale(1.0e19/le10mcPots); le10DISmcEnuRw150->Sumw2(); le10DISmcEnuRw150->Rebin(le10rebinAft); le10DISmcEnuRw150->Scale(1.0e19/le10mcPots); le10NCmcEnuRw150->Sumw2(); le10NCmcEnuRw150->Rebin(le10rebinAft); le10NCmcEnuRw150->Scale(1.0e19/le10mcPots); le10dataEnu150->Sumw2(); le10dataEnu150->Rebin(le10rebinAft); le10dataEnu150->Scale(1.0e19/le10dataPots); Int_t lastBin200 = le10mcEnu->GetXaxis()->FindBin(0.199); TH1D* le10mcEnu200 = le10mcEnu->ProjectionY("le10mcEnu200",firstBin,lastBin200); TH1D* le10mcEnuRw200 = le10mcEnuRw->ProjectionY("le10mcEnuRw200",firstBin,lastBin200); TH1D* le10QEmcEnuRw200 = le10QEmcEnuRw->ProjectionY("le10QEmcEnuRw200",firstBin,lastBin200); TH1D* le10RESmcEnuRw200 = le10RESmcEnuRw->ProjectionY("le10RESmcEnuRw200",firstBin,lastBin200); TH1D* le10DISmcEnuRw200 = le10DISmcEnuRw->ProjectionY("le10DISmcEnuRw200",firstBin,lastBin200); TH1D* le10NCmcEnuRw200 = le10NCmcEnuRw->ProjectionY("le10NCmcEnuRw200",firstBin,lastBin200); TH1D* le10dataEnu200 = le10dataEnu->ProjectionY("le10dataEnu200",firstBin,lastBin200); le10mcEnu200->Sumw2(); le10mcEnu200->Rebin(le10rebinAft); le10mcEnu200->Scale(1.0e19/le10mcPots); le10mcEnuRw200->Sumw2(); le10mcEnuRw200->Rebin(le10rebinAft); le10mcEnuRw200->Scale(1.0e19/le10mcPots); le10QEmcEnuRw200->Sumw2(); le10QEmcEnuRw200->Rebin(le10rebinAft); le10QEmcEnuRw200->Scale(1.0e19/le10mcPots); le10RESmcEnuRw200->Sumw2(); le10RESmcEnuRw200->Rebin(le10rebinAft); le10RESmcEnuRw200->Scale(1.0e19/le10mcPots); le10DISmcEnuRw200->Sumw2(); le10DISmcEnuRw200->Rebin(le10rebinAft); le10DISmcEnuRw200->Scale(1.0e19/le10mcPots); le10NCmcEnuRw200->Sumw2(); le10NCmcEnuRw200->Rebin(le10rebinAft); le10NCmcEnuRw200->Scale(1.0e19/le10mcPots); le10dataEnu200->Sumw2(); le10dataEnu200->Rebin(le10rebinAft); le10dataEnu200->Scale(1.0e19/le10dataPots); Int_t lastBin250 = le10mcEnu->GetXaxis()->FindBin(0.249); TH1D* le10mcEnu250 = le10mcEnu->ProjectionY("le10mcEnu250",firstBin,lastBin250); TH1D* le10mcEnuRw250 = le10mcEnuRw->ProjectionY("le10mcEnuRw250",firstBin,lastBin250); TH1D* le10QEmcEnuRw250 = le10QEmcEnuRw->ProjectionY("le10QEmcEnuRw250",firstBin,lastBin250); TH1D* le10RESmcEnuRw250 = le10RESmcEnuRw->ProjectionY("le10RESmcEnuRw250",firstBin,lastBin250); TH1D* le10DISmcEnuRw250 = le10DISmcEnuRw->ProjectionY("le10DISmcEnuRw250",firstBin,lastBin250); TH1D* le10NCmcEnuRw250 = le10NCmcEnuRw->ProjectionY("le10NCmcEnuRw250",firstBin,lastBin250); TH1D* le10dataEnu250 = le10dataEnu->ProjectionY("le10dataEnu250",firstBin,lastBin250); le10mcEnu250->Sumw2(); le10mcEnu250->Rebin(le10rebinAft); le10mcEnu250->Scale(1.0e19/le10mcPots); le10mcEnuRw250->Sumw2(); le10mcEnuRw250->Rebin(le10rebinAft); le10mcEnuRw250->Scale(1.0e19/le10mcPots); le10QEmcEnuRw250->Sumw2(); le10QEmcEnuRw250->Rebin(le10rebinAft); le10QEmcEnuRw250->Scale(1.0e19/le10mcPots); le10RESmcEnuRw250->Sumw2(); le10RESmcEnuRw250->Rebin(le10rebinAft); le10RESmcEnuRw250->Scale(1.0e19/le10mcPots); le10DISmcEnuRw250->Sumw2(); le10DISmcEnuRw250->Rebin(le10rebinAft); le10DISmcEnuRw250->Scale(1.0e19/le10mcPots); le10NCmcEnuRw250->Sumw2(); le10NCmcEnuRw250->Rebin(le10rebinAft); le10NCmcEnuRw250->Scale(1.0e19/le10mcPots); le10dataEnu250->Sumw2(); le10dataEnu250->Rebin(le10rebinAft); le10dataEnu250->Scale(1.0e19/le10dataPots); Int_t lastBin500 = le10mcEnu->GetXaxis()->FindBin(0.499); TH1D* le10mcEnu500 = le10mcEnu->ProjectionY("le10mcEnu500",firstBin,lastBin500); TH1D* le10mcEnuRw500 = le10mcEnuRw->ProjectionY("le10mcEnuRw500",firstBin,lastBin500); TH1D* le10QEmcEnuRw500 = le10QEmcEnuRw->ProjectionY("le10QEmcEnuRw500",firstBin,lastBin500); TH1D* le10RESmcEnuRw500 = le10RESmcEnuRw->ProjectionY("le10RESmcEnuRw500",firstBin,lastBin500); TH1D* le10DISmcEnuRw500 = le10DISmcEnuRw->ProjectionY("le10DISmcEnuRw500",firstBin,lastBin500); TH1D* le10NCmcEnuRw500 = le10NCmcEnuRw->ProjectionY("le10NCmcEnuRw500",firstBin,lastBin500); TH1D* le10dataEnu500 = le10dataEnu->ProjectionY("le10dataEnu500",firstBin,lastBin500); le10mcEnu500->Sumw2(); le10mcEnu500->Rebin(le10rebinAft); le10mcEnu500->Scale(1.0e19/le10mcPots); le10mcEnuRw500->Sumw2(); le10mcEnuRw500->Rebin(le10rebinAft); le10mcEnuRw500->Scale(1.0e19/le10mcPots); le10QEmcEnuRw500->Sumw2(); le10QEmcEnuRw500->Rebin(le10rebinAft); le10QEmcEnuRw500->Scale(1.0e19/le10mcPots); le10RESmcEnuRw500->Sumw2(); le10RESmcEnuRw500->Rebin(le10rebinAft); le10RESmcEnuRw500->Scale(1.0e19/le10mcPots); le10DISmcEnuRw500->Sumw2(); le10DISmcEnuRw500->Rebin(le10rebinAft); le10DISmcEnuRw500->Scale(1.0e19/le10mcPots); le10NCmcEnuRw500->Sumw2(); le10NCmcEnuRw500->Rebin(le10rebinAft); le10NCmcEnuRw500->Scale(1.0e19/le10mcPots); le10dataEnu500->Sumw2(); le10dataEnu500->Rebin(le10rebinAft); le10dataEnu500->Scale(1.0e19/le10dataPots); Int_t lastBin1GeV = le10mcEnu->GetXaxis()->FindBin(0.999); TH1D* le10mcEnu1GeV = le10mcEnu->ProjectionY("le10mcEnu1GeV",firstBin,lastBin1GeV); TH1D* le10mcEnuRw1GeV = le10mcEnuRw->ProjectionY("le10mcEnuRw1GeV",firstBin,lastBin1GeV); TH1D* le10QEmcEnuRw1GeV = le10QEmcEnuRw->ProjectionY("le10QEmcEnuRw1GeV",firstBin,lastBin1GeV); TH1D* le10RESmcEnuRw1GeV = le10RESmcEnuRw->ProjectionY("le10RESmcEnuRw1GeV",firstBin,lastBin1GeV); TH1D* le10DISmcEnuRw1GeV = le10DISmcEnuRw->ProjectionY("le10DISmcEnuRw1GeV",firstBin,lastBin1GeV); TH1D* le10NCmcEnuRw1GeV = le10NCmcEnuRw->ProjectionY("le10NCmcEnuRw1GeV",firstBin,lastBin1GeV); TH1D* le10dataEnu1GeV = le10dataEnu->ProjectionY("le10dataEnu1GeV",firstBin,lastBin1GeV); le10mcEnu1GeV->Sumw2(); le10mcEnu1GeV->Rebin(le10rebinAft); le10mcEnu1GeV->Scale(1.0e19/le10mcPots); le10mcEnuRw1GeV->Sumw2(); le10mcEnuRw1GeV->Rebin(le10rebinAft); le10mcEnuRw1GeV->Scale(1.0e19/le10mcPots); le10QEmcEnuRw1GeV->Sumw2(); le10QEmcEnuRw1GeV->Rebin(le10rebinAft); le10QEmcEnuRw1GeV->Scale(1.0e19/le10mcPots); le10RESmcEnuRw1GeV->Sumw2(); le10RESmcEnuRw1GeV->Rebin(le10rebinAft); le10RESmcEnuRw1GeV->Scale(1.0e19/le10mcPots); le10DISmcEnuRw1GeV->Sumw2(); le10DISmcEnuRw1GeV->Rebin(le10rebinAft); le10DISmcEnuRw1GeV->Scale(1.0e19/le10mcPots); le10NCmcEnuRw1GeV->Sumw2(); le10NCmcEnuRw1GeV->Rebin(le10rebinAft); le10NCmcEnuRw1GeV->Scale(1.0e19/le10mcPots); le10dataEnu1GeV->Sumw2(); le10dataEnu1GeV->Rebin(le10rebinAft); le10dataEnu1GeV->Scale(1.0e19/le10dataPots); TCanvas* c4 = new TCanvas("c4","Sliding Cut on E_{had} Distributions"); TLegend* leg4 = new TLegend(0.45,0.45,0.85,0.88); c4->Divide(2,2); c4->cd(1); Float_t axMax10 = le10mcEnuAft2->GetBinContent(le10mcEnuAft2->GetMaximumBin()); if((le10mcEnuAft2Rw->GetBinContent(le10mcEnuAft2Rw->GetMaximumBin()))>axMax10) axMax10 = le10mcEnuAft2Rw->GetBinContent(le10mcEnuAft2Rw->GetMaximumBin()); if((le10dataEnuAft2->GetBinContent(le10dataEnuAft2->GetMaximumBin()))>axMax10) axMax10 = le10dataEnuAft2->GetBinContent(le10dataEnuAft2->GetMaximumBin()); le10mcEnuAft2->GetYaxis()->SetRangeUser(0.0,axMax10*1.1); le10mcEnuAft2->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); le10mcEnuAft2->SetTitle("E_{had}=0 CC-like (LE-10 Beam) ; Reconstructed E_{#nu} ; Per 1e19 PoTs"); le10mcEnuAft2->SetLineColor(4); le10mcEnuAft2->Draw("hist"); le10mcEnuAft2Rw->SetLineColor(2); le10mcEnuAft2Rw->Draw("sames && hist && err"); le10dataEnuAft2->Draw("sames"); leg4->SetFillColor(0); leg4->AddEntry(le10dataEnuAft2,"Data"); leg4->AddEntry(le10mcEnuAft2,"Nominal MC"); leg4->AddEntry(le10mcEnuAft2Rw,"Tuned MC"); le10QEmcEnuAft2Rw->SetFillStyle(3001); le10QEmcEnuAft2Rw->SetFillColor(7); le10QEmcEnuAft2Rw->SetLineColor(7); if(showQEevents) { le10QEmcEnuAft2Rw->Draw("hist && sames"); leg4->AddEntry(le10QEmcEnuAft2Rw,"True #nu_{#mu} CC QEL"); } le10RESmcEnuAft2Rw->SetFillStyle(3002); le10RESmcEnuAft2Rw->SetFillColor(3); le10RESmcEnuAft2Rw->SetLineColor(3); if(showRESevents) { le10RESmcEnuAft2Rw->Draw("hist && sames"); leg4->AddEntry(le10RESmcEnuAft2Rw,"True #nu_{#mu} CC RES"); } le10DISmcEnuAft2Rw->SetFillStyle(3003); le10DISmcEnuAft2Rw->SetFillColor(30); le10DISmcEnuAft2Rw->SetLineColor(30); if(showDISevents) { le10DISmcEnuAft2Rw->Draw("hist && sames"); leg4->AddEntry(le10DISmcEnuAft2Rw,"True #nu_{#mu} CC DIS"); } le10NCmcEnuAft2Rw->SetFillStyle(3001); le10NCmcEnuAft2Rw->SetFillColor(6); le10NCmcEnuAft2Rw->SetLineColor(6); if(showNCevents) { le10NCmcEnuAft2Rw->Draw("hist && sames"); leg4->AddEntry(le10NCmcEnuAft2Rw,"True #nu_{#mu} NC"); } leg4->Draw(); c4->cd(2); Float_t axMax11 = le10mcEnu50->GetBinContent(le10mcEnu50->GetMaximumBin()); if((le10mcEnuRw50->GetBinContent(le10mcEnuRw50->GetMaximumBin()))>axMax11) axMax11 = le10mcEnuRw50->GetBinContent(le10mcEnuRw50->GetMaximumBin()); if((le10dataEnu50->GetBinContent(le10dataEnu50->GetMaximumBin()))>axMax11) axMax11 = le10dataEnu50->GetBinContent(le10dataEnu50->GetMaximumBin()); le10mcEnu50->GetYaxis()->SetRangeUser(0.0,axMax11*1.1); le10mcEnu50->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); le10mcEnu50->SetTitle("E_{had}<50MeV CC-like (LE-10 Beam) ; Reconstructed E_{#nu} ; Per 1e19 PoTs"); le10mcEnu50->SetLineColor(4); le10mcEnu50->Draw("hist"); le10mcEnuRw50->SetLineColor(2); le10mcEnuRw50->Draw("sames && hist && err"); le10dataEnu50->Draw("sames"); le10QEmcEnuRw50->SetFillStyle(3001); le10QEmcEnuRw50->SetFillColor(7); le10QEmcEnuRw50->SetLineColor(7); if(showQEevents) { le10QEmcEnuRw50->Draw("hist && sames"); } le10RESmcEnuRw50->SetFillStyle(3002); le10RESmcEnuRw50->SetFillColor(3); le10RESmcEnuRw50->SetLineColor(3); if(showRESevents) { le10RESmcEnuRw50->Draw("hist && sames"); } le10DISmcEnuRw50->SetFillStyle(3003); le10DISmcEnuRw50->SetFillColor(30); le10DISmcEnuRw50->SetLineColor(30); if(showDISevents) { le10DISmcEnuRw50->Draw("hist && sames"); } le10NCmcEnuRw50->SetFillStyle(3001); le10NCmcEnuRw50->SetFillColor(6); le10NCmcEnuRw50->SetLineColor(6); if(showNCevents) { le10NCmcEnuRw50->Draw("hist && sames"); } c4->cd(3); Float_t axMax12 = le10mcEnu100->GetBinContent(le10mcEnu100->GetMaximumBin()); if((le10mcEnuRw100->GetBinContent(le10mcEnuRw100->GetMaximumBin()))>axMax12) axMax12 = le10mcEnuRw100->GetBinContent(le10mcEnuRw100->GetMaximumBin()); if((le10dataEnu100->GetBinContent(le10dataEnu100->GetMaximumBin()))>axMax12) axMax12 = le10dataEnu100->GetBinContent(le10dataEnu100->GetMaximumBin()); le10mcEnu100->GetYaxis()->SetRangeUser(0.0,axMax12*1.1); le10mcEnu100->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); le10mcEnu100->SetTitle("E_{had}<100MeV CC-like (LE-10 Beam) ; Reconstructed E_{#nu} ; Per 1e19 PoTs"); le10mcEnu100->SetLineColor(4); le10mcEnu100->Draw("hist"); le10mcEnuRw100->SetLineColor(2); le10mcEnuRw100->Draw("sames && hist && err"); le10dataEnu100->Draw("sames"); le10QEmcEnuRw100->SetFillStyle(3001); le10QEmcEnuRw100->SetFillColor(7); le10QEmcEnuRw100->SetLineColor(7); if(showQEevents) { le10QEmcEnuRw100->Draw("hist && sames"); } le10RESmcEnuRw100->SetFillStyle(3002); le10RESmcEnuRw100->SetFillColor(3); le10RESmcEnuRw100->SetLineColor(3); if(showRESevents) { le10RESmcEnuRw100->Draw("hist && sames"); } le10DISmcEnuRw100->SetFillStyle(3003); le10DISmcEnuRw100->SetFillColor(30); le10DISmcEnuRw100->SetLineColor(30); if(showDISevents) { le10DISmcEnuRw100->Draw("hist && sames"); } le10NCmcEnuRw100->SetFillStyle(3001); le10NCmcEnuRw100->SetFillColor(6); le10NCmcEnuRw100->SetLineColor(6); if(showNCevents) { le10NCmcEnuRw100->Draw("hist && sames"); } c4->cd(4); Float_t axMax13 = le10mcEnu200->GetBinContent(le10mcEnu200->GetMaximumBin()); if((le10mcEnuRw200->GetBinContent(le10mcEnuRw200->GetMaximumBin()))>axMax13) axMax13 = le10mcEnuRw200->GetBinContent(le10mcEnuRw200->GetMaximumBin()); if((le10dataEnu200->GetBinContent(le10dataEnu200->GetMaximumBin()))>axMax13) axMax13 = le10dataEnu200->GetBinContent(le10dataEnu200->GetMaximumBin()); le10mcEnu200->GetYaxis()->SetRangeUser(0.0,axMax13*1.1); le10mcEnu200->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); le10mcEnu200->SetTitle("E_{had}<200MeV CC-like (LE-10 Beam) ; Reconstructed E_{#nu} ; Per 1e19 PoTs"); le10mcEnu200->SetLineColor(4); le10mcEnu200->Draw("hist"); le10mcEnuRw200->SetLineColor(2); le10mcEnuRw200->Draw("sames && hist && err"); le10dataEnu200->Draw("sames"); le10QEmcEnuRw200->SetFillStyle(3001); le10QEmcEnuRw200->SetFillColor(7); le10QEmcEnuRw200->SetLineColor(7); if(showQEevents) { le10QEmcEnuRw200->Draw("hist && sames"); } le10RESmcEnuRw200->SetFillStyle(3002); le10RESmcEnuRw200->SetFillColor(3); le10RESmcEnuRw200->SetLineColor(3); if(showRESevents) { le10RESmcEnuRw200->Draw("hist && sames"); } le10DISmcEnuRw200->SetFillStyle(3003); le10DISmcEnuRw200->SetFillColor(30); le10DISmcEnuRw200->SetLineColor(30); if(showDISevents) { le10DISmcEnuRw200->Draw("hist && sames"); } le10NCmcEnuRw200->SetFillStyle(3001); le10NCmcEnuRw200->SetFillColor(6); le10NCmcEnuRw200->SetLineColor(6); if(showNCevents) { le10NCmcEnuRw200->Draw("hist && sames"); } c4->Update(); TCanvas* c5 = new TCanvas("c5","Sliding Cut on E_{had} Ratios"); TH1D* ratio0 = (TH1D*)le10dataEnuAft2->Clone(); ratio0->SetNameTitle("ratio0","ratio0"); ratio0->Divide(ratio0,le10mcEnuAft2Rw,1,1); ratio0->SetTitle("E_{had}Rebin(ratioRebin); ratio0->Scale(1.0/ratioRebin); ratio0->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); ratio0->GetYaxis()->SetRangeUser(ratioAxisLow,ratioAxisHigh); ratio0->Draw(); TH1D* ratio50 = (TH1D*)le10dataEnu50->Clone(); ratio50->SetNameTitle("ratio50","ratio50"); ratio50->Divide(ratio50,le10mcEnuRw50,1,1); ratio50->SetLineColor(2); ratio50->Rebin(ratioRebin); ratio50->Scale(1.0/ratioRebin); ratio50->Draw("sames"); TH1D* ratio100 = (TH1D*)le10dataEnu100->Clone(); ratio100->SetNameTitle("ratio100","ratio100"); ratio100->Divide(ratio100,le10mcEnuRw100,1,1); ratio100->SetLineColor(4); ratio100->Rebin(ratioRebin); ratio100->Scale(1.0/ratioRebin); ratio100->Draw("sames"); TH1D* ratio200 = (TH1D*)le10dataEnu200->Clone(); ratio200->SetNameTitle("ratio200","ratio200"); ratio200->Divide(ratio200,le10mcEnuRw200,1,1); ratio200->SetLineColor(6); ratio200->Rebin(ratioRebin); ratio200->Scale(1.0/ratioRebin); ratio200->Draw("sames"); TF1* ratLine4 = new TF1("ratLine4","1",-1000,1000); ratLine4->SetLineColor(14); ratLine4->SetLineStyle(2); ratLine4->Draw("sames"); TLegend* leg5 = new TLegend(0.6,0.7,0.85,0.88,"E_{had}<"); leg5->SetFillColor(0); leg5->AddEntry(ratio0,"0 MeV"); leg5->AddEntry(ratio50,"50 MeV"); leg5->AddEntry(ratio100,"100 MeV"); leg5->AddEntry(ratio200,"200 MeV"); leg5->Draw(); c5->Update(); TCanvas* c6 = new TCanvas("c6","Sliding Cut on E_{had} Distributions 2"); TLegend* leg6 = new TLegend(0.45,0.45,0.85,0.88); c6->Divide(2,2); c6->cd(1); //Float_t axMax14 = le10mcEnuAft2->GetBinContent(le10mcEnuAft2->GetMaximumBin()); //if((le10mcEnuAft2Rw->GetBinContent(le10mcEnuAft2Rw->GetMaximumBin()))>axMax14) axMax14 = le10mcEnuAft2Rw->GetBinContent(le10mcEnuAft2Rw->GetMaximumBin()); //if((le10dataEnuAft2->GetBinContent(le10dataEnuAft2->GetMaximumBin()))>axMax14) axMax14 = le10dataEnuAft2->GetBinContent(le10dataEnuAft2->GetMaximumBin()); //le10mcEnuAft2->GetYaxis()->SetRangeUser(0.0,axMax14*1.1); //le10mcEnuAft2->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); //le10mcEnuAft2->SetTitle("E_{had}=0 CC-like (LE-10 Beam) ; Reconstructed E_{#nu} ; Per 1e19 PoTs"); //le10mcEnuAft2->SetLineColor(4); le10mcEnuAft2->Draw("hist"); //le10mcEnuAft2Rw->SetLineColor(2); le10mcEnuAft2Rw->Draw("sames && hist && err"); le10dataEnuAft2->Draw("sames"); leg6->SetFillColor(0); leg6->AddEntry(le10dataEnuAft2,"Data"); leg6->AddEntry(le10mcEnuAft2,"Nominal MC"); leg6->AddEntry(le10mcEnuAft2Rw,"Tuned MC"); //le10QEmcEnuAft2Rw->SetFillStyle(3001); //le10QEmcEnuAft2Rw->SetFillColor(7); //le10QEmcEnuAft2Rw->SetLineColor(7); if(showQEevents) { le10QEmcEnuAft2Rw->Draw("hist && sames"); leg6->AddEntry(le10QEmcEnuAft2Rw,"True #nu_{#mu} CC QEL"); } //le10RESmcEnuAft2Rw->SetFillStyle(3002); //le10RESmcEnuAft2Rw->SetFillColor(3); //le10RESmcEnuAft2Rw->SetLineColor(3); if(showRESevents) { le10RESmcEnuAft2Rw->Draw("hist && sames"); leg6->AddEntry(le10RESmcEnuAft2Rw,"True #nu_{#mu} CC RES"); } //le10DISmcEnuAft2Rw->SetFillStyle(3003); //le10DISmcEnuAft2Rw->SetFillColor(30); //le10DISmcEnuAft2Rw->SetLineColor(30); if(showDISevents) { le10DISmcEnuAft2Rw->Draw("hist && sames"); leg6->AddEntry(le10DISmcEnuAft2Rw,"True #nu_{#mu} CC DIS"); } //le10NCmcEnuAft2Rw->SetFillStyle(3001); //le10NCmcEnuAft2Rw->SetFillColor(6); //le10NCmcEnuAft2Rw->SetLineColor(6); if(showNCevents) { le10NCmcEnuAft2Rw->Draw("hist && sames"); leg6->AddEntry(le10NCmcEnuAft2Rw,"True #nu_{#mu} NC"); } leg6->Draw(); c6->cd(2); Float_t axMax15 = le10mcEnu150->GetBinContent(le10mcEnu150->GetMaximumBin()); if((le10mcEnuRw150->GetBinContent(le10mcEnuRw150->GetMaximumBin()))>axMax15) axMax15 = le10mcEnuRw150->GetBinContent(le10mcEnuRw150->GetMaximumBin()); if((le10dataEnu150->GetBinContent(le10dataEnu150->GetMaximumBin()))>axMax15) axMax15 = le10dataEnu150->GetBinContent(le10dataEnu150->GetMaximumBin()); le10mcEnu150->GetYaxis()->SetRangeUser(0.0,axMax15*1.1); le10mcEnu150->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); le10mcEnu150->SetTitle("E_{had}<150MeV CC-like (LE-10 Beam) ; Reconstructed E_{#nu} ; Per 1e19 PoTs"); le10mcEnu150->SetLineColor(4); le10mcEnu150->Draw("hist"); le10mcEnuRw150->SetLineColor(2); le10mcEnuRw150->Draw("sames && hist && err"); le10dataEnu150->Draw("sames"); le10QEmcEnuRw150->SetFillStyle(3001); le10QEmcEnuRw150->SetFillColor(7); le10QEmcEnuRw150->SetLineColor(7); if(showQEevents) { le10QEmcEnuRw150->Draw("hist && sames"); } le10RESmcEnuRw150->SetFillStyle(3002); le10RESmcEnuRw150->SetFillColor(3); le10RESmcEnuRw150->SetLineColor(3); if(showRESevents) { le10RESmcEnuRw150->Draw("hist && sames"); } le10DISmcEnuRw150->SetFillStyle(3003); le10DISmcEnuRw150->SetFillColor(30); le10DISmcEnuRw150->SetLineColor(30); if(showDISevents) { le10DISmcEnuRw150->Draw("hist && sames"); } le10NCmcEnuRw150->SetFillStyle(3001); le10NCmcEnuRw150->SetFillColor(6); le10NCmcEnuRw150->SetLineColor(6); if(showNCevents) { le10NCmcEnuRw150->Draw("hist && sames"); } c6->cd(3); Float_t axMax16 = le10mcEnu500->GetBinContent(le10mcEnu500->GetMaximumBin()); if((le10mcEnuRw500->GetBinContent(le10mcEnuRw500->GetMaximumBin()))>axMax16) axMax16 = le10mcEnuRw500->GetBinContent(le10mcEnuRw500->GetMaximumBin()); if((le10dataEnu500->GetBinContent(le10dataEnu500->GetMaximumBin()))>axMax16) axMax16 = le10dataEnu500->GetBinContent(le10dataEnu500->GetMaximumBin()); le10mcEnu500->GetYaxis()->SetRangeUser(0.0,axMax16*1.1); le10mcEnu500->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); le10mcEnu500->SetTitle("E_{had}<500MeV CC-like (LE-10 Beam) ; Reconstructed E_{#nu} ; Per 1e19 PoTs"); le10mcEnu500->SetLineColor(4); le10mcEnu500->Draw("hist"); le10mcEnuRw500->SetLineColor(2); le10mcEnuRw500->Draw("sames && hist && err"); le10dataEnu500->Draw("sames"); le10QEmcEnuRw500->SetFillStyle(3001); le10QEmcEnuRw500->SetFillColor(7); le10QEmcEnuRw500->SetLineColor(7); if(showQEevents) { le10QEmcEnuRw500->Draw("hist && sames"); } le10RESmcEnuRw500->SetFillStyle(3002); le10RESmcEnuRw500->SetFillColor(3); le10RESmcEnuRw500->SetLineColor(3); if(showRESevents) { le10RESmcEnuRw500->Draw("hist && sames"); } le10DISmcEnuRw500->SetFillStyle(3003); le10DISmcEnuRw500->SetFillColor(30); le10DISmcEnuRw500->SetLineColor(30); if(showDISevents) { le10DISmcEnuRw500->Draw("hist && sames"); } le10NCmcEnuRw500->SetFillStyle(3001); le10NCmcEnuRw500->SetFillColor(6); le10NCmcEnuRw500->SetLineColor(6); if(showNCevents) { le10NCmcEnuRw500->Draw("hist && sames"); } c6->cd(4); Float_t axMax17 = le10mcEnu1GeV->GetBinContent(le10mcEnu1GeV->GetMaximumBin()); if((le10mcEnuRw1GeV->GetBinContent(le10mcEnuRw1GeV->GetMaximumBin()))>axMax17) axMax17 = le10mcEnuRw1GeV->GetBinContent(le10mcEnuRw1GeV->GetMaximumBin()); if((le10dataEnu1GeV->GetBinContent(le10dataEnu1GeV->GetMaximumBin()))>axMax17) axMax17 = le10dataEnu1GeV->GetBinContent(le10dataEnu1GeV->GetMaximumBin()); le10mcEnu1GeV->GetYaxis()->SetRangeUser(0.0,axMax17*1.1); le10mcEnu1GeV->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); le10mcEnu1GeV->SetTitle("E_{had}<1GeV CC-like (LE-10 Beam) ; Reconstructed E_{#nu} ; Per 1e19 PoTs"); le10mcEnu1GeV->SetLineColor(4); le10mcEnu1GeV->Draw("hist"); le10mcEnuRw1GeV->SetLineColor(2); le10mcEnuRw1GeV->Draw("sames && hist && err"); le10dataEnu1GeV->Draw("sames"); le10QEmcEnuRw1GeV->SetFillStyle(3001); le10QEmcEnuRw1GeV->SetFillColor(7); le10QEmcEnuRw1GeV->SetLineColor(7); if(showQEevents) { le10QEmcEnuRw1GeV->Draw("hist && sames"); } le10RESmcEnuRw1GeV->SetFillStyle(3002); le10RESmcEnuRw1GeV->SetFillColor(3); le10RESmcEnuRw1GeV->SetLineColor(3); if(showRESevents) { le10RESmcEnuRw1GeV->Draw("hist && sames"); } le10DISmcEnuRw1GeV->SetFillStyle(3003); le10DISmcEnuRw1GeV->SetFillColor(30); le10DISmcEnuRw1GeV->SetLineColor(30); if(showDISevents) { le10DISmcEnuRw1GeV->Draw("hist && sames"); } le10NCmcEnuRw1GeV->SetFillStyle(3001); le10NCmcEnuRw1GeV->SetFillColor(6); le10NCmcEnuRw1GeV->SetLineColor(6); if(showNCevents) { le10NCmcEnuRw1GeV->Draw("hist && sames"); } c6->Update(); TCanvas* c7 = new TCanvas("c7","Sliding Cut on E_{had} Ratios 2"); TH1D* ratio02 = (TH1D*)le10dataEnuAft2->Clone(); ratio02->SetNameTitle("ratio02","ratio02"); ratio02->Divide(ratio02,le10mcEnuAft2Rw,1,1); ratio02->SetTitle("E_{had}Rebin(ratioRebin); ratio02->Scale(1.0/ratioRebin); ratio02->GetXaxis()->SetRangeUser(enuAxisLow,enuAxisHigh); ratio02->GetYaxis()->SetRangeUser(ratioAxisLow,ratioAxisHigh); ratio02->Draw(); TH1D* ratio150 = (TH1D*)le10dataEnu150->Clone(); ratio150->SetNameTitle("ratio150","ratio150"); ratio150->Divide(ratio150,le10mcEnuRw150,1,1); ratio150->SetLineColor(2); ratio150->Rebin(ratioRebin); ratio150->Scale(1.0/ratioRebin); ratio150->Draw("sames"); TH1D* ratio250 = (TH1D*)le10dataEnu250->Clone(); ratio250->SetNameTitle("ratio250","ratio250"); ratio250->Divide(ratio250,le10mcEnuRw250,1,1); ratio250->SetLineColor(8); ratio250->Rebin(ratioRebin); ratio250->Scale(1.0/ratioRebin); TH1D* ratio500 = (TH1D*)le10dataEnu500->Clone(); ratio500->SetNameTitle("ratio500","ratio500"); ratio500->Divide(ratio500,le10mcEnuRw500,1,1); ratio500->SetLineColor(4); ratio500->Rebin(ratioRebin); ratio500->Scale(1.0/ratioRebin); ratio500->Draw("sames"); TH1D* ratio1GeV = (TH1D*)le10dataEnu1GeV->Clone(); ratio1GeV->SetNameTitle("ratio1GeV","ratio1GeV"); ratio1GeV->Divide(ratio1GeV,le10mcEnuRw1GeV,1,1); ratio1GeV->SetLineColor(6); ratio1GeV->Rebin(ratioRebin); ratio1GeV->Scale(1.0/ratioRebin); ratio1GeV->Draw("sames"); ratLine4->Draw("sames"); TLegend* leg7 = new TLegend(0.6,0.7,0.85,0.88,"E_{had}<"); leg7->SetFillColor(0); leg7->AddEntry(ratio02,"0 MeV"); leg7->AddEntry(ratio150,"150 MeV"); leg7->AddEntry(ratio500,"500 MeV"); leg7->AddEntry(ratio1GeV,"1 GeV"); leg7->Draw(); c7->Update(); // want to look at means and peaks of data/tunedMC ratios as the ehad cut slides // but only in the region where differences are seen (i.e. not tail of distribution) Double_t eshwCuts[8]; Double_t ratioPeaks[8]; Double_t ratioMeans[8]; eshwCuts[0] = 0.0; eshwCuts[1] = 0.05; eshwCuts[2] = 0.1; eshwCuts[3] = 0.15; eshwCuts[4] = 0.2; eshwCuts[5] = 0.25; eshwCuts[6] = 0.5; eshwCuts[7] = 1.0; TH1D* ratio0clone = (TH1D*)ratio0->Clone(); ratio0clone->SetNameTitle("ratio0clone","ratio0clone"); Int_t initialBin = ratio0clone->FindBin(0.01); Int_t finalBin = ratio0clone->FindBin(4.99); ratio0clone->GetXaxis()->SetRangeUser(0.0,5.0); ratioPeaks[0] = ratio0clone->GetBinContent(ratio0clone->GetMaximumBin()); for(Int_t i=1;i<=finalBin;i++){ ratioMeans[0]+=ratio0clone->GetBinContent(i); } ratioMeans[0] = (ratioMeans[0]/static_cast(finalBin)); TH1D* ratio50clone = (TH1D*)ratio50->Clone(); ratio50clone->SetNameTitle("ratio50clone","ratio50clone"); ratio50clone->GetXaxis()->SetRangeUser(0.0,5.0); ratioPeaks[1] = ratio50clone->GetBinContent(ratio50clone->GetMaximumBin()); for(Int_t i=1;i<=finalBin;i++){ ratioMeans[1]+=ratio50clone->GetBinContent(i); } ratioMeans[1] = (ratioMeans[1]/static_cast(finalBin)); TH1D* ratio100clone = (TH1D*)ratio100->Clone(); ratio100clone->SetNameTitle("ratio100clone","ratio100clone"); ratio100clone->GetXaxis()->SetRangeUser(0.0,5.0); ratioPeaks[2] = ratio100clone->GetBinContent(ratio100clone->GetMaximumBin()); for(Int_t i=1;i<=finalBin;i++){ ratioMeans[2]+=ratio100clone->GetBinContent(i); } ratioMeans[2] = (ratioMeans[2]/static_cast(finalBin)); TH1D* ratio150clone = (TH1D*)ratio150->Clone(); ratio150clone->SetNameTitle("ratio150clone","ratio150clone"); ratio150clone->GetXaxis()->SetRangeUser(0.0,5.0); ratioPeaks[3] = ratio150clone->GetBinContent(ratio150clone->GetMaximumBin()); for(Int_t i=1;i<=finalBin;i++){ ratioMeans[3]+=ratio150clone->GetBinContent(i); } ratioMeans[3] = (ratioMeans[3]/static_cast(finalBin)); TH1D* ratio200clone = (TH1D*)ratio200->Clone(); ratio200clone->SetNameTitle("ratio200clone","ratio200clone"); ratio200clone->GetXaxis()->SetRangeUser(0.0,5.0); ratioPeaks[4] = ratio200clone->GetBinContent(ratio200clone->GetMaximumBin()); for(Int_t i=1;i<=finalBin;i++){ ratioMeans[4]+=ratio200clone->GetBinContent(i); } ratioMeans[4] = (ratioMeans[4]/static_cast(finalBin)); TH1D* ratio250clone = (TH1D*)ratio250->Clone(); ratio250clone->SetNameTitle("ratio250clone","ratio250clone"); ratio250clone->GetXaxis()->SetRangeUser(0.0,5.0); ratioPeaks[5] = ratio250clone->GetBinContent(ratio250clone->GetMaximumBin()); for(Int_t i=1;i<=finalBin;i++){ ratioMeans[5]+=ratio250clone->GetBinContent(i); } ratioMeans[5] = (ratioMeans[5]/static_cast(finalBin)); TH1D* ratio500clone = (TH1D*)ratio500->Clone(); ratio500clone->SetNameTitle("ratio500clone","ratio500clone"); ratio500clone->GetXaxis()->SetRangeUser(0.0,5.0); ratioPeaks[6] = ratio500clone->GetBinContent(ratio500clone->GetMaximumBin()); for(Int_t i=1;i<=finalBin;i++){ ratioMeans[6]+=ratio500clone->GetBinContent(i); } ratioMeans[6] = (ratioMeans[6]/static_cast(finalBin)); TH1D* ratio1GeVclone = (TH1D*)ratio1GeV->Clone(); ratio1GeVclone->SetNameTitle("ratio1GeVclone","ratio1GeVclone"); ratio1GeVclone->GetXaxis()->SetRangeUser(0.0,5.0); ratioPeaks[7] = ratio1GeVclone->GetBinContent(ratio1GeVclone->GetMaximumBin()); for(Int_t i=1;i<=finalBin;i++){ ratioMeans[7]+=ratio1GeVclone->GetBinContent(i); } ratioMeans[7] = (ratioMeans[7]/static_cast(finalBin)); TCanvas* c8 = new TCanvas("c8","Effect of Sliding Cut on Ratios"); c8->Divide(1,2); c8->cd(1); TGraph* gr1 = new TGraph(8,eshwCuts,ratioPeaks); gr1->SetMarkerColor(2); gr1->SetLineColor(2); gr1->SetTitle("CC-like Events with E_{#nu} #in [0,5) GeV (LE-10 Beam) ; E_{had} < X (GeV) ; Peak Ratio (Data / Tuned MC)"); gr1->Draw("AC*"); c8->cd(2); TGraph* gr2 = new TGraph(8,eshwCuts,ratioMeans); gr2->SetMarkerColor(4); gr2->SetLineColor(4); gr2->SetTitle("CC-like Events with E_{#nu} #in [0,5) GeV (LE-10 Beam) ; E_{had} < X (GeV) ; Mean Ratio (Data / Tuned MC)"); gr2->Draw("AC*"); c8->Update(); for(Int_t i=0;i<8;i++){ cout << ratioMeans[i] << endl; } } }