gen_func_fluid.h

Go to the documentation of this file.

// Copyright (C) 2020  Philipp Basler, Margarete Mühlleitner and Jonas Müller
// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas
// Müller
//
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef GEN_FUNC_FLUID_H
#define GEN_FUNC_FLUID_H
#include <BSMPT/baryo_calculation/transport_equations.h>
#include <BSMPT/models/IncludeAllModels.h>
#include <BSMPT/models/SMparam.h>
#include <BSMPT/utility/utility.h>
#include <boost/numeric/odeint.hpp>
#include <iostream>
 
namespace BSMPT
{
namespace Baryo
{
using namespace boost::numeric::odeint;
typedef std::vector<double> state_type;
 
const double C_smallcut = 1e-20;
 
const double C_AbsErr = 1e-6;
const double C_RelErr = 1e-9;
 
class Calc_Gam_M
{
private:
  double hf(double w);
  double hf_prime(double w);
 
public:
  double m_full;
  double beta;
  double T;
  double vw;
  double GamT;
  double msqrt_thermal;
  double dmsqrt_thermal;
  void set_class(double T,
                 double vw,
                 double mt,
                 double m_thermal,
                 double dm_thermal,
                 bool use_lep = false);
  void operator()(const state_type &Gam, state_type &dGam, const double k);
};
double Nintegrate_GamM(Calc_Gam_M &C_Gam);
class Calc_Scp
{
private:
  double nf(double w);
  double nf_prime(double w);
 
public:
  double GamT;
  double m_full;
  double T;
  double vw;
  double theta_prime;
  double msqrt_thermal;
  double dmsqrt_thermal;
  int YukType;
 
  void operator()(const state_type &Scp, state_type &dScp, const double k);
  void set_class(double T,
                 double vw,
                 double mt,
                 double theta_prime,
                 double msqrt_thermal_in,
                 double dmsqrt_thermal_in,
                 bool use_lep = false);
};
double Nintegrate_Scp(Calc_Scp &C_Scp);
 
class Calc_kappa_t
{
private:
public:
  double mt;
  double Temp;
  void set_class(double Temp_in, double mt_in);
  void operator()(const state_type &, state_type &, const double);
};
double NIntegrate_kappa(const Calc_kappa_t &C_kap);
class Calc_eta
{
private:
  ISMConstants SMConstants;
  double Temp;
  double vw;
  boost_cubic_b_spline<double> nL_cub;
  double exponent_prefactor;
  std::vector<double> array_z, array_nL;
 
public:
  double prefactor;
  [[deprecated("Will call Calc_eta with GetSMConstants(). Please use the "
               "detailed overload "
               "to ensure consistent SM constants through all "
               "routines.")]] Calc_eta();
  Calc_eta(const ISMConstants &smConstants);
  void set_class(std::vector<double> array_z,
                 std::vector<double> array_nL,
                 double Temp,
                 double vw);
  void set_class(std::pair<std::vector<double>, std::vector<double>> arr,
                 double Temp,
                 double vw);
  void operator()(const state_type &eta, state_type &deta, const double z);
};
double Nintegrate_eta(const Calc_eta &C_eta,
                      const double &z_start,
                      const double &z_end);
 
class gen_fluid
{
private:
  const ISMConstants SMConstants;
 
public:
  [[deprecated("Will call gen_fluid with GetSMConstants(). Please use the "
               "detailed overload "
               "to ensure consistent SM constants through all "
               "routines.")]] gen_fluid();
  gen_fluid(const ISMConstants &smConstants);
  int bot_mass_flag;
  int tau_mass_flag =
      1; // Changing to zero for massless tau leptons --> might cause problems!
  std::shared_ptr<Class_Potential_Origin> modelPointer;
  std::vector<double> par;
  std::vector<double> parCT;
  std::vector<double> vcritical;
  std::vector<double> gen_vcritical;
  std::vector<double> vsym;
  double tanbeta;
  int Yuk_Type;
  double symmetric_CP_violating_phase;
  double broken_CP_violating_phase;
  double TOP_symmetric_CP_violating_phase;
  double TOP_broken_CP_violating_phase;
  double BOT_symmetric_CP_violating_phase;
  double BOT_broken_CP_violating_phase;
  double TAU_symmetric_CP_violating_phase;
  double TAU_broken_CP_violating_phase;
  double Temp;
  double vw;
  double LW;
  /*
  SM input parameters
*/
  double gS     = 1.23;
  double g      = 0.65;
  double gprime = 0.36;
  double alphaS = 1. / 7;
  double alphaW = 1. / 30;
  double mtop_0{0};
  double mbot_0{0};
  double mtau_0{0};
 
  double Dq;
  double Dt;
  double Dh;
  double Dlep;
  double Dtau;
  double yuk_q;
  double Gam_SS;
  double Gam_Y;
  double Gam_Y_t;
  double Gam_Y_b;
  double Gam_Y_tau;
 
  double kappa_QL_0 = 6; // Taken from 1710.04061-->SU(2) left-handed quark
  double kappa_H_0  = 4; // Taken from 1710.04061-->SU(2) complex scalar doublet
  double kappa_QR_0 = 3; // Taken from 1710.04061--> right-handed fermion
                         // singlet
  double kappa_LL_0 = 2; // Left-handed Lepton
  double kappa_RL_0 = 1; // Right-handed Lepton
 
  Calc_Scp Calc_Scp_obj; // Class reference to the numerical evaulation of the
                         // CP-violating source term
  Calc_kappa_t Calc_kappa_obj; // Class reference to the numerical evaluation of
                               // the statistical factor kappa.
  Calc_Gam_M Calc_Gam_obj; // Class reference to the numerical evaluation of the
                           // relaxation rates.
 
  void set_class(const int bottom_mass_inp,
                 struct GSL_integration_mubl &container,
                 const Calc_Gam_M &calc_Gam_obj,
                 const Calc_Scp &Calc_Scp_obj,
                 const Calc_kappa_t &Calc_kappa_inp);
  double msqrt_thermal_top;
  double dmsqrt_thermal_top;
  double msqrt_thermal_bot;
  double dmsqrt_thermal_bot;
  double msqrt_thermal_tau;
  double dmsqrt_thermal_tau;
  std::pair<double, double> Calc_ThermalMass_q(double &YukCoupling_in,
                                               double &T_in);
  std::pair<double, double> Calc_ThermalMass_l(double &YukCoupling_in,
                                               double &T_in);
 
  void top_func(double z,
                std::vector<double> &m_quark,
                std::vector<double> &m_quark_prime);
  void tau_func(double z,
                std::vector<double> &m_lep,
                std::vector<double> &m_lep_prime);
  std::vector<double> omegaprime(double z);
  double atan2_mod(double Im, double Re);
  std::vector<double> Calc_theta(double z, double CP_sym, double CP_brk);
};
 
} // namespace Baryo
} // namespace BSMPT
 
#endif