Prod4Loaders.cxx

Go to the documentation of this file.

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

#include <iostream>

namespace ana
{
  //..........................................................................
  void Prod4LoadersBase::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 Prod4LoadersBase::SetLoaderFDMCPaths(const std::string& prefix,
                                            const std::string& suffix,
                                            const bool noTau)
  {
    if(noTau)  // don't set tau path
      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 Prod4LoadersBase::SetLoaderNDMCPath(const std::string& ndmc)
  {
    SetLoaderPaths("", "", "", ndmc);
  }

  //..........................................................................
  const std::string Prod4LoadersBase::ECAFTypeToString(ECAFType type)
  {
    const std::map<ECAFType, std::string> mapStringECAFType {
      {ECAFType::kFullCAF, "caf"},
      {ECAFType::kDecaf, "nue_or_numu_or_nus_contain"},
      {ECAFType::kNueConcat, "nue2018"},
      {ECAFType::kNumuConcat, "numu2018"},
      {ECAFType::kNusConcat, "nus2018"}
    };

    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 Prod4LoadersBase::ECAFTypeFlatToTier(ECAFType type,
                                                   EFlatness flat) const
  {
    // 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;
  }

  //..........................................................................
  Prod4DataLoaders::Prod4DataLoaders(ECAFType type,
                                     FluxType flux,
                                     std::string WhichPeriod,
                                     std::string WhichNDPeriod,
                                     EFlatness flat)
    : cafType(ECAFTypeToString(type)),
      dataTier(ECAFTypeFlatToTier(type, flat)),
      fluxType(flux==kFHC? "fhc":"rhc")
  {
    std::string nddata = "";
    const std::string ndrel = (flux==kFHC ? "f":"f");  // same at the moment,
                                                       // but could change

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

    const bool isFull = ((WhichNDPeriod == "full") || (WhichPeriod == "full"));

    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;
      if(isFull)
        std::cerr << "\nWARNING: " << WhichPeriod
          << " does not include RHC data in epoch7a" << std::endl << std::endl;
    }

    // Concat definition
    if(type == kNueConcat || type == kNumuConcat || type == kNusConcat)
      nddata = "prod_"+dataTier+"_R17-09-05-prod4recopreview." + ndrel +
      "_nd_numi_" + fluxType + "_" + WhichNDPeriod +
      "_v1_addShortSimpleCVN_goodruns_" + cafType;
    // Decaf definition
    if(type == kDecaf)
      nddata = "prod_"+dataTier+"_R17-09-05-prod4recopreview." + ndrel +
      "_nd_numi_" + fluxType + "_" + WhichNDPeriod + "_" +
      cafType + "_v1_addShortSimpleCVN_goodruns";
    // CAF definition
    if(type == kFullCAF)
      nddata = "prod_"+dataTier+"_R17-09-05-prod4recopreview." + ndrel +
      "_nd_numi_" + fluxType + "_" + WhichNDPeriod +
      "_v1_addShortSimpleCVN_goodruns";

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

  //..........................................................................
  Prod4NomLoaders::Prod4NomLoaders(ECAFType type,
                                   FluxType flux,
                                   std::string WhichPeriod,
                                   std::string WhichNDPeriod,
                                   EFlatness flat)
    : Prod4DataLoaders(type, flux, WhichPeriod, WhichNDPeriod, flat)
  {
    const std::string rel = "c";
    const std::string ndrel = "c";

    // Concats
    if(type == kNueConcat || type == kNumuConcat || type == kNusConcat)
    {

      if(WhichPeriod == "full" && WhichNDPeriod == "full")  // only "full"
      {
        std::cerr << "\nWARNING: concats are only available for 'full' dataset"
          << std::endl << std::endl;
        SetLoaderFDMCPaths(
          "prod_"+dataTier+"_R17-11-14-prod4reco.neutron-respin." + rel +
          "_fd_genie",
          fluxType + "_nova_v08_" + WhichPeriod + "_v1_" + cafType);
        SetLoaderNDMCPath(
          "prod_"+dataTier+"_R17-11-14-prod4reco.neutron-respin." + ndrel +
          "_nd_genie_nonswap_" + fluxType + "_nova_v08_" + WhichNDPeriod +
          "_v1_" + cafType);
      }
    }

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

    // Full CAFs
    if(type == kFullCAF)
    {
      // Using neutron respin for all NDMC and FDMC
      SetLoaderFDMCPaths(
        "prod_"+dataTier+"_R17-11-14-prod4reco.neutron-respin." + rel + "_fd_genie",
        fluxType + "_nova_v08_" + WhichPeriod + "_v1");
      SetLoaderNDMCPath(
        "prod_"+dataTier+"_R17-11-14-prod4reco.neutron-respin." + ndrel +
        "_nd_genie_nonswap_" + fluxType + "_nova_v08_" + WhichNDPeriod + "_v1");
    }
  }

  //..........................................................................
  Prod4AbsCalibLoaders::Prod4AbsCalibLoaders(ECAFType type,
                                             FluxType flux,
                                             int sign,
                                             std::string WhichPeriod,
                                             std::string WhichNDPeriod)
    : Prod4DataLoaders(type, flux, WhichPeriod, WhichNDPeriod)
  {
    assert(abs(sign) == 1);

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

    const std::string posneg = (sign > 0) ? "pos" : "neg";

    if(type == kNueConcat || type == kNumuConcat || type == kNusConcat)
    {
      if(WhichPeriod == "full" && WhichNDPeriod == "full")  // only "full"
      {
        SetLoaderFDMCPaths(
          "prod_sumdecaf_R17-11-14-prod4reco." + rel + "_fd_genie",
          fluxType + "_nova_v08_" + WhichPeriod + "_calib-shift-fd-xyview-" +
            posneg + "-offset_v1_" + cafType);
        SetLoaderNDMCPath(
          "prod_sumdecaf_R17-11-14-prod4reco." + ndrel + "_nd_genie_nonswap_" +
          fluxType + "_nova_v08_" + WhichNDPeriod + "_calib-shift-nd-xyview-" +
          posneg + "-offset_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_caf_R17-11-14-prod4reco." + rel + "_fd_genie",
        fluxType + "_nova_v08_" + WhichPeriod + "_calib-shift-fd-xyview-" +
          posneg + "-offset_v1");
      SetLoaderNDMCPath(
        "prod_caf_R17-11-14-prod4reco." + ndrel + "_nd_genie_nonswap_" +
        fluxType + "_nova_v08_" + WhichNDPeriod + "_calib-shift-nd-xyview-" +
        posneg + "-offset_v1");
    }
  }

  //..........................................................................
  Prod4LightLevelLoaders::Prod4LightLevelLoaders(ECAFType type,
                                                 FluxType flux,
                                                 int sign,
                                                 std::string WhichPeriod,
                                                 std::string WhichNDPeriod)
    : Prod4DataLoaders(type, flux, WhichPeriod, WhichNDPeriod)
  {
    assert((abs(sign) == 1) || (sign == 0));

    const std::string rel = (sign == 0) ? "i":"g";  // assuming same for FHC/RHC
    const std::string ndrel = "g";  // assuming same for FHC/RHC

    std::string updown;
    if(sign == 1) updown = "lightup-calibdown";
    else if (sign == -1) updown = "lightdown-calibup";
    // We do still need noshift for light level in prod4
    else if (sign == 0) updown = "noshift";

    if(type == kNueConcat || type == kNumuConcat || type == kNusConcat)
    {
      if (sign == 0)
      {
        // TODO: remove this when the definitions are available
        std::cerr << "\nWARNING: concats not available for noshift sample yet "
          << "---> use full CAFs" << std::endl << std::endl;
      }
      if(WhichPeriod == "full" && WhichNDPeriod == "full")  // only "full"
      {
        SetLoaderFDMCPaths(
          "prod_sumdecaf_R17-11-14-prod4reco." + rel + "_fd_genie",
          fluxType + "_nova_v08_" + WhichPeriod + "_lightmodel-" +
            updown + "_v1_" + cafType);
        if (abs(sign) == 1)  // noshift is for FD only
          SetLoaderNDMCPath(
            "prod_sumdecaf_R17-11-14-prod4reco." + ndrel +
            "_nd_genie_nonswap_" + fluxType + "_nova_v08_" + WhichNDPeriod +
            "_lightmodel-" + updown + "_v1_" + cafType);
        else
          std::cerr << "\nWARNING: skipping NDMC loader for LightLevelNom"
            << std::endl << std::endl;
      }
    }

    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_caf_R17-11-14-prod4reco." + rel + "_fd_genie",
        fluxType + "_nova_v08_" + WhichPeriod + "_lightmodel-" + updown +
        "_v1");
      if (abs(sign) == 1)  // noshift is for FD only
        SetLoaderNDMCPath(
          "prod_caf_R17-11-14-prod4reco." + ndrel + "_nd_genie_nonswap_" +
          fluxType + "_nova_v08_" + WhichNDPeriod + "_lightmodel-" + updown +
          "_v1");
      else
        std::cerr << "\nWARNING: skipping NDMC loader for LightLevelNom"
          << std::endl << std::endl;
    }
  }

  //..........................................................................
  Prod4CherenkovLoaders::Prod4CherenkovLoaders(ECAFType type,
                                               FluxType flux,
                                               std::string WhichPeriod,
                                               std::string WhichNDPeriod)
    : Prod4DataLoaders(type, flux, WhichPeriod, WhichNDPeriod)
  {
    const std::string rel = "g";  // assuming same for FHC/RHC
    const std::string ndrel = "g";  // assuming same for FHC/RHC


    if(type == kNueConcat || type == kNumuConcat || type == kNusConcat)
    {
      if(WhichPeriod == "full" && WhichNDPeriod == "full")  // only "full"
      {
        SetLoaderFDMCPaths(
          "prod_sumdecaf_R17-11-14-prod4reco." + rel + "_fd_genie",
          fluxType + "_nova_v08_" + WhichPeriod +
          "_ckv-proton-shift-down_v1_" + cafType);
        SetLoaderNDMCPath(
          "prod_sumdecaf_R17-11-14-prod4reco." + ndrel + "_nd_genie_nonswap_" +
          fluxType + "_nova_v08_" + WhichNDPeriod +
          "_ckv-proton-shift-down_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_caf_R17-11-14-prod4reco." + rel + "_fd_genie",
        fluxType + "_nova_v08_" + WhichPeriod + "_ckv-proton-shift-down_v2");
      SetLoaderNDMCPath (
        "prod_caf_R17-11-14-prod4reco." + ndrel+ "_nd_genie_nonswap_" +
        fluxType + "_nova_v08_" + WhichNDPeriod + "_ckv-proton-shift-down_v1");
    }
  }

  //..........................................................................
  Prod4CalibShapeLoaders::Prod4CalibShapeLoaders(ECAFType type,
                                                 FluxType flux,
                                                 std::string WhichPeriod,
                                                 std::string WhichNDPeriod)
    : Prod4DataLoaders(type, flux, WhichPeriod, WhichNDPeriod)
  {
    const std::string rel = "f";  // assuming same for FHC/RHC
    const std::string ndrel = "g";  // assuming same for FHC/RHC

    if(type == kNueConcat || type == kNumuConcat || type == kNusConcat)
    {
      if(WhichPeriod == "full" && WhichNDPeriod == "full")  // only "full"
      {
        SetLoaderFDMCPaths(
          "prod_sumdecaf_R17-11-14-prod4reco." + rel + "_fd_genie",
          fluxType + "_nova_v08_" + WhichPeriod +
          "_calib-shift-fd-func_v1_" + cafType);
        SetLoaderNDMCPath(
          "prod_sumdecaf_R17-11-14-prod4reco." + ndrel + "_nd_genie_nonswap_" +
          fluxType + "_nova_v08_" + WhichNDPeriod + "_calib-shift-nd-func_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_caf_R17-11-14-prod4reco." + rel + "_fd_genie",
        fluxType + "_nova_v08_" + WhichPeriod + "_calib-shift-fd-func_v1");
      SetLoaderNDMCPath(
        "prod_caf_R17-11-14-prod4reco." + ndrel + "_nd_genie_nonswap_" +
        fluxType + "_nova_v08_" + WhichNDPeriod + "_calib-shift-nd-func_v1");
    }
  }

} // namespace