Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | Private Member Functions | List of all members
ana::ModularExtrapSterile Class Reference

#include "/cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N19-12-08/CAFAna/Extrap/ExtrapSterile.h"

Inheritance diagram for ana::ModularExtrapSterile:
ana::ModularExtrap ana::IExtrap

Public Member Functions

 ModularExtrapSterile (const ModularExtrapSterile &)=delete
 
ModularExtrapSterileoperator= (const ModularExtrapSterile &)=delete
 
 ModularExtrapSterile (ModularExtrapSterile &&)=default
 
ModularExtrapSterileoperator= (ModularExtrapSterile &&)=default
 
virtual ~ModularExtrapSterile ()=default
 
void SaveTo (TDirectory *dir) const override
 
OscillatableSpectrum OscNCComponent ()
 Return the oscillatable NC component. More...
 
Spectrum NCTotalComponent () override
 Override the ModularExtrap method. More...
 
Ratio NCNueProportion ()
 Return the proportion of NCs that originate as a given neutrino flavor/sign. More...
 
Ratio NCAntiNueProportion ()
 
Ratio NCNumuProportion ()
 
Ratio NCAntiNumuProportion ()
 
void SavePlotsNue (TDirectory *dir, double potFD) const
 
void SavePlotsNueRHC (TDirectory *dir, double potFD) const
 
void SavePlotsNumu (TDirectory *dir, double potFD) const
 
OscillatableSpectrum NueSurvComponent () override
 Charged current electron neutrino survival ( $\nu_e\to\nu_e$) More...
 
OscillatableSpectrum AntiNueSurvComponent () override
 Charged current electron antineutrino survival ( $\bar\nu_e\to\bar\nu_e$) More...
 
OscillatableSpectrum NumuSurvComponent () override
 Charged current muon neutrino survival ( $\nu_\mu\to\nu_\mu$) More...
 
OscillatableSpectrum AntiNumuSurvComponent () override
 Charged current muon antineutrino survival ( $\bar\nu_\mu\to\bar\nu_\mu$) More...
 
OscillatableSpectrum NueAppComponent () override
 Charged current electron neutrino appearance ( $\nu_\mu\to\nu_e$) More...
 
OscillatableSpectrum AntiNueAppComponent () override
 Charged current electron antineutrino appearance ( $\bar\nu_\mu\to\bar\nu_e$) More...
 
OscillatableSpectrum NumuAppComponent () override
 Charged current muon neutrino appearance ( $\nu_e\to\nu_\mu$) More...
 
OscillatableSpectrum AntiNumuAppComponent () override
 Charged current muon antineutrino appearance ( $\bar\nu_e\to\bar\nu_\mu$) More...
 
OscillatableSpectrum TauFromMuComponent () override
 Charged current tau neutrino appearance from muon neutrino ( $\nu_\mu\to\nu_\tau$) More...
 
OscillatableSpectrum AntiTauFromMuComponent () override
 Charged current tau antineutrino appearance from muon antineutrino ( $\bar\nu_\mu\to\bar\nu_\tau$) More...
 
OscillatableSpectrum TauFromEComponent () override
 Charged current tau neutrino appearance from electron neutrino ( $\nu_e\to\nu_\tau$) More...
 
OscillatableSpectrum AntiTauFromEComponent () override
 Charged current tau antineutrino appearance from electron antineutrino ( $\bar\nu_e\to\bar\nu_\tau$) More...
 
Spectrum NCComponent () override
 
Spectrum NCAntiComponent () override
 
std::vector< ModularExtrapComponent * > GetModExtrapComponents () const
 
void DeDuplicateNueDecomps () const
 

Static Public Member Functions

static ModularExtrapSterile NCDisappearance (Loaders &loaders, const IDecomp &NCSurvDecomp, const IDecomp &NumuOscDecomp, const HistAxis &axis, const HistAxis &axisNumuND, const Cut &fdcut, const Cut &NCNDcut, const Cut &NumuNDcut, const SystShifts &shiftMC=kNoShift, const Var &weight=kUnweighted)
 Creates a NC disappearance extrapolation. More...
 
static ModularExtrapSterile NCDisappearance (SpectrumLoaderBase &nearMCLoader, SpectrumLoaderBase &farMCswapLoader, SpectrumLoaderBase &farMCnonswapLoader, SpectrumLoaderBase &farMCtauswapLoader, const IDecomp &NCSurvDecomp, const IDecomp &NumuOscDecomp, const HistAxis &axis, const HistAxis &axisNumuND, const Cut &fdcut, const Cut &NCNDcut, const Cut &NumuNDcut, const SystShifts &shiftMC=kNoShift, const Var &weight=kUnweighted)
 Creates a NC disappearance extrapolation with individual spectrum loaders. More...
 
static ModularExtrapSterile TrivialExtrapNC (Loaders &loaders, const HistAxis &axis, const Cut &fdcut, const SystShifts &shiftMC=kNoShift, const Var &weight=kUnweighted)
 Creates a NC disappearance "extrapolation" by returning FD MC. More...
 
static ModularExtrapSterile TrivialExtrapNC (SpectrumLoaderBase &farMCswapLoader, SpectrumLoaderBase &farMCnonswapLoader, SpectrumLoaderBase &farMCtauswapLoader, const HistAxis &axis, const Cut &fdcut, const SystShifts &shiftMC=kNoShift, const Var &weight=kUnweighted)
 
static std::unique_ptr< ModularExtrapSterileLoadFrom (TDirectory *dir)
 
static ModularExtrap Nue (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=kNoShift, const Var &weight=kUnweighted)
 Creates a nue-like extrapolation. More...
 
static ModularExtrap Nue (SpectrumLoaderBase &nearMCLoader, SpectrumLoaderBase &farMCswapLoader, SpectrumLoaderBase &farMCnonswapLoader, SpectrumLoaderBase &farMCtauswapLoader, const IDecomp &nueDecomp, const IDecomp &numuDecomp, const HistAxis &axis, const HistAxis &axisNumuND, const Cut &fdcut, const Cut &nueNDcut, const Cut &numuNDcut, const SystShifts &shiftMC=kNoShift, const Var &weight=kUnweighted)
 Creates a nue-like extrapolation with individual spectrum loaders. More...
 
static ModularExtrap NueRHC (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=kNoShift, const Var &weight=kUnweighted)
 Creates a nue-like extrapolation for RHC mode. More...
 
static ModularExtrap NueRHC (SpectrumLoaderBase &nearMCLoader, SpectrumLoaderBase &farMCswapLoader, SpectrumLoaderBase &farMCnonswapLoader, SpectrumLoaderBase &farMCtauswapLoader, const IDecomp &nueDecomp, const IDecomp &numuDecomp, const HistAxis &axis, const HistAxis &axisNumuND, const Cut &fdcut, const Cut &nueNDcut, const Cut &numuNDcut, const SystShifts &shiftMC=kNoShift, const Var &weight=kUnweighted)
 Creates a nue-like extrapolation for RHC mode. More...
 
static ModularExtrap NueFlux (Loaders &loaders, const FluxDecomp &nueDecomp, const IDecomp &numuDecomp, const HistAxis &axis, const HistAxis &axisNumuND, const Cut &fdcut, const Cut &nueNDcut, const Cut &numuNDcut, const SystShifts &shiftMC=kNoShift, const Var &weight=kUnweighted)
 
static ModularExtrap NueFlux (SpectrumLoaderBase &nearMCLoader, SpectrumLoaderBase &farMCswapLoader, SpectrumLoaderBase &farMCnonswapLoader, SpectrumLoaderBase &farMCtauswapLoader, const FluxDecomp &nueDecomp, const IDecomp &numuDecomp, const HistAxis &axis, const HistAxis &axisNumuND, const Cut &fdcut, const Cut &nueNDcut, const Cut &numuNDcut, const SystShifts &shiftMC=kNoShift, const Var &weight=kUnweighted)
 Creates a nue-like extrapolation for RHC mode. More...
 
static ModularExtrap Numu (Loaders &loaders, const IDecomp &numuDecomp, const HistAxis &axis, const Cut &fdcut, const Cut &ndcut, const SystShifts &shiftMC=kNoShift, const Var &weight=kUnweighted)
 Creates a numu-like extrapolation. More...
 
static ModularExtrap Numu (SpectrumLoaderBase &nearMCLoader, SpectrumLoaderBase &farMCswapLoader, SpectrumLoaderBase &farMCnonswapLoader, SpectrumLoaderBase &farMCtauswapLoader, const IDecomp &numuDecomp, const HistAxis &axis, const Cut &fdcut, const Cut &ndcut, const SystShifts &shiftMC=kNoShift, const Var &weight=kUnweighted)
 Creates a numu-like extrapolation with individual spectrum loaders. More...
 

Protected Member Functions

 ModularExtrapSterile (ModularExtrap &&load)
 Constructor necessary for loading an extrapolation from file. More...
 
void GenerateNCRatios ()
 

Protected Attributes

std::unique_ptr< SpectrumfNCNueNumerator
 
std::unique_ptr< SpectrumfNCAntiNueNumerator
 
std::unique_ptr< SpectrumfNCNumuNumerator
 
std::unique_ptr< SpectrumfNCAntiNumuNumerator
 
std::unique_ptr< SpectrumfNCDenominator
 
std::unique_ptr< RatiofNCNueProportion
 
std::unique_ptr< RatiofNCAntiNueProportion
 
std::unique_ptr< RatiofNCNumuProportion
 
std::unique_ptr< RatiofNCAntiNumuProportion
 
std::unique_ptr< ModularExtrapComponentfEEextrap
 
std::unique_ptr< ModularExtrapComponentfEEAntiextrap
 
std::unique_ptr< ModularExtrapComponentfMMextrap
 
