Prod5Loaders.cxx

Go to the documentation of this file.

#include "CAFAna/Analysis/Prod3Loaders.h"  // ECAFType
#include "CAFAna/Analysis/Prod5Loaders.h"

#include <iostream>

namespace ana
{
  //..........................................................................
  void Prod5LoadersBase::SetLoaderPaths(const std::string& fdmc_nonswap,
                                        const std::string& fdmc_fluxswap,
                                        const std::string& fdmc_tauswap,
                                        const std::string& ndmc,
                                        const std::string& nddata)
  {
    if(!fdmc_nonswap.empty())
      SetLoaderPath(fdmc_nonswap, caf::kFARDET,
                    Loaders::kMC, ana::kBeam, Loaders::kNonSwap);
    if(!fdmc_fluxswap.empty())
      SetLoaderPath(fdmc_fluxswap, caf::kFARDET,
                    Loaders::kMC, ana::kBeam, Loaders::kFluxSwap);
    if(!fdmc_tauswap.empty())
      SetLoaderPath(fdmc_tauswap, caf::kFARDET,
                    Loaders::kMC, ana::kBeam, Loaders::kTauSwap);
    if(!ndmc.empty())
      SetLoaderPath(ndmc, caf::kNEARDET,
                    Loaders::kMC, ana::kBeam, Loaders::kNonSwap);
    if(!nddata.empty())
      SetLoaderPath(nddata, caf::kNEARDET,
                    Loaders::kData, ana::kBeam, Loaders::kNonSwap);
  }

  //..........................................................................
  void Prod5LoadersBase::SetLoaderFDMCPaths(const std::string& prefix,
                                            const std::string& suffix,
                                            const bool noTau)
  {
    if(noTau)  // don't set tau path
      // the previous way with "_" was rather confusing
      SetLoaderPaths(prefix+"nonswap_"+suffix,
                     prefix+"fluxswap_"+suffix);
    else  // set all three beam MC paths
      SetLoaderPaths(prefix+"nonswap_"+suffix,
                     prefix+"fluxswap_"+suffix,
                     prefix+"tau_"+suffix);
  }

  //..........................................................................
  void Prod5LoadersBase::SetLoaderNDMCPath(const std::string& ndmc)
  {
    SetLoaderPaths("", "", "", ndmc);
  }

  //..........................................................................
  const std::string Prod5LoadersBase::ECAFTypeToString(ECAFType type)
  {
    const std::map<ECAFType, std::string> mapStringECAFType {
      {ECAFType::kFullCAF, "caf"},
      {ECAFType::kDecaf, "nue_or_numu_or_nus_contain"},
      {ECAFType::kNueConcat, "nue2020"},
      {ECAFType::kNumuConcat, "numu2020"},
      {ECAFType::kNusConcat, "nus2020"}
    };

    auto it = mapStringECAFType.find(type);
    if(it == mapStringECAFType.end()) {
      std::cout << "Unknown ECAFType " << type << std::endl;
      std::cout << "Aborting..." << std::endl;
      abort();
    }
    return it->second;
  }

  //..........................................................................
  std::string Prod5LoadersBase::ECAFTypeFlatToTier(ECAFType type,
                                                   EFlatness flat,
                                                   bool flatCAFsExist) const
  {
    if(flat == kFlatCAF && !flatCAFsExist){
      std::cout << "\nWARNING: FlatCAFs not available (yet) for " << GetSystString() << ", falling back to regular CAFs.\nIf they are in fact now available, please change the appropriate 'false' to 'true' in Prod5Loaders.cxx and commit." << std::endl;
      flat = kNormalCAF;
    }

    // TODO - remove this logic once flatcafs are more widely available
    if(flat == kFlatCAF){
      if(type == kFullCAF){
        std::cerr << "\nWARNING: FlatCAFs not available, using regular CAFs"
                  << std::endl << std::endl;
        flat = kNormalCAF;
      }
      if(type == kDecaf){
        std::cerr << "\nWARNING: FlatDecafs not available, using regular decafs"
                  << std::endl << std::endl;
        flat = kNormalCAF;
      }
    }


    std::string ret;

    switch(type){
    case ECAFType::kFullCAF:   ret =      "caf"; break;
    case ECAFType::kDecaf:     ret =    "decaf"; break;
    case ECAFType::kNueConcat:  // fallthrough
    case ECAFType::kNumuConcat: // fallthrough
    case ECAFType::kNusConcat: ret = "sumdecaf"; break;
    default:
      std::cout << "Unknown ECAFType " << type << std::endl;
      std::cout << "Aborting..." << std::endl;
      abort();
    }

    if(flat == kFlatCAF) return "flat"+ret; else return ret;
  }

