CalculateEtaInterface.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_BARYO_CALCULATION_CALCULATEETAINTERFACE_H_
#define SRC_BARYO_CALCULATION_CALCULATEETAINTERFACE_H_
 
#include <BSMPT/baryo_calculation/Fluid_Type/gen_calc.h>
#include <BSMPT/baryo_calculation/Fluid_Type/gen_func_fluid.h>
#include <BSMPT/baryo_calculation/transport_equations.h>
#include <BSMPT/minimizer/Minimizer.h>
#include <BSMPT/models/IncludeAllModels.h>
#include <BSMPT/models/SMparam.h>
#include <string>
#include <vector>
 
namespace BSMPT
{
namespace Baryo
{
 
struct AdditionalBaryoArgs
{
  const bool Used{true};
 
  AdditionalBaryoArgs(bool SetUsed = true) : Used{SetUsed} {}
};
 
class CalculateEtaInterface
{
protected:
  std::vector<bool> method_transport;
 
  double vw;
  double TC;
  std::vector<double> vev_critical;
  std::vector<double> vev_symmetric;
  std::shared_ptr<Class_Potential_Origin> modelPointer;
  // /**
  //  * struct to pass all necessary informations for the transport methods to
  //  the respective classes. Also calculates the wall thickness LW
  //  */
 
  // GSL_integration_mubl GSL_integration_mubl_container;
 
  Calc_Gam_M Calc_Gam_inp;
  Calc_Scp Calc_Scp_inp;
  Calc_kappa_t Calc_kappa_inp;
  const std::size_t n_step = 50;
  Calc_eta C_eta;
  int bot_mass_flag;
  GSL_integration_mubl GSL_integration_mubl_container;
 
  const ISMConstants SMConstants;
 
public:
  [[deprecated(
      "Will call CalculateEtaInterface with GetSMConstants(). Please use the "
      "detailed overload "
      "to ensure consistent SM constants through all "
      "routines.")]] CalculateEtaInterface(const std::pair<std::vector<bool>,
                                                           int> &config);
 
  CalculateEtaInterface(const std::pair<std::vector<bool>, int> &config,
                        const ISMConstants &smConstants);
 
  [[deprecated(
      "Will call CalculateEtaInterface with GetSMConstants(). Please use the "
      "detailed overload "
      "to ensure consistent SM constants through all "
      "routines.")]] CalculateEtaInterface(const std::vector<bool>
                                               &method_input,
                                           const int &bot_mass_flag_in);
 
  CalculateEtaInterface(const std::vector<bool> &method_input,
                        const int &bot_mass_flag_in,
                        const ISMConstants &smConstants);
 
  [[deprecated(
      "Will call CalculateEtaInterface with GetSMConstants(). Please use the "
      "detailed overload "
      "to ensure consistent SM constants through all "
      "routines.")]] CalculateEtaInterface(const std::string &file);
 
  CalculateEtaInterface(const std::string &file,
                        const ISMConstants &smConstants);
 
  virtual ~CalculateEtaInterface();
 
  std::pair<std::vector<bool>, int>
  ReadConfigFile(const std::string &file) const;
 
  std::vector<std::string> legend() const;
  void
  setNumerics(const double &vw_input,
              const std::vector<double> &vev_critical_input,
              const std::vector<double> &vev_symmetric_input,
              const double &TC_input,
              std::shared_ptr<Class_Potential_Origin> &modelPointer_input,
              const int &WhichMinimizer = Minimizer::WhichMinimizerDefault);
  void
  setNumerics(const double &vw_input,
              const std::vector<double> &vev_critical_input,
              const std::vector<double> &vev_symmetric_input,
              const double &TC_input,
              std::shared_ptr<Class_Potential_Origin> &modelPointer_input,
              const AdditionalBaryoArgs &AddBaryoArgs,
              const int &WhichMinimizer = Minimizer::WhichMinimizerDefault);
  std::vector<double> CalcEta();
  std::vector<double>
  CalcEta(const double &vw_input,
          const std::vector<double> &vev_critical_input,
          const std::vector<double> &vev_symmetric_input,
          const double &TC_input,
          std::shared_ptr<Class_Potential_Origin> &modelPointer_input,
          const int &WhichMinimizer = Minimizer::WhichMinimizerDefault);
 
  std::vector<double>
  CalcEta(const double &vw_input,
          const std::vector<double> &vev_critical_input,
          const std::vector<double> &vev_symmetric_input,
          const double &TC_input,
          std::shared_ptr<Class_Potential_Origin> &modelPointer_input,
          const AdditionalBaryoArgs &AddBaryoArgs,
          const int &WhichMinimizer = Minimizer::WhichMinimizerDefault);
 
  void setvw(double vw_in);
 
  double getLW() const;
 
  Calc_Gam_M get_class_CalcGamM() const;
  Calc_Scp get_class_Scp() const;
  Calc_kappa_t get_class_kappa() const;
 
  auto getSymmetricCPViolatingPhase_top() const
  {
    return GSL_integration_mubl_container.getSymmetricCPViolatingPhase_top();
  }
 
  auto getBrokenCPViolatingPhase_top() const
  {
    return GSL_integration_mubl_container.getBrokenCPViolatingPhase_top();
  }
 
  auto getSymmetricCPViolatingPhase_bot() const
  {
    return GSL_integration_mubl_container.getSymmetricCPViolatingPhase_bot();
  }
 
  auto getBrokenCPViolatingPhase_bot() const
  {
    return GSL_integration_mubl_container.getBrokenCPViolatingPhase_bot();
  }
 
  auto getSymmetricCPViolatingPhase_tau() const
  {
    return GSL_integration_mubl_container.getSymmetricCPViolatingPhase_tau();
  }
 
  auto getBrokenCPViolatingPhase_tau() const
  {
    return GSL_integration_mubl_container.getBrokenCPViolatingPhase_tau();
  }
 
  void set_transport_method(TransportMethod method)
  {
    GSL_integration_mubl_container.set_transport_method(method);
  }
 
  auto getGSL_integration_mubl_container() const
  {
    return GSL_integration_mubl_container;
  }
};
 
} // namespace Baryo
} // namespace BSMPT
 
#endif /* SRC_BARYO_CALCULATION_CALCULATEETAINTERFACE_H_ */