std::unique_ptr< ModularExtrapComponentfMMAntiextrap
 
std::unique_ptr< ModularExtrapComponentfMEextrap
 
std::unique_ptr< ModularExtrapComponentfMEAntiextrap
 
std::unique_ptr< ModularExtrapComponentfEMextrap
 
std::unique_ptr< ModularExtrapComponentfEMAntiextrap
 
std::unique_ptr< ModularExtrapComponentfNCTotalextrap
 
std::unique_ptr< ModularExtrapComponentfNCextrap
 
std::unique_ptr< ModularExtrapComponentfNCAntiextrap
 
std::unique_ptr< ModularExtrapComponentfMTextrap
 
std::unique_ptr< ModularExtrapComponentfMTAntiextrap
 
std::unique_ptr< ModularExtrapComponentfETextrap
 
std::unique_ptr< ModularExtrapComponentfETAntiextrap
 

Private Member Functions

 ModularExtrapSterile (SpectrumLoaderBase &farMCswapLoader, SpectrumLoaderBase &farMCnonswapLoader, SpectrumLoaderBase &farMCtauswapLoader, const HistAxis &axis, const Cut &fdcut, const SystShifts &shiftMC, const Var &weight)
 Sets up all components to use FD MC–internal use only. More...
 

Detailed Description

A ModularExtrap compatible with sterile oscillations. Only extrapolates one sample.

Definition at line 24 of file ExtrapSterile.h.

Constructor & Destructor Documentation

ana::ModularExtrapSterile::ModularExtrapSterile ( SpectrumLoaderBase farMCswapLoader,
SpectrumLoaderBase farMCnonswapLoader,
SpectrumLoaderBase farMCtauswapLoader,
const HistAxis axis,
const Cut fdcut,
const SystShifts shiftMC,
const Var weight 
)
private

Sets up all components to use FD MC–internal use only.

Use a named constructor to create a ModularExtrapSterile.

Definition at line 189 of file ExtrapSterile.cxx.

References GenerateNCRatios(), and ana::SpectrumLoaderBase::RegisterCompletionCallback().

Referenced by LoadFrom(), and NCAntiNumuProportion().

197  : ModularExtrap(
198  farMCswap,
199  farMCnonswap,
200  farMCtauswap,
201  axis,
202  fdcut,
203  shiftMC,
204  weight
205  ), // Sets up the components with default NoReweights
206 
207  // Set up Spectrum objects for NC Proportion Ratios
208  fNCNueNumerator(std::make_unique<Spectrum>(farMCnonswap, axis,
209  fdcut && kIsNC && !kIsAntiNu && kNCBeamNue,
210  shiftMC, weight)),
211  fNCAntiNueNumerator(std::make_unique<Spectrum>(farMCnonswap, axis,
212  fdcut && kIsNC && kIsAntiNu && kNCBeamNue,
213  shiftMC, weight)),
214  fNCNumuNumerator(std::make_unique<Spectrum>(farMCnonswap, axis,
215  fdcut && kIsNC && !kIsAntiNu && kNCBeamNumu,
216  shiftMC, weight)),
217  fNCAntiNumuNumerator(std::make_unique<Spectrum>(farMCnonswap, axis,
218  fdcut && kIsNC && kIsAntiNu && kNCBeamNumu,
219  shiftMC, weight)),
220  fNCDenominator(std::make_unique<Spectrum>(farMCnonswap, axis,
221  fdcut && kIsNC,
222  shiftMC, weight))
223  {
224  // Generate the ratios once the necessary loader has 'gone'
225  farMCnonswap.RegisterCompletionCallback(this, &ModularExtrapSterile::GenerateNCRatios);
226  }
std::unique_ptr< Spectrum > fNCNueNumerator
const Var weight
std::unique_ptr< Spectrum > fNCNumuNumerator
std::unique_ptr< Spectrum > fNCAntiNumuNumerator
const Cut kIsAntiNu([](const caf::SRProxy *sr){if(sr->mc.nnu==0) return false;assert(sr->mc.nnu==1);return sr->mc.nu[0].pdg< 0;})
Is this truly an antineutrino?
Definition: TruthCuts.h:53
std::unique_ptr< Spectrum > fNCDenominator
const Cut kNCBeamNue(NCFlavSel(12, 12))
Select NC .
const Cut kIsNC([](const caf::SRProxy *sr){if(sr->mc.nnu==0) return false;assert(sr->mc.nnu==1);return!sr->mc.nu[0].iscc;})
Is this a Neutral Current event?
Definition: TruthCuts.h:8
const Cut kNCBeamNumu(NCFlavSel(14, 14))
Select NC .
std::unique_ptr< Spectrum > fNCAntiNueNumerator
ana::ModularExtrapSterile::ModularExtrapSterile ( const ModularExtrapSterile )
delete
ana::ModularExtrapSterile::ModularExtrapSterile ( ModularExtrapSterile &&  )
default
virtual ana::ModularExtrapSterile::~ModularExtrapSterile ( )
virtualdefault
ana::ModularExtrapSterile::ModularExtrapSterile ( ModularExtrap &&  load)
protected

Constructor necessary for loading an extrapolation from file.

Definition at line 229 of file ExtrapSterile.cxx.

230  : ModularExtrap(std::move(load)) // Sets up the ModularExtrapComponents
231  {
232  }
void load(std::string lib)
Definition: load_libs.C:3

Member Function Documentation

OscillatableSpectrum ana::ModularExtrap::AntiNueAppComponent ( )
overridevirtualinherited

Charged current electron antineutrino appearance ( $\bar\nu_\mu\to\bar\nu_e$)

Implements ana::IExtrap.

Definition at line 704 of file ModularExtrap.cxx.

References ana::ModularExtrap::fMEAntiextrap.

705  {return fMEAntiextrap->Return();}
std::unique_ptr< ModularExtrapComponent > fMEAntiextrap
OscillatableSpectrum ana::ModularExtrap::AntiNueSurvComponent ( )
overridevirtualinherited

Charged current electron antineutrino survival ( $\bar\nu_e\to\bar\nu_e$)

Implements ana::IExtrap.

Definition at line 692 of file ModularExtrap.cxx.

References ana::ModularExtrap::fEEAntiextrap.

693  {return fEEAntiextrap->Return();}
std::unique_ptr< ModularExtrapComponent > fEEAntiextrap
OscillatableSpectrum ana::ModularExtrap::AntiNumuAppComponent ( )
overridevirtualinherited

Charged current muon antineutrino appearance ( $\bar\nu_e\to\bar\nu_\mu$)

Implements ana::IExtrap.

Definition at line 710 of file ModularExtrap.cxx.

References ana::ModularExtrap::fEMAntiextrap.

711  {return fEMAntiextrap->Return();}
std::unique_ptr< ModularExtrapComponent > fEMAntiextrap
OscillatableSpectrum ana::ModularExtrap::AntiNumuSurvComponent ( )
overridevirtualinherited

Charged current muon antineutrino survival ( $\bar\nu_\mu\to\bar\nu_\mu$)

Implements ana::IExtrap.

Definition at line 698 of file ModularExtrap.cxx.

References ana::ModularExtrap::fMMAntiextrap.

699  {return fMMAntiextrap->Return();}
std::unique_ptr< ModularExtrapComponent > fMMAntiextrap
OscillatableSpectrum ana::ModularExtrap::AntiTauFromEComponent ( )
overridevirtualinherited

Charged current tau antineutrino appearance from electron antineutrino ( $\bar\nu_e\to\bar\nu_\tau$)

Implements ana::IExtrap.

Definition at line 731 of file ModularExtrap.cxx.

References ana::ModularExtrap::fETAntiextrap.

732  {return fETAntiextrap->Return();}
std::unique_ptr< ModularExtrapComponent > fETAntiextrap
OscillatableSpectrum ana::ModularExtrap::AntiTauFromMuComponent ( )
overridevirtualinherited

Charged current tau antineutrino appearance from muon antineutrino ( $\bar\nu_\mu\to\bar\nu_\tau$)

Implements ana::IExtrap.

Definition at line 725 of file ModularExtrap.cxx.

References ana::ModularExtrap::fMTAntiextrap.

726  {return fMTAntiextrap->Return();}
std::unique_ptr< ModularExtrapComponent > fMTAntiextrap
void ana::ModularExtrap::DeDuplicateNueDecomps ( ) const
inherited

Definition at line 660 of file ModularExtrap.cxx.

References ana::RecoReweight::fDecomp, ana::ModularExtrap::fEEextrap, ana::ModularExtrap::fMMextrap, ana::ModularExtrap::fNCTotalextrap, ana::RecoReweight::GetDecomp(), ana::MichelDecomp::GetNueEstimateDecomp(), Munits::mm, make_root_from_grid_output::nc, and run_unfold_genie_multiprocess::ncmd.

Referenced by ana::PredictionSystNueSecondAna::DedupDecomps(), and ana::ModularExtrap::GetModExtrapComponents().

661  {
662  // TODO it would be far far better if the SaveTo/LoadFrom procedure didn't
663  // duplicate these in the first place.
664 
665  RecoReweight* mm = dynamic_cast<RecoReweight*>(fMMextrap.get());
666  RecoReweight* ee = dynamic_cast<RecoReweight*>(fEEextrap.get());
667  RecoReweight* nc = dynamic_cast<RecoReweight*>(fNCTotalextrap.get());
668 
669  assert(mm && ee && nc);
670 
671  const MichelDecomp* eemd = dynamic_cast<const MichelDecomp*>(ee->GetDecomp());
672  const MichelDecomp* ncmd = dynamic_cast<const MichelDecomp*>(nc->GetDecomp());
673 
674  // Probably this is the proportional decomp case
675  if(!eemd || !ncmd) return;
676 
677  delete eemd->GetNueEstimateDecomp();
678  delete ncmd->GetNueEstimateDecomp();
679 
680  delete ee->fDecomp;
681  delete nc->fDecomp;
682 
683  ee->fDecomp = mm->fDecomp;
684  nc->fDecomp = mm->fDecomp;
685  }
std::unique_ptr< ModularExtrapComponent > fMMextrap
std::unique_ptr< ModularExtrapComponent > fNCTotalextrap
static constexpr Double_t mm
Definition: Munits.h:136
std::unique_ptr< ModularExtrapComponent > fEEextrap
void ana::ModularExtrapSterile::GenerateNCRatios ( )
protected

