lowe.h

Go to the documentation of this file.

// ====================================================================
// This file is part of FlexibleSUSY.
//
// FlexibleSUSY is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published
// by the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// FlexibleSUSY is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with FlexibleSUSY.  If not, see
// <http://www.gnu.org/licenses/>.
// ====================================================================
 
#ifndef LOWE_H
#define LOWE_H
 
#include "betafunction.hpp"
#include "ckm.hpp"
#include "pmns.hpp"
#include <array>
#include <iosfwd>
#include <Eigen/Core>
 
namespace softsusy {
 
enum EMass {mUp=1, mCharm, mTop, mDown, mStrange, mBottom, mElectron,
           mMuon, mTau};
enum EGauge {ALPHA=1, ALPHAS};
 
enum QedQcd_input_parmeters : int {
   alpha_em_MSbar_at_MZ,
   alpha_s_MSbar_at_MZ,
   GFermi,
   MZ_pole, MW_pole,
   Mv1_pole, Mv2_pole, Mv3_pole,
   Me_pole, Mm_pole, Mtau_pole,
   mu_2GeV, ms_2GeV, Mt_pole,
   md_2GeV, mc_mc, mb_mb,
   CKM_theta_12, CKM_theta_13, CKM_theta_23, CKM_delta,
   PMNS_theta_12, PMNS_theta_13, PMNS_theta_23, PMNS_delta, PMNS_alpha_1, PMNS_alpha_2,
   NUMBER_OF_LOW_ENERGY_INPUT_PARAMETERS
};
 
extern const std::array<std::string, NUMBER_OF_LOW_ENERGY_INPUT_PARAMETERS> QedQcd_input_parmeter_names;
 
class QedQcd: public flexiblesusy::Beta_function
{
public:
  using Input_t = Eigen::Array<double,NUMBER_OF_LOW_ENERGY_INPUT_PARAMETERS,1>;
 
private:
  Eigen::Array<double,2,1> a{Eigen::Array<double,2,1>::Zero()};  
  Eigen::Array<double,9,1> mf{Eigen::Array<double,9,1>::Zero()}; 
  Input_t input{Input_t::Zero()}; 
  double mbPole;    
 
  double qedBeta() const;   
  double qcdBeta() const;   
  Eigen::Array<double,9,1> massBeta() const; 
  void runto_safe(double, double eps = -1.0); 
 
  int flavours(double) const;  
 
  double extractPoleMb(double asMb);
 
public:
  QedQcd();
  QedQcd(const QedQcd&) = default;
  QedQcd(QedQcd&&) = default;
  QedQcd& operator=(const QedQcd&) = default;
  QedQcd& operator=(QedQcd&&) = default;
  virtual ~QedQcd() = default;
 
  // Beta_function interface
  virtual Eigen::ArrayXd get() const override;
  virtual void set(const Eigen::ArrayXd&) override;
  virtual Eigen::ArrayXd beta() const override;
 
  void setPoleMt(double mt) { input(Mt_pole) = mt; } 
  void setPoleMb(double mb) { mbPole = mb; } 
  void setPoleMtau(double mtau) { input(Mtau_pole) = mtau; } 
  void setPoleMmuon(double m) { input(Mm_pole) = m; } 
  void setPoleMel(double m) { input(Me_pole) = m;  } 
  void setMbMb(double mb)   { input(mb_mb) = mb;   } 
  void setMcMc(double mc)   { input(mc_mc) = mc;   } 
  void setMu2GeV(double mu) { input(mu_2GeV) = mu; } 
  void setMd2GeV(double md) { input(md_2GeV) = md; } 
  void setMs2GeV(double ms) { input(ms_2GeV) = ms; } 
  void setPoleMW(double mw) { input(MW_pole) = mw; } 
  void setPoleMZ(double mz) { input(MZ_pole) = mz; } 
  void setMasses(const Eigen::Array<double,9,1>& m) { mf = m; }
  void setMass(EMass mno, double m) { mf(mno - 1) = m; }
  void setNeutrinoPoleMass(int i, double m) { input(Mv1_pole + i - 1) = m; }
  void setAlphas(const Eigen::Array<double,2,1>& o) { a = o; }
  void setAlpha(EGauge ai, double ap) { a(ai - 1) = ap; }
  void setAlphaEmInput(double a) { input(alpha_em_MSbar_at_MZ) = a; }
  void setAlphaSInput(double a) { input(alpha_s_MSbar_at_MZ) = a; }
  void setCKM(const flexiblesusy::CKM_parameters&);
  void setPMNS(const flexiblesusy::PMNS_parameters&);
  void setFermiConstant(double gf) { input(GFermi) = gf; }
  void set_input(const Input_t& i) { input = i; }
 
  Input_t displayInput() const { return input; }
  double displayPoleMt() const { return input(Mt_pole); }
  double displayPoleMtau() const { return input(Mtau_pole); }
  double displayPoleMmuon() const { return input(Mm_pole); }
  double displayPoleMel() const { return input(Me_pole); }
  double displayPoleMb() const { return mbPole; }
  double displayPoleMW() const { return input(MW_pole); }
  double displayPoleMZ() const { return input(MZ_pole); }
  auto displayMass() const -> decltype(mf) { return mf; }
  double displayMass(EMass mno) const { return mf(mno - 1); }
  double displayUpQuarkRunningMass(int) const;
  double displayDownQuarkRunningMass(int) const;
  double displayNeutrinoPoleMass(int i) const { return input(Mv1_pole + i - 1); }
  double displayLeptonPoleMass(int) const;
  double displayLeptonRunningMass(int) const;
  double displayAlpha(EGauge ai) const { return a(ai - 1); }
  auto displayAlphas() const -> decltype(a) { return a; }
  double displayAlphaEmInput() const { return input(alpha_em_MSbar_at_MZ); }
  double displayAlphaSInput() const { return input(alpha_s_MSbar_at_MZ); }
  double displayFermiConstant() const { return input(GFermi); }
  Input_t display_input() const { return input; }
  static std::array<std::string, NUMBER_OF_LOW_ENERGY_INPUT_PARAMETERS> display_input_parameter_names();
  double displayMbMb() const { return input(mb_mb); }
  double displayMcMc() const { return input(mc_mc); }
  double displayMu2GeV() const { return input(mu_2GeV); }
  double displayMd2GeV() const { return input(md_2GeV); }
  double displayMs2GeV() const { return input(ms_2GeV); }
  flexiblesusy::CKM_parameters displayCKM() const;
  Eigen::Matrix<double,3,3> get_real_ckm() const { return displayCKM().get_real_ckm(); }
  Eigen::Matrix<std::complex<double>,3,3> get_complex_ckm() const { return displayCKM().get_complex_ckm(); }
  flexiblesusy::PMNS_parameters displayPMNS() const;
  Eigen::Matrix<double,3,3> get_real_pmns() const { return displayPMNS().get_real_pmns(); }
  Eigen::Matrix<std::complex<double>,3,3> get_complex_pmns() const { return displayPMNS().get_complex_pmns(); }
 
  void toMz();
  void to(double scale, double precision_goal = 1e-5, int max_iterations = 20);
  Eigen::Array<double,3,1> guess_alpha_SM5(double scale) const;
};
 
std::ostream & operator<<(std::ostream &, const QedQcd &);
 
bool operator ==(const QedQcd&, const QedQcd&);
 
} // namespace softsusy
 
#endif