ScaleFunction.hh

Go to the documentation of this file.

 
#pragma once
 
#include <functional>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
namespace HEJ{
  class Event;
 
  class ScaleFunction {
  public:
 
    ScaleFunction(std::string name, std::function<double(Event const &)> fun):
      name_{std::move(name)},
      fun_{std::move(fun)}
    {}
 
    std::string const & name() const {
      return name_;
    }
 
    double operator()(Event const & ev) const {
      return fun_(ev);
    }
 
  private:
    friend ScaleFunction operator*(double factor, ScaleFunction base_scale);
    friend ScaleFunction operator/(ScaleFunction base_scale, double denom);
 
    std::string name_;
    std::function<double(Event const &)> fun_;
  };
 
 
  ScaleFunction operator*(double factor, ScaleFunction base_scale);
 
  ScaleFunction operator/(ScaleFunction base_scale, double denom);
 
 
  double H_T(Event const &);
  double max_jet_pt(Event const &);
  double jet_invariant_mass(Event const &);
  double m_j1j2(Event const &);
 
  class FixedScale {
  public:
    explicit FixedScale(double mu): mu_{mu} {}
    double operator()(Event const &) const {
      return mu_;
    }
  private:
    double mu_;
  };
 
  class ParameterDescription;
 
  class ScaleGenerator{
  public:
    ScaleGenerator() = default;
 
    template<class ScaleFunIterator, class FactorIterator>
    ScaleGenerator(
        ScaleFunIterator scale_functions_begin,
        ScaleFunIterator scale_functions_end,
        FactorIterator scale_factors_begin,
        FactorIterator scale_factors_end,
        double max_scale_ratio
    ):
      scales_(scale_functions_begin, scale_functions_end),
      scale_factors_(scale_factors_begin, scale_factors_end),
      max_scale_ratio_{max_scale_ratio}
    {
      gen_descriptions();
    }
 
    ScaleGenerator(
        std::vector<ScaleFunction> scales,
        std::vector<double> scale_factors,
        double max_scale_ratio
    ):
      scales_(std::move(scales)),
      scale_factors_(std::move(scale_factors)),
      max_scale_ratio_{max_scale_ratio}
    {
      gen_descriptions();
    }
 
    Event operator()(Event event) const;
 
  private:
    void gen_descriptions();
 
    std::vector<ScaleFunction> scales_;
    std::vector<double> scale_factors_;
    std::vector<std::shared_ptr<ParameterDescription>> descriptions_;
    double max_scale_ratio_;
  };
 
}