Definition at line 245 of file ExtrapSterile.cxx.

References fNCAntiNueNumerator, fNCAntiNueProportion, fNCAntiNumuNumerator, fNCAntiNumuProportion, fNCDenominator, fNCNueNumerator, fNCNueProportion, fNCNumuNumerator, and fNCNumuProportion.

Referenced by ModularExtrapSterile(), and NCAntiNumuProportion().

246  {
247  fNCNueProportion = std::make_unique<Ratio>(*fNCNueNumerator.get(), *fNCDenominator.get());
248  fNCAntiNueProportion = std::make_unique<Ratio>(*fNCAntiNueNumerator.get(), *fNCDenominator.get());
249  fNCNumuProportion = std::make_unique<Ratio>(*fNCNumuNumerator.get(), *fNCDenominator.get());
250  fNCAntiNumuProportion = std::make_unique<Ratio>(*fNCAntiNumuNumerator.get(), *fNCDenominator.get());
251  }
std::unique_ptr< Spectrum > fNCNueNumerator
std::unique_ptr< Spectrum > fNCNumuNumerator
std::unique_ptr< Ratio > fNCNumuProportion
std::unique_ptr< Spectrum > fNCAntiNumuNumerator
std::unique_ptr< Spectrum > fNCDenominator
std::unique_ptr< Ratio > fNCAntiNueProportion
std::unique_ptr< Spectrum > fNCAntiNueNumerator
std::unique_ptr< Ratio > fNCAntiNumuProportion
std::unique_ptr< Ratio > fNCNueProportion
std::vector<ModularExtrapComponent*> ana::ModularExtrap::GetModExtrapComponents ( ) const
inlineinherited

Definition at line 179 of file ModularExtrap.h.

References ana::ModularExtrap::DeDuplicateNueDecomps(), ana::ModularExtrap::fEEAntiextrap, ana::ModularExtrap::fEEextrap, ana::ModularExtrap::fEMAntiextrap, ana::ModularExtrap::fEMextrap, ana::ModularExtrap::fETAntiextrap, ana::ModularExtrap::fETextrap, ana::ModularExtrap::fMEAntiextrap, ana::ModularExtrap::fMEextrap, ana::ModularExtrap::fMMAntiextrap, ana::ModularExtrap::fMMextrap, ana::ModularExtrap::fMTAntiextrap, ana::ModularExtrap::fMTextrap, ana::ModularExtrap::fNCAntiextrap, ana::ModularExtrap::fNCextrap, ana::ModularExtrap::fNCTotalextrap, ana::ModularExtrap::ModularExtrap(), and ana::weight.

Referenced by ana::PredictionSystNueSecondAna::DedupDecomps(), ana::PredictionSystNueSecondAna::FreePrediction(), ana::GetDecomp(), and make_files_for_decomp_plots().

180  {
181  return {
182  fEEextrap.get(), fEEAntiextrap.get(),
183  fMMextrap.get(), fMMAntiextrap.get(),
184  fMEextrap.get(), fMEAntiextrap.get(),
185  fEMextrap.get(), fEMAntiextrap.get(),
186  //nc
187  fNCTotalextrap.get(), fNCextrap.get(), fNCAntiextrap.get(),
188  //end nc
189  fMTextrap.get(), fMTAntiextrap.get(),
190  fETextrap.get(), fETAntiextrap.get()};
191  }
std::unique_ptr< ModularExtrapComponent > fMMextrap
std::unique_ptr< ModularExtrapComponent > fMEextrap
std::unique_ptr< ModularExtrapComponent > fEMAntiextrap
std::unique_ptr< ModularExtrapComponent > fNCextrap
std::unique_ptr< ModularExtrapComponent > fMTAntiextrap
std::unique_ptr< ModularExtrapComponent > fNCTotalextrap
std::unique_ptr< ModularExtrapComponent > fMEAntiextrap
std::unique_ptr< ModularExtrapComponent > fEMextrap
std::unique_ptr< ModularExtrapComponent > fEEAntiextrap
std::unique_ptr< ModularExtrapComponent > fNCAntiextrap
std::unique_ptr< ModularExtrapComponent > fMMAntiextrap
std::unique_ptr< ModularExtrapComponent > fETAntiextrap
std::unique_ptr< ModularExtrapComponent > fEEextrap
std::unique_ptr< ModularExtrapComponent > fMTextrap
std::unique_ptr< ModularExtrapComponent > fETextrap
std::unique_ptr< ModularExtrapSterile > ana::ModularExtrapSterile::LoadFrom ( TDirectory *  dir)
static

Definition at line 273 of file ExtrapSterile.cxx.

References fNCAntiNueNumerator, fNCAntiNumuNumerator, fNCDenominator, fNCNueNumerator, fNCNumuNumerator, LOAD_SPECT, ana::ModularExtrap::LoadFrom(), ModularExtrapSterile(), runNovaSAM::release, and runNovaSAM::ret.

Referenced by ana::LoadFrom< IExtrap >().

274  {
275  std::unique_ptr<ModularExtrapSterile> ret(
276  new ModularExtrapSterile( std::move( *(ModularExtrap::LoadFrom(dir).release()) ) )
277  );
278 
279  // This is a lot of repetitive typing. Define a macro
280 #define LOAD_SPECT(FIELD, LABEL) assert(dir->GetDirectory(LABEL)); ret->FIELD = std::move(Spectrum::LoadFrom(dir->GetDirectory(LABEL)));
281 
282  LOAD_SPECT(fNCNueNumerator, "NCNue");
283  LOAD_SPECT(fNCAntiNueNumerator, "NCAntiNue");
284  LOAD_SPECT(fNCNumuNumerator, "NCNumu");
285  LOAD_SPECT(fNCAntiNumuNumerator, "NCAntiNumu");
286  LOAD_SPECT(fNCDenominator, "AllNC");
287 
288  ret->GenerateNCRatios(); // Make sure to generate the ratios
289 
290  return ret;
291  }
std::unique_ptr< Spectrum > fNCNueNumerator
std::unique_ptr< Spectrum > fNCNumuNumerator
std::unique_ptr< Spectrum > fNCAntiNumuNumerator
std::unique_ptr< Spectrum > fNCDenominator
#define LOAD_SPECT(FIELD, LABEL)
ModularExtrapSterile(SpectrumLoaderBase &farMCswapLoader, SpectrumLoaderBase &farMCnonswapLoader, SpectrumLoaderBase &farMCtauswapLoader, const HistAxis &axis, const Cut &fdcut, const SystShifts &shiftMC, const Var &weight)
Sets up all components to use FD MC–internal use only.
TDirectory * dir
Definition: macro.C:5
std::unique_ptr< Spectrum > fNCAntiNueNumerator
static std::unique_ptr< ModularExtrap > LoadFrom(TDirectory *dir)
Spectrum ana::ModularExtrap::NCAntiComponent ( )
overridevirtualinherited

Implements ana::IExtrap.

Definition at line 716 of file ModularExtrap.cxx.

References ana::ModularExtrap::fNCAntiextrap.

Referenced by ana::ModularExtrap::NCTotalComponent().

717  {return fNCAntiextrap->Return().Unoscillated();}
std::unique_ptr< ModularExtrapComponent > fNCAntiextrap
Ratio ana::ModularExtrapSterile::NCAntiNueProportion ( )
inline

Definition at line 115 of file ExtrapSterile.h.

References fNCAntiNueProportion.

Referenced by ana::PredictionSterile::PredictComponent().

115 { return *fNCAntiNueProportion.get(); }
std::unique_ptr< Ratio > fNCAntiNueProportion
Ratio ana::ModularExtrapSterile::NCAntiNumuProportion ( )
inline

Definition at line 117 of file ExtrapSterile.h.

References fNCAntiNumuProportion, GenerateNCRatios(), load(), and ModularExtrapSterile().

Referenced by ana::PredictionSterile::PredictComponent().

117 { return *fNCAntiNumuProportion.get(); }
std::unique_ptr< Ratio > fNCAntiNumuProportion
Spectrum ana::ModularExtrap::NCComponent ( )
overridevirtualinherited

Implements ana::IExtrap.

Definition at line 713 of file ModularExtrap.cxx.

References ana::ModularExtrap::fNCextrap.

Referenced by ana::ModularExtrap::NCTotalComponent().

714  {return fNCextrap->Return().Unoscillated();}
std::unique_ptr< ModularExtrapComponent > fNCextrap
ModularExtrapSterile ana::ModularExtrapSterile::NCDisappearance ( Loaders loaders,
const IDecomp NCSurvDecomp,
const IDecomp NumuOscDecomp,
const HistAxis axis,
const HistAxis axisNumuND,
const Cut fdcut,
const Cut NCNDcut,
const Cut NumuNDcut,
const SystShifts shiftMC = kNoShift,
const Var weight = kUnweighted 
)
static

Creates a NC disappearance extrapolation.

NCSurvDecomp and NCNDcut are for survival components selected as NCs. NumuOscDecomp and NumuNDCut are for components oscillated from numus, which then get selected as NCs.

Definition at line 19 of file ExtrapSterile.cxx.

