Multiverse.h

Go to the documentation of this file.

#pragma once

#include "CAFAna/Core/Spectrum.h"
#include "CAFAna/Core/Var.h"

namespace ana {
  typedef TH1 * (TransformFunc_t)(TH1 *);
  typedef TH1 * (ProductFunc_t)(TH1 *, TH1 *);
  typedef Spectrum * (TransformSpectraFunc_t)(Spectrum *);
  class Multiverse {
  public:

    Multiverse(SpectrumLoaderBase &,
               const HistAxis &, 
               const Cut &,
               std::vector<SystShifts>,
               const Var &);
    Multiverse(SpectrumLoaderBase &,
               const NuTruthHistAxis &, 
               const NuTruthCut &,
               std::vector<SystShifts>,
               const NuTruthVar &);
    Multiverse(SpectrumLoaderBase &,
               const NuTruthHistAxis &,
               const NuTruthCut &,
               const SystShifts &,
               std::vector<NuTruthVar>,
               const NuTruthVar &);
    Multiverse(SpectrumLoaderBase &,
               const HistAxis &,
               const Cut &,
               const SystShifts &,
               std::vector<Var>,
               const Var &);
    // support for multiple loaders, eg. nominal + nue enhanced sample
    Multiverse(std::vector<SpectrumLoaderBase*>,
               const HistAxis &, 
               const Cut &,
               std::vector<SystShifts>,
               const Var &);
    Multiverse(std::vector<SpectrumLoaderBase*>,
               const NuTruthHistAxis &, 
               const NuTruthCut &,
               std::vector<SystShifts>,
               const NuTruthVar &);
    Multiverse(std::vector<SpectrumLoaderBase*>,
               const NuTruthHistAxis &,
               const NuTruthCut &,
               const SystShifts &,
               std::vector<NuTruthVar>,
               const NuTruthVar &);
    Multiverse(std::vector<SpectrumLoaderBase*>,
               const HistAxis &,
               const Cut &,
               const SystShifts &,
               std::vector<Var>,
               const Var &);
    
    Multiverse(std::vector<Spectrum*>);
    Multiverse(std::vector<TH1*>,
               int);
    
    static Multiverse CopyAndTransform(const Multiverse & rhs,
                                       const std::function<TransformFunc_t>& transform);    
    void Transform(const Multiverse & rhs,
                   const std::function<ProductFunc_t>& transform);    
    void Transform(const std::function<TransformFunc_t>& transform);
    void Transform(const std::function<TransformSpectraFunc_t>& transform);
    
    Spectrum * GetPlusOneSigmaShift(const Spectrum*);
    Spectrum * GetMinusOneSigmaShift(const Spectrum*);
    Spectrum * GetNSigmaShift(const Spectrum*, double);
    TH1 * GetPlusOneSigmaShift(const TH1*);
    TH1 * GetMinusOneSigmaShift(const TH1*);
    TH1 * GetNSigmaShift(const TH1*, double);

    const std::vector<TH1 *> GetUniversesHist(); 
    const std::vector<TH1 *> GetUniversesHist(int line_color,
                                              int line_style = kSolid); 
    
    void SaveTo(TDirectory * dir, const std::string& name) const;
    static std::unique_ptr<Multiverse> LoadFrom(TDirectory * dir, const std::string& name);    

    Multiverse(const Multiverse &);
    Multiverse(Multiverse &&);
    Multiverse & operator=(const Multiverse &);
    Multiverse & operator=(Multiverse &&);
    ~Multiverse();
    
    void Divide(Multiverse &,bool = false);
    void Scale(double scale);
    Multiverse & operator*=(const Multiverse &);
    Multiverse operator*(const Multiverse &) const;

    Multiverse & operator/=(const Spectrum &);
    Multiverse operator/(const Spectrum &) const;
    Multiverse & operator*=(const Spectrum &);
    Multiverse operator*(const Spectrum &) const;

    Multiverse & operator/=(const TH1 &);
    Multiverse operator/(const TH1 &) const;
    Multiverse & operator*=(const TH1 &);
    Multiverse operator*(const TH1 &) const;

    int GetNUniverses() const { return fNUniverses; }
    
  private:
    
    void DivisionHelper(TH1*, TH1*, bool);
    
    double BinSigma(std::vector<double>, double, double);
    void InitFromSpectra();
    TH1 * ToHist(const Spectrum *, double = -1);
    Spectrum * ToSpectrum(TH1 * h, double POT = 1, double livetime = 0);
    std::vector<Spectrum*> fSpectra;
    std::vector<Binning> fBinning;
    std::vector<std::string> fLabels;

    std::vector<TH1 *> fHists;

    int fNUniverses;
  };
}