ana::PredictionInterp Class Reference

Implements systematic errors by interpolation between shifted templates. More...

#include "/cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N20-04-08/CAFAna/Prediction/PredictionInterp.h"

Inheritance diagram for ana::PredictionInterp:

Classes
struct	Coeffs
struct	Key_t
struct	ShiftedPreds
struct	Val_t

Public Types
enum	EMode_t { kCombineSigns, kSplitBySign }
enum	CoeffsType {   kNueApp, kNueSurv, kNumuSurv, kNC,   kOther, kNCoeffTypes }

Public Member Functions
	PredictionInterp (std::vector< const ISyst * > systs, osc::IOscCalculator *osc, const IPredictionGenerator &predGen, Loaders &loaders, const SystShifts &shiftMC=kNoShift, EMode_t mode=kCombineSigns)
virtual	~PredictionInterp ()
Spectrum	Predict (osc::IOscCalculator *calc) const override
SpectrumStan	Predict (osc::IOscCalculatorStan *calc) const override
Spectrum	PredictSyst (osc::IOscCalculator *calc, const SystShifts &shift) const override
SpectrumStan	PredictSyst (osc::IOscCalculatorStan *calc, const SystShifts &shift) const override
Spectrum	PredictComponent (osc::IOscCalculator *calc, Flavors::Flavors_t flav, Current::Current_t curr, Sign::Sign_t sign) const override
SpectrumStan	PredictComponent (osc::IOscCalculatorStan *calc, Flavors::Flavors_t flav, Current::Current_t curr, Sign::Sign_t sign) const override
Spectrum	PredictComponentSyst (osc::IOscCalculator *calc, const SystShifts &shift, Flavors::Flavors_t flav, Current::Current_t curr, Sign::Sign_t sign) const override
SpectrumStan	PredictComponentSyst (osc::IOscCalculatorStan *calc, const SystShifts &shift, Flavors::Flavors_t flav, Current::Current_t curr, Sign::Sign_t sign) const override
void	Derivative (osc::IOscCalculator *calc, const SystShifts &shift, double pot, std::unordered_map< const ISyst *, std::vector< double >> &dp) const override
virtual void	SaveTo (TDirectory *dir) const override
void	MinimizeMemory ()
void	DebugPlot (const ISyst *syst, osc::IOscCalculator *calc, Flavors::Flavors_t flav=Flavors::kAll, Current::Current_t curr=Current::kBoth, Sign::Sign_t sign=Sign::kBoth) const
void	DebugPlots (osc::IOscCalculator *calc, const std::string &savePattern="", Flavors::Flavors_t flav=Flavors::kAll, Current::Current_t curr=Current::kBoth, Sign::Sign_t sign=Sign::kBoth) const
void	SetOscSeed (osc::IOscCalculator *oscSeed)
void	DebugPlotColz (const ISyst *syst, osc::IOscCalculator *calc, Flavors::Flavors_t flav=Flavors::kAll, Current::Current_t curr=Current::kBoth, Sign::Sign_t sign=Sign::kBoth) const
void	DebugPlotsColz (osc::IOscCalculator *calc, const std::string &savePattern="", Flavors::Flavors_t flav=Flavors::kAll, Current::Current_t curr=Current::kBoth, Sign::Sign_t sign=Sign::kBoth) const
bool	SplitBySign () const
	PredictionInterp ()
std::vector< std::vector< Coeffs > >	FitRatios (const std::vector< double > &shifts, const std::vector< std::unique_ptr< TH1 >> &ratios) const
	Find coefficients describing this set of shifts. More...
std::vector< std::vector< Coeffs > >	FitComponent (const std::vector< double > &shifts, const std::vector< IPrediction * > &preds, Flavors::Flavors_t flav, Current::Current_t curr, Sign::Sign_t sign) const
	Find coefficients describing the ratios from this component. More...
Spectrum	ShiftSpectrum (const Spectrum &s, CoeffsType type, bool nubar, const SystShifts &shift) const
SpectrumStan	ShiftSpectrum (const SpectrumStan &s, CoeffsType type, bool nubar, const SystShifts &shift) const
Spectrum	ShiftedComponent (osc::IOscCalculator *calc, const TMD5 *hash, const SystShifts &shift, Flavors::Flavors_t flav, Current::Current_t curr, Sign::Sign_t sign, CoeffsType type) const
	Helper for PredictComponentSyst. More...
SpectrumStan	ShiftedComponent (osc::_IOscCalculator< stan::math::var > *calc, const TMD5 *hash, const SystShifts &shift, Flavors::Flavors_t flav, Current::Current_t curr, Sign::Sign_t sign, CoeffsType type) const
virtual Spectrum	PredictUnoscillated () const
virtual OscillatableSpectrum	ComponentCC (int from, int to) const
virtual Spectrum	ComponentNCTotal () const
virtual Spectrum	ComponentNC () const
virtual Spectrum	ComponentNCAnti () const

Static Public Member Functions
static std::unique_ptr< PredictionInterp >	LoadFrom (TDirectory *dir)
static void	LoadFromBody (TDirectory *dir, PredictionInterp *ret, std::vector< const ISyst * > veto={})

Protected Member Functions
std::vector< std::vector< Coeffs > >	FitSumComponent (const std::vector< ShiftedPreds > &spf, Flavors::Flavors_t flav, Current::Current_t curr, Sign::Sign_t sign) const
void	InitFits () const
void	InitFitsHelper (ShiftedPreds &sp, std::vector< std::vector< std::vector< Coeffs >>> &fits, Sign::Sign_t sign) const
void	InitFitsSumHelper (std::vector< ShiftedPreds > &sps, std::vector< std::vector< std::vector< Coeffs >>> &fits, Sign::Sign_t sign) const
void	ComponentDerivative (osc::IOscCalculator *calc, Flavors::Flavors_t flav, Current::Current_t curr, Sign::Sign_t sign, CoeffsType type, const SystShifts &shift, double pot, std::unordered_map< const ISyst *, std::vector< double >> &dp) const
	Helper for Derivative. More...
template<typename U , typename T >
U	_ShiftedComponent (osc::_IOscCalculator< T > *calc, const TMD5 *hash, const SystShifts &shift, Flavors::Flavors_t flav, Current::Current_t curr, Sign::Sign_t sign, CoeffsType type) const
	Templated helper for ShiftedComponent. More...
template<typename U , typename T >
U	_PredictComponentSyst (osc::_IOscCalculator< T > *calc, const SystShifts &shift, Flavors::Flavors_t flav, Current::Current_t curr, Sign::Sign_t sign) const
	Templated helper for PredictComponentSyst. More...
template<typename T >
void	ShiftBins (unsigned int N, T *arr, CoeffsType type, bool nubar, const SystShifts &shift) const
	Helper for ShiftSpectrum. More...

Protected Attributes
std::unique_ptr< IPrediction >	fPredNom
	The nominal prediction. More...
std::unordered_map< const ISyst *, ShiftedPreds >	fPreds
std::unordered_map< const ISyst *, ShiftedPreds >	fSumPreds
ShiftedPreds	fSummedsp
osc::IOscCalculator *	fOscOrigin
	The oscillation values we assume when evaluating the coefficients. More...
Spectrum	fBinning
	Dummy spectrum to provide binning. More...
std::map< Key_t, Val_t >	fNomCache
bool	fSplitBySign

Detailed Description

Implements systematic errors by interpolation between shifted templates.

Definition at line 28 of file PredictionInterp.h.

Member Enumeration Documentation

enum ana::PredictionInterp::CoeffsType

Enumerator
kNueApp
kNueSurv
kNumuSurv
kNC
kOther	Taus, numu appearance.
kNCoeffTypes

Definition at line 127 of file PredictionInterp.h.

                     {
        kNueApp, kNueSurv, kNumuSurv, kNC,
        kOther, ///< Taus, numu appearance
        kNCoeffTypes
      };

enum ana::PredictionInterp::EMode_t

Enumerator
kCombineSigns
kSplitBySign

Definition at line 31 of file PredictionInterp.h.

                  {
        kCombineSigns, kSplitBySign
      };

Constructor & Destructor Documentation

ana::PredictionInterp::PredictionInterp	(	std::vector< const ISyst * >	systs,
		osc::IOscCalculator *	osc,
		const IPredictionGenerator &	predGen,
		Loaders &	loaders,
		const SystShifts &	shiftMC = kNoShift,
		EMode_t	mode = kCombineSigns
	)

Parameters

systs	What systematics we should be capable of interpolating
osc	The oscillation point to expand around
predGen	Construct an IPrediction from the following information.
loaders	The loaders to be passed on to the underlying prediction
shiftMC	Underlying shift. Use with care. Mostly for PredictionNumuFAHadE. Should not contain any of of systs
mode	In FHC the wrong-sign has bad stats and probably the fits can't be split out reasonably. For RHC it's important not to conflate them.

Definition at line 62 of file PredictionInterp.cxx.

References fPredNom, fPreds, fSplitBySign, kSplitBySign, loaders, ana::SystShifts::SetShift(), ana::PredictionInterp::ShiftedPreds::shifts, plotSysts::syst, ana::PredictionInterp::ShiftedPreds::systName, and systs.

    : fOscOrigin(osc ? osc->Copy() : 0),
      fBinning(0, {}, {}, 0, 0),
      fSplitBySign(mode == kSplitBySign)
  {
    for(const ISyst* syst: systs){
      ShiftedPreds sp;
      sp.systName = syst->ShortName();

      // Genie reweight shifts aren't able to provide +/-3 sigma
      if(syst->IsGenieReweight())
        sp.shifts = {-2, -1, 0, +1, +2};
      else
        sp.shifts = {-3, -2, -1, 0, +1, +2, +3};

      for(int sigma: sp.shifts){
        SystShifts shiftHere = shiftMC;
        shiftHere.SetShift(syst, sigma);
        sp.preds.push_back(predGen.Generate(loaders, shiftHere).release());
      }

      fPreds.emplace(syst, sp);
    } // end for syst

    fPredNom = predGen.Generate(loaders, shiftMC);
  }