  //..........................................................................
  Prod5DataLoaders::Prod5DataLoaders(ECAFType type,
                                     FluxType flux,
                                     std::string WhichPeriod,
                                     std::string WhichNDPeriod,
                                     EFlatness flat)
    : cafType(ECAFTypeToString(type)),
      dataTier(ECAFTypeFlatToTier(type, flat, true)),
      fluxType(flux==kFHC? "fhc":"rhc")
  {
    std::string nddata = "";
    const bool isFull = ((WhichNDPeriod == "full") && (WhichPeriod == "full"));
    
    std::string ndrel = (flux == kFHC) ? "d.f.h.l":"g";  // could change

    if(type == kFullCAF)
    {
      if(flux == kFHC && !(WhichNDPeriod == "full"))
      {
        if(WhichNDPeriod == "period1")
          ndrel = "l";
        else if((WhichNDPeriod == "period9") || (WhichNDPeriod == "period10"))
          ndrel = "h";
        else
          ndrel = "d.f";
      }
    }

    // Some period/flux validation checks
    // Only need to do these once --> in DataLoaders
    const bool isRHCPeriod = (
      (WhichNDPeriod == "period4") || (WhichPeriod == "period4") ||
      (WhichNDPeriod == "period6") || (WhichPeriod == "period6") ||
      (WhichNDPeriod == "period7") || (WhichPeriod == "period7") ||
      (WhichNDPeriod == "period8") || (WhichPeriod == "period8"));

    if(flux == kFHC)
      if(isRHCPeriod && !isFull)  // Warn that it's not an FHC period
        std::cerr << "\nWARNING: ND " << WhichNDPeriod << " and FD "
          << WhichPeriod << " contains no FHC data" << std::endl << std::endl;
    if(flux == kRHC)
    {
      if(!isRHCPeriod && !isFull)  // Now warn that it's not an RHC period
        std::cerr << "\nWARNING: ND " << WhichNDPeriod << " and FD "
          << WhichPeriod << " contains no RHC data" << std::endl << std::endl;
    }

    // Concat definition
    if(type == kNueConcat || type == kNumuConcat || type == kNusConcat)
    {
      nddata = "prod_"+dataTier+"_R19-11-18-prod5reco." + ndrel +
      "_nd_numi_" + fluxType + "_" + WhichNDPeriod +
      "_v1_goodruns_" + cafType;

      if(!isFull)
      {
        std::cerr << "\nWARNING: loaders not available for individual periods, only full sample" << std::endl << std::endl;
        abort();
      }
    }
    // Decaf definition
    if(type == kDecaf)
    {
      nddata = "prod_"+dataTier+"_R19-11-18-prod5reco." + ndrel +
      "_nd_numi_" + fluxType + "_" + WhichNDPeriod + "_" +
      cafType + "_v1_goodruns";

      std::cerr <<  "\nWARNING: " << cafType << " of definition " << nddata << " not available yet" << std::endl << std::endl;
    } 
    // CAF definition
    if(type == kFullCAF)
    {
      nddata = "prod_"+dataTier+"_R19-11-18-prod5reco." + ndrel +
      "_nd_numi_" + fluxType + "_" + WhichNDPeriod +
      "_v1";
      
      if(!(WhichNDPeriod == "period10"))
        nddata += "_goodruns";  // period 10 does not have a goodruns definition
    }

    SetLoaderPath(nddata, caf::kNEARDET, Loaders::kData,
                  ana::kBeam, Loaders::kNonSwap);
  }

