IPrediction.cxx

Go to the documentation of this file.

#include "CAFAna/Prediction/IPrediction.h"

#include "CAFAna/Core/LoadFromFile.h"
#include "Utilities/func/Stan.h"
#include "CAFAna/Core/StanTypedefs.h"

#include "OscLib/func/IOscCalculator.h"

#include <cassert>
#include <iostream>

#include "TDirectory.h"
#include "TObjString.h"

// To implement LoadFrom()
#include "CAFAna/Prediction/PredictionNoOsc.h"
#include "CAFAna/Prediction/PredictionNoExtrap.h"
#include "CAFAna/Prediction/PredictionExtrap.h"
#include "CAFAna/Prediction/PredictionInterp.h"
#include "CAFAna/Prediction/PredictionNumuFAHadE.h"
#include "CAFAna/Prediction/PredictionCombinePeriods.h"
#include "CAFAna/Prediction/PredictionExtendToPeripheral.h"
#include "CAFAna/Prediction/PredictionInterpTemplates.h"
#include "CAFAna/Prediction/PredictionSterile.h"
#include "CAFAna/Prediction/PredictionNueRebinSA.h"
#include "CAFAna/Prediction/PredictionSystNueSecondAna.h"
#include "CAFAna/Prediction/PredictionSystNue2017.h"
#include "CAFAna/Prediction/PredictionAddRock.h"
#include "CAFAna/Prediction/NDPredictionSterile.h"
#include "CAFAna/Prediction/FDPredictionSterile.h"
#include "CAFAna/Prediction/PredictionXSecTuning.h"

namespace ana
{
  //----------------------------------------------------------------------
  // Definition to satisfy declaration in Core/LoadFromFile.h
  template <>
  std::unique_ptr<IPrediction> LoadFrom<IPrediction>(TDirectory* dir)
  {
    TObjString* ptag = (TObjString*)dir->Get("type");
    assert(ptag);

    const TString tag = ptag->GetString();

    if(tag == "PredictionNoExtrap") return PredictionNoExtrap::LoadFrom(dir);
    if(tag == "PredictionExtrap") return PredictionExtrap::LoadFrom(dir);

    // Backwards compatibility
    if(tag == "PredictionInterp" ||
       tag == "PredictionInterp2") return PredictionInterp::LoadFrom(dir);

    if(tag == "PredictionNoOsc") return PredictionNoOsc::LoadFrom(dir);

    if(tag == "PredictionNumuFAHadE") return PredictionNumuFAHadE::LoadFrom(dir);

    if(tag == "PredictionCombinePeriods") return PredictionCombinePeriods::LoadFrom(dir);

    if(tag == "PredictionTemplateShift") return PredictionTemplateShift::LoadFrom(dir);

    if(tag == "PredictionSterile") return PredictionSterile::LoadFrom(dir);

    if(tag == "PredictionNueRebinSA") return PredictionNueRebinSA::LoadFrom(dir);

    if(tag == "PredictionSystNueSecondAna") return PredictionSystNueSecondAna::LoadFrom(dir);

    if(tag == "PredictionSystNue2017") return PredictionSystNue2017::LoadFrom(dir);

    if(tag == "PredictionExtendToPeripheral") return PredictionExtendToPeripheral::LoadFrom(dir);

    if(tag == "PredictionAddRock") return PredictionAddRock::LoadFrom(dir);

    if(tag == "NDPredictionSterile") return NDPredictionSterile::LoadFrom(dir);
    if(tag == "FDPredictionSterile") return FDPredictionSterile::LoadFrom(dir);

    if(tag == "PredictionXSecTuning") return PredictionXSecTuning::LoadFrom(dir);

    std::cerr << "Unknown Prediction type '" << tag << "'" << std::endl;
    abort();
  }

  //----------------------------------------------------------------------
  Spectrum IPrediction::PredictUnoscillated() const
  {
    // Default implementation
    osc::NoOscillations noosc;
    return Predict(&noosc);
  }


  //----------------------------------------------------------------------
  // placeholder method that should be overridden by Stan-aware concrete Prediction classes
  SpectrumStan IPrediction::Predict(osc::IOscCalculatorStan *calc) const
  {
    assert(0 && "This Prediction hasn't implemented a Stan-aware Predict()!");
  }

  //----------------------------------------------------------------------
  Spectrum IPrediction::PredictSyst(osc::IOscCalculator* calc,
                                    const SystShifts& syst) const
  {
    assert(syst.IsNominal() && "This Prediction doesn't support PredictSyst(). Did you just mean Predict()?");

    // Default implementation: no treatment of systematics
    return Predict(calc);
  }

  //----------------------------------------------------------------------
  SpectrumStan IPrediction::PredictSyst(osc::IOscCalculatorStan* calc,
                                        const SystShifts& syst) const
  {
    assert(syst.IsNominal() && "This Prediction doesn't support PredictSyst(). Did you just mean Predict()?");

    // Default implementation: no treatment of systematics
    return Predict(calc);
  }

  //----------------------------------------------------------------------
  // placeholder method that should be overridden by Stan-aware concrete Prediction classes
  SpectrumStan IPrediction::PredictComponent(osc::IOscCalculatorStan *calc,
                                             Flavors::Flavors_t flav,
                                             Current::Current_t curr,
                                             Sign::Sign_t sign) const
  {
    assert(0 && "This Prediction hasn't implemented a Stan-aware PredictComponent()!");
  }

  //----------------------------------------------------------------------
  Spectrum IPrediction::PredictComponentSyst(osc::IOscCalculator* calc,
                                             const SystShifts& syst,
                                             Flavors::Flavors_t flav,
                                             Current::Current_t curr,
                                             Sign::Sign_t sign) const
  {
    assert(syst.IsNominal() && "This Prediction doesn't support PredictSyst(). Did you just mean Predict()?");

    // Default implementation: no treatment of systematics
    return PredictComponent(calc, flav, curr, sign);
  }


  //----------------------------------------------------------------------
  SpectrumStan IPrediction::PredictComponentSyst(osc::IOscCalculatorStan* calc,
                                                 const SystShifts& syst,
                                                 Flavors::Flavors_t flav,
                                                 Current::Current_t curr,
                                                 Sign::Sign_t sign) const
  {
    assert(syst.IsNominal() && "This Prediction doesn't support PredictSyst(). Did you just mean Predict()?");

    // Default implementation: no treatment of systematics
    return PredictComponent(calc, flav, curr, sign);
  }

  //----------------------------------------------------------------------
  void IPrediction::SaveTo(TDirectory*) const
  {
    assert(0 && "Not implemented");
  }

}