NueRHCExtrap.cxx

Go to the documentation of this file.

#include "3FlavorAna/Extrap/NueRHCExtrap.h"

#include "CAFAna/Core/Loaders.h"
#include "CAFAna/Core/SpectrumLoaderBase.h"
#include "CAFAna/Core/SystShifts.h"
#include "CAFAna/Cuts/TruthCuts.h"
#include "CAFAna/Decomp/IDecomp.h"
#include "3FlavorAna/Extrap/FluxReweight.h"

namespace ana
{
  //---------------------------------------------------------------------------

  NueRHCExtrap::NueRHCExtrap(SpectrumLoaderBase& nearMC,
                             SpectrumLoaderBase& farMCswap,
                             SpectrumLoaderBase& farMCnonswap,
                             SpectrumLoaderBase& farMCtauswap,
                             const IDecomp& nueDecomp,
                             const IDecomp& numuDecomp,
                             const HistAxis& axis,
                             const HistAxis& axisNumuND,
                             const Cut& fdcut,
                             const Cut& nueNDcut,
                             const Cut& numuNDcut,
                             const SystShifts& shiftMC,
                             const Var& weight)
      : ModularExtrap(farMCswap,
                      farMCnonswap,
                      farMCtauswap,
                      axis,
                      fdcut,
                      shiftMC,
                      weight)
  {
    // mu -> mu  ----
    fMMextrap = std::unique_ptr<ModularExtrapComponent>(
        new RecoReweight(
            nearMC, axis, fdcut, shiftMC, weight,
            "mu -> mu", "#nu_{#mu} #rightarrow #nu_{#mu}",
            nueNDcut, nueDecomp,                            // nue selection in ND
            DecompResult::numu, kIsNumuCC && !kIsAntiNu,    // numu truth in ND
            farMCnonswap, kIsNumuCC && !kIsAntiNu           // mu->mu in FD
        )
    );
    // mubar -> mubar ---
    fMMAntiextrap = std::unique_ptr<ModularExtrapComponent>(
        new RecoReweight(
            nearMC, axis, fdcut, shiftMC, weight,
            "mubar -> mubar", "#bar{#nu}_{#mu} #rightarrow #bar{#nu}_{#mu}",
            nueNDcut, nueDecomp,                            // nue selection in ND
            DecompResult::numubar, kIsNumuCC && kIsAntiNu,    // numu truth in ND
            farMCnonswap, kIsNumuCC && kIsAntiNu           // mu->mu in FD
        )
    );

    // mu -> e ----
    fMEextrap = std::unique_ptr<ModularExtrapComponent>(
        new TruthReweight(
            nearMC, axis, axisNumuND, fdcut, shiftMC, weight,
            "mu -> e", "#nu_{#mu} #rightarrow #nu_{e}",
            numuNDcut, numuDecomp,                          // numu selection in ND
            DecompResult::numu, kIsNumuCC && !kIsAntiNu,    // numu truth in ND
            farMCswap, kIsSig && !kIsAntiNu                 // mu->e in FD
        )
    );
    // mubar -> ebar
    fMEAntiextrap = std::unique_ptr<ModularExtrapComponent>(
        new TruthReweight(
            nearMC, axis, axisNumuND, fdcut, shiftMC, weight,
            "mubar -> ebar", "#bar{#nu}_{#mu} #rightarrow #bar{#nu}_{e}",
            numuNDcut, numuDecomp,                          // numu selection in ND
            DecompResult::numubar, kIsNumuCC && kIsAntiNu,  // numubar truth in ND
            farMCswap, kIsSig && kIsAntiNu                  // mubar->ebar in FD
        )
    );

    // NC -> NC ----
    fNCextrap = std::unique_ptr<ModularExtrapComponent>(
        new RecoReweight(
            nearMC, axis, fdcut, shiftMC, weight,
            "NC -> NC", "NC #rightarrow NC",
            nueNDcut, nueDecomp,                            // nue selection in ND
            DecompResult::NC, kIsNC  && !kIsAntiNu,         // NC truth in ND
            farMCswap, kIsNC && !kIsAntiNu,                 // NC->NC in FD
            farMCnonswap, farMCtauswap                      // extra NC stats
        )
    );
    // NC Anti -> NC Anti ---
    fNCAntiextrap = std::unique_ptr<ModularExtrapComponent>(
        new RecoReweight(
            nearMC, axis, fdcut, shiftMC, weight,
            "NCbar -> NCbar", "NC bar #rightarrow NC bar",
            nueNDcut, nueDecomp,                            // nue selection in ND
            DecompResult::NCbar, kIsNC && kIsAntiNu,           // NC truth in ND
            farMCswap, kIsNC && kIsAntiNu,                  // NC->NC in FD
            farMCnonswap, farMCtauswap                      // extra NC stats
        )
    );

    // e -> e ----
    fEEextrap = std::unique_ptr<ModularExtrapComponent>(
        new RecoReweight(
            nearMC, axis, fdcut, shiftMC, weight,
            "e -> e", "#nu_{e} #rightarrow #nu_{e}",
            nueNDcut, nueDecomp,                           // nue selection in ND
            DecompResult::nue, kIsBeamNue && !kIsAntiNu,   // nue truth in ND
            farMCnonswap, kIsBeamNue && !kIsAntiNu         // e->e in FD
        )
    );

    // ebar -> ebar ---
    fEEAntiextrap = std::unique_ptr<ModularExtrapComponent>(
        new RecoReweight(
            nearMC, axis, fdcut, shiftMC, weight,
            "ebar -> ebar", "#bar{#nu}_{e} #rightarrow #bar{#nu}_{e}",
            nueNDcut, nueDecomp,                             // nue selection in ND
            DecompResult::nuebar, kIsBeamNue && kIsAntiNu,   // nue truth in ND
            farMCnonswap, kIsBeamNue && kIsAntiNu            // e->e in FD
        )
    );
  }

 //---------------------------------------------------------------------------

  NueRHCExtrap::NueRHCExtrap(Loaders& loaders,
                             const IDecomp& nueDecomp,
                             const IDecomp& numuDecomp,
                             const HistAxis& axis,
                             const HistAxis& axisNumuND,
                             const Cut& fdcut,
                             const Cut& nueNDcut,
                             const Cut& numuNDcut,
                             const SystShifts& shiftMC,
                             const Var& weight)
      : NueRHCExtrap(loaders.GetLoader(caf::kNEARDET,
                                       Loaders::kMC,
                                       ana::kBeam,
                                       Loaders::kNonSwap),
                     loaders.GetLoader(caf::kFARDET,
                                       Loaders::kMC,
                                       ana::kBeam,
                                       Loaders::kFluxSwap),
                     loaders.GetLoader(caf::kFARDET,
                                       Loaders::kMC,
                                       ana::kBeam,
                                       Loaders::kNonSwap),
                     loaders.GetLoader(caf::kFARDET,
                                       Loaders::kMC,
                                       ana::kBeam,
                                       Loaders::kTauSwap),
                     nueDecomp,
                     numuDecomp,
                     axis,
                     axisNumuND,
                     fdcut,
                     nueNDcut,
                     numuNDcut,
                     shiftMC,
                     weight)
  {}

}