transport_equations.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 SRC_transport_equations_H_
#define SRC_transport_equations_H_
 
#include <BSMPT/minimizer/Minimizer.h>
#include <BSMPT/models/IncludeAllModels.h>
#include <boost/numeric/odeint.hpp>
#include <boost/numeric/odeint/iterator/const_step_time_iterator.hpp>
 
#include <BSMPT/utility/utility.h>
 
namespace BSMPT
{
class Class_Potential_Origin;
//  namespace Kfactors {
//    class Kfactors_interpolated_GSL;
//  }
 
namespace Baryo
{
 
typedef std::vector<double> state_type;
typedef boost::numeric::odeint::runge_kutta_cash_karp54<state_type>
    error_stepper_type;
 
enum class TransportMethod
{
  top,
  bottom,
  tau
};
 
class transport_equations
{
protected:
  bool UseTanBetaSuppression = false;
  bool UseVelocityTransportEquations = false;
  double vw;
  double LW;
  double TC;
  double symmetric_CP_violating_phase = -500000;
  double broken_CP_violating_phase = -500000;
  std::shared_ptr<Class_Potential_Origin> modelPointer;
 
  std::vector<double> vev_critical;
 
public:
  transport_equations(const struct GSL_integration_mubl &params);
  virtual ~transport_equations();
 
  transport_equations &
  operator()(const state_type &x, state_type &dxdt, const double /* z */);
 
  std::vector<double>
  get_top_mass_and_derivative(const std::vector<double> &vev) const;
 
  double get_W_mass(const std::vector<double> &vev, const double &T) const;
 
  std::vector<double> calculate_vev(const double &z) const;
 
  std::vector<double> calculate_vev_derivative(const double &z) const;
 
  double calculate_theta(const double &z, const int &diff) const;
};
 
struct GSL_integration_mubl
{
public:
private:
  bool UseVelocityTransportEquations = false;
 
  std::shared_ptr<Class_Potential_Origin> modelPointer;
  double vw;
 
  double LW;
 
  double zmax;
 
  double TC;
 
  double vc;
 
  std::vector<double> vev_critical;
  std::vector<double> vev_symmetric;
 
  double symmetric_CP_violating_phase = -500000;
 
  double broken_CP_violating_phase = -500000;
 
  double TOP_symmetric_CP_violating_phase;
  double TOP_broken_CP_violating_phase;
  double BOT_symmetric_CP_violating_phase;
  double BOT_broken_CP_violating_phase;
  // TODO: Calculation of the Tau phase
  double TAU_symmetric_CP_violating_phase;
  double TAU_broken_CP_violating_phase;
  std::vector<double> par;
  TransportMethod transport_method{TransportMethod::top};
 
  std::vector<double> vev_sym_theta;
 
public:
  void setSymmetricCPViolatingPhase(double Phase);
  double getSymmetricCPViolatingPhase() const;
  double getBrokenCPViolatingPhase() const;
  double getSymmetricCPViolatingPhase_top() const;
  double getSymmetricCPViolatingPhase_bot() const;
  double getSymmetricCPViolatingPhase_tau() const;
 
  double getBrokenCPViolatingPhase_top() const;
  double getBrokenCPViolatingPhase_bot() const;
  double getBrokenCPViolatingPhase_tau() const;
 
  std::vector<double> getVEVCritical() const;
  std::vector<double> getVEVsym() const;
  double getTC() const;
  void setTC(double TC_in);
  double getZMAX() const;
  void setvw(double vw_in);
  double getvw() const;
  double getLW() const;
 
  void setpar(std::vector<double>);
  std::vector<double> getpar();
  void set_transport_method(TransportMethod method);
  TransportMethod get_transport_method();
  void setZMAX(double z_in, bool MultiplesOfLW);
 
  void set_vev_sym_theta(std::vector<double> &vev_in);
  std::vector<double> get_vev_sym_theta() const;
 
  void setUseVelocityTransportEquations(bool in);
 
  bool getUseVelocityTransportEquations() const;
 
  void init(const double &vw_input,
            std::vector<double> &vev_critical_input,
            std::vector<double> &vev_symmetric_input,
            const double &TC_input,
            std::shared_ptr<Class_Potential_Origin> &modelPointer_input,
            const int &WhichMinimizer = Minimizer::WhichMinimizerDefault);
 
  std::shared_ptr<Class_Potential_Origin> getModelPointer() const;
};
 
struct GSL_mubl_interpolation
{
  boost_cubic_b_spline<double> spline;
  double vw;
  double TC;
};
 
std::vector<double>
calculateTransportEquation(const double &z,
                           const std::vector<double> &parStart,
                           const struct GSL_integration_mubl &params);
 
double mubl_func(double z, void *p);
 
double eta_integrand_func(double z, void *p);
 
double Integrate_mubl(const struct GSL_integration_mubl &p);
 
GSL_mubl_interpolation
generate_mubl_spline(const struct GSL_integration_mubl &p, int nstep);
 
double mubl_interpolation(double z, void *p);
 
double Integrate_mubl_interpolated(const struct GSL_integration_mubl &p);
 
struct push_back_state_and_time
{
  std::vector<state_type> &m_states;
  std::vector<double> &m_times;
 
  push_back_state_and_time(std::vector<state_type> &states,
                           std::vector<double> &times)
      : m_states(states)
      , m_times(times)
  {
  }
 
  void operator()(const state_type &x, double t)
  {
    m_states.push_back(x);
    m_times.push_back(t);
  }
};
 
} // namespace Baryo
} // namespace BSMPT
 
#endif /* SRC_transport_equations_H_ */