parameters.hpp

Go to the documentation of this file.

#pragma once
#include <cassert>
#include <array>
#include <limits>
#include <complex>
#include <type_traits>
#include <ostream>
#include <string>

#include "constants.hpp"
#include "mass_schemes.hpp"
#include "alpha_s.hpp"

namespace QQbar_threshold{
  typedef std::complex<double> complex;

  namespace pert_order{
    enum order{
      LO = 0,
      NLO,
      N2LO,
      NNLO = N2LO,
      N3LO,
      NNNLO = N3LO
    };

    inline
    order operator++(order & o){
      return o = static_cast<order>(o + 1);
    }

    inline
    order operator--(order & o){
      return o = static_cast<order>(o - 1);
    }

    std::string to_string(order o);

    std::ostream& operator<<(std::ostream& os, order o);

  }
  using namespace pert_order;

  enum class SM;

  inline
  constexpr SM operator|(SM a, SM b){
    typedef std::underlying_type<SM>::type SM_type;
    return static_cast<SM>(static_cast<SM_type>(a) | static_cast<SM_type>(b));
  }

  inline
  SM & operator|=(SM & a, SM b){
    return a = a | b;
  }

  inline
  constexpr SM operator&(SM a, SM b){
    typedef std::underlying_type<SM>::type SM_type;
    return static_cast<SM>(static_cast<SM_type>(a) & static_cast<SM_type>(b));
  }


  enum class SM{
    none = 0,
    QED = 1 << 0,
    Higgs = 1 << 1,
    QEDHiggs = QED|Higgs,
    all = (1 << 3) - 1
  };

  inline
  constexpr bool operator!(SM a){
    return a == SM::none;
  }

  std::string to_string(SM s);

  std::ostream& operator<<(std::ostream& os, SM s);

  enum class production_channel{
    photon_only = 0,
      S_wave_only,
      all
  };

  std::string to_string(production_channel p);

  std::ostream& operator<<(std::ostream& os, production_channel p);



  struct contribution_factors{
    std::array<double,3> v_Coulomb = {{1.,1.,1.}};
    std::array<double,2> v_delta = {{1.,1.}};
    std::array<double,2> v_r2inv = {{1.,1.}};
    std::array<double,2> v_p2 = {{1.,1.}};
    std::array<double,1> v_kinetic = {{1.}};
    std::array<double,1> ultrasoft = {{1.}};
    std::array<double,1> v_Higgs = {{1.}};
    std::array<double,1> v_QED_Coulomb = {{1.}};
    std::array<double,3> cv = {{1.,1.,1.}};
    std::array<double,2> cv_Higgs = {{1.,1.}};
    std::array<double,1> Cv_QED = {{1.}};
    std::array<double,1> Cv_WZ = {{1.}};
    std::array<double,1> Ca_QED = {{1.}};
    std::array<double,1> Ca_WZ = {{1.}};
    std::array<double,2> dv = {{1.,1.}};
    std::array<double,1> ca = {{1.}};
  };

  struct alpha_s_options{
    double mu0;
    double alpha_s;
  };

  std::string to_string(alpha_s_options o);

  static_assert(
      std::numeric_limits<double>::has_quiet_NaN,
      "Quiet NaN not available"
  );


  struct options{
    contribution_factors contributions;
    double alpha_s_mZ = QQbar_threshold::alpha_s_mZ;
    alpha_s_options alpha_s_mu0 = {
      std::numeric_limits<double>::quiet_NaN(),
      std::numeric_limits<double>::quiet_NaN()
    };
    double m_Higgs = QQbar_threshold::m_Higgs;
    double Yukawa_factor = 1;
    double invariant_mass_cut = std::numeric_limits<double>::quiet_NaN();
    double ml = 0;
    double r4 = std::numeric_limits<double>::quiet_NaN();
    double alpha;
    double mu_alpha;
    int resum_poles = 6;
    SM beyond_QCD;
    scheme mass_scheme;
    production_channel production = production_channel::all;
    bool resonant_only;
    bool expand_s;
    bool double_light_insertion = false;
  };

  std::string to_string(options const & opt);

  struct scales{
    double soft;
    double weak;
  };

  struct top_properties{
    double m;
    double width;
  };


  std::string bottom_internal_settings(
      double mu, double m, order o, options opt
  );

  std::string bottom_internal_settings(
      double sqrt_s, double mu, double m, order o, options opt
  );

  std::string top_internal_settings(
      double mu, double m, order o, options opt
  );

  std::string top_internal_settings(
      double sqrt_s, scales mu, top_properties M, order o, options opt
  );
  std::string top_internal_settings(
      double sqrt_s, double mu, top_properties M, order o, options opt
  );

  std::ostream& operator<<(std::ostream& os, options const & obt);


  options bottom_options();

  options top_options();

  struct parameters{
      contribution_factors contributions;
      complex E_shifted;
      double s;
      double m;
      double width;
      double mu;
      double alpha_s;
      double m_Higgs;
      double Yukawa_t2;
      double invariant_mass_cut;
      double ml;
      double e_q;
      std::array<double, detail::last_coupling + 1> c_q;
      double r4;
      double mu_w;
      double alpha;
      double mu_alpha;
      int order;
      int nl;
      int resum_poles;
      SM beyond_QCD;
      scheme mass_scheme;
      production_channel production;
      bool resonant_only;
      bool expand_s;
      bool double_light_insertion;
  };

  parameters gen_bottom_parameters(
      double mu, double m, order o,
      options opt
  );
  parameters gen_bottom_parameters(
      double sqrt_s, double mu, double m, order o,
      options opt
  );
  parameters gen_bottom_parameters(
      double sqrt_s, scales mu, double m, order o,
      options opt
  );
  parameters gen_top_parameters(
      double mu, double m, order o,
      options opt
  );
  parameters gen_top_parameters(
      double sqrt_s, double mu, top_properties M, order o,
      options opt
  );
  parameters gen_top_parameters(
      double sqrt_s, scales mu, top_properties M, order o,
      options opt
  );

  std::string to_string(parameters const & p);

}