References allInOneTrainingPlots::axis, ana::Loaders::GetLoader(), ana::kBeam, caf::kFARDET, ana::Loaders::kFluxSwap, ana::Loaders::kMC, caf::kNEARDET, ana::Loaders::kNonSwap, ana::Loaders::kTauSwap, and ana::weight.

Referenced by AnaResultsLoad(), ExtendedAxesLoad(), ana::SterileGenerator::Generate(), MakeNus17Prediction(), MakeNusPrediction(), SideBandLoad(), sterile_demo(), SystsBirksLoad(), SystsCalibAbsLoad(), SystsCalibAbsLoad17(), SystsCalibAbsMethod17(), SystsCalibRelLoad(), SystsCalibRelLoad17(), SystsDecompLoad(), SystsDecompLoad17(), SystsGENIELoad(), SystsGENIELoad17(), SystsMCStatsLoad(), SystsNoiseLoad(), and SystsPPFXLoad17().

31  {
33  loaders.GetLoader(
35  loaders.GetLoader(
37  loaders.GetLoader(
39  loaders.GetLoader(
41  NCSurvDecomp,
42  NumuOscDecomp,
43  axis,
44  axisNumuND,
45  fdcut,
46  NCNDcut,
47  NumuNDcut,
48  shiftMC,
49  weight
50  );
51  }
Near Detector underground.
Definition: SREnums.h:10
Far Detector at Ash River.
Definition: SREnums.h:11
const Var weight
std::vector< Loaders * > loaders
Definition: syst_header.h:385
static ModularExtrapSterile NCDisappearance(Loaders &loaders, const IDecomp &NCSurvDecomp, const IDecomp &NumuOscDecomp, const HistAxis &axis, const HistAxis &axisNumuND, const Cut &fdcut, const Cut &NCNDcut, const Cut &NumuNDcut, const SystShifts &shiftMC=kNoShift, const Var &weight=kUnweighted)
Creates a NC disappearance extrapolation.
ModularExtrapSterile ana::ModularExtrapSterile::NCDisappearance ( SpectrumLoaderBase nearMCLoader,
SpectrumLoaderBase farMCswapLoader,
SpectrumLoaderBase farMCnonswapLoader,
SpectrumLoaderBase farMCtauswapLoader,
const IDecomp NCSurvDecomp,
const IDecomp NumuOscDecomp,
const HistAxis axis,
const HistAxis axisNumuND,
const Cut fdcut,
const Cut NCNDcut,
const Cut NumuNDcut,
const SystShifts shiftMC = kNoShift,
const Var weight = kUnweighted 
)
static

Creates a NC disappearance extrapolation with individual spectrum loaders.

NCSurvDecomp and NCNDcut are for survival components selected as NCs. NumuOscDecomp and NumuNDCut are for components oscillated from numus, which then get selected as NCs.

Definition at line 54 of file ExtrapSterile.cxx.

References ana::ModularExtrap::fEEextrap, ana::ModularExtrap::fMEAntiextrap, ana::ModularExtrap::fMEextrap, ana::ModularExtrap::fMMextrap, ana::ModularExtrap::fNCextrap, ana::kIsAntiNu, ana::kIsBeamNue(), ana::kIsNC, ana::kIsNumuCC(), ana::kIsSig(), ana::NCtot, ana::nue, ana::numu, and ana::numubar.

69  {
70  // Initialize all components with NoReweights,
71  // make sure other objects exist
72  ModularExtrapSterile extrap(
73  farMCswap,
74  farMCnonswap,
75  farMCtauswap,
76  axis,
77  fdcut,
78  shiftMC,
79  weight
80  );
81 
82  // NC -> NC ----
83  extrap.fNCextrap = std::unique_ptr<ModularExtrapComponent>(
84  new RecoReweight(
85  nearMC, axis, fdcut, shiftMC, weight,
86  "NC -> NC", "NC #rightarrow NC",
87  NCNDcut, NCSurvDecomp, // NC selection in ND
88  DecompResult::NCtot, kIsNC, // NC truth in ND
89  farMCswap, kIsNC, // NC->NC in FD
90  farMCnonswap, farMCtauswap // extra NC stats
91  )
92  );
93 
94  // mu -> mu ----
95  extrap.fMMextrap = std::unique_ptr<ModularExtrapComponent>(
96  new RecoReweight(
97  nearMC, axis, fdcut, shiftMC, weight,
98  "mu -> mu", "#mu #rightarrow #mu",
99  NCNDcut, NCSurvDecomp, // NC selection in ND
100  DecompResult::numu, kIsNumuCC && !kIsAntiNu, // numu truth in ND
101  farMCnonswap, kIsNumuCC && !kIsAntiNu // mu->mu in FD
102  )
103  );
104 
105  // mu -> e ----
106  extrap.fMEextrap = std::unique_ptr<ModularExtrapComponent>(
107  new TruthReweight(
108  nearMC, axis, axisNumuND, fdcut, shiftMC, weight,
109  "mu -> e", "#mu #rightarrow e",
110  NumuNDcut, NumuOscDecomp, // numu selection in ND
111  DecompResult::numu, kIsNumuCC && !kIsAntiNu, // numu truth in ND
112  farMCswap, kIsSig && !kIsAntiNu // mu->e in FD
113  )
114  );
115  extrap.fMEAntiextrap = std::unique_ptr<ModularExtrapComponent>(
116  new TruthReweight(
117  nearMC, axis, axisNumuND, fdcut, shiftMC, weight,
118  "mubar -> ebar", "#bar{#mu} #rightarrow #bar{e}",
119  NumuNDcut, NumuOscDecomp, // numu selection in ND
120  DecompResult::numubar, kIsNumuCC && kIsAntiNu, // numubar truth in ND
121  farMCswap, kIsSig && kIsAntiNu // mubar->ebar in FD
122  )
123  );
124 
125  // e -> e ----
126  extrap.fEEextrap = std::unique_ptr<ModularExtrapComponent>(
127  new RecoReweight(
128  nearMC, axis, fdcut, shiftMC, weight,
129  "e -> e", "e #rightarrow e",
130  NCNDcut, NCSurvDecomp, // NC selection in ND
131  DecompResult::nue, kIsBeamNue && !kIsAntiNu, // nue truth in ND
132  farMCnonswap, kIsBeamNue && !kIsAntiNu // e->e in FD
133  )
134  );
135 
136  return extrap;
137  }
const Cut kIsNumuCC(CCFlavSel(14, 14))
Select CC .
const Var weight
const Cut kIsAntiNu([](const caf::SRProxy *sr){if(sr->mc.nnu==0) return false;assert(sr->mc.nnu==1);return sr->mc.nu[0].pdg< 0;})
Is this truly an antineutrino?
Definition: TruthCuts.h:53
const Cut kIsBeamNue(CCFlavSel(12, 12))
Select CC .
ModularExtrapSterile(SpectrumLoaderBase &farMCswapLoader, SpectrumLoaderBase &farMCnonswapLoader, SpectrumLoaderBase &farMCtauswapLoader, const HistAxis &axis, const Cut &fdcut, const SystShifts &shiftMC, const Var &weight)
Sets up all components to use FD MC–internal use only.
const Cut kIsNC([](const caf::SRProxy *sr){if(sr->mc.nnu==0) return false;assert(sr->mc.nnu==1);return!sr->mc.nu[0].iscc;})
Is this a Neutral Current event?
Definition: TruthCuts.h:8
const Cut kIsSig(CCFlavSel(12, 14))
Select CC .
Ratio ana::ModularExtrapSterile::NCNueProportion ( )
inline

Return the proportion of NCs that originate as a given neutrino flavor/sign.

Definition at line 114 of file ExtrapSterile.h.

References fNCNueProportion.

Referenced by ana::PredictionSterile::PredictComponent().

114 { return *fNCNueProportion.get(); }
std::unique_ptr< Ratio > fNCNueProportion
Ratio ana::ModularExtrapSterile::NCNumuProportion ( )
inline

Definition at line 116 of file ExtrapSterile.h.

References fNCNumuProportion.

Referenced by ana::PredictionSterile::PredictComponent().

116 { return *fNCNumuProportion.get(); }
std::unique_ptr< Ratio > fNCNumuProportion
Spectrum ana::ModularExtrapSterile::NCTotalComponent ( )
overridevirtual

Override the ModularExtrap method.

Implements ana::IExtrap.

Definition at line 239 of file ExtrapSterile.cxx.

References OscNCComponent(), and ana::OscillatableSpectrum::Unoscillated().

240  {
241  return OscNCComponent().Unoscillated();
242  }
OscillatableSpectrum OscNCComponent()
Return the oscillatable NC component.
ModularExtrap ana::ModularExtrap::Nue ( 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 = kNoShift,
const Var weight = kUnweighted 
)
staticinherited

Creates a nue-like extrapolation.

numuDecomp and numuNDCut are for the signal component (mu->e). nueDecomp and nueNDCut are for the backgound components.

Definition at line 14 of file ModularExtrap.cxx.

References allInOneTrainingPlots::axis, ana::Loaders::GetLoader(), ana::kBeam, caf::kFARDET, ana::Loaders::kFluxSwap, ana::Loaders::kMC, caf::kNEARDET, ana::Loaders::kNonSwap, ana::Loaders::kTauSwap, and ana::weight.

Referenced by ana::NuePropExtrapGenerator::Generate(), ana::NueComboExtrapGenerator::Generate(), make_nue_filesyst_pred(), make_nueFDprediction(), make_nueFDprediction_kinematics(), make_nueFDprediction_kinematics_FHC(), make_nueFDprediction_kinematics_FHC_REW(), make_nueFDprediction_kinematics_REW(), MichelDecompTest(), modularextrap_demo_nue(), test_micheldecomp(), and test_nueextrapsyst().

25  {
26  return ModularExtrap::Nue(
27  loaders.GetLoader(
29  loaders.GetLoader(
31  loaders.GetLoader(
33  loaders.GetLoader(
35  nueDecomp,
36  numuDecomp,
37  axis,
38  axisNumuND,
39  fdcut,
40  nueNDcut,
41  numuNDcut,
42  shiftMC,
43  weight
44  );
45  }
Near Detector underground.
Definition: SREnums.h:10
Far Detector at Ash River.
Definition: SREnums.h:11
const Var weight
static ModularExtrap Nue(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=kNoShift, const Var &weight=kUnweighted)
Creates a nue-like extrapolation.
std::vector< Loaders * > loaders
Definition: syst_header.h:385
ModularExtrap ana::ModularExtrap::Nue ( SpectrumLoaderBase nearMCLoader,
SpectrumLoaderBase farMCswapLoader,
SpectrumLoaderBase farMCnonswapLoader,
SpectrumLoaderBase farMCtauswapLoader,
const IDecomp nueDecomp,
const IDecomp numuDecomp,
const HistAxis axis,
const HistAxis axisNumuND,
const Cut fdcut,
const Cut nueNDcut,
const Cut numuNDcut,
const SystShifts shiftMC = kNoShift,
const Var weight = kUnweighted 
)
staticinherited

Creates a nue-like extrapolation with individual spectrum loaders.

numuDecomp and numuNDCut are for the signal component (mu->e). nueDecomp and nueNDCut are for the backgound components.

Definition at line 148 of file ModularExtrap.cxx.

References ana::ModularExtrap::fEEextrap, ana::ModularExtrap::fMEAntiextrap, ana::ModularExtrap::fMEextrap, ana::ModularExtrap::fMMextrap, ana::ModularExtrap::fNCAntiextrap, ana::ModularExtrap::fNCextrap, ana::kIsAntiNu, ana::kIsBeamNue(), ana::kIsNC, ana::kIsNumuCC(), ana::kIsSig(), ana::NC, ana::NCbar, ana::nue, ana::numu, and ana::numubar.

162  {
163 
164  ModularExtrap extrap(
165  farMCswap,
166  farMCnonswap,
167  farMCtauswap,
168  axis,
169  fdcut,
170  shiftMC,
171  weight
172  );
173 
174  // mu -> mu ----
175  extrap.fMMextrap = std::unique_ptr<ModularExtrapComponent>(
176  new RecoReweight(
177  nearMC, axis, fdcut, shiftMC, weight,
178  "mu -> mu", "#nu_{#mu} #rightarrow #nu_{#mu}",
179  nueNDcut, nueDecomp, // nue selection in ND
180  DecompResult::numu, kIsNumuCC && !kIsAntiNu, // numu truth in ND
181  farMCnonswap, kIsNumuCC && !kIsAntiNu // mu->mu in FD
182  )
183  );
184 
185  // mu -> e ----
186  extrap.fMEextrap = std::unique_ptr<ModularExtrapComponent>(
187  new TruthReweight(
188  nearMC, axis, axisNumuND, fdcut, shiftMC, weight,
189  "mu -> e", "#nu_{#mu} #rightarrow #nu_{e}",
190  numuNDcut, numuDecomp, // numu selection in ND
191  DecompResult::numu, kIsNumuCC && !kIsAntiNu, // numu truth in ND
192  farMCswap, kIsSig && !kIsAntiNu // mu->e in FD
193  )
194  );
195 
196  // mubar -> ebar
197  extrap.fMEAntiextrap = std::unique_ptr<ModularExtrapComponent>(
198  new TruthReweight(
199  nearMC, axis, axisNumuND, fdcut, shiftMC, weight,
200  "mubar -> ebar", "#bar{#nu}_{#mu} #rightarrow #bar{#nu}_{e}",
201  numuNDcut, numuDecomp, // numu selection in ND
202  DecompResult::numubar, kIsNumuCC && kIsAntiNu, // numubar truth in ND
203  farMCswap, kIsSig && kIsAntiNu // mubar->ebar in FD
204  )
205  );
206 
207 
208  // NC -> NC ----
209  extrap.fNCextrap = std::unique_ptr<ModularExtrapComponent>(
210  new RecoReweight(
211  nearMC, axis, fdcut, shiftMC, weight,
212  "NC -> NC", "NC #rightarrow NC",
213  nueNDcut, nueDecomp, // nue selection in ND
214  DecompResult::NC, kIsNC && !kIsAntiNu, // NC truth in ND
215  farMCswap, kIsNC && !kIsAntiNu, // NC->NC in FD
216  farMCnonswap, farMCtauswap // extra NC stats
217  )
218  );
219 
220  // NCAnti -> NCAnti ---
221  extrap.fNCAntiextrap = std::unique_ptr<ModularExtrapComponent>(
222  new RecoReweight(
223  nearMC, axis, fdcut, shiftMC, weight,
224  "NCbar -> NCbar", "NC bar #rightarrow NC bar",
225  nueNDcut, nueDecomp, // nue selection in ND
226  DecompResult::NCbar, kIsNC && kIsAntiNu, // NC Anti truth in ND
227  farMCswap, kIsNC && kIsAntiNu, // NC Anti->NC Anti in FD
228  farMCnonswap, farMCtauswap // extra NC Anti stats
229  )
230  );
231 
232 
233  // e -> e ----
234  extrap.fEEextrap = std::unique_ptr<ModularExtrapComponent>(
235  new RecoReweight(
236  nearMC, axis, fdcut, shiftMC, weight,
237  "e -> e", "#nu_{e} #rightarrow #nu_{e}",
238  nueNDcut, nueDecomp, // nue selection in ND
239  DecompResult::nue, kIsBeamNue && !kIsAntiNu, // nue truth in ND
240  farMCnonswap, kIsBeamNue && !kIsAntiNu // e->e in FD
241  )
242  );
243 
244  return extrap;
245 
246  }
const Cut kIsNumuCC(CCFlavSel(14, 14))
Select CC .
const Var weight
const Cut kIsAntiNu([](const caf::SRProxy *sr){if(sr->mc.nnu==0) return false;assert(sr->mc.nnu==1);return sr->mc.nu[0].pdg< 0;})
Is this truly an antineutrino?
Definition: TruthCuts.h:53
const Cut kIsBeamNue(CCFlavSel(12, 12))
Select CC .
const Cut kIsNC([](const caf::SRProxy *sr){if(sr->mc.nnu==0) return false;assert(sr->mc.nnu==1);return!sr->mc.nu[0].iscc;})
Is this a Neutral Current event?
Definition: TruthCuts.h:8
const Cut kIsSig(CCFlavSel(12, 14))
Select CC .
OscillatableSpectrum ana::ModularExtrap::NueAppComponent ( )
overridevirtualinherited

Charged current electron neutrino appearance ( $\nu_\mu\to\nu_e$)

Implements ana::IExtrap.

Definition at line 701 of file ModularExtrap.cxx.

References ana::ModularExtrap::fMEextrap.

702  {return fMEextrap->Return();}
std::unique_ptr< ModularExtrapComponent > fMEextrap
ModularExtrap ana::ModularExtrap::NueFlux ( Loaders loaders,
const FluxDecomp nueDecomp,
const IDecomp numuDecomp,
const HistAxis axis,
const HistAxis axisNumuND,
const Cut fdcut,
const Cut nueNDcut,
const Cut numuNDcut,
const SystShifts shiftMC = kNoShift,
const Var weight = kUnweighted 
)
staticinherited

Definition at line 84 of file ModularExtrap.cxx.

References allInOneTrainingPlots::axis, ana::Loaders::GetLoader(), ana::kBeam, caf::kFARDET, ana::Loaders::kFluxSwap, ana::Loaders::kMC, caf::kNEARDET, ana::Loaders::kNonSwap, ana::Loaders::kTauSwap, and ana::weight.

95  {
97  loaders.GetLoader(
99  loaders.GetLoader(
101  loaders.GetLoader(
103  loaders.GetLoader(
105  nueDecomp,
106  numuDecomp,
107  axis,
108  axisNumuND,
109  fdcut,
110  nueNDcut,
111  numuNDcut,
112  shiftMC,
113  weight
114  );
115  }
Near Detector underground.
Definition: SREnums.h:10
Far Detector at Ash River.
Definition: SREnums.h:11
const Var weight
static ModularExtrap NueFlux(Loaders &loaders, const FluxDecomp &nueDecomp, const IDecomp &numuDecomp, const HistAxis &axis, const HistAxis &axisNumuND, const Cut &fdcut, const Cut &nueNDcut, const Cut &numuNDcut, const SystShifts &shiftMC=kNoShift, const Var &weight=kUnweighted)
std::vector< Loaders * > loaders
Definition: syst_header.h:385
ModularExtrap ana::ModularExtrap::NueFlux ( SpectrumLoaderBase nearMCLoader,
SpectrumLoaderBase farMCswapLoader,
SpectrumLoaderBase farMCnonswapLoader,
SpectrumLoaderBase farMCtauswapLoader,
const FluxDecomp nueDecomp,
const IDecomp numuDecomp,
const HistAxis axis,
const HistAxis axisNumuND,
const Cut fdcut,
const Cut nueNDcut,
const Cut numuNDcut,
const SystShifts shiftMC = kNoShift,
const Var weight = kUnweighted 
)
staticinherited

Creates a nue-like extrapolation for RHC mode.

Definition at line 248 of file ModularExtrap.cxx.

References ana::ModularExtrap::fEEAntiextrap, ana::kIsAntiNu, ana::kIsBeamNue(), and ana::ModularExtrap::NueRHC().

262  {
264  nearMC,
265  farMCswap,
266  farMCnonswap,
267  farMCtauswap,
268  nueDecomp,
269  numuDecomp,
270  axis,
271  axisNumuND,
272  fdcut,
273  nueNDcut,
274  numuNDcut,
275  shiftMC,
276  weight
277  );
278 
279  extrap.fEEAntiextrap = std::unique_ptr<ModularExtrapComponent>(
280  new FluxReweight(
281  nearMC, axis, fdcut, shiftMC, weight,
282  "ebar -> ebar", "#bar{#nu}_{e} #rightarrow #bar{#nu}_{e}",
283  nueNDcut, nueDecomp, // nue selection in ND
284  farMCnonswap, kIsBeamNue && kIsAntiNu // e->e in FD
285  )
286  );
287  return extrap;
288  }
const Var weight
const Cut kIsAntiNu([](const caf::SRProxy *sr){if(sr->mc.nnu==0) return false;assert(sr->mc.nnu==1);return sr->mc.nu[0].pdg< 0;})
Is this truly an antineutrino?
Definition: TruthCuts.h:53
const Cut kIsBeamNue(CCFlavSel(12, 12))
Select CC .
static ModularExtrap NueRHC(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=kNoShift, const Var &weight=kUnweighted)
Creates a nue-like extrapolation for RHC mode.
ModularExtrap ana::ModularExtrap::NueRHC ( 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 = kNoShift,
const Var weight = kUnweighted 
)
staticinherited

Creates a nue-like extrapolation for RHC mode.

Definition at line 49 of file ModularExtrap.cxx.

References allInOneTrainingPlots::axis, ana::Loaders::GetLoader(), ana::kBeam, caf::kFARDET, ana::Loaders::kFluxSwap, ana::Loaders::kMC, caf::kNEARDET, ana::Loaders::kNonSwap, ana::Loaders::kTauSwap, and ana::weight.

Referenced by ana::NuePropExtrapRHCGenerator::Generate(), make_nueFDprediction_kinematics_RHC(), make_nueFDprediction_kinematics_RHC_REW(), and ana::ModularExtrap::NueFlux().

60  {
61  return ModularExtrap::NueRHC(
62  loaders.GetLoader(
64  loaders.GetLoader(
66  loaders.GetLoader(
68  loaders.GetLoader(
70  nueDecomp,
71  numuDecomp,
72  axis,
73  axisNumuND,
74  fdcut,
75  nueNDcut,
76  numuNDcut,
77  shiftMC,
78  weight
79  );
80  }
Near Detector underground.
Definition: SREnums.h:10
Far Detector at Ash River.
Definition: SREnums.h:11
const Var weight
static ModularExtrap NueRHC(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=kNoShift, const Var &weight=kUnweighted)
Creates a nue-like extrapolation for RHC mode.
std::vector< Loaders * > loaders
Definition: syst_header.h:385
ModularExtrap ana::ModularExtrap::NueRHC ( SpectrumLoaderBase nearMCLoader,
SpectrumLoaderBase farMCswapLoader,
SpectrumLoaderBase farMCnonswapLoader,
SpectrumLoaderBase farMCtauswapLoader,
const IDecomp nueDecomp,
const IDecomp numuDecomp,
const HistAxis axis,
const HistAxis axisNumuND,
const Cut fdcut,
const Cut nueNDcut,
const Cut numuNDcut,
const SystShifts shiftMC = kNoShift,
const Var weight = kUnweighted 
)
staticinherited

Creates a nue-like extrapolation for RHC mode.

Definition at line 291 of file ModularExtrap.cxx.

References ana::ModularExtrap::fEEAntiextrap, ana::ModularExtrap::fEEextrap, ana::ModularExtrap::fMEAntiextrap, ana::ModularExtrap::fMEextrap, ana::ModularExtrap::fMMAntiextrap, ana::ModularExtrap::fMMextrap, ana::ModularExtrap::fNCAntiextrap, ana::ModularExtrap::fNCextrap, ana::kIsAntiNu, ana::kIsBeamNue(), ana::kIsNC, ana::kIsNumuCC(), ana::kIsSig(), ana::NC, ana::NCbar, ana::nue, ana::nuebar, ana::numu, and ana::numubar.

305  {
306 
307  ModularExtrap extrap(
308  farMCswap,
309  farMCnonswap,
310  farMCtauswap,
311  axis,
312  fdcut,
313  shiftMC,
314  weight
315  );
316  // mu -> mu ----
317  extrap.fMMextrap = std::unique_ptr<ModularExtrapComponent>(
318  new RecoReweight(
319  nearMC, axis, fdcut, shiftMC, weight,
320  "mu -> mu", "#nu_{#mu} #rightarrow #nu_{#mu}",
321  nueNDcut, nueDecomp, // nue selection in ND
322  DecompResult::numu, kIsNumuCC && !kIsAntiNu, // numu truth in ND
323  farMCnonswap, kIsNumuCC && !kIsAntiNu // mu->mu in FD
324  )
325  );
326  // mubar -> mubar ---
327  extrap.fMMAntiextrap = std::unique_ptr<ModularExtrapComponent>(
328  new RecoReweight(
329  nearMC, axis, fdcut, shiftMC, weight,
330  "mubar -> mubar", "#bar{#nu}_{#mu} #rightarrow #bar{#nu}_{#mu}",
331  nueNDcut, nueDecomp, // nue selection in ND
332  DecompResult::numubar, kIsNumuCC && kIsAntiNu, // numu truth in ND
333  farMCnonswap, kIsNumuCC && kIsAntiNu // mu->mu in FD
334  )
335  );
336 
337  // mu -> e ----
338  extrap.fMEextrap = std::unique_ptr<ModularExtrapComponent>(
339  new TruthReweight(
340  nearMC, axis, axisNumuND, fdcut, shiftMC, weight,
341  "mu -> e", "#nu_{#mu} #rightarrow #nu_{e}",
342  numuNDcut, numuDecomp, // numu selection in ND
343  DecompResult::numu, kIsNumuCC && !kIsAntiNu, // numu truth in ND
344  farMCswap, kIsSig && !kIsAntiNu // mu->e in FD
345  )
346  );
347  // mubar -> ebar
348  extrap.fMEAntiextrap = std::unique_ptr<ModularExtrapComponent>(
349  new TruthReweight(
350  nearMC, axis, axisNumuND, fdcut, shiftMC, weight,
351  "mubar -> ebar", "#bar{#nu}_{#mu} #rightarrow #bar{#nu}_{e}",
352  numuNDcut, numuDecomp, // numu selection in ND
353  DecompResult::numubar, kIsNumuCC && kIsAntiNu, // numubar truth in ND
354  farMCswap, kIsSig && kIsAntiNu // mubar->ebar in FD
355  )
356  );
357 
358  // NC -> NC ----
359  extrap.fNCextrap = std::unique_ptr<ModularExtrapComponent>(
360  new RecoReweight(
361  nearMC, axis, fdcut, shiftMC, weight,
362  "NC -> NC", "NC #rightarrow NC",
363  nueNDcut, nueDecomp, // nue selection in ND
364  DecompResult::NC, kIsNC && !kIsAntiNu, // NC truth in ND
365  farMCswap, kIsNC && !kIsAntiNu, // NC->NC in FD
366  farMCnonswap, farMCtauswap // extra NC stats
367  )
368  );
369  // NC Anti -> NC Anti ---
370  extrap.fNCAntiextrap = std::unique_ptr<ModularExtrapComponent>(
371  new RecoReweight(
372  nearMC, axis, fdcut, shiftMC, weight,
373  "NCbar -> NCbar", "NC bar #rightarrow NC bar",
374  nueNDcut, nueDecomp, // nue selection in ND
375  DecompResult::NCbar, kIsNC && kIsAntiNu, // NC truth in ND
376  farMCswap, kIsNC && kIsAntiNu, // NC->NC in FD
377  farMCnonswap, farMCtauswap // extra NC stats
378  )
379  );
380 
381  // e -> e ----
382  extrap.fEEextrap = std::unique_ptr<ModularExtrapComponent>(
383  new RecoReweight(
384  nearMC, axis, fdcut, shiftMC, weight,
385  "e -> e", "#nu_{e} #rightarrow #nu_{e}",
386  nueNDcut, nueDecomp, // nue selection in ND
387  DecompResult::nue, kIsBeamNue && !kIsAntiNu, // nue truth in ND
388  farMCnonswap, kIsBeamNue && !kIsAntiNu // e->e in FD
389  )
390  );
391 
392  // ebar -> ebar ---
393  extrap.fEEAntiextrap = std::unique_ptr<ModularExtrapComponent>(
394  new RecoReweight(
395  nearMC, axis, fdcut, shiftMC, weight,
396  "ebar -> ebar", "#bar{#nu}_{e} #rightarrow #bar{#nu}_{e}",
397  nueNDcut, nueDecomp, // nue selection in ND
398  DecompResult::nuebar, kIsBeamNue && kIsAntiNu, // nue truth in ND
399  farMCnonswap, kIsBeamNue && kIsAntiNu // e->e in FD
400  )
401  );
402 
403  return extrap;
404 
405  }
const Cut kIsNumuCC(CCFlavSel(14, 14))
Select CC .
const Var weight
const Cut kIsAntiNu([](const caf::SRProxy *sr){if(sr->mc.nnu==0) return false;assert(sr->mc.nnu==1);return sr->mc.nu[0].pdg< 0;})
Is this truly an antineutrino?
Definition: TruthCuts.h:53
const Cut kIsBeamNue(CCFlavSel(12, 12))
Select CC .
const Cut kIsNC([](const caf::SRProxy *sr){if(sr->mc.nnu==0) return false;assert(sr->mc.nnu==1);return!sr->mc.nu[0].iscc;})
Is this a Neutral Current event?
Definition: TruthCuts.h:8
const Cut kIsSig(CCFlavSel(12, 14))
Select CC .
OscillatableSpectrum ana::ModularExtrap::NueSurvComponent ( )
overridevirtualinherited

Charged current electron neutrino survival ( $\nu_e\to\nu_e$)

Implements ana::IExtrap.

Definition at line 689 of file ModularExtrap.cxx.

References ana::ModularExtrap::fEEextrap.

690  {return fEEextrap->Return();}
std::unique_ptr< ModularExtrapComponent > fEEextrap
ModularExtrap ana::ModularExtrap::Numu ( Loaders loaders,
const IDecomp numuDecomp,
const HistAxis axis,
const Cut fdcut,
const Cut ndcut,
const SystShifts shiftMC = kNoShift,
const Var weight = kUnweighted 
)
staticinherited

Creates a numu-like extrapolation.

Definition at line 119 of file ModularExtrap.cxx.

References allInOneTrainingPlots::axis, ana::Loaders::GetLoader(), ana::kBeam, caf::kFARDET, ana::Loaders::kFluxSwap, ana::Loaders::kMC, caf::kNEARDET, ana::Loaders::kNonSwap, ana::Loaders::kTauSwap, and ana::weight.

Referenced by ana::NumuExtrapGenerator::Generate(), and modularextrap_demo_numu().

127  {
128  return ModularExtrap::Numu(
129  loaders.GetLoader(
131  loaders.GetLoader(
133  loaders.GetLoader(
135  loaders.GetLoader(
137  numuDecomp,
138  axis,
139  fdcut,
140  ndcut,
141  shiftMC,
142  weight
143  );
144  }
Near Detector underground.
Definition: SREnums.h:10
Far Detector at Ash River.
Definition: SREnums.h:11
const Var weight
static ModularExtrap Numu(Loaders &loaders, const IDecomp &numuDecomp, const HistAxis &axis, const Cut &fdcut, const Cut &ndcut, const SystShifts &shiftMC=kNoShift, const Var &weight=kUnweighted)
Creates a numu-like extrapolation.
std::vector< Loaders * > loaders
Definition: syst_header.h:385
ModularExtrap ana::ModularExtrap::Numu ( SpectrumLoaderBase nearMCLoader,
SpectrumLoaderBase farMCswapLoader,
SpectrumLoaderBase farMCnonswapLoader,
SpectrumLoaderBase farMCtauswapLoader,
const IDecomp numuDecomp,
const HistAxis axis,
const Cut fdcut,
const Cut ndcut,
const SystShifts shiftMC = kNoShift,
const Var weight = kUnweighted 
)
staticinherited

Creates a numu-like extrapolation with individual spectrum loaders.

Definition at line 409 of file ModularExtrap.cxx.

References ana::ModularExtrap::fMMAntiextrap, ana::ModularExtrap::fMMextrap, ana::kIsAntiNu, ana::kIsNumuCC(), ana::numu, and ana::numubar.

420  {
421 
422  ModularExtrap extrap(
423  farMCswap,
424  farMCnonswap,
425  farMCtauswap,
426  axis,
427  fdcut,
428  shiftMC,
429  weight
430  );
431 
432  // mu -> mu ----
433  extrap.fMMextrap = std::unique_ptr<ModularExtrapComponent>(
434  new TruthReweight(
435  nearMC, axis, axis, fdcut, shiftMC, weight,
436  "mu -> mu", "#nu_{#mu} #rightarrow #nu_{#mu}",
437  numuNDcut, numuDecomp, // numu selection in ND
438  DecompResult::numu, kIsNumuCC && !kIsAntiNu, // numu truth in ND
439  farMCnonswap, kIsNumuCC && !kIsAntiNu // mu->mu in FD
440  )
441  );
442  // mubar -> mubar ---
443  extrap.fMMAntiextrap = std::unique_ptr<ModularExtrapComponent>(
444  new TruthReweight(
445  nearMC, axis, axis, fdcut, shiftMC, weight,
446  "mubar -> mubar", "#bar{#nu}_{#mu} #rightarrow #bar{#nu}_{#mu}",
447  numuNDcut, numuDecomp, // numu selection in ND
448  DecompResult::numubar, kIsNumuCC && kIsAntiNu, // numubar truth in ND
449  farMCnonswap, kIsNumuCC && kIsAntiNu // mubar->mubar in FD
450  )
451  );
452 
453  return extrap;
454 
455  }
const Cut kIsNumuCC(CCFlavSel(14, 14))
Select CC .
const Var weight
const Cut kIsAntiNu([](const caf::SRProxy *sr){if(sr->mc.nnu==0) return false;assert(sr->mc.nnu==1);return sr->mc.nu[0].pdg< 0;})
Is this truly an antineutrino?
Definition: TruthCuts.h:53
OscillatableSpectrum ana::ModularExtrap::NumuAppComponent ( )
overridevirtualinherited

Charged current muon neutrino appearance ( $\nu_e\to\nu_\mu$)

Implements ana::IExtrap.

Definition at line 707 of file ModularExtrap.cxx.

References ana::ModularExtrap::fEMextrap.

708  {return fEMextrap->Return();}
std::unique_ptr< ModularExtrapComponent > fEMextrap
OscillatableSpectrum ana::ModularExtrap::NumuSurvComponent ( )
overridevirtualinherited

Charged current muon neutrino survival ( $\nu_\mu\to\nu_\mu$)

Implements ana::IExtrap.

Definition at line 695 of file ModularExtrap.cxx.

References ana::ModularExtrap::fMMextrap.

696  {return fMMextrap->Return();}
std::unique_ptr< ModularExtrapComponent > fMMextrap
ModularExtrapSterile& ana::ModularExtrapSterile::operator= ( const ModularExtrapSterile )
delete
ModularExtrapSterile& ana::ModularExtrapSterile::operator= ( ModularExtrapSterile &&  )
default
OscillatableSpectrum ana::ModularExtrapSterile::OscNCComponent ( )

Return the oscillatable NC component.

Definition at line 235 of file ExtrapSterile.cxx.

References ana::ModularExtrap::fNCextrap.

Referenced by NCTotalComponent(), and ana::PredictionSterile::PredictComponent().

236  {return fNCextrap->Return();}
std::unique_ptr< ModularExtrapComponent > fNCextrap
void ana::ModularExtrap::SavePlotsNue ( TDirectory *  dir,
double  potFD 
) const
inherited

Definition at line 489 of file ModularExtrap.cxx.

References ana::ModularExtrap::fEEextrap, ana::ModularExtrap::fMEAntiextrap, ana::ModularExtrap::fMEextrap, ana::ModularExtrap::fMMextrap, ana::ModularExtrap::fNCTotalextrap, and tmp.

Referenced by modularextrap_demo_nue().

490  {
491  TDirectory* tmp = gDirectory;
492  dir->cd();
493  fMEextrap->SavePlots( dir->mkdir("MEextrap"), potFD );
494  fMEAntiextrap->SavePlots( dir->mkdir("MEAntiextrap"), potFD );
495  fEEextrap->SavePlots( dir->mkdir("EEextrap"), potFD );
496  fMMextrap->SavePlots( dir->mkdir("MMextrap"), potFD );
497  fNCTotalextrap->SavePlots( dir->mkdir("NCTotalextrap"), potFD );
498  tmp->cd();
499  }
std::unique_ptr< ModularExtrapComponent > fMMextrap
std::unique_ptr< ModularExtrapComponent > fMEextrap
Float_t tmp
Definition: plot.C:36
std::unique_ptr< ModularExtrapComponent > fNCTotalextrap
std::unique_ptr< ModularExtrapComponent > fMEAntiextrap
TDirectory * dir
Definition: macro.C:5
std::unique_ptr< ModularExtrapComponent > fEEextrap
void ana::ModularExtrap::SavePlotsNueRHC ( TDirectory *  dir,
double  potFD 
) const
inherited

Definition at line 503 of file ModularExtrap.cxx.

References ana::ModularExtrap::fEEAntiextrap, ana::ModularExtrap::fEEextrap, ana::ModularExtrap::fMEAntiextrap, ana::ModularExtrap::fMEextrap, ana::ModularExtrap::fMMAntiextrap, ana::ModularExtrap::fMMextrap, ana::ModularExtrap::fNCAntiextrap, ana::ModularExtrap::fNCextrap, and tmp.

504  {
505  TDirectory* tmp = gDirectory;
506  dir->cd();
507  fMEextrap->SavePlots( dir->mkdir("MEextrap"), potFD );
508  fMEAntiextrap->SavePlots( dir->mkdir("MEAntiextrap"), potFD );
509  fEEextrap->SavePlots( dir->mkdir("EEextrap"), potFD );
510  fEEAntiextrap->SavePlots( dir->mkdir("EEAntiextrap"), potFD );
511  fMMextrap->SavePlots( dir->mkdir("MMextrap"), potFD );
512  fMMAntiextrap->SavePlots( dir->mkdir("MMAntiextrap"), potFD );
513  fNCextrap->SavePlots( dir->mkdir("NCextrap"), potFD );
514  fNCAntiextrap->SavePlots( dir->mkdir("NCAntiextrap"), potFD );
515  tmp->cd();
516  }
std::unique_ptr< ModularExtrapComponent > fMMextrap
std::unique_ptr< ModularExtrapComponent > fMEextrap
Float_t tmp
Definition: plot.C:36
std::unique_ptr< ModularExtrapComponent > fNCextrap
std::unique_ptr< ModularExtrapComponent > fMEAntiextrap
std::unique_ptr< ModularExtrapComponent > fEEAntiextrap
std::unique_ptr< ModularExtrapComponent > fNCAntiextrap
std::unique_ptr< ModularExtrapComponent > fMMAntiextrap
TDirectory * dir
Definition: macro.C:5
std::unique_ptr< ModularExtrapComponent > fEEextrap
void ana::ModularExtrap::SavePlotsNumu ( TDirectory *  dir,
double  potFD 
) const
inherited

Definition at line 520 of file ModularExtrap.cxx.

References ana::ModularExtrap::fMMAntiextrap, ana::ModularExtrap::fMMextrap, and tmp.

Referenced by make_extrap_figure_hists(), and modularextrap_demo_numu().

521  {
522  TDirectory* tmp = gDirectory;
523  dir->cd();
524  fMMextrap->SavePlots( dir->mkdir("MMextrap"), potFD );
525  fMMAntiextrap->SavePlots( dir->mkdir("MMAntiextrap"), potFD );
526  tmp->cd();
527  }
std::unique_ptr< ModularExtrapComponent > fMMextrap
Float_t tmp
Definition: plot.C:36
std::unique_ptr< ModularExtrapComponent > fMMAntiextrap
TDirectory * dir
Definition: macro.C:5
void ana::ModularExtrapSterile::SaveTo ( TDirectory *  dir) const
overridevirtual

Reimplemented from ana::IExtrap.

Definition at line 254 of file ExtrapSterile.cxx.

References fNCAntiNueNumerator, fNCAntiNumuNumerator, fNCDenominator, fNCNueNumerator, fNCNumuNumerator, ana::ModularExtrap::SaveTo(), and tmp.

Referenced by MakeNus17Prediction(), and MakeNusPrediction().

255  {
256  TDirectory* tmp = gDirectory;
257 
259 
260  dir->cd();
261  TObjString("ModularExtrapSterile").Write("type", TObject::kOverwrite);
262 
263  fNCNueNumerator->SaveTo(dir->mkdir("NCNue"));
264  fNCAntiNueNumerator->SaveTo(dir->mkdir("NCAntiNue"));
265  fNCNumuNumerator->SaveTo(dir->mkdir("NCNumu"));
266  fNCAntiNumuNumerator->SaveTo(dir->mkdir("NCAntiNumu"));
267  fNCDenominator->SaveTo(dir->mkdir("AllNC"));
268 
269  tmp->cd();
270  }
std::unique_ptr< Spectrum > fNCNueNumerator
std::unique_ptr< Spectrum > fNCNumuNumerator
std::unique_ptr< Spectrum > fNCAntiNumuNumerator
Float_t tmp
Definition: plot.C:36
std::unique_ptr< Spectrum > fNCDenominator
void SaveTo(TDirectory *dir) const override
TDirectory * dir
Definition: macro.C:5
std::unique_ptr< Spectrum > fNCAntiNueNumerator
OscillatableSpectrum ana::ModularExtrap::TauFromEComponent ( )
overridevirtualinherited

Charged current tau neutrino appearance from electron neutrino ( $\nu_e\to\nu_\tau$)

Implements ana::IExtrap.

Definition at line 728 of file ModularExtrap.cxx.

References ana::ModularExtrap::fETextrap.

729  {return fETextrap->Return();}
std::unique_ptr< ModularExtrapComponent > fETextrap
OscillatableSpectrum ana::ModularExtrap::TauFromMuComponent ( )
overridevirtualinherited

Charged current tau neutrino appearance from muon neutrino ( $\nu_\mu\to\nu_\tau$)

Implements ana::IExtrap.

Definition at line 722 of file ModularExtrap.cxx.

References ana::ModularExtrap::fMTextrap.

723  {return fMTextrap->Return();}
std::unique_ptr< ModularExtrapComponent > fMTextrap
ModularExtrapSterile ana::ModularExtrapSterile::TrivialExtrapNC ( Loaders loaders,
const HistAxis axis,
const Cut fdcut,
const SystShifts shiftMC = kNoShift,
const Var weight = kUnweighted 
)
static

Creates a NC disappearance "extrapolation" by returning FD MC.

Definition at line 140 of file ExtrapSterile.cxx.

References allInOneTrainingPlots::axis, ana::Loaders::GetLoader(), ana::kBeam, caf::kFARDET, ana::Loaders::kFluxSwap, ana::Loaders::kMC, ana::Loaders::kNonSwap, ana::Loaders::kTauSwap, and ana::weight.

147  {
149  loaders.GetLoader(
151  loaders.GetLoader(
153  loaders.GetLoader(
155  axis,
156  fdcut,
157  shiftMC,
158  weight
159  );
160  }
Far Detector at Ash River.
Definition: SREnums.h:11
const Var weight
std::vector< Loaders * > loaders
Definition: syst_header.h:385
static ModularExtrapSterile TrivialExtrapNC(Loaders &loaders, const HistAxis &axis, const Cut &fdcut, const SystShifts &shiftMC=kNoShift, const Var &weight=kUnweighted)
Creates a NC disappearance "extrapolation" by returning FD MC.
ModularExtrapSterile ana::ModularExtrapSterile::TrivialExtrapNC ( SpectrumLoaderBase farMCswapLoader,
SpectrumLoaderBase farMCnonswapLoader,
SpectrumLoaderBase farMCtauswapLoader,
const HistAxis axis,
const Cut fdcut,
const SystShifts shiftMC = kNoShift,
const Var weight = kUnweighted 
)
static

Creates a NC disappearance "extrapolation" by returning FD MC, using individual SpectrumLoaders

Definition at line 163 of file ExtrapSterile.cxx.

172  {
173  // Initialize all components with NoReweights,
174  // make sure other objects exist
175  ModularExtrapSterile extrap(
176  farMCswap,
177  farMCnonswap,
178  farMCtauswap,
179  axis,
180  fdcut,
181  shiftMC,
182  weight
183  );
184 
185  return extrap;
186  }
const Var weight
ModularExtrapSterile(SpectrumLoaderBase &farMCswapLoader, SpectrumLoaderBase &farMCnonswapLoader, SpectrumLoaderBase &farMCtauswapLoader, const HistAxis &axis, const Cut &fdcut, const SystShifts &shiftMC, const Var &weight)
Sets up all components to use FD MC–internal use only.

Member Data Documentation

std::unique_ptr<ModularExtrapComponent> ana::ModularExtrap::fEEAntiextrap
protectedinherited
std::unique_ptr<ModularExtrapComponent> ana::ModularExtrap::fEEextrap
protectedinherited
std::unique_ptr<ModularExtrapComponent> ana::ModularExtrap::fEMAntiextrap
protectedinherited
std::unique_ptr<ModularExtrapComponent> ana::ModularExtrap::fEMextrap
protectedinherited
std::unique_ptr<ModularExtrapComponent> ana::ModularExtrap::fETAntiextrap
protectedinherited
std::unique_ptr<ModularExtrapComponent> ana::ModularExtrap::fETextrap
protectedinherited
std::unique_ptr<ModularExtrapComponent> ana::ModularExtrap::fMEAntiextrap
protectedinherited
std::unique_ptr<ModularExtrapComponent> ana::ModularExtrap::fMEextrap
protectedinherited
std::unique_ptr<ModularExtrapComponent> ana::ModularExtrap::fMMAntiextrap
protectedinherited
std::unique_ptr<ModularExtrapComponent> ana::ModularExtrap::fMMextrap
protectedinherited
std::unique_ptr<ModularExtrapComponent> ana::ModularExtrap::fMTAntiextrap
protectedinherited
std::unique_ptr<ModularExtrapComponent> ana::ModularExtrap::fMTextrap
protectedinherited
std::unique_ptr<ModularExtrapComponent> ana::ModularExtrap::fNCAntiextrap
protectedinherited
std::unique_ptr<Spectrum> ana::ModularExtrapSterile::fNCAntiNueNumerator
protected

Definition at line 126 of file ExtrapSterile.h.

Referenced by GenerateNCRatios(), LoadFrom(), and SaveTo().

std::unique_ptr<Ratio> ana::ModularExtrapSterile::fNCAntiNueProportion
protected

Definition at line 132 of file ExtrapSterile.h.

Referenced by GenerateNCRatios(), and NCAntiNueProportion().

std::unique_ptr<Spectrum> ana::ModularExtrapSterile::fNCAntiNumuNumerator
protected

Definition at line 128 of file ExtrapSterile.h.

Referenced by GenerateNCRatios(), LoadFrom(), and SaveTo().

std::unique_ptr<Ratio> ana::ModularExtrapSterile::fNCAntiNumuProportion
protected

Definition at line 134 of file ExtrapSterile.h.

Referenced by GenerateNCRatios(), and NCAntiNumuProportion().

std::unique_ptr<Spectrum> ana::ModularExtrapSterile::fNCDenominator
protected

Definition at line 129 of file ExtrapSterile.h.

Referenced by GenerateNCRatios(), LoadFrom(), and SaveTo().

std::unique_ptr<ModularExtrapComponent> ana::ModularExtrap::fNCextrap
protectedinherited
std::unique_ptr<Spectrum> ana::ModularExtrapSterile::fNCNueNumerator
protected

Definition at line 125 of file ExtrapSterile.h.

Referenced by GenerateNCRatios(), LoadFrom(), and SaveTo().

std::unique_ptr<Ratio> ana::ModularExtrapSterile::fNCNueProportion
protected

Definition at line 131 of file ExtrapSterile.h.

Referenced by GenerateNCRatios(), and NCNueProportion().

std::unique_ptr<Spectrum> ana::ModularExtrapSterile::fNCNumuNumerator
protected

Definition at line 127 of file ExtrapSterile.h.

Referenced by GenerateNCRatios(), LoadFrom(), and SaveTo().

std::unique_ptr<Ratio> ana::ModularExtrapSterile::fNCNumuProportion
protected

Definition at line 133 of file ExtrapSterile.h.

Referenced by GenerateNCRatios(), and NCNumuProportion().

std::unique_ptr<ModularExtrapComponent> ana::ModularExtrap::fNCTotalextrap
protectedinherited

The documentation for this class was generated from the following files: