Parameters.hh

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
#include "HEJ/exceptions.hh"
 
namespace HEJ {
 
  template<class T>
  struct Parameters {
    T central{};
    std::vector<T> variations;
 
    template<class T_ext>
    Parameters<T>& operator*=(Parameters<T_ext> const & other);
    Parameters<T>& operator*=(double factor);
    template<class T_ext>
    Parameters<T>& operator/=(Parameters<T_ext> const & other);
    Parameters<T>& operator/=(double factor);
    template<class T_ext>
    Parameters<T>& operator+=(Parameters<T_ext> const & other);
    template<class T_ext>
    Parameters<T>& operator-=(Parameters<T_ext> const & other);
  };
 
  template<class T1, class T2> inline
  Parameters<T1> operator*(Parameters<T1> a, Parameters<T2> const & b) {
    a*=b;
    return a;
  }
  template<class T> inline
  Parameters<T> operator*(Parameters<T> a, double b) {
    a*=b;
    return a;
  }
  template<class T> inline
  Parameters<T> operator*(double b, Parameters<T> a) {
    a*=b;
    return a;
  }
  template<class T1, class T2> inline
  Parameters<T1> operator/(Parameters<T1> a, Parameters<T2> const & b) {
    a/=b;
    return a;
  }
  template<class T> inline
  Parameters<T> operator/(Parameters<T> a, double b) {
    a/=b;
    return a;
  }
  template<class T1, class T2> inline
  Parameters<T1> operator+(Parameters<T1> a, Parameters<T2> const & b) {
    a+=b;
    return a;
  }
  template<class T1, class T2> inline
  Parameters<T1> operator-(Parameters<T1> a, Parameters<T2> const & b) {
    a-=b;
    return a;
  }
 
  using Weights = Parameters<double>;
 
  struct ParameterDescription {
    std::string scale_name;
    double mur_factor{};
    double muf_factor{};
 
    ParameterDescription() = default;
    ParameterDescription(
      std::string scale_name, double mur_factor, double muf_factor
    ):
      scale_name{std::move(scale_name)},
      mur_factor{mur_factor}, muf_factor{muf_factor}
    {}
  };
 
  std::string to_string(ParameterDescription const & p);
 
  std::string to_simple_string(ParameterDescription const & p);
 
  struct EventParameters{
    double mur{};              
    double muf{};              
    double weight{};           
    std::shared_ptr<ParameterDescription> description = nullptr;
 
    EventParameters& operator*=(double factor){
      weight*=factor;
      return *this;
    }
    EventParameters& operator/=(double factor){
      weight/=factor;
      return *this;
    }
    EventParameters& operator+=(double factor){
      weight+=factor;
      return *this;
    }
    EventParameters& operator-=(double factor){
      weight-=factor;
      return *this;
    }
  };
  inline EventParameters operator*(EventParameters a, double b){
    a*=b;
    return a;
  }
  inline EventParameters operator*(double b, EventParameters a){
    a*=b;
    return a;
  }
  inline EventParameters operator/(EventParameters a, double b){
    a/=b;
    return a;
  }
 
  template<class T>
  template<class T_ext>
  Parameters<T>& Parameters<T>::operator*=(Parameters<T_ext> const & other) {
    if(other.variations.size() != variations.size()) {
      throw std::invalid_argument{"Wrong number of Parameters"};
    }
    central *= other.central;
    for(std::size_t i = 0; i < variations.size(); ++i) {
      variations[i] *= other.variations[i];
    }
    return *this;
  }
 
  template<class T>
  Parameters<T>& Parameters<T>::operator*=(double factor) {
    central *= factor;
    for(auto & wt: variations) wt *= factor;
    return *this;
  }
 
  template<class T>
  template<class T_ext>
  Parameters<T>& Parameters<T>::operator/=(Parameters<T_ext> const & other) {
    if(other.variations.size() != variations.size()) {
      throw std::invalid_argument{"Wrong number of Parameters"};
    }
    central /= other.central;
    for(std::size_t i = 0; i < variations.size(); ++i) {
      variations[i] /= other.variations[i];
    }
    return *this;
  }
 
  template<class T>
  Parameters<T>& Parameters<T>::operator/=(double factor) {
    central /= factor;
    for(auto & wt: variations) wt /= factor;
    return *this;
  }
 
  template<class T>
  template<class T_ext>
  Parameters<T>& Parameters<T>::operator+=(Parameters<T_ext> const & other) {
    if(other.variations.size() != variations.size()) {
      throw std::invalid_argument{"Wrong number of Parameters"};
    }
    central += other.central;
    for(std::size_t i = 0; i < variations.size(); ++i) {
      variations[i] += other.variations[i];
    }
    return *this;
  }
 
  template<class T>
  template<class T_ext>
  Parameters<T>& Parameters<T>::operator-=(Parameters<T_ext> const & other) {
    if(other.variations.size() != variations.size()) {
      throw std::invalid_argument{"Wrong number of Parameters"};
    }
    central -= other.central;
    for(std::size_t i = 0; i < variations.size(); ++i) {
      variations[i] -= other.variations[i];
    }
    return *this;
  }
} // namespace HEJ