SystsMCStatsLoad.C File Reference

#include "CAFAna/Core/Loaders.h"
#include "CAFAna/Core/SystShifts.h"
#include "CAFAna/Core/Utilities.h"
#include "CAFAna/Cuts/Cuts.h"
#include "NuXAna/Cuts/NusCuts.h"
#include "CAFAna/Cuts/SpillCuts.h"
#include "CAFAna/Decomp/ProportionalDecomp.h"
#include "CAFAna/Extrap/ExtrapSterile.h"
#include "CAFAna/Prediction/PredictionGenerator.h"
#include "NuXAna/Prediction/PredictionSterile.h"
#include "CAFAna/Systs/Systs.h"
#include "CAFAna/Vars/GenieWeights.h"
#include "NuXAna/Vars/HistAxes.h"
#include "NuXAna/macros/NuSLoadMacroDefs.h"
#include "NuXAna/macros/NuSSystFunctions.h"

Go to the source code of this file.

Functions
void	SystsMCStatsLoad ()

Function Documentation

void SystsMCStatsLoad

(

)

Definition at line 19 of file SystsMCStatsLoad.C.

References caf::Proxy< caf::SRHeader >::evt, ana::fnamefar_concat, ana::fnamenear_concat, ana::fnameneardata_concat, ana::fnameswap_concat, ana::fnametau_concat, PandAna.Demos.tute_pid_validation::folder, ana::Loaders::Go(), caf::Proxy< caf::StandardRecord >::hdr, caf::Proxy< caf::SRHeader >::ismc, ana::kBeam, ana::kCaloE, ana::Loaders::kData, caf::kFARDET, ana::Loaders::kFluxSwap, ana::Loaders::kMC, ana::kNCBinsNumuCCAxis, ana::kNCDisappearanceEnergyBinning, caf::kNEARDET, ana::Loaders::kNonSwap, ana::kNoShift, ana::kNumuND, ana::kNusFD, ana::kNusND, ana::kOnly14DB, ana::kStandardSpillCuts, ana::Loaders::kTauSwap, ana::kTuftsWeightCC, loaders, ana::ModularExtrapSterile::NCDisappearance(), ana::SaveMaps(), ana::Loaders::SetLoaderPath(), ana::Loaders::SetSpillCut(), sr, and string.