ana::PredictionInterp::~PredictionInterp ( )

virtual

Definition at line 95 of file PredictionInterp.cxx.

References fPredNom.

  {
    //    for(auto it: fPreds) for(IPrediction* p: it.second.preds) delete p;
    //    delete fOscOrigin;

    // It isn't really a unique ptr when we use PredictionInterpTemplates
    fPredNom.release();
  }

ana::PredictionInterp::PredictionInterp ( )

inline

Definition at line 133 of file PredictionInterp.h.

References dir, and runNovaSAM::ret.

: fOscOrigin(nullptr), fBinning(0, {}, {}, 0, 0), fSplitBySign(false) {}

Member Function Documentation

template<typename U , typename T >

U ana::PredictionInterp::_PredictComponentSyst ( osc::_IOscCalculator< T > *  calc, const SystShifts &  shift, Flavors::Flavors_t  flav, Current::Current_t  curr, Sign::Sign_t  sign  ) const

protected

Templated helper for PredictComponentSyst.

Definition at line 615 of file PredictionInterp.cxx.

References ana::SystShifts::ActiveSysts(), ana::assert(), om::cerr, ana::Spectrum::Clear(), allTimeWatchdog::endl, fBinning, fPreds, osc::_IOscCalculator< T >::GetParamsHash(), samweb_client.utility::hash, InitFits(), ana::Flavors::kAll, ana::Current::kCC, ana::Current::kNC, kNC, kNueApp, kNueSurv, ana::Flavors::kNuEToNuE, ana::Flavors::kNuEToNuMu, ana::Flavors::kNuEToNuTau, kNumuSurv, ana::Flavors::kNuMuToNuE, ana::Flavors::kNuMuToNuMu, ana::Flavors::kNuMuToNuTau, kOther, runNovaSAM::ret, ShiftedComponent(), and plotSysts::syst.

  {
    InitFits();

    U ret = fBinning;
    ret.Clear();

    // Check that we're able to handle all the systs we were passed
    for(const ISyst* syst: shift.ActiveSysts()){
      if(fPreds.find(syst) == fPreds.end()){
        std::cerr << "This PredictionInterp is not set up to handle the requested systematic: " << syst->ShortName() << std::endl;
        abort();
      }
    } // end for syst


    const TMD5* hash = calc ? calc->GetParamsHash() : 0;

    if(curr & Current::kCC){
      if(flav & Flavors::kNuEToNuE)    ret += ShiftedComponent(calc, hash, shift, Flavors::kNuEToNuE,    Current::kCC, sign, kNueSurv);
      if(flav & Flavors::kNuEToNuMu)   ret += ShiftedComponent(calc, hash, shift, Flavors::kNuEToNuMu,   Current::kCC, sign, kOther  );
      if(flav & Flavors::kNuEToNuTau)  ret += ShiftedComponent(calc, hash, shift, Flavors::kNuEToNuTau,  Current::kCC, sign, kOther  );

      if(flav & Flavors::kNuMuToNuE)   ret += ShiftedComponent(calc, hash, shift, Flavors::kNuMuToNuE,   Current::kCC, sign, kNueApp  );
      if(flav & Flavors::kNuMuToNuMu)  ret += ShiftedComponent(calc, hash, shift, Flavors::kNuMuToNuMu,  Current::kCC, sign, kNumuSurv);
      if(flav & Flavors::kNuMuToNuTau) ret += ShiftedComponent(calc, hash, shift, Flavors::kNuMuToNuTau, Current::kCC, sign, kOther   );
    }
    if(curr & Current::kNC){
      assert(flav == Flavors::kAll); // Don't know how to calculate anything else

      ret += ShiftedComponent(calc, hash, shift, Flavors::kAll, Current::kNC, sign, kNC);
    }

    delete hash;

    return ret;
  }

template<typename U , typename T >

U ana::PredictionInterp::_ShiftedComponent ( osc::_IOscCalculator< T > *  calc, const TMD5 *  hash, const SystShifts &  shift, Flavors::Flavors_t  flav, Current::Current_t  curr, Sign::Sign_t  sign, CoeffsType  type  ) const

protected

Templated helper for ShiftedComponent.

Definition at line 563 of file PredictionInterp.cxx.

References febshutoff_auto::curr, fNomCache, fPredNom, fSplitBySign, samweb_client.utility::hash, it, ana::Sign::kAntiNu, ana::Sign::kBoth, findDuplicateFiles::key, ana::Sign::kNu, ShiftedComponent(), and ShiftSpectrum().

  {
    static_assert(std::is_same<T, double>::value || std::is_same<T, stan::math::var>::value,
                  "PredictionInterp::ShiftedComponent() can only be called using doubles or stan::math::vars");

    if(fSplitBySign && sign == Sign::kBoth){
      return (ShiftedComponent(calc, hash, shift, flav, curr, Sign::kAntiNu, type)+
              ShiftedComponent(calc, hash, shift, flav, curr, Sign::kNu,     type));
    }

    // Must be the base case of the recursion to use the cache. Otherwise we
    // can cache systematically shifted versions of our children, which is
    // wrong. Also, some calculators won't hash themselves.
    // Moreover, caching is not going to work with stan::math::vars
    // since they get reset every time Stan's log_prob() is called.
    const bool canCache = (hash != 0) && !std::is_same<T, stan::math::var>::value;

    const Key_t key = {flav, curr, sign};
    auto it = fNomCache.find(key);

    // Should the interpolation use the nubar fits?
    const bool nubar = (fSplitBySign && sign == Sign::kAntiNu);

    // We have the nominal for this exact combination of flav, curr, sign, calc
    // stored.  Shift it and return.
    if(canCache && it != fNomCache.end() && it->second.hash == *hash){
      return ShiftSpectrum(it->second.nom, type, nubar, shift);
    }

    // We need to compute the nominal again for whatever reason
    const auto nom = fPredNom->PredictComponent(calc, flav, curr, sign);

    if(canCache){
      // Insert into the cache if not already there, or update if there but
      // with old oscillation parameters.
      if(it == fNomCache.end())
        fNomCache.emplace(key, Val_t({*hash, nom}));
      else
        it->second = {*hash, nom};
    }

    return ShiftSpectrum(nom, type, nubar, shift);
  }

virtual OscillatableSpectrum ana::IPrediction::ComponentCC ( int  from, int  to  ) const

inlinevirtualinherited

Reimplemented in ana::PredictionExtendToPeripheral, ana::PredictionAddRock, ana::PredictionCombinePeriods, ana::PredictionExtrap, and ana::PredictionExtrapSum.

Definition at line 103 of file IPrediction.h.

References om::cout, and allTimeWatchdog::endl.

Referenced by ana::PredictionCombinePeriods::ComponentCC(), ana::PredictionAddRock::ComponentCC(), ND_DataMC(), ana::PredictionExtendToPeripheral::PredictionExtendToPeripheral(), and ana::PredictionNueRebinSA::PredictionNueRebinSA().

      {std::cout << "WARNING! ComponentCC is unimplemented in IPrediction" << std::endl; abort();}

void ana::PredictionInterp::ComponentDerivative ( osc::IOscCalculator *  calc, Flavors::Flavors_t  flav, Current::Current_t  curr, Sign::Sign_t  sign, CoeffsType  type, const SystShifts &  shift, double  pot, std::unordered_map< const ISyst *, std::vector< double >> &  dp  ) const

protected

Helper for Derivative.

Definition at line 679 of file PredictionInterp.cxx.

References ana::PredictionInterp::Coeffs::a, ana::assert(), ana::PredictionInterp::Coeffs::b, ana::PredictionInterp::Coeffs::c, calib::corr(), util::cube(), ana::PredictionInterp::Coeffs::d, ana::HistCache::Delete(), release_diff::diff, MakeMiniprodValidationCuts::f, fits, fPreds, fSplitBySign, ana::SystShifts::GetShift(), demo3::h, it, ana::Sign::kAntiNu, ana::Sign::kBoth, ana::Sign::kNu, std::max(), std::min(), getGoodRuns4SAM::n, PredictComponentSyst(), util::sqr(), plotSysts::syst, ana::Spectrum::ToTH1(), and submit_syst::x.