  //..........................................................................
  Prod5NomLoaders::Prod5NomLoaders(ECAFType type,
                                   FluxType flux,
                                   std::string WhichPeriod,
                                   std::string WhichNDPeriod,
                                   EFlatness flat)
    : Prod5DataLoaders(type, flux, WhichPeriod, WhichNDPeriod, flat)
  {    
    const std::string rel = "f";
    std::string ndrel = (flux==kFHC) ? "d.h.l":"d";
    
    if(flux == kFHC && !(WhichNDPeriod == "full"))
      ndrel = (WhichNDPeriod=="period5") ? "l":"d";
    
    // Concats
    if(type == kNueConcat || type == kNumuConcat || type == kNusConcat)
    {
      if(WhichPeriod == "full" && WhichNDPeriod == "full")  // only "full"
      {
        SetLoaderFDMCPaths(
          "prod_"+dataTier+"_R19-11-18-prod5reco." + rel +
          "_fd_genie_N1810j0211a_",
          fluxType + "_nova_v08_" + WhichPeriod + "_v1_" + cafType);
        SetLoaderNDMCPath(
          "prod_"+dataTier+"_R19-11-18-prod5reco." + ndrel +
          "_nd_genie_N1810j0211a_nonswap_" + fluxType + "_nova_v08_" + WhichNDPeriod +
          "_v1_" + cafType);
      }
      else
      {
        std::cerr << "\nWARNING: loaders not available for individual periods, only full sample" << std::endl << std::endl;
        abort();
      }
    }

    // Decafs
    if(type == kDecaf)
    {
      std::cerr << "\nWARNING: decaf loaders not available, "
        << "use full CAF instead" << std::endl << std::endl;
      abort();
    }

    // Full CAFs
    if(type == kFullCAF)
    {
      SetLoaderFDMCPaths(
        "prod_"+dataTier+"_R19-11-18-prod5reco." + rel + "_fd_genie_N1810j0211a_",
        fluxType + "_nova_v08_" + WhichPeriod + "_v1");
      SetLoaderNDMCPath(
        "prod_"+dataTier+"_R19-11-18-prod5reco." + ndrel +
        "_nd_genie_N1810j0211a_nonswap_" + fluxType + "_nova_v08_" + WhichNDPeriod + "_v1");
    }
  }

  //..........................................................................
  Prod5AbsCalibLoaders::Prod5AbsCalibLoaders(ECAFType type,
                                             FluxType flux,
                                             int sign,
                                             std::string WhichPeriod,
                                             std::string WhichNDPeriod,
                                             EFlatness flat)
    : Prod5NomLoaders(type, flux, WhichPeriod, WhichNDPeriod, flat)
  {
    assert(abs(sign) == 1);
    
    const bool isFull = ((WhichNDPeriod == "full") && (WhichPeriod == "full"));
    if(!isFull)
    {
      std::cerr << "\nWARNING: loaders not available for individual periods, only full sample" << std::endl << std::endl;
      abort();
    }

    const std::string rel = "l";  // assuming same for FHC/RHC
    const std::string ndrel = "l";  // assuming same for FHC/RHC

    const std::string updown = (sign > 0) ? "calibup" : "calibdown";
    
    std::string ndsuffix = "";
    if(flux == kFHC)
      ndsuffix = "_prod5";

    const std::string tier = ECAFTypeFlatToTier(type, flat, false);

    if(type == kNueConcat || type == kNumuConcat || type == kNusConcat)
    {
      if(WhichPeriod == "full" && WhichNDPeriod == "full")  // only "full"
      {
        SetLoaderFDMCPaths(
          "prod_" + tier + "_R19-11-18-prod5reco." + rel + "_fd_genie_N1810j0211a_",
          fluxType + "_nova_v08_" + WhichPeriod + "_" +
          updown + "_v1_" + cafType, true);
        SetLoaderNDMCPath(
          "prod_" + tier + "_R19-11-18-prod5reco." + ndrel +
          "_nd_genie_N1810j0211a_nonswap_" + fluxType + "_nova_v08_" + WhichNDPeriod +
          "_" + updown + "_v1" + ndsuffix + "_" + cafType);
      }
    }

    if(type == kDecaf)
    {
      std::cerr << "\nWARNING: decaf loaders not available, "
        << "use full CAF instead" << std::endl << std::endl;
      abort();
    }

    if(type == kFullCAF)
    {
      SetLoaderFDMCPaths(
        "prod_"+tier+"_R19-11-18-prod5reco." + rel + "_fd_genie_N1810j0211a_",
        fluxType + "_nova_v08_" + WhichPeriod + "_" + updown + "_v1",
        true);
      SetLoaderNDMCPath(
        "prod_"+tier+"_R19-11-18-prod5reco." + ndrel + "_nd_genie_N1810j0211a_nonswap_" +
        fluxType + "_nova_v08_" + WhichNDPeriod + "_" + updown + "_v1" + ndsuffix);
    }
  }

  //..........................................................................
  Prod5LightLevelLoaders::Prod5LightLevelLoaders(ECAFType type,
                                                 FluxType flux,
                                                 int sign,
                                                 std::string WhichPeriod,
                                                 std::string WhichNDPeriod,
                                                 EFlatness flat)
    : Prod5NomLoaders(type, flux, WhichPeriod, WhichNDPeriod, flat)
  {
    assert((abs(sign) == 1));
    
    const bool isFull = ((WhichNDPeriod == "full") && (WhichPeriod == "full"));
    if(!isFull)
    {
      std::cerr << "\nWARNING: loaders not available for individual periods, only full sample" << std::endl << std::endl;
      abort();
    }

    const std::string rel = "j";  // assuming same for FHC/RHC
    const std::string ndrel = (flux == kFHC) ? "j.l":"j";  // assuming same for FHC/RHC

    const std::string updown = (sign == 1) ? "llup" : "lldown";

    const std::string tier = ECAFTypeFlatToTier(type, flat, false);

    if(type == kNueConcat || type == kNumuConcat || type == kNusConcat)
    {
      SetLoaderFDMCPaths(
        "prod_"+tier+"_R19-11-18-prod5reco." + rel + "_fd_genie_N1810j0211a_",
        fluxType + "_nova_v08_" + WhichPeriod + "_" +
        updown + "_v1_" + cafType, true);
      SetLoaderNDMCPath(
        "prod_"+tier+"_R19-11-18-prod5reco." + ndrel +
        "_nd_genie_N1810j0211a_nonswap_" + fluxType + "_nova_v08_" + WhichNDPeriod +
        "_" + updown + "_v1_" + cafType);
    }

    if(type == kDecaf)
    {
      std::cerr << "\nWARNING: decaf loaders not available, "
        << "use full CAF instead" << std::endl << std::endl;
      abort();
    }

    if(type == kFullCAF)
    {
      SetLoaderFDMCPaths(
        "prod_"+tier+"_R19-11-18-prod5reco." + rel + "_fd_genie_N1810j0211a_",
        fluxType + "_nova_v08_" + WhichPeriod + "_" + updown + "_v1",
        true);
      SetLoaderNDMCPath(
        "prod_"+tier+"_R19-11-18-prod5reco." + ndrel + "_nd_genie_N1810j0211a_nonswap_" +
        fluxType + "_nova_v08_" + WhichNDPeriod + "_" + updown + "_v1");
    }
  }

  //..........................................................................
  Prod5CherenkovLoaders::Prod5CherenkovLoaders(ECAFType type,
                                               FluxType flux,
                                               std::string WhichPeriod,
                                               std::string WhichNDPeriod,
                                               EFlatness flat)
    : Prod5NomLoaders(type, flux, WhichPeriod, WhichNDPeriod, flat)
  {
    const bool isFull = ((WhichNDPeriod == "full") && (WhichPeriod == "full"));
    if(!isFull)
    {
      std::cerr << "\nWARNING: loaders not available for individual periods, only full sample" << std::endl << std::endl;
      abort();
    }
    
    const std::string rel = "j";  // assuming same for FHC/RHC
    const std::string ndrel = (flux == kFHC) ? "j.l":"j";;  // assuming same for FHC/RHC

    const std::string tier = ECAFTypeFlatToTier(type, flat, false);

    if(type == kNueConcat || type == kNumuConcat || type == kNusConcat)
    {
      SetLoaderFDMCPaths(
        "prod_"+tier+"_R19-11-18-prod5reco." + rel + "_fd_genie_N1810j0211a_",
        fluxType + "_nova_v08_" + WhichPeriod +
        "_cherenkov_v1_" + cafType, true);
      SetLoaderNDMCPath(
        "prod_"+tier+"_R19-11-18-prod5reco." + ndrel + "_nd_genie_N1810j0211a_nonswap_" +
        fluxType + "_nova_v08_" + WhichNDPeriod +
        "_cherenkov_v1_" + cafType);
    }

    if(type == kDecaf)
    {
      std::cerr << "\nWARNING: decaf loaders not available, "
        << "use full CAF instead" << std::endl << std::endl;
      abort();
    }

    if(type == kFullCAF)
    {
      SetLoaderFDMCPaths(
        "prod_"+tier+"_R19-11-18-prod5reco." + rel + "_fd_genie_N1810j0211a_",
        fluxType + "_nova_v08_" + WhichPeriod + "_cherenkov_v1",
        true);
      SetLoaderNDMCPath (
        "prod_"+tier+"_R19-11-18-prod5reco." + ndrel+ "_nd_genie_N1810j0211a_nonswap_" +
        fluxType + "_nova_v08_" + WhichNDPeriod + "_cherenkov_v1");
    }
  }