{
  TH1::AddDirectory(0);

  std::string fnear = "defname: prod_decaf_S16-04-08_nd_genie_nonswap_genierw_fhc_nova_v08_full_nus_or_numu_contain_v1 with stride 5";
  std::string ffar  = "defname: prod_decaf_S16-04-08_fd_genie_nonswap_fhc_nova_v08_full_nus_contain_v1 with stride 5";
  std::string fswap = "defname: prod_decaf_S16-04-08_fd_genie_fluxswap_fhc_nova_v08_full_nus_contain_v1 with stride 5";
  std::string ftau  = "defname: prod_decaf_S16-04-08_fd_genie_tau_fhc_nova_v08_full_nus_contain_v1 with stride 5";

  Loaders loaders;

  loaders.SetLoaderPath(fnamenear_concat, caf::kNEARDET, Loaders::kMC, ana::kBeam, Loaders::kNonSwap);
  loaders.SetLoaderPath(fnamefar_concat,  caf::kFARDET,  Loaders::kMC, ana::kBeam, Loaders::kNonSwap);
  loaders.SetLoaderPath(fnameswap_concat, caf::kFARDET,  Loaders::kMC, ana::kBeam, Loaders::kFluxSwap);
  loaders.SetLoaderPath(fnametau_concat,  caf::kFARDET,  Loaders::kMC, ana::kBeam, Loaders::kTauSwap);
  loaders.SetLoaderPath(fnameneardata_concat, caf::kNEARDET, Loaders::kData, ana::kBeam, Loaders::kNonSwap);

  loaders.SetSpillCut(kOnly14DB && kStandardSpillCuts);

  // A map to set up systematics, starting with a label for the systematic,
  // and finishing with a vector for items necessary to set up the Syst object
  std::map<std::string, std::string> shiftlabels;
  shiftlabels["Set1"] = "Set 1";
  shiftlabels["Set2"] = "Set 2";
  shiftlabels["Set3"] = "Set 3";
  shiftlabels["Set4"] = "Set 4";

  const Cut kMod0(
    [](const caf::SRProxy* sr)
    {
      if(sr->hdr.ismc == false) { return true; }
      int evtno = sr->hdr.evt;
      if((evtno % 5) == 0) { return true; }
      return false;
    });
  const Cut kMod1(
    [](const caf::SRProxy* sr)
    {
      if(sr->hdr.ismc == false) { return true; }
      int evtno = sr->hdr.evt;
      if((evtno % 5) == 1) { return true; }
      return false;
    });
  const Cut kMod2(
    [](const caf::SRProxy* sr)
    {
      if(sr->hdr.ismc == false) { return true; }
      int evtno = sr->hdr.evt;
      if((evtno % 5) == 2) { return true; }
      return false;
    });
  const Cut kMod3(
    [](const caf::SRProxy* sr)
    {
      if(sr->hdr.ismc == false) { return true; }
      int evtno = sr->hdr.evt;
      if((evtno % 5) == 3) { return true; }
      return false;
    });
  const Cut kMod4(
    [](const caf::SRProxy* sr)
    {
      if(sr->hdr.ismc == false) { return true; }
      int evtno = sr->hdr.evt;
      if((evtno % 5) == 4) { return true; }
      return false;
    });

  // A map of systematic objects, indexed by the same label as above
  std::map<std::string, Cut*> systematics;
  systematics["Set1"] = new Cut(kMod1);
  systematics["Set2"] = new Cut(kMod2);
  systematics["Set3"] = new Cut(kMod3);
  systematics["Set4"] = new Cut(kMod4);

  // Define a map of samples and cuts/axes to set them up
  // Each sample, essentially, is a way to set up the analysis
  std::string labelRecoE = "Calorimetric Energy (GeV)";
  std::map<std::string, std::pair<HistAxis*, std::pair<Cut*, Cut*> > > cut_samples;
  std::pair<Cut*, Cut*> Ana01(new Cut(kNusND), new Cut(kNusFD));
  cut_samples["Ana01"] = std::pair<HistAxis*, std::pair<Cut*, Cut*> >(
    new HistAxis(labelRecoE, kNCDisappearanceEnergyBinning, kCaloE),
    Ana01
  );

  // Set up maps to the decompositions/predictions (each flavor component)
  // Nominal maps are indexed purely by sample label
  // Shifted maps are indexed by sample label, systematic label, then sigma of the shift
  std::map<std::string,                                     IDecomp*>     decomps_nominal;
  std::map<std::string, std::map<std::string, std::map<int, IDecomp*> > > decomps_shifted;
  std::map<std::string,                                     PredictionNoExtrap*>     predsNE_nominal;
  std::map<std::string, std::map<std::string, std::map<int, PredictionNoExtrap*> > > predsNE_shifted;
  std::map<std::string,                                     PredictionSterile*>      predsSt_nominal;
  std::map<std::string, std::map<std::string, std::map<int, PredictionSterile*> > >  predsSt_shifted;

  // Set up the actual decompositions/predictions
  // sample.first = the sample label
  // shiftlabel.first = the systematic shift label
  // sample.second.first = the sample HistAxis
  // sample.second.second = the sample Cut
  for(const auto& sample : cut_samples) {
    // Set up the nominal decompositions
    // Only one is needed per sample
    decomps_nominal[sample.first] = new ProportionalDecomp(
      loaders,
      *sample.second.first, *sample.second.second.first && kMod0,
      kNoShift, kNoShift, kTuftsWeightCC
    );
    predsNE_nominal[sample.first] = new PredictionNoExtrap(
      loaders,
      *sample.second.first, *sample.second.second.second && kMod0,
      kNoShift, kTuftsWeightCC
    );

    ProportionalDecomp* decompnc_n   = new ProportionalDecomp(
      loaders,
      *sample.second.first, *sample.second.second.first && kMod0,
      kNoShift, kNoShift, kTuftsWeightCC
    );
    ProportionalDecomp* decompnumu_n = new ProportionalDecomp(
      loaders,
      kNCBinsNumuCCAxis, kNumuND && kMod0,
      kNoShift, kNoShift, kTuftsWeightCC
    );
    ModularExtrapSterile* extrap_n = new ModularExtrapSterile(ModularExtrapSterile::NCDisappearance(
      loaders, *decompnc_n, *decompnumu_n,
      *sample.second.first, kNCBinsNumuCCAxis,
      *sample.second.second.second && kMod0,
      *sample.second.second.first && kMod0,
      kNumuND && kMod0,
      kNoShift, kTuftsWeightCC
    ));
    predsSt_nominal[sample.first] = new PredictionSterile(extrap_n);

    // Set up the shifted decompositions
    // One is needed for every sample, systematic, and sigma level
    for(const auto& systlabel : systematics) {
      int ndpos = 0;
      int fdpos = 1;
      int fspos = 2;
      int ftpos = 3;

      decomps_shifted[sample.first][systlabel.first][1] = new ProportionalDecomp(
        loaders,
        *sample.second.first, *sample.second.second.first && *systlabel.second,
        kNoShift, kNoShift, kTuftsWeightCC
      );
      predsNE_shifted[sample.first][systlabel.first][1] = new PredictionNoExtrap(
        loaders,
        *sample.second.first, *sample.second.second.second && *systlabel.second,
        kNoShift, kTuftsWeightCC
      );

      ProportionalDecomp* decompnc_s   = new ProportionalDecomp(
        loaders,
        *sample.second.first, *sample.second.second.first && *systlabel.second,
        kNoShift, kNoShift, kTuftsWeightCC
      );
      ProportionalDecomp* decompnumu_s = new ProportionalDecomp(
        loaders,
        kNCBinsNumuCCAxis, kNumuND && *systlabel.second,
        kNoShift, kNoShift, kTuftsWeightCC
      );
      ModularExtrapSterile* extrap_s = new ModularExtrapSterile(ModularExtrapSterile::NCDisappearance(
        loaders, *decompnc_s, *decompnumu_s,
        *sample.second.first, kNCBinsNumuCCAxis,
        *sample.second.second.second && *systlabel.second,
        *sample.second.second.first && *systlabel.second,
        kNumuND && *systlabel.second,
        kNoShift, kTuftsWeightCC
      ));
      predsSt_shifted[sample.first][systlabel.first][1] = new PredictionSterile(
        extrap_s
      );
    }
  }

  loaders.Go();

  std::string folder = "/nova/ana/steriles/Ana01/Systematics/";
  std::string filenm = "SystsMCStats";

  std::string fullLocation = folder + filenm + ".root";
  TFile* rootF = new TFile(fullLocation.c_str(), "RECREATE");

  SaveMaps(rootF,
    decomps_nominal, decomps_shifted,
    predsNE_nominal, predsNE_shifted,
    predsSt_nominal, predsSt_shifted
  );
}