Referenced by Derivative().

  {
    if(fSplitBySign && sign == Sign::kBoth){
      ComponentDerivative(calc, flav, curr, Sign::kNu,     type, shift, pot, dp);
      ComponentDerivative(calc, flav, curr, Sign::kAntiNu, type, shift, pot, dp);
      return;
    }

    // this method is only ever going to be used by the "Frequentist" version of the class.
    // don't bother templating.
    const Spectrum base = PredictComponentSyst(calc, shift, flav, curr, sign);
    TH1D* h = base.ToTH1(pot);
    double* arr = h->GetArray();
    const unsigned int N = h->GetNbinsX()+2;


    // Should the interpolation use the nubar fits?
    const bool nubar = (fSplitBySign && sign == Sign::kAntiNu);

    for(auto& it: dp){
      const ISyst* syst = it.first;
      std::vector<double>& diff = it.second;
      if(diff.empty()) diff.resize(N);
      assert(diff.size() == N);
      assert(fPreds.find(syst) != fPreds.end());
      const ShiftedPreds& sp = fPreds[syst];

      // not instrumenting this method for stan::math::vars
      // since we're using autodiff anyway
      double x = util::GetValAs<double>(shift.GetShift(syst));

      int shiftBin = (x - sp.shifts[0])/sp.Stride();
      shiftBin = std::max(0, shiftBin);
      shiftBin = std::min(shiftBin, sp.nCoeffs-1);

      const Coeffs* fits = nubar ? &sp.fitsNubarRemap[type][shiftBin].front() : &sp.fitsRemap[type][shiftBin].front();

      x -= sp.shifts[shiftBin];

      const double x_cube = util::cube(x);
      const double x_sqr = util::sqr(x);

      for(unsigned int n = 0; n < N; ++n){
        // Uncomment to debug crashes in this function
        // assert(type < fits.size());
        // assert(n < sp.fits[type].size());
        // assert(shiftBin < int(sp.fits[type][n].size()));
        const Coeffs& f = fits[n];

        const double corr = f.a*x_cube + f.b*x_sqr + f.c*x + f.d;
        if(corr > 0) diff[n] += (3*f.a*x_sqr + 2*f.b*x + f.c)/corr*arr[n];
      } // end for n
    } // end for syst

    HistCache::Delete(h);
  }

virtual Spectrum ana::IPrediction::ComponentNC ( ) const

inlinevirtualinherited

Reimplemented in ana::PredictionExtendToPeripheral, ana::PredictionAddRock, ana::PredictionCombinePeriods, ana::PredictionExtrap, and ana::PredictionExtrapSum.

Definition at line 111 of file IPrediction.h.

References om::cout, and allTimeWatchdog::endl.

Referenced by ana::PredictionAddRock::ComponentNC(), and ana::PredictionExtendToPeripheral::PredictionExtendToPeripheral().

      {std::cout << "WARNING! ComponentNC is unimplemented in IPrediction" << std::endl; abort();}

virtual Spectrum ana::IPrediction::ComponentNCAnti ( ) const

inlinevirtualinherited

Reimplemented in ana::PredictionExtendToPeripheral, ana::PredictionAddRock, ana::PredictionCombinePeriods, ana::PredictionExtrap, and ana::PredictionExtrapSum.

Definition at line 113 of file IPrediction.h.

References om::cout, dir, allTimeWatchdog::endl, and ana::SaveTo().

Referenced by ana::PredictionAddRock::ComponentNCAnti(), and ana::PredictionExtendToPeripheral::PredictionExtendToPeripheral().

      {std::cout << "WARNING! ComponentNCAnti is unimplemented in IPrediction" << std::endl; abort();}

virtual Spectrum ana::IPrediction::ComponentNCTotal ( ) const

inlinevirtualinherited

Reimplemented in ana::PredictionExtendToPeripheral, ana::PredictionAddRock, ana::PredictionCombinePeriods, ana::PredictionExtrap, and ana::PredictionExtrapSum.

Definition at line 109 of file IPrediction.h.

References om::cout, and allTimeWatchdog::endl.

Referenced by ana::PredictionAddRock::ComponentNCTotal(), ND_DataMC(), and ana::PredictionExtendToPeripheral::PredictionExtendToPeripheral().

      {std::cout << "WARNING! ComponentNCTotal is unimplemented in IPrediction" << std::endl; abort();}

void ana::PredictionInterp::DebugPlot	(	const ISyst *	syst,
		osc::IOscCalculator *	calc,
		Flavors::Flavors_t	flav = Flavors::kAll,
		Current::Current_t	curr = Current::kBoth,
		Sign::Sign_t	sign = Sign::kBoth
	)		const

Definition at line 920 of file PredictionInterp.cxx.

References bin, plot_validation_datamc::c, om::cout, Draw(), allTimeWatchdog::endl, genie::utils::style::Format(), fPredNom, fPreds, demo3::h, MECModelEnuComparisons::i, InitFits(), makeTrainCVSamples::int, std::isnan(), it, nbins, ana::IPrediction::PredictComponent(), PredictComponentSyst(), plotSysts::ratio, ana::ISyst::ShortName(), std::sqrt(), ss, and submit_syst::x.

Referenced by DebugPlots().

  {
    InitFits();

    auto it = fPreds.find(syst);
    if(it == fPreds.end()){
      std::cout << "PredictionInterp::DebugPlots(): "
                << syst->ShortName() << " not found" << std::endl;
      return;
    }


    // force-convert to _Spectrum<double> for ease here since in DebugPlots()
    // we're not concerned with preserving autodiff or speed.
    // (more instances further below.)
    std::unique_ptr<TH1> nom(Spectrum(fPredNom->PredictComponent(calc, flav, curr, sign)).ToTH1(18e20));
    const int nbins = nom->GetNbinsX();

    TGraph* curves[nbins];
    TGraph* points[nbins];

    for(int i = 0; i <= 80; ++i){
      const double x = .1*i-4;
      const SystShifts ss(it->first, x);
      std::unique_ptr<TH1> h(Spectrum(PredictComponentSyst(calc, ss, flav, curr, sign)).ToTH1(18e20));

      for(int bin = 0; bin < nbins; ++bin){
        if(i == 0){
          curves[bin] = new TGraph;
          points[bin] = new TGraph;
        }

        const double ratio = h->GetBinContent(bin+1)/nom->GetBinContent(bin+1);

        if(!std::isnan(ratio)) curves[bin]->SetPoint(curves[bin]->GetN(), x, ratio);
        else curves[bin]->SetPoint(curves[bin]->GetN(), x, 1);
      } // end for bin
    } // end for i (x)

    // As elswhere, to allow BirksC etc that need a different nominal to plot
    // right.
    IPrediction* pNom = 0;
    for(unsigned int shiftIdx = 0; shiftIdx < it->second.shifts.size(); ++shiftIdx){
      if(it->second.shifts[shiftIdx] == 0) pNom = it->second.preds[shiftIdx];
    }
    if(pNom){ // if not, probably MinimizeMemory() was called
      std::unique_ptr<TH1> hnom(Spectrum(pNom->PredictComponent(calc, flav, curr, sign)).ToTH1(18e20));

      for(unsigned int shiftIdx = 0; shiftIdx < it->second.shifts.size(); ++shiftIdx){
        if(!it->second.preds[shiftIdx]) continue; // Probably MinimizeMemory()
        std::unique_ptr<TH1> h;
        h = std::move(std::unique_ptr<TH1>(Spectrum(it->second.preds[shiftIdx]->PredictComponent(calc, flav, curr, sign)).ToTH1(18e20)));

        for(int bin = 0; bin < nbins; ++bin){
          const double ratio = h->GetBinContent(bin+1)/hnom->GetBinContent(bin+1);
          if(!std::isnan(ratio)) points[bin]->SetPoint(points[bin]->GetN(), it->second.shifts[shiftIdx], ratio);
          else points[bin]->SetPoint(points[bin]->GetN(), it->second.shifts[shiftIdx], 1);
        }
      } // end for shiftIdx
    } // end if pNom


    int nx = int(sqrt(nbins));
    int ny = int(sqrt(nbins));
    if(nx*ny < nbins) ++nx;
    if(nx*ny < nbins) ++ny;

    TCanvas* c = new TCanvas;
    c->Divide(nx, ny);

    for(int bin = 0; bin < nbins; ++bin){
      c->cd(bin+1);
      (new TH2F("",
                TString::Format("%s %g < %s < %g;Shift;Ratio",
                                it->second.systName.c_str(),
                                nom->GetXaxis()->GetBinLowEdge(bin+1),
                                nom->GetXaxis()->GetTitle(),
                                nom->GetXaxis()->GetBinUpEdge(bin+1)),
                100, -4, +4, 100, .5, 1.5))->Draw();
      curves[bin]->Draw("l same");
      points[bin]->SetMarkerStyle(kFullDotMedium);
      points[bin]->Draw("p same");
    } // end for bin

    c->cd(0);
  }

void ana::PredictionInterp::DebugPlotColz	(	const ISyst *	syst,
		osc::IOscCalculator *	calc,
		Flavors::Flavors_t	flav = Flavors::kAll,
		Current::Current_t	curr = Current::kBoth,
		Sign::Sign_t	sign = Sign::kBoth
	)		const

Definition at line 1029 of file PredictionInterp.cxx.

References bin, fPredNom, demo3::h, h2, MECModelEnuComparisons::i, InitFits(), std::isinf(), std::isnan(), ana::ISyst::LatexName(), nbins, PredictComponentSyst(), plotSysts::ratio, ss, and submit_syst::y.

Referenced by DebugPlotsColz().

  {
    InitFits();

    std::unique_ptr<TH1> nom(fPredNom->PredictComponent(calc, flav, curr, sign).ToTH1(18e20));
    const int nbins = nom->GetNbinsX();

    TH2* h2 = new TH2F("", (syst->LatexName()+";;#sigma").c_str(),
                       nbins, nom->GetXaxis()->GetXmin(), nom->GetXaxis()->GetXmax(),
                       80, -4, +4);
    h2->GetXaxis()->SetTitle(nom->GetXaxis()->GetTitle());

    for(int i = 1; i <= 80; ++i){
      const double y = h2->GetYaxis()->GetBinCenter(i);
      const SystShifts ss(syst, y);
      std::unique_ptr<TH1> h(PredictComponentSyst(calc, ss, flav, curr, sign).ToTH1(18e20));

      for(int bin = 0; bin < nbins; ++bin){
        const double ratio = h->GetBinContent(bin+1)/nom->GetBinContent(bin+1);

        if(!isnan(ratio) && !isinf(ratio))
          h2->Fill(h2->GetXaxis()->GetBinCenter(bin), y, ratio);
      } // end for bin
    } // end for i (x)

    h2->Draw("colz");
    h2->SetMinimum(0.5);
    h2->SetMaximum(1.5);
  }

