Projection.h

Go to the documentation of this file.

#ifndef AMPGEN_PROJECTION_H
#define AMPGEN_PROJECTION_H
 
#include <stddef.h>
#include <functional>
#include <string>
#include <utility>
 
#include <TH1D.h>
#include <TH2D.h>
#include <THStack.h>
 
#include "AmpGen/ArgumentPack.h"
#include "AmpGen/Types.h"
#include "AmpGen/KeyedFunctors.h"
 
namespace AmpGen {
  class Projection2D;
  class Event;
  class EventList;
 
  class Projection {
    using keyedFunctors = KeyedFunctors<double(Event)>;
 
  public:
    Projection();
    template <class FCN>
    Projection(const FCN &fcn, const std::string &name, const std::string &xAxisTitle, const size_t &nBins, const double &min, const double &max,
               const std::string &units = "")
        : Projection(std::function<double(const Event &)>(fcn), name, xAxisTitle, nBins, min, max, units) {}
    Projection(const std::function<double(const Event &)> &fcn, const std::string &name, const std::string &xAxisTitle, const size_t &nBins, const double &min,
               const double &max, const std::string &units = "");
    const std::string name() const;
    template <class eventlist_type, class... ARGS> TH1D *operator()(const eventlist_type &evts, const ARGS... args) const {
      return projInternal(evts, ArgumentPack(args...));
    }
    template <class eventlist_type, class... ARGS>
    std::tuple<std::vector<TH1D *>, THStack *> operator()(const eventlist_type &evts, const keyedFunctors &weightFunction, const ARGS... args) const {
      return projInternal(evts, weightFunction, ArgumentPack(args...));
    }
 
    double operator()(const Event &evt) const;
 
    TH1D *plot(const std::string &prefix = "") const;
 
    std::function<int(const Event &evt)> binFunctor() const;
    void setRange(const double &min, const double &max) {
      m_min = min;
      m_max = max;
      m_width = (m_max - m_min) / double(m_nBins);
    }
 
    friend class Projection2D;
    template <class eventlist_type> TH1D *projInternal(const eventlist_type &, const ArgumentPack &) const;
    template <class eventlist_type>
    std::tuple<std::vector<TH1D *>, THStack *> projInternal(const eventlist_type &, const keyedFunctors &, const ArgumentPack &) const;
    std::function<double(const Event &)> m_func;
    std::string m_name = {""};
    std::string m_xAxisTitle = {""};
    std::string m_units = {""};
    size_t m_nBins = {0};
    double m_min = {0};
    double m_max = {0};
    double m_width = {0};
  };
 
  class Projection2D {
    friend class Projection;
    Projection xAxis;
    Projection yAxis;
    template <typename eventlist_type> TH2D *projInternal(const eventlist_type &, const ArgumentPack &) const;
 
  public:
    Projection2D(const Projection &_xAxis, const Projection &_yAxis) : xAxis(_xAxis), yAxis(_yAxis) {}
 
    TH2D *plot(const std::string &prefix = "") const;
    template <class eventlist_type, class... ARGS> TH2D *operator()(const eventlist_type &evts, const ARGS... args) const {
      return projInternal(evts, ArgumentPack(args...));
    }
 
    std::pair<double, double> operator()(const Event &evt) const;
  };
  namespace PlotOptions {
    DECLARE_ARGUMENT(LineColor, int);
    DECLARE_ARGUMENT(DrawStyle, std::string);
    DECLARE_ARGUMENT(Selection, std::function<bool(const Event &)>);
    DECLARE_ARGUMENT(Prefix, std::string);
    DECLARE_ARGUMENT(Norm, double);
    DECLARE_ARGUMENT(AddTo, THStack *);
    DECLARE_ARGUMENT(AutoWrite, bool);
  }
} // namespace AmpGen
 
#endif