  //..........................................................................
  Prod5CalibShapeLoaders::Prod5CalibShapeLoaders(ECAFType type,
                                                 FluxType flux,
                                                 std::string WhichPeriod,
                                                 std::string WhichNDPeriod,
                                                 EFlatness flat)
    : Prod5NomLoaders(type, flux, WhichPeriod, WhichNDPeriod, flat)
  {
    const bool isFull = ((WhichNDPeriod == "full") && (WhichPeriod == "full"));
    if(!isFull)
    {
      std::cerr << "\nWARNING: loaders not available for individual periods, only full sample" << std::endl << std::endl;
      abort();
    }
    
    const std::string rel = "m";  // assuming same for FHC/RHC
    const std::string ndrel = "m";  // assuming same for FHC/RHC

    std::string ndsuffix = "";
    if(flux == kFHC)
      ndsuffix = "_prod5";

    const std::string tier = ECAFTypeFlatToTier(type, flat, false);

    if(type == kNueConcat || type == kNumuConcat || type == kNusConcat)
    {
      if(WhichPeriod == "full" && WhichNDPeriod == "full")  // only "full"
      {
        SetLoaderFDMCPaths(
          "prod_"+tier+"_R19-11-18-prod5reco." + rel + "_fd_genie_N1810j0211a_",
          fluxType + "_nova_v08_" + WhichPeriod + "_calibshape_v1_" + cafType, true);
        SetLoaderNDMCPath(
          "prod_"+tier+"_R19-11-18-prod5reco." + ndrel + "_nd_genie_N1810j0211a_nonswap_" +
          fluxType + "_nova_v08_" + WhichNDPeriod +
          "_calibshape_v1" + ndsuffix + "_" + cafType);
      }
    }

    if(type == kDecaf)
    {
      std::cerr << "\nWARNING: decaf loaders not available, "
        << "use full CAF or concats instead" << std::endl << std::endl;
      abort();
    }

    if(type == kFullCAF)
    {
      SetLoaderFDMCPaths(
        "prod_"+tier+"_R19-11-18-prod5reco." + rel + "_fd_genie_N1810j0211a_",
        fluxType + "_nova_v08_" + WhichPeriod + "_calibshape_v1",
        true);
      SetLoaderNDMCPath(
        "prod_"+tier+"_R19-11-18-prod5reco." + ndrel + "_nd_genie_N1810j0211a_nonswap_" +
        fluxType + "_nova_v08_" + WhichNDPeriod + "_calibshape_v1");
    }
  }
  
  Prod5CalibDriftLoaders::Prod5CalibDriftLoaders(ECAFType type,
                                                 FluxType flux,
                                                 std::string WhichPeriod,
                                                 std::string WhichNDPeriod,
                                                 EFlatness flat)
    : Prod5NomLoaders(type, flux, WhichPeriod, WhichNDPeriod, flat)
  {
    const bool isFull = ((WhichNDPeriod == "full") && (WhichPeriod == "full"));
    if(!isFull)
    {
      std::cerr << "\nWARNING: loaders not available for individual periods, only full sample" << std::endl << std::endl;
      abort();
    }
    
    const std::string rel = "m";  // assuming same for FHC/RHC
    const std::string ndrel = "m";  // assuming same for FHC/RHC

    const std::string tier = ECAFTypeFlatToTier(type, flat, false);

    if(type == kNueConcat || type == kNumuConcat || type == kNusConcat)
    {
      if(WhichPeriod == "full" && WhichNDPeriod == "full")  // only "full"
      {
        SetLoaderFDMCPaths(
          "prod_"+tier+"_R19-11-18-prod5reco." + rel + "_fd_genie_N1810j0211a_",
          fluxType + "_nova_v08_" + WhichPeriod + "_detectoraging_v1_" + cafType, true);
        SetLoaderNDMCPath(
          "prod_"+tier+"_R19-11-18-prod5reco." + ndrel + "_nd_genie_N1810j0211a_nonswap_" +
          fluxType + "_nova_v08_" + WhichNDPeriod +
          "_detectoraging_v1_" + cafType);
      }
    }

    if(type == kDecaf)
    {
      std::cerr << "\nWARNING: decaf loaders not available, "
        << "use full CAF or concats instead" << std::endl << std::endl;
      abort();
    }

    if(type == kFullCAF)
    {
      SetLoaderFDMCPaths(
        "prod_"+tier+"_R19-11-18-prod5reco." + rel + "_fd_genie_N1810j0211a_",
        fluxType + "_nova_v08_" + WhichPeriod + "_detectoraging_v1",
        true);
      SetLoaderNDMCPath(
        "prod_"+tier+"_R19-11-18-prod5reco." + ndrel + "_nd_genie_N1810j0211a_nonswap_" +
        fluxType + "_nova_v08_" + WhichNDPeriod + "_detectoraging_v1");
    }
  }

} // namespace