void ana::PredictionInterp::DebugPlots	(	osc::IOscCalculator *	calc,
		const std::string &	savePattern = "",
		Flavors::Flavors_t	flav = Flavors::kAll,
		Current::Current_t	curr = Current::kBoth,
		Sign::Sign_t	sign = Sign::kBoth
	)		const

Definition at line 1012 of file PredictionInterp.cxx.

References ana::assert(), DebugPlot(), genie::utils::style::Format(), fPreds, and it.

Referenced by check_predinterp(), check_predinterp_numu(), and test_prediction_interp().

  {
    for(auto& it: fPreds){
      DebugPlot(it.first, calc, flav, curr, sign);

      if(!savePattern.empty()){
        assert(savePattern.find("%s") != std::string::npos);
        gPad->Print(TString::Format(savePattern.c_str(), it.second.systName.c_str()).Data());
      }
    } // end for it
  }

void ana::PredictionInterp::DebugPlotsColz	(	osc::IOscCalculator *	calc,
		const std::string &	savePattern = "",
		Flavors::Flavors_t	flav = Flavors::kAll,
		Current::Current_t	curr = Current::kBoth,
		Sign::Sign_t	sign = Sign::kBoth
	)		const

Definition at line 1064 of file PredictionInterp.cxx.

References ana::assert(), DebugPlotColz(), genie::utils::style::Format(), fPreds, InitFits(), and it.

  {
    InitFits();

    for(auto it: fPreds){
      new TCanvas;
      DebugPlotColz(it.first, calc, flav, curr, sign);

      if(!savePattern.empty()){
        assert(savePattern.find("%s") != std::string::npos);
        gPad->Print(TString::Format(savePattern.c_str(), it.second.systName.c_str()).Data());
      }
    } // end for it
  }

void ana::PredictionInterp::Derivative ( osc::IOscCalculator *  calc, const SystShifts &  shift, double  pot, std::unordered_map< const ISyst *, std::vector< double >> &  dp  ) const

overridevirtual

Reimplemented from ana::IPrediction.

Definition at line 744 of file PredictionInterp.cxx.

References om::cerr, ComponentDerivative(), allTimeWatchdog::endl, fPreds, InitFits(), it, ana::Flavors::kAll, ana::Sign::kBoth, ana::Current::kCC, ana::Current::kNC, kNC, kNueApp, kNueSurv, ana::Flavors::kNuEToNuE, ana::Flavors::kNuEToNuMu, ana::Flavors::kNuEToNuTau, kNumuSurv, ana::Flavors::kNuMuToNuE, ana::Flavors::kNuMuToNuMu, ana::Flavors::kNuMuToNuTau, and kOther.

  {
    InitFits();

    // Check that we're able to handle all the systs we were passed
    for(auto& it: dp){
      if(fPreds.find(it.first) == fPreds.end()){
        std::cerr << "This PredictionInterp is not set up to handle the requested systematic: " << it.first->ShortName() << std::endl;
        abort();
      }
      it.second.clear();
    } // end for syst

    ComponentDerivative(calc, Flavors::kNuEToNuE,    Current::kCC, Sign::kBoth, kNueSurv,  shift, pot, dp);
    ComponentDerivative(calc, Flavors::kNuEToNuMu,   Current::kCC, Sign::kBoth, kOther,    shift, pot, dp);
    ComponentDerivative(calc, Flavors::kNuEToNuTau,  Current::kCC, Sign::kBoth, kOther,    shift, pot, dp);

    ComponentDerivative(calc, Flavors::kNuMuToNuE,   Current::kCC, Sign::kBoth, kNueApp,   shift, pot, dp);
    ComponentDerivative(calc, Flavors::kNuMuToNuMu,  Current::kCC, Sign::kBoth, kNumuSurv, shift, pot, dp);
    ComponentDerivative(calc, Flavors::kNuMuToNuTau, Current::kCC, Sign::kBoth, kOther,    shift, pot, dp);

    ComponentDerivative(calc, Flavors::kAll, Current::kNC, Sign::kBoth, kNC, shift, pot, dp);

    // Simpler (much slower) implementation in terms of finite differences for
    // test purposes
    /*
    const Spectrum p0 = PredictSyst(calc, shift);
    TH1D* h0 = p0.ToTH1(pot);

    const double dx = 1e-9;
    for(auto& it: dp){
      const ISyst* s =  it.first;
      std::vector<double>& v = it.second;
      SystShifts s2 = shift;
      s2.SetShift(s, s2.GetShift(s)+dx);

      const Spectrum p1 = PredictSyst(calc, s2);

      TH1D* h1 = p1.ToTH1(pot);

      v.resize(h1->GetNbinsX()+2);
      for(int i = 0; i < h1->GetNbinsX()+2; ++i){
        v[i] = (h1->GetBinContent(i) - h0->GetBinContent(i))/dx;
      }

      HistCache::Delete(h1);
    }

    HistCache::Delete(h0);
    */
  }

std::vector< std::vector< PredictionInterp::Coeffs > > ana::PredictionInterp::FitComponent	(	const std::vector< double > &	shifts,
		const std::vector< IPrediction * > &	preds,
		Flavors::Flavors_t	flav,
		Current::Current_t	curr,
		Sign::Sign_t	sign
	)		const

Find coefficients describing the ratios from this component.

Definition at line 198 of file PredictionInterp.cxx.

References ana::assert(), om::cout, allTimeWatchdog::endl, FitRatios(), fOscOrigin, MECModelEnuComparisons::i, ana::IPrediction::PredictComponent(), r(), plotSysts::ratios, and submit_syst::y.

Referenced by InitFitsHelper().

  {
    IPrediction* pNom = 0;
    for(unsigned int i = 0; i < shifts.size(); ++i){
      if(shifts[i] == 0) pNom = preds[i];
    }
    assert(pNom);

    // Do it this way rather than via fPredNom so that systematics evaluated
    // relative to some alternate nominal (eg Birks C where the appropriate
    // nominal is no-rock) can work.
    const Spectrum nom = pNom->PredictComponent(fOscOrigin,
                                                flav, curr, sign);

    std::vector<std::unique_ptr<TH1>> ratios;
    for(auto& p: preds){
      ratios.emplace_back(Ratio(p->PredictComponent(fOscOrigin,
                                                    flav, curr, sign),
                                nom).ToTH1());

      // Check none of the ratio values is utterly crazy
      std::unique_ptr<TH1>& r = ratios.back();
      for(int i = 0; i < r->GetNbinsX()+2; ++i){
        const double y = r->GetBinContent(i);
        if(y > 500){
          std::cout << "PredictionInterp: WARNING, ratio in bin "
                    << i << " is " << y << ". Ignoring." << std::endl;
          r->SetBinContent(i, 1);
        }
      }
    }

    return FitRatios(shifts, ratios);
  }

std::vector< std::vector< PredictionInterp::Coeffs > > ana::PredictionInterp::FitRatios	(	const std::vector< double > &	shifts,
		const std::vector< std::unique_ptr< TH1 >> &	ratios
	)		const

Find coefficients describing this set of shifts.

Definition at line 106 of file PredictionInterp.cxx.

References ana::assert(), plot_validation_datamc::c, lem_server::cs, util::cube(), e, stan::math::fabs(), MECModelEnuComparisons::i, m, plotSysts::ratios, res, runNovaSAM::ret, util::sqr(), update_sam_good_runs_metadata::stride, registry_explorer::v, y1, and submit_syst::y2.

