MakeUnoscPlots.C

Go to the documentation of this file.

// script to plot the variables for the NuS20 preselection, 
// along with the correlation between each variable and 
// each other variable.
//
// author: Adam Lister
// date  : 2020-02-19
// email : adam.lister@wisc.edu

#pragma once

// framework includes
#include "StandardRecord/Proxy/SRProxy.h"
#include "CAFAna/Core/Loaders.h"
#include "CAFAna/Core/Binning.h"
#include "CAFAna/Core/Spectrum.h"
#include "CAFAna/Core/SpectrumLoader.h"
#include "CAFAna/Core/EventList.h"
#include "CAFAna/Core/Utilities.h"
#include "CAFAna/Analysis/Prod5Loaders.h"
#include "CAFAna/Cuts/Cuts.h"
#include "CAFAna/Cuts/SpillCuts.h"
#include "CAFAna/Vars/Vars.h"
#include "CAFAna/Prediction/PredictionNoExtrap.h" 
#include "CAFAna/Prediction/PredictionGenerator.h"

#include "3FlavorAna/Vars/NueVarsExtra.h"
#include "3FlavorAna/Vars/NumuVarsExtra.h"
#include "3FlavorAna/Cuts/NueCuts2020.h"
#include "3FlavorAna/Cuts/NumuCuts2020.h"

#include "NuXAna/Vars/NusVars.h"
#include "NuXAna/Vars/NusVarsTemp.h"
#include "NuXAna/Cuts/NusCuts20.h"
#include "NuXAna/Cuts/NusCuts.h"

#include "TMVA/Reader.h"
#include "TMVA/IMethod.h"
#include "TString.h"

// selection includes
#include "NuXAna/macros/Nus20/Selection/PredictionHandler.h"
#include "NuXAna/macros/Nus20/Selection/CutFlow.h"
#include "NuXAna/macros/Nus20/Selection/CutVariables.h"

// root includes
#include "TFile.h"
#include "TCanvas.h"
#include "TH1.h"
#include "TH2.h"

#include <cassert>

using namespace ana;

void addVars(PredictionHandler* predH, std::string det);

void MakeUnoscPlots(TString opt){

  bool isCaf    = opt.Contains("caf"   , TString::kIgnoreCase);
  bool isConcat = opt.Contains("concat", TString::kIgnoreCase); 
  assert(isCaf or isConcat);

  bool isND     = opt.Contains("nd"     , TString::kIgnoreCase);
  bool isFD     = opt.Contains("fd"     , TString::kIgnoreCase);
  bool isFDData = opt.Contains("fddata" , TString::kIgnoreCase);
  bool isNDData = opt.Contains("nddata" , TString::kIgnoreCase);

  bool isCosmic = opt.Contains("cos"    , TString::kIgnoreCase);
  bool isSysts  = opt.Contains("syst"   , TString::kIgnoreCase);

  // ----------------------
  // set up loaders
  // ----------------------

  // placeholders...
  std::string kFDDataFHCNus20Concat = "";
  std::string kFDDataFHCNus20CAF    = "";
  std::string kFDCosmicFHCProd5     = "prod_sumdecaf_R19-11-18-prod5reco.i_fd_cosmic_fhc_full_v1_goodruns_nus2020";
  std::string kFDCosmicFHCProd5CAF  = "prod_caf_R19-11-18-prod5reco.i_fd_cosmic_fhc_full_v1_goodruns";
  std::string kNDBurnerData         = "nux_burner_prod_caf_R19-11-18-prod5reco.d.f.h_nd_numi_fhc_period235910_v1_goodruns";

  Loaders* loadersMC = new Prod5NomLoaders(
      isConcat? ECAFType::kNusConcat : ECAFType::kFullCAF,
      Loaders::FluxType::kFHC);
  loadersMC->SetSpillCut(kStandardSpillCuts);

  SpectrumLoader* loadersFDData = nullptr;
  if (isFDData) {
    const std::string dataDef = 
      isConcat? kFDDataFHCNus20Concat : kFDDataFHCNus20CAF;
    loadersFDData = new SpectrumLoader(dataDef);
    loadersFDData->SetSpillCut(kStandardSpillCuts);
  }

  SpectrumLoader* loadersNDData = nullptr;
  if (isNDData) {
   loadersNDData = new SpectrumLoader(kNDBurnerData);
   loadersNDData->SetSpillCut(kStandardSpillCuts);
  }

  SpectrumLoader* loadersCosmic = nullptr;
  if (isCosmic){
    loadersCosmic = new SpectrumLoader(kFDCosmicFHCProd5CAF, kCosmic);
                //loadersCosmic->SetSpillCut(kStandardSpillCuts);
    loadersCosmic->SetSpillCut(kStandardSpillCuts_FD_Prod4MotivatedDQ); // uses good runs list from prod4
  }

  // --------------------------
  // setup prediction handler
  // --------------------------

  FDPredictionHandler fdPredH("NoExtrap");
  fdPredH.AddLoaders(loadersMC);
  if (isFDData)
   fdPredH.AddData(loadersFDData);
  if (isCosmic)
   fdPredH.AddCosmics(loadersCosmic);

  NDPredictionHandler ndPredH("Decomp");
  ndPredH.AddLoaders(loadersMC);
  if (isNDData)
    ndPredH.AddData(loadersNDData);

  if (isFD)
    addVars(&fdPredH, "fd");

  if (isND)
    addVars(&ndPredH, "nd");
    
  loadersMC->Go();
  if (isFDData)
    loadersFDData->Go();
  if (isNDData)
    loadersNDData->Go();
  if (isCosmic)
    loadersCosmic->Go();

  std::cout << "got all spectra" << std::endl;

  // setup output file
  std::string fileOutName = "SelectionSpectr_Unosc.root";
  TFile* fileOut = new TFile(fileOutName.c_str(), "RECREATE");
 
  if (isFD)
    fdPredH.Save(fileOut);
  if (isND)
    ndPredH.Save(fileOut);

  fileOut->Close();

}

void addVars(PredictionHandler* predH, std::string det ){

  std::vector<VarContainer>   vars;
        std::vector<VarContainer2D> vars2D;
        std::vector<VarContainer3D> vars3D;
  std::vector<CutContainer>   cuts;
  std::vector<CutContainer>   subcuts;

  if (det == "nd"){
    vars    = varsND;
                vars2D  = vars2DND;
                vars3D  = vars3DND;
    cuts    = cutsND;
    subcuts = subCutsND;
  }
  else if (det == "fd"){
    vars    = varsFD;
                vars2D  = vars2DFD;
                vars3D  = vars3DFD;
    cuts    = cutsFD;
    subcuts = subCutsFD;
  }
  else {
    throw std::logic_error("options for detector are nd or fd");
  }

  for (size_t iCut = 0; iCut < cuts.size(); ++iCut){

    ana::Cut    thisCut  = cuts.at(iCut).cut;
    std::string thisName = cuts.at(iCut).name;

    for (size_t iSub = 0; iSub < subcuts.size(); ++iSub){

      ana::Cut    fullCut  = thisCut && subcuts.at(iSub).cut;
      std::string fullName = thisName + subcuts.at(iSub).name;

      for (size_t iVar = 0; iVar < vars.size(); ++iVar){

                                std::cout << vars.at(iVar).name+fullName << std::endl;

                                // one dimensional
        predH->AddVar((vars.at(iVar).name+fullName).c_str(),
                       vars.at(iVar).label.c_str(),
                       vars.at(iVar).var,
                       vars.at(iVar).bins,
                       fullCut,
                       kNoShift,
                       kUnweighted,
                                                                                         cuts.at(iCut).cutdata && subcuts.at(iSub).cutdata);
      }

                        // two dimensional
      for (size_t iVar = 0; iVar < vars2D.size(); ++iVar){

        predH->AddVar((vars2D.at(iVar).name+fullName).c_str(),
                       vars2D.at(iVar).labelx.c_str(),
                       vars2D.at(iVar).labely.c_str(),
                       vars2D.at(iVar).varx,
                       vars2D.at(iVar).vary,
                       vars2D.at(iVar).binsx,
                       vars2D.at(iVar).binsy,
                       fullCut,
                       kNoShift,
                       kUnweighted,
                                                                       cuts.at(iCut).cutdata && subcuts.at(iSub).cutdata);
      }

                        // three dimensional
      for (size_t iVar = 0; iVar < vars3D.size(); ++iVar){

        predH->AddVar((vars3D.at(iVar).name+fullName).c_str(),
                       vars3D.at(iVar).labelx.c_str(),
                       vars3D.at(iVar).labely.c_str(),
                                                                                         vars3D.at(iVar).labelz.c_str(),
                       vars3D.at(iVar).varx,
                       vars3D.at(iVar).vary,
                                                                                         vars3D.at(iVar).varz,
                       vars3D.at(iVar).binsx,
                       vars3D.at(iVar).binsy,
                                                                                         vars3D.at(iVar).binsz,
                       fullCut,
                       kNoShift,
                       kUnweighted,
                                                                       cuts.at(iCut).cutdata && subcuts.at(iSub).cutdata);
      }
    }
  }
}