SpectrumLoaderBase.h

Go to the documentation of this file.

#pragma once

#include <cassert>
#include <functional>
#include <list>
#include <memory>
#include <set>
#include <string>
#include <vector>

#include "CAFAna/Core/Cut.h"
#include "CAFAna/Core/FwdDeclare.h"
#include "CAFAna/Core/IFileSource.h"
#include "CAFAna/Core/MultiVar.h"
#include "CAFAna/Core/SystShifts.h"
#include "CAFAna/Core/Var.h"

#include "CAFAna/Core/SpectrumSink.h"
#include "CAFAna/Core/ExposureSource.h"

#include "CAFAna/Core/RecordMultiSink.h"

class TFile;
class TH1;

namespace std
{
  template<> struct hash<std::pair<int, int>>
  {
    size_t operator()(const std::pair<int, int>& x) const
    {
      return std::hash<int>()(x.first*65536 + x.second);
    }
  };

  template<> struct hash<std::tuple<int, int, int>>
  {
    size_t operator()(const std::tuple<int, int, int>& x) const
    {
      return std::hash<int>()(std::get<0>(x)*1048576 + std::get<1>(x)*1024 + std::get<2>(x));
    }
  };

  template<> struct hash<std::tuple<int, int, int, int>>
  {
    size_t operator()(const std::tuple<int, int, int, int>& x) const
    {
      return std::hash<int>()(std::get<0>(x)*16777216 + std::get<1>(x)*65536 + std::get<2>(x) * 256 + std::get<3>(x));
    }
  };
}

namespace ana
{
  class IFileSource;
  class ReweightableSpectrum;

  class CutApplier;
  class SystApplier;
  class WeightApplier;

  /// Base class for the various types of spectrum loader
  class SpectrumLoaderBase
  {
  public:

    friend class ReweightableSpectrum;
    friend class NDOscillatableSpectrum;
    friend class OscillatableSpectrum;
    friend class Spectrum;

    virtual ~SpectrumLoaderBase();

    void SetSpillCut(const SpillCut& cut);

    /// For use by the \ref Spectrum constructor
    virtual void AddSpectrum(Spectrum& spect,
                             const Var& var,
                             const Cut& cut,
                             const SystShifts& shift,
                             const Var& wei = kUnweighted);

    /// For use by the \ref Spectrum constructor
    virtual void AddSpectrum(Spectrum& spect,
                             const MultiVar& var,
                             const Cut& cut,
                             const SystShifts& shift,
                             const Var& wei = kUnweighted);

    /// For use by the \ref Spectrum constructor
    virtual void AddSpectrum(Spectrum& spect,
                             const NuTruthVar& var,
                             const NuTruthCut& cut,
                             const SystShifts& shift,
                             const NuTruthVar& wei = kNuTruthUnweighted);

    /// For use by the constructors of \ref ReweightableSpectrum subclasses
    virtual void AddReweightableSpectrum(ReweightableSpectrum& spect,
                                         const Var& var,
                                         const Cut& cut,
                                         const SystShifts& shift,
                                         const Var& wei);

    /// Uses include counting the total POT or spills in a run
    virtual void AddSpillHistogram(TH1* h,
                                   const SpillVar& var,
                                   const SpillCut& cut,
                                   const SpillVar& wei = kSpillUnweighted);

    /// Load all the registered spectra
    virtual void Go() = 0;

    /// Indicate whether or not \ref Go has been called
    virtual bool Gone() const {return fGone;}

    double GetWeightedPOT();

  protected:
    /// Component of other constructors
    SpectrumLoaderBase();
    /// Construct from a filename, wildcard, SAM definition, or SAM query
    SpectrumLoaderBase(const std::string& wildcard);
    /// Construct from an explicit list of files
    SpectrumLoaderBase(const std::vector<std::string>& fnames);

    // Move operations
    SpectrumLoaderBase(SpectrumLoaderBase&&) = default;
    SpectrumLoaderBase& operator=(SpectrumLoaderBase&&) = default;