Referenced by FitComponent(), and FitSumComponent().

  {
    assert(shifts.size() == ratios.size());
    std::vector<std::vector<Coeffs>> ret;

    const int binMax = ratios[0]->GetNbinsX();

    for(int binIdx = 0; binIdx < binMax+2; ++binIdx){
      ret.push_back({});
      // This is cubic interpolation. For each adjacent set of four points we
      // determine coefficients for a cubic which will be the curve between the
      // center two. We constrain the function to match the two center points
      // and to have the right mean gradient at them. This causes this patch to
      // match smoothly with the next one along. The resulting function is
      // continuous and first and second differentiable. At the ends of the
      // range we fit a quadratic instead with only one constraint on the
      // slope. The coordinate conventions are that point y1 sits at x=0 and y2
      // at x=1. The matrices are simply the inverses of writing out the
      // constraints expressed above.

      // Special-case for linear interpolation
      if(ratios.size() == 2){
        const double y0 = ratios[0]->GetBinContent(binIdx);
        const double y1 = ratios[1]->GetBinContent(binIdx);

        ret.back().emplace_back(0, 0, y1-y0, y0);
        continue;
      }

      {
        const double y1 = ratios[0]->GetBinContent(binIdx);
        const double y2 = ratios[1]->GetBinContent(binIdx);
        const double y3 = ratios[2]->GetBinContent(binIdx);
        const double v[3] = {y1, y2, (y3-y1)/2};
        const double m[9] = { 1, -1,  1,
                             -2,  2, -1,
                              1,  0,  0};
        const TVectorD res = TMatrixD(3, 3, m) * TVectorD(3, v);
        ret.back().emplace_back(0, res(0), res(1), res(2));
      }

      // We're assuming here that the shifts are separated by exactly 1 sigma.
      for(unsigned int shiftIdx = 1; shiftIdx < ratios.size()-2; ++shiftIdx){
        const double y0 = ratios[shiftIdx-1]->GetBinContent(binIdx);
        const double y1 = ratios[shiftIdx  ]->GetBinContent(binIdx);
        const double y2 = ratios[shiftIdx+1]->GetBinContent(binIdx);
        const double y3 = ratios[shiftIdx+2]->GetBinContent(binIdx);

        const double v[4] = {y1, y2, (y2-y0)/2, (y3-y1)/2};
        const double m[16] = { 2, -2,  1,  1,
                              -3,  3, -2, -1,
                               0,  0,  1,  0,
                               1,  0,  0,  0};
        const TVectorD res = TMatrixD(4, 4, m) * TVectorD(4, v);
        ret.back().emplace_back(res(0), res(1), res(2), res(3));
      } // end for shiftIdx

      {
        const int N = ratios.size()-3;
        const double y0 = ratios[N  ]->GetBinContent(binIdx);
        const double y1 = ratios[N+1]->GetBinContent(binIdx);
        const double y2 = ratios[N+2]->GetBinContent(binIdx);
        const double v[3] = {y1, y2, (y2-y0)/2};
        const double m[9] = {-1,  1, -1,
                              0,  0,  1,
                              1,  0,  0};
        const TVectorD res = TMatrixD(3, 3, m) * TVectorD(3, v);
        ret.back().emplace_back(0, res(0), res(1), res(2));
      }
    } // end for binIdx

    double stride = -1;
    for(unsigned int i = 0; i < shifts.size()-1; ++i){
      const double newStride = shifts[i+1]-shifts[i];
      assert((stride < 0 || fabs(stride-newStride) < 1e-3) &&
             "Variably-spaced syst templates are unsupported");
      stride = newStride;
    }

    // If the stride is actually not 1, need to rescale all the coefficients
    for(std::vector<Coeffs>& cs: ret)
      for(Coeffs& c: cs){
        c = Coeffs(c.a/util::cube(stride),
                   c.b/util::sqr(stride),
                   c.c/stride,
                   c.d);}
    return ret;
  }

std::vector< std::vector< PredictionInterp::Coeffs > > ana::PredictionInterp::FitSumComponent ( const std::vector< ShiftedPreds > &  spf, Flavors::Flavors_t  flav, Current::Current_t  curr, Sign::Sign_t  sign  ) const

protected

Definition at line 239 of file PredictionInterp.cxx.

References ana::assert(), bin, ana::HistCache::Copy(), ana::HistCache::Delete(), FitRatios(), fOscOrigin, ana::Spectrum::GetBinnings(), chisquared::hpred, MECModelEnuComparisons::i, ana::HistCache::New(), pot, ana::Spectrum::POT(), ana::IPrediction::PredictComponent(), std::sqrt(), and ana::Spectrum::ToTH1().

Referenced by InitFitsSumHelper().

  { 
    IPrediction* pNom = 0;
    //take 1st one as template 
    std::vector<double> shifts = sps[0].shifts;
    std::vector<IPrediction*> preds = sps[0].preds;

    //for now, genie only take +-2
    assert(shifts[2] == 0 && "PredictionSumInterp only implemented for +-2 shifts");

    for(unsigned int i = 0; i < shifts.size(); ++i){
      if(shifts[i] == 0) pNom = preds[i];
    }
    assert(pNom);

    const Spectrum nom = pNom->PredictComponent(fOscOrigin, 
                                                flav, curr, sign);
    
    std::vector<std::unique_ptr<TH1>> sumratios;

    double pot = nom.POT();
    const Binning binning = nom.GetBinnings()[0];
    DontAddDirectory guard;
    TH1D* hnom = nom.ToTH1(pot);
    TH1D* hsummed = HistCache::Copy(hnom);

    double* quads = hsummed->GetArray();
    int nbin = hnom->GetNbinsX();
    double* from = hnom->GetArray();

    for(unsigned int i = 0; i < shifts.size(); i++){
      for(auto& sp: sps){

        IPrediction* p = sp.preds[i];
        // force-convert to _Spectrum<double> since we don't need autodiff here
        TH1D* hpred = Spectrum(p->PredictComponent(fOscOrigin, flav, curr, sign)).ToTH1(pot);

        double* to = hpred->GetArray();
        for(int bin = 0; bin < nbin+2; ++bin){
          to[bin] -= from[bin];
          to[bin] *= to[bin];
          quads[bin] += to[bin];
        }//end all bins
        HistCache::Delete(hpred);
      }//end all systpreds

      //sqrt of sum of diff
      for(int bin = 0; bin < nbin+2; ++bin){
        quads[bin] = sqrt(quads[bin]);
        if(shifts[i]<0) quads[bin] *= -1.0;
        quads[bin] += from[bin];
        quads[bin] /= from[bin];
      }

      std::unique_ptr<TH1> hret(HistCache::New("", binning));

      for( int i = 0; i< nbin+2; ++i){ hret->SetBinContent( i, quads[i]);}
   
      sumratios.emplace_back(std::move(hret));
    } //end shifts
    HistCache::Delete(hsummed);
    HistCache::Delete(hnom);
    return FitRatios(shifts, sumratios);
  }

void ana::PredictionInterp::InitFits ( ) const

protected

Definition at line 338 of file PredictionInterp.cxx.

References ana::Spectrum::Clear(), om::cout, allTimeWatchdog::endl, fBinning, ana::PredictionInterp::ShiftedPreds::FillRemaps(), ana::PredictionInterp::ShiftedPreds::fits, ana::PredictionInterp::ShiftedPreds::fitsNubar, fOscOrigin, fPredNom, fPreds, fSplitBySign, fSummedsp, fSumPreds, InitFitsHelper(), InitFitsSumHelper(), it, ana::Sign::kAntiNu, ana::Sign::kBoth, ana::Sign::kNu, ana::kSummedSyst, ana::Spectrum::Livetime(), ana::PredictionInterp::ShiftedPreds::nCoeffs, ana::Spectrum::POT(), ana::PredictionInterp::ShiftedPreds::shifts, and ana::PredictionInterp::ShiftedPreds::systName.

Referenced by _PredictComponentSyst(), DebugPlot(), DebugPlotColz(), DebugPlotsColz(), Derivative(), ana::PredictionSyst3Flavor2020::PredictionSyst3Flavor2020(), ana::PredictionSystJoint2018::PredictionSystJoint2018(), ana::PredictionSystJointDemo::PredictionSystJointDemo(), ana::PredictionSystNue2017::PredictionSystNue2017(), ana::PredictionSystNueSecondAna::PredictionSystNueSecondAna(), ana::PredictionSystNumu2017::PredictionSystNumu2017(), PredictSyst(), SaveTo(), and SetOscSeed().

  {

    // No systs
    if(fPreds.empty() && fSumPreds.empty()){
      if(fBinning.POT() > 0 || fBinning.Livetime() > 0) return;
    }
    // Already initialized, Summed merged to fPreds
    else if(!fPreds.empty() && !fPreds.begin()->second.fits.empty()) return;

    for(auto& it: fPreds){
      ShiftedPreds& sp = it.second;

      if(fSplitBySign){
        InitFitsHelper(sp, sp.fits, Sign::kNu);
        InitFitsHelper(sp, sp.fitsNubar, Sign::kAntiNu);
      }
      else{
        InitFitsHelper(sp, sp.fits, Sign::kBoth);
      }
      sp.nCoeffs = sp.fits[0][0].size();

      // Copy the outputs into the remapped indexing order. TODO this is very
      // ugly. Best would be to generate things in this order natively.
      sp.FillRemaps();
    }

    if(!fSumPreds.empty()){
      std::cout<<"PredictionInterp: Summing "<<fSumPreds.size()<<
               " systematics..."<<std::endl;
      std::vector<ShiftedPreds> sp;
      for(auto& it: fSumPreds) sp.push_back( it.second);

      fSummedsp.systName = "Summed Syst";
      fSummedsp.shifts = {-2, -1, 0, 1, 2};
 
      if(fSplitBySign){
        InitFitsSumHelper(sp, fSummedsp.fits, Sign::kNu);
        InitFitsSumHelper(sp, fSummedsp.fitsNubar, Sign::kAntiNu);
      }
      else{
        InitFitsSumHelper(sp, fSummedsp.fits, Sign::kBoth);
      }
      fSummedsp.nCoeffs = fSummedsp.fits[0][0].size();

      fPreds.emplace(&kSummedSyst, fSummedsp);
    }

    // Predict something, anything, so that we can know what binning to use
    fBinning = fPredNom->Predict(fOscOrigin);
    fBinning.Clear();
  }

void ana::PredictionInterp::InitFitsHelper ( ShiftedPreds &  sp, std::vector< std::vector< std::vector< Coeffs >>> &  fits, Sign::Sign_t  sign  ) const

protected

Definition at line 308 of file PredictionInterp.cxx.

References FitComponent(), fits, ana::Flavors::kAll, ana::Flavors::kAllNuTau, ana::Current::kCC, ana::Current::kNC, kNC, kNCoeffTypes, kNueApp, kNueSurv, ana::Flavors::kNuEToNuE, ana::Flavors::kNuEToNuMu, kNumuSurv, ana::Flavors::kNuMuToNuE, ana::Flavors::kNuMuToNuMu, kOther, ana::PredictionInterp::ShiftedPreds::preds, and ana::PredictionInterp::ShiftedPreds::shifts.

Referenced by InitFits().

  {
    fits.resize(kNCoeffTypes);

    fits[kNueApp]   = FitComponent(sp.shifts, sp.preds, Flavors::kNuMuToNuE,  Current::kCC, sign);
    fits[kNueSurv]  = FitComponent(sp.shifts, sp.preds, Flavors::kNuEToNuE,   Current::kCC, sign);
    fits[kNumuSurv] = FitComponent(sp.shifts, sp.preds, Flavors::kNuMuToNuMu, Current::kCC, sign);

    fits[kNC]       = FitComponent(sp.shifts, sp.preds, Flavors::kAll, Current::kNC, sign);

    fits[kOther] = FitComponent(sp.shifts, sp.preds, Flavors::kNuEToNuMu | Flavors::kAllNuTau, Current::kCC, sign);
  }

void ana::PredictionInterp::InitFitsSumHelper ( std::vector< ShiftedPreds > &  sps, std::vector< std::vector< std::vector< Coeffs >>> &  fits, Sign::Sign_t  sign  ) const

protected

Definition at line 324 of file PredictionInterp.cxx.

References fits, FitSumComponent(), ana::Flavors::kAll, ana::Flavors::kAllNuTau, ana::Current::kCC, ana::Current::kNC, kNC, kNCoeffTypes, kNueApp, kNueSurv, ana::Flavors::kNuEToNuE, ana::Flavors::kNuEToNuMu, kNumuSurv, ana::Flavors::kNuMuToNuE, ana::Flavors::kNuMuToNuMu, and kOther.

Referenced by InitFits().

  {
    fits.resize(kNCoeffTypes);
    fits[kNueApp]   = FitSumComponent(sp, Flavors::kNuMuToNuE,  Current::kCC, sign);
    fits[kNueSurv]  = FitSumComponent(sp, Flavors::kNuEToNuE,   Current::kCC, sign);
    fits[kNumuSurv] = FitSumComponent(sp, Flavors::kNuMuToNuMu, Current::kCC, sign);

    fits[kNC]       = FitSumComponent(sp, Flavors::kAll, Current::kNC, sign);

    fits[kOther] = FitSumComponent(sp, Flavors::kNuEToNuMu | Flavors::kAllNuTau, Current::kCC, sign);
  }

std::unique_ptr< PredictionInterp > ana::PredictionInterp::LoadFrom ( TDirectory *  dir )

static

Definition at line 845 of file PredictionInterp.cxx.

References ana::assert(), LoadFromBody(), runNovaSAM::ret, and getGoodRuns4SAM::tag.

Referenced by CalcRWithSystsNus17(), FCContour(), futureSig_reach_singlePOTcombo_syst(), genie_contours(), get_sa_syst_mags(), get_sa_systs_mags_v2(), get_univ_chisq(), getHists_FNEX(), joint_fit_make_experiments(), joint_fit_make_fc_slice(), joint_fit_make_fc_surf(), ana::LoadFrom< IPrediction >(), LoadPrediction(), make_fc_points(), make_nus17_fc_surfs(), make_nus_fc_surfs(), makeMatrixElementSurface(), plot_extrap_syst_fa(), plot_sa_results(), plot_sa_results_nodata(), PlotNus17PredSystsData(), and PlotNusSensAna01().

  {
    TObjString* tag = (TObjString*)dir->Get("type");
    assert(tag);
    assert(tag->GetString() == "PredictionInterp" ||
           tag->GetString() == "PredictionInterp2"); // backwards compatibility

    auto ret = std::make_unique<PredictionInterp>();

    LoadFromBody(dir, ret.get());

    TObjString* split_sign = (TObjString*)dir->Get("split_sign");
    // Can be missing from old files
    ret->fSplitBySign = (split_sign && split_sign->String() == "yes");

    return ret;
  }

void ana::PredictionInterp::LoadFromBody ( TDirectory *  dir, PredictionInterp *  ret, std::vector< const ISyst * >  veto = {}  )

static

Definition at line 864 of file PredictionInterp.cxx.

References genie::utils::style::Format(), fOscOrigin, fPredNom, fPreds, ana::LoadFrom< IPrediction >(), plot_validation_datamc::pred, ana::PredictionInterp::ShiftedPreds::preds, runNovaSAM::release, plotSysts::shift, ana::PredictionInterp::ShiftedPreds::shifts, ana::Registry< T >::ShortNameToPtr(), plotSysts::syst, and ana::PredictionInterp::ShiftedPreds::systName.

Referenced by ana::PredictionSystJoint2018::LoadFrom(), ana::PredictionSystJointDemo::LoadFrom(), LoadFrom(), ana::PredictionSystNueSecondAna::LoadFrom(), ana::PredictionSystNue2017::LoadFrom(), and ana::PredictionSystNumu2017::LoadFrom().

  {
    ret->fPredNom = ana::LoadFrom<IPrediction>(dir->GetDirectory("pred_nom"));

    TH1* hSystNames = (TH1*)dir->Get("syst_names");
    if(hSystNames){
      for(int systIdx = 0; systIdx < hSystNames->GetNbinsX(); ++systIdx){
        ShiftedPreds sp;
        sp.systName = hSystNames->GetXaxis()->GetBinLabel(systIdx+1);

        auto syst = Registry<ISyst>::ShortNameToPtr(sp.systName);

        if(std::find(veto.begin(), veto.end(), syst) != veto.end()) continue;

        for(int shift = -3; shift <= +3; ++shift){
          TDirectory* preddir = dir->GetDirectory(TString::Format("pred_%s_%+d", sp.systName.c_str(), shift).Data());
          if(!preddir) continue; // Can happen for genie systs

          IPrediction* pred = ana::LoadFrom<IPrediction>(preddir).release();

          sp.shifts.push_back(shift);
          sp.preds.push_back(pred);
        } // end for shift

        ret->fPreds.emplace(syst, sp);
      } // end for systIdx
    } // end if hSystNames

    ret->fOscOrigin = ana::LoadFrom<osc::IOscCalculator>(dir->GetDirectory("osc_origin")).release();
  }

void ana::PredictionInterp::MinimizeMemory

(

)

After calling this DebugPlots won't work fully and SaveTo won't work at all.

Definition at line 897 of file PredictionInterp.cxx.

References fPredNom, fPreds, MECModelEnuComparisons::i, and it.

Referenced by ana::PredictionSyst3Flavor2020::PredictionSyst3Flavor2020(), ana::PredictionSystJoint2018::PredictionSystJoint2018(), and ana::PredictionSystJointDemo::PredictionSystJointDemo().

  {
    std::set<IPrediction*> todel;
    for(auto& it: fPreds){
      std::vector<IPrediction*>& preds = it.second.preds;
      for(unsigned int i = 0; i < preds.size(); ++i){
        if(preds[i] != fPredNom.get()){
          todel.insert(preds[i]);
          preds[i] = 0;
        }
      }
    }

    for(IPrediction* p: todel) delete p;

    // We probably just freed up a lot of memory, but malloc by default hangs
    // on to all of it as cache.
    #ifndef DARWINBUILD
    malloc_trim(0);
    #endif
  }

Spectrum ana::PredictionInterp::Predict ( osc::IOscCalculator *  calc ) const

overridevirtual

Implements ana::IPrediction.

Definition at line 399 of file PredictionInterp.cxx.

References fPredNom.

Referenced by ana::PredictionSystJoint2018::AddNormSyst(), ana::PredictionSystJointDemo::AddNormSyst(), ana::PredictionSyst3Flavor2020::AddNormSyst(), ana::PredictionSystNueSecondAna::AddNormSysts(), ana::PredictionSystNue2017::AddNormSysts(), ana::PredictionSystNumu2017::AddNormSysts(), compare_pid_cut_sens(), contours(), drawSystsShiftingNDdata_updatedAna(), extrap_syst_fa(), fa_fd_data_mc_systs(), GetNuePrediction2017(), GetNuePrediction2018(), GetNuePrediction2019(), ana::GetNuePrediction2020(), getSensitivity(), joint_fit_make_fc_slice(), joint_fit_make_fc_surf(), make_fc_slice(), make_fc_surf(), makeSystTable(), makeSystTable_reduced(), saTestContours(), saveContours_oscpar(), saveContours_systs(), sensitivity(), sensitivity_slices(), syst_plot_test(), test_stanfit_systpulls(), TestPred(), and Toy_analyses().

  {
    return fPredNom->Predict(calc);
  }

SpectrumStan ana::PredictionInterp::Predict ( osc::IOscCalculatorStan *  calc ) const

overridevirtual

Reimplemented from ana::IPrediction.

Definition at line 405 of file PredictionInterp.cxx.

References fPredNom.

  {
    return fPredNom->Predict(calc);
  }

Spectrum ana::PredictionInterp::PredictComponent ( osc::IOscCalculator *  calc, Flavors::Flavors_t  flav, Current::Current_t  curr, Sign::Sign_t  sign  ) const

overridevirtual

Implements ana::IPrediction.

Definition at line 411 of file PredictionInterp.cxx.

References fPredNom.

Referenced by compare_pid_cut_sens(), fa_fd_data_mc_systs(), syst_plot_test(), systematics_table(), and systematics_table_from_pred_interp().

  {
    return fPredNom->PredictComponent(calc, flav, curr, sign);
  }

SpectrumStan ana::PredictionInterp::PredictComponent ( osc::IOscCalculatorStan *  calc, Flavors::Flavors_t  flav, Current::Current_t  curr, Sign::Sign_t  sign  ) const

overridevirtual

Reimplemented from ana::IPrediction.

Definition at line 420 of file PredictionInterp.cxx.

References fPredNom.

  {
    return fPredNom->PredictComponent(calc, flav, curr, sign);
  }

Spectrum ana::PredictionInterp::PredictComponentSyst ( osc::IOscCalculator *  calc, const SystShifts &  shift, Flavors::Flavors_t  flav, Current::Current_t  curr, Sign::Sign_t  sign  ) const

overridevirtual

Reimplemented from ana::IPrediction.

Definition at line 659 of file PredictionInterp.cxx.

References calc, febshutoff_auto::curr, plotSysts::shift, and canMan::sign().

Referenced by check_predinterp(), check_predinterp_numu(), ComponentDerivative(), DebugPlot(), DebugPlotColz(), plot_datamcpred(), PredictSyst(), systematics_table(), and systematics_table_from_pred_interp().

  {
    return _PredictComponentSyst<Spectrum>(calc, shift, flav, curr, sign);
  }

SpectrumStan ana::PredictionInterp::PredictComponentSyst ( osc::IOscCalculatorStan *  calc, const SystShifts &  shift, Flavors::Flavors_t  flav, Current::Current_t  curr, Sign::Sign_t  sign  ) const

overridevirtual

Reimplemented from ana::IPrediction.

Definition at line 669 of file PredictionInterp.cxx.

References calc, febshutoff_auto::curr, plotSysts::shift, and canMan::sign().

  {
    return _PredictComponentSyst<SpectrumStan>(calc, shift, flav, curr, sign);
  }

Spectrum ana::PredictionInterp::PredictSyst ( osc::IOscCalculator *  calc, const SystShifts &  shift  ) const

overridevirtual

Reimplemented from ana::IPrediction.

Definition at line 429 of file PredictionInterp.cxx.

References InitFits(), ana::Flavors::kAll, ana::Current::kBoth, ana::Sign::kBoth, and PredictComponentSyst().

Referenced by check_predinterp(), check_predinterp_numu(), demo::DrawUpDownRatioCanvas(), mec_tuning(), mec_tuning_fitter_2020(), starPlot(), test_stanfit_systpulls(), and TestPred().

  {
    InitFits();

    return PredictComponentSyst(calc,
                                shift,
                                Flavors::kAll,
                                Current::kBoth,
                                Sign::kBoth);
  }

SpectrumStan ana::PredictionInterp::PredictSyst ( osc::IOscCalculatorStan *  calc, const SystShifts &  shift  ) const

overridevirtual

Reimplemented from ana::IPrediction.

Definition at line 442 of file PredictionInterp.cxx.

References InitFits(), ana::Flavors::kAll, ana::Current::kBoth, ana::Sign::kBoth, and PredictComponentSyst().

  {
    InitFits();

    return PredictComponentSyst(calc,
                                shift,
                                Flavors::kAll,
                                Current::kBoth,
                                Sign::kBoth);
  }

Spectrum ana::IPrediction::PredictUnoscillated ( ) const

virtualinherited

Reimplemented in ana::PredictionSterile.

Definition at line 82 of file IPrediction.cxx.

References noosc, and ana::IPrediction::Predict().

Referenced by cc(), demo5(), demo::DrawUpDownRatioCanvas(), Efficiency(), efficiency(), efficiencySA(), fa_fd_data_mc_systs(), GetSpectra(), numu_demo_split_plot(), plot_nd_data_mc(), template_basic(), and test_ana().

  {
    // Default implementation
    osc::NoOscillations noosc;
    return Predict(&noosc);
  }

void ana::PredictionInterp::SaveTo ( TDirectory *  dir ) const

overridevirtual

Reimplemented from ana::IPrediction.

Reimplemented in ana::PredictionSystNumu2017, ana::PredictionSystNue2017, ana::PredictionSystNueSecondAna, ana::PredictionSyst3Flavor2020, ana::PredictionSystJointDemo, and ana::PredictionSystJoint2018.

Definition at line 800 of file PredictionInterp.cxx.

References om::cout, allTimeWatchdog::endl, genie::utils::style::Format(), fOscOrigin, fPredNom, fPreds, fSplitBySign, MECModelEnuComparisons::i, InitFits(), makeTrainCVSamples::int, it, ana::PredictionInterp::ShiftedPreds::preds, ana::SaveTo(), ana::PredictionInterp::ShiftedPreds::shifts, ana::PredictionInterp::ShiftedPreds::systName, and tmp.

Referenced by extrap_syst_fa(), FDDataMCSystBandLoad(), getPredictions(), getPredictions_updatedAna(), joint_fit_make_sa_pred_numu(), make_nue_fd_datamc(), make_nue_firstana_extrap(), make_prediction_rhc(), make_sa_pred(), MakeCovarSim(), MakeNus17PredictionSysts(), MakeNusPredictionSystsAna01(), makePred(), mec_tuning_preds_2020(), saTestContours(), SavePrediction(), savePrediction_complete(), savePrediction_extrap(), savePrediction_systs(), ana::PredictionSystJoint2018::SaveTo(), ana::PredictionSystJointDemo::SaveTo(), ana::PredictionSystNueSecondAna::SaveTo(), ana::PredictionSystNue2017::SaveTo(), and ana::PredictionSystNumu2017::SaveTo().

  {
    InitFits();

    TDirectory* tmp = gDirectory;

    dir->cd();
    TObjString("PredictionInterp").Write("type");


    fPredNom->SaveTo(dir->mkdir("pred_nom"));


    for(auto it: fPreds){
      const ShiftedPreds& sp = it.second;

      for(unsigned int i = 0; i < sp.shifts.size(); ++i){
        if(!sp.preds[i]){
          std::cout << "Can't save a PredictionInterp after MinimizeMemory()" << std::endl;
          abort();
        }
        sp.preds[i]->SaveTo(dir->mkdir(TString::Format("pred_%s_%+d",
                                                       sp.systName.c_str(),
                                                       int(sp.shifts[i])).Data()));
      } // end for i
    } // end for it

    ana::SaveTo(*fOscOrigin, dir->mkdir("osc_origin"));

    if(!fPreds.empty()){
      TH1F hSystNames("syst_names", ";Syst names", fPreds.size(), 0, fPreds.size());
      int binIdx = 1;
      for(auto it: fPreds){
        hSystNames.GetXaxis()->SetBinLabel(binIdx++, it.second.systName.c_str());
      }
      hSystNames.Write("syst_names");
    }

    TObjString split_sign = fSplitBySign ? "yes" : "no";
    split_sign.Write("split_sign");

    tmp->cd();
  }

void ana::PredictionInterp::SetOscSeed

(

osc::IOscCalculator *

oscSeed

)

Definition at line 392 of file PredictionInterp.cxx.

References osc::_IOscCalculator< T >::Copy(), fOscOrigin, fPreds, InitFits(), and it.

                                                             {
    fOscOrigin = oscSeed->Copy();
    for(auto& it: fPreds) it.second.fits.clear();
    InitFits();
  }

template<typename T >

void ana::PredictionInterp::ShiftBins ( unsigned int  N, T *  arr, CoeffsType  type, bool  nubar, const SystShifts &  shift  ) const

protected

Helper for ShiftSpectrum.

Definition at line 484 of file PredictionInterp.cxx.

References ana::PredictionInterp::Coeffs::a, ana::assert(), ana::PredictionInterp::Coeffs::b, ana::PredictionInterp::Coeffs::c, calib::corr(), util::cube(), ana::PredictionInterp::Coeffs::d, MakeMiniprodValidationCuts::f, fits, ana::PredictionInterp::ShiftedPreds::fitsNubarRemap, ana::PredictionInterp::ShiftedPreds::fitsRemap, fPreds, fSplitBySign, ana::SystShifts::GetShift(), MECModelEnuComparisons::i, it, std::max(), std::min(), getGoodRuns4SAM::n, ana::PredictionInterp::ShiftedPreds::nCoeffs, ana::PredictionInterp::ShiftedPreds::shifts, util::sqr(), ana::PredictionInterp::ShiftedPreds::Stride(), plotSysts::syst, T, and submit_syst::x.

Referenced by ShiftSpectrum().

  {
    static_assert(std::is_same<T, double>::value || std::is_same<T, stan::math::var>::value,
                  "PredictionInterp::ShiftBins() can only be called using doubles or stan::math::vars");
    if(nubar) assert(fSplitBySign);

    T corr[N];
    for(unsigned int i = 0; i < N; ++i) corr[i] = 1;

    for(auto& it: fPreds){
      const ISyst* syst = it.first;
      const ShiftedPreds& sp = it.second;

      T x = shift.GetShift<T>(syst);

      // need to actually do the calculation for the autodiff version
      // to make sure the gradient is computed correctly
      if(x == 0 && !std::is_same<T, stan::math::var>::value) continue;

      int shiftBin = (util::GetValAs<double>(x) - sp.shifts[0])/sp.Stride();
      shiftBin = std::max(0, shiftBin);
      shiftBin = std::min(shiftBin, sp.nCoeffs-1);

      const Coeffs* fits = nubar ? &sp.fitsNubarRemap[type][shiftBin].front() : &sp.fitsRemap[type][shiftBin].front();

      x -= sp.shifts[shiftBin];
      
      const T x_cube = util::cube(x);
      const T x_sqr = util::sqr(x);

      for(unsigned int n = 0; n < N; ++n){
        // Uncomment to debug crashes in this function
        // assert(type < fits.size());
        // assert(n < sp.fits[type].size());
        // assert(shiftBin < int(sp.fits[type][n].size()));

        const Coeffs& f = fits[n];

        corr[n] *= f.a*x_cube + f.b*x_sqr + f.c*x + f.d;
     } // end for n
    } // end for syst

    for(unsigned int n = 0; n < N; ++n){
      // std::max() doesn't work with stan::math::var
      arr[n] *= (corr[n] > 0.) ? corr[n] : 0.;
    }

  }

Spectrum ana::PredictionInterp::ShiftedComponent	(	osc::IOscCalculator *	calc,
		const TMD5 *	hash,
		const SystShifts &	shift,
		Flavors::Flavors_t	flav,
		Current::Current_t	curr,
		Sign::Sign_t	sign,
		CoeffsType	type
	)		const

Helper for PredictComponentSyst.

Definition at line 538 of file PredictionInterp.cxx.

References calc, febshutoff_auto::curr, samweb_client.utility::hash, plotSysts::shift, and canMan::sign().

Referenced by _PredictComponentSyst(), and _ShiftedComponent().

  {
    return _ShiftedComponent<Spectrum>(calc, hash, shift, flav, curr, sign, type);
  }

SpectrumStan ana::PredictionInterp::ShiftedComponent	(	osc::_IOscCalculator< stan::math::var > *	calc,
		const TMD5 *	hash,
		const SystShifts &	shift,
		Flavors::Flavors_t	flav,
		Current::Current_t	curr,
		Sign::Sign_t	sign,
		CoeffsType	type
	)		const

Definition at line 550 of file PredictionInterp.cxx.

References calc, febshutoff_auto::curr, samweb_client.utility::hash, plotSysts::shift, and canMan::sign().

  {
    return _ShiftedComponent<SpectrumStan>(calc, hash, shift, flav, curr, sign, type);
  }

Spectrum ana::PredictionInterp::ShiftSpectrum	(	const Spectrum &	s,
		CoeffsType	type,
		bool	nubar,
		const SystShifts &	shift
	)		const

Definition at line 455 of file PredictionInterp.cxx.

References ana::Spectrum::GetBinnings(), ana::Spectrum::GetLabels(), demo3::h, ana::Spectrum::Livetime(), ana::Spectrum::POT(), plotSysts::shift, ShiftBins(), and ana::Spectrum::ToTH1().

Referenced by _ShiftedComponent().

  {
    // TODO histogram operations could be too slow
    TH1D *h = s.ToTH1(s.POT());

    ShiftBins(h->GetNbinsX()+2, h->GetArray(), type, nubar, shift);

    return Spectrum(std::unique_ptr<TH1D>(h), s.GetLabels(), s.GetBinnings(), s.POT(), s.Livetime());
  }

SpectrumStan ana::PredictionInterp::ShiftSpectrum	(	const SpectrumStan &	s,
		CoeffsType	type,
		bool	nubar,
		const SystShifts &	shift
	)		const

Definition at line 469 of file PredictionInterp.cxx.

References ana::SpectrumStan::GetBinnings(), ana::SpectrumStan::GetLabels(), ana::SpectrumStan::Livetime(), ana::SpectrumStan::POT(), plotSysts::shift, ShiftBins(), and ana::SpectrumStan::ToBins().

  {

    auto binContents = s.ToBins(s.POT());

    ShiftBins(binContents.size(), &binContents.front(), type, nubar, shift);

    return SpectrumStan(std::move(binContents), s.GetLabels(), s.GetBinnings(), s.POT(), s.Livetime());
  }

bool ana::PredictionInterp::SplitBySign ( ) const

inline

Definition at line 126 of file PredictionInterp.h.

{return fSplitBySign;}

Member Data Documentation

Spectrum ana::PredictionInterp::fBinning

mutableprotected

Dummy spectrum to provide binning.

Definition at line 223 of file PredictionInterp.h.

Referenced by _PredictComponentSyst(), and InitFits().

std::map<Key_t, Val_t> ana::PredictionInterp::fNomCache

mutableprotected

Definition at line 241 of file PredictionInterp.h.

Referenced by _ShiftedComponent().

osc::IOscCalculator* ana::PredictionInterp::fOscOrigin

protected

The oscillation values we assume when evaluating the coefficients.

Definition at line 221 of file PredictionInterp.h.

Referenced by ana::PredictionSystJoint2018::AddNormSyst(), ana::PredictionSystJointDemo::AddNormSyst(), ana::PredictionSyst3Flavor2020::AddNormSyst(), ana::PredictionSystNueSecondAna::AddNormSysts(), ana::PredictionSystNue2017::AddNormSysts(), ana::PredictionSystNumu2017::AddNormSysts(), FitComponent(), FitSumComponent(), InitFits(), LoadFromBody(), ana::PredictionSyst3Flavor2020::PredictionSyst3Flavor2020(), ana::PredictionSystJoint2018::PredictionSystJoint2018(), ana::PredictionSystJointDemo::PredictionSystJointDemo(), ana::PredictionSystNue2017::PredictionSystNue2017(), ana::PredictionSystNueSecondAna::PredictionSystNueSecondAna(), ana::PredictionSystNumu2017::PredictionSystNumu2017(), SaveTo(), and SetOscSeed().

std::unique_ptr<IPrediction> ana::PredictionInterp::fPredNom

protected

The nominal prediction.

Definition at line 185 of file PredictionInterp.h.

Referenced by _ShiftedComponent(), ana::PredictionSystJoint2018::AddNormSyst(), ana::PredictionSystJointDemo::AddNormSyst(), ana::PredictionSyst3Flavor2020::AddNormSyst(), ana::PredictionSystNueSecondAna::AddNormSysts(), ana::PredictionSystNue2017::AddNormSysts(), ana::PredictionSystNumu2017::AddNormSysts(), DebugPlot(), DebugPlotColz(), ana::PredictionSystJoint2018::GetNominalPrediction(), ana::PredictionSystJointDemo::GetNominalPrediction(), InitFits(), LoadFromBody(), MinimizeMemory(), Predict(), PredictComponent(), PredictionInterp(), ana::PredictionSyst3Flavor2020::PredictionSyst3Flavor2020(), ana::PredictionSystJoint2018::PredictionSystJoint2018(), ana::PredictionSystJointDemo::PredictionSystJointDemo(), ana::PredictionSystNue2017::PredictionSystNue2017(), ana::PredictionSystNueSecondAna::PredictionSystNueSecondAna(), ana::PredictionSystNumu2017::PredictionSystNumu2017(), SaveTo(), and ~PredictionInterp().

std::unordered_map<const ISyst*, ShiftedPreds> ana::PredictionInterp::fPreds

mutableprotected

Definition at line 216 of file PredictionInterp.h.

Referenced by _PredictComponentSyst(), ana::PredictionSystJoint2018::AddNormSyst(), ana::PredictionSystJointDemo::AddNormSyst(), ana::PredictionSyst3Flavor2020::AddNormSyst(), ana::PredictionSystNueSecondAna::AddNormSysts(), ana::PredictionSystNue2017::AddNormSysts(), ana::PredictionSystNumu2017::AddNormSysts(), ComponentDerivative(), DebugPlot(), DebugPlots(), DebugPlotsColz(), Derivative(), ana::PredictionSystJoint2018::GetShiftedPrediction(), ana::PredictionSystJointDemo::GetShiftedPrediction(), InitFits(), LoadFromBody(), MinimizeMemory(), PredictionInterp(), ana::PredictionSyst3Flavor2020::PredictionSyst3Flavor2020(), ana::PredictionSystJoint2018::PredictionSystJoint2018(), ana::PredictionSystJointDemo::PredictionSystJointDemo(), ana::PredictionSystNue2017::PredictionSystNue2017(), ana::PredictionSystNueSecondAna::PredictionSystNueSecondAna(), ana::PredictionSystNumu2017::PredictionSystNumu2017(), SaveTo(), SetOscSeed(), and ShiftBins().

bool ana::PredictionInterp::fSplitBySign

protected

Definition at line 243 of file PredictionInterp.h.

Referenced by _ShiftedComponent(), ana::PredictionSystJoint2018::AddNormSyst(), ana::PredictionSystJointDemo::AddNormSyst(), ana::PredictionSyst3Flavor2020::AddNormSyst(), ComponentDerivative(), InitFits(), PredictionInterp(), ana::PredictionSyst3Flavor2020::PredictionSyst3Flavor2020(), ana::PredictionSystJoint2018::PredictionSystJoint2018(), ana::PredictionSystJointDemo::PredictionSystJointDemo(), SaveTo(), and ShiftBins().

ShiftedPreds ana::PredictionInterp::fSummedsp

mutableprotected

Definition at line 218 of file PredictionInterp.h.

Referenced by InitFits(), ana::PredictionSyst3Flavor2020::PredictionSyst3Flavor2020(), ana::PredictionSystJoint2018::PredictionSystJoint2018(), and ana::PredictionSystJointDemo::PredictionSystJointDemo().

std::unordered_map<const ISyst*, ShiftedPreds> ana::PredictionInterp::fSumPreds

mutableprotected

Definition at line 217 of file PredictionInterp.h.

Referenced by InitFits(), ana::PredictionSyst3Flavor2020::PredictionSyst3Flavor2020(), ana::PredictionSystJoint2018::PredictionSystJoint2018(), and ana::PredictionSystJointDemo::PredictionSystJointDemo().

---

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

• /cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N20-04-08/CAFAna/Prediction/PredictionInterp.h
• /cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N20-04-08/CAFAna/Prediction/PredictionInterp.cxx