    // No copy operations because I don't want to deal with pointers
    SpectrumLoaderBase(const SpectrumLoaderBase&) = delete;
    SpectrumLoaderBase& operator=(const SpectrumLoaderBase&) = delete;

    /// Figure out if \a str is a wildcard or SAM query and return a source
    IFileSource* WildcardOrSAMQuery(const std::string& str) const;

    virtual void AccumulateExposures(const caf::SRSpillProxy* spill) = 0;

    /// Forwards to \ref fFileSource
    int NFiles() const;

    /// Forwards to \ref fFileSource but also accumulates POT and livetime
    TFile* GetNextFile();

    std::string fWildcard;
    std::unique_ptr<IFileSource> fFileSource;

    bool fGone; ///< Has Go() been called? Can't add more histograms after that

    double fPOT; ///< Accumulated by calls to \ref GetNextFile
    double fRunPOT; ///< Crude measure, not including spill cuts

    double fSinglePOT;
    double fBeamNue;
    double fSingleNue;
    double fWeightedPOT;

    WeightApplier* GetSinkSCW(const SystShifts& shift,
                              const Cut& cut,
                              const Var& wei);

    std::set<IRecordSink*> fSpectrumSinks;

    std::unordered_map<std::tuple<int, int, int>, WeightApplier*> fSinksSCW;
    std::unordered_map<std::pair<int, int>, CutApplier*> fSinksSC;
    std::unordered_map<int, SystApplier*> fSinksS;

    RecordMultiSink fSink;

    ExposureSource fExposureSource;

    /// Helper for \ref SpectrumLoaderBase. Details of SpillVar plots
    struct SpillHistDef
    {
      SpillHistDef(TH1* _h,
                   const SpillVar& _var,
                   const SpillCut& _cut,
                   const SpillVar& _wei = kSpillUnweighted)
        : h(_h), var(_var), cut(_cut), wei(_wei)
      {
      }

      TH1* h;
      const SpillVar var;
      const SpillCut cut;
      const SpillVar wei;
    };

    /// Histograms that are filled from the nuTree
    struct NuHistDef
    {
      NuHistDef(Spectrum& _spect,
                const NuTruthVar& _var,
                const NuTruthCut& _cut,
                const SystShifts& _shift,
                const NuTruthVar& _wei = kNuTruthUnweighted)
        : spect(_spect), var(_var), cut(_cut), shift(_shift), wei(_wei)
      {
      }

      Spectrum& spect;
      const NuTruthVar var;
      const NuTruthCut cut;
      const SystShifts shift;
      const NuTruthVar wei;
    };

    std::list<SpillHistDef> fSpillHistDefs;
    std::list<NuHistDef> fNuHistDefs;

    /// Cut applied to the spill branch for every event
    std::unique_ptr<SpillCut> fSpillCut;
  };

  /// \brief Dummy loader that doesn't load any files
  ///
  /// Useful when a loader is required for a component you want to ignore
  class NullLoader: public SpectrumLoaderBase
  {
  public:
    NullLoader() {}
    ~NullLoader();

    virtual void Go() override;
    void AddSpectrum(Spectrum& spect,
                     const Var& var,
                     const Cut& cut,
                     const SystShifts& shift,
                     const Var& wei = kUnweighted) override {}
    void AddSpectrum(Spectrum& spect,
                     const MultiVar& var,
                     const Cut& cut,
                     const SystShifts& shift,
                     const Var& wei = kUnweighted) override {}
    void AddSpectrum(Spectrum& spect,
                     const NuTruthVar& var,
                     const NuTruthCut& cut,
                     const SystShifts& shift,
                     const NuTruthVar& wei = kNuTruthUnweighted) override {}
    void AddReweightableSpectrum(ReweightableSpectrum& spect,
                                 const Var& var,
                                 const Cut& cut,
                                 const SystShifts& shift,
                                 const Var& wei) override {}

    void AccumulateExposures(const caf::SRSpillProxy* spill) override {};
  };
  /// \brief Dummy loader that doesn't load any files
  ///
  /// Useful when a loader is required for a component you want to ignore
  static NullLoader kNullLoader;
}