susy.h

Go to the documentation of this file.

 
#ifndef SUSY_H
#define SUSY_H
 
#include <iostream>
#include <cmath>
#include <fstream>
#include "lowe.h"
#include "utils.h"
#include "rge.h"
#include "tensor.h"
 
namespace softsusy {
  
  const static int numSusyPars = 33;
  
  typedef enum {YU=1, YD, YE} yukawa;
  
  struct sBrevity {
    DoubleMatrix dt, ut, et, u2, d2, e2, u2t, e2t, d2t;
    DoubleVector  gsq, g3, g4;
    double uuT, ddT, eeT;
    DoubleMatrix u1, d1, e1;
    
    sBrevity();
    sBrevity(const sBrevity &);
    const sBrevity & operator=(const sBrevity &);
    
    void calculate(const DoubleMatrix & yu, const DoubleMatrix & yd, const
                   DoubleMatrix & ye, const DoubleVector  & g);
  };
  
  inline sBrevity::sBrevity()
    : dt(3, 3), ut(3, 3), et(3, 3), u2(3, 3), 
      d2(3, 3), e2(3, 3), u2t(3, 3), 
      e2t(3, 3), d2t(3, 3), gsq(1, 3), g3(1, 3), g4(1, 3), uuT(0.0),
      ddT(0.0), eeT(0.0), u1(3, 3), d1(3, 3), e1(3, 3)
  {}
  
  inline sBrevity::sBrevity(const sBrevity &s)
    : dt(s.dt), ut(s.ut), et(s.ut), u2(s.u2), d2(s.d2),
      e2(s.e2), u2t(s.u2t),
      e2t(s.e2t), d2t(s.d2t), gsq(s.gsq), g3(s.g3), g4(s.g4),
      uuT(s.uuT), ddT(s.ddT), eeT(s.eeT), u1(s.u1), d1(s.d1), e1(s.e1) 
  {}
  
  class MssmSusy {
  private:
    Approx mssmSusyApprox;
    DoubleMatrix u, d, e; 
    DoubleVector g; 
    double smu, tanb, hVev;   
    int mixing;
  public:
    MssmSusy(); 
    MssmSusy(const MssmSusy &); 
    MssmSusy(const DoubleMatrix & u, const DoubleMatrix & d, const
             DoubleMatrix & e, const DoubleVector & v, double m,
             double tb, double h, int mix);
    virtual ~MssmSusy() {}; 
    
    const MssmSusy & operator=(const MssmSusy & s);
    void setMssmSusy(const MssmSusy &s);
 
    void setMssmLoops(double l) { mssmSusyApprox.setLoops(l); };
    void setHvev(double h);
    void setSomePars(const MssmSusy & s);
    void setYukawaElement(yukawa, int, int, double);
    void setYukawaMatrix(yukawa, const DoubleMatrix &);
    void setGaugeCoupling(int, double);
    void setAllGauge(const DoubleVector  &);
    void setSusyMu(double);
    void setTanb(double); 
    void setMssmApprox(int l, int t); 
    inline void setMssmApprox(const Approx & a) { mssmSusyApprox = a; };
    void set(const DoubleVector &);
    void set(const DoubleVector &, int & k);
    void setMixing(double mix) { mixing = mix; };
    
    int displayMssmLoops() const { return mssmSusyApprox.displayLoops(); };
    double displayHvev() const;
    inline const MssmSusy & displayMssmSusy() const;
    double displayYukawaElement(yukawa, int, int) const;
    const DoubleMatrix & displayYukawaMatrix(yukawa) const;
    double displayGaugeCoupling(int) const;
    DoubleVector  displayGauge() const;
    double displaySusyMu() const;
    double displayTanb() const;
    Approx displayMssmApprox() const { return mssmSusyApprox; };
    const DoubleVector display() const;
    int displayMixing() const { return mixing; };
    
    void getMasses(QedQcd & r, double vev) const;
    void quarkMixing(const DoubleMatrix & CKM, int mix);
    void setDiagYukawas(const QedQcd &, double vev);
    void getQuarkMixedYukawas(const QedQcd & r, const DoubleMatrix &
                              CKM, int mix, double vev);
    void diagQuarkBasis(DoubleMatrix & vdl, DoubleMatrix & vdr, 
                        DoubleMatrix & vul, DoubleMatrix & vur) const;
    MssmSusy beta(sBrevity &) const;
 
    void getOneLpAnom(DoubleMatrix & gEE, DoubleMatrix & gLL,
                      DoubleMatrix & gQQ, DoubleMatrix & gDD,
                      DoubleMatrix & gUU, double & gH1H1, double &
                      gH2H2, sBrevity & a) const; 
    void getTwoLpAnom(DoubleMatrix & gEE, DoubleMatrix & gLL,
                      DoubleMatrix & gQQ, DoubleMatrix & gDD,
                      DoubleMatrix & gUU, double & gH1H1, double &
                      gH2H2, sBrevity & a) const; 
    
    
    void getThreeLpAnom(DoubleMatrix & gEE, DoubleMatrix & gLL,
                        DoubleMatrix & gQQ, DoubleMatrix & gDD,
                        DoubleMatrix & gUU, double & gH1H1, double &
                        gH2H2, sBrevity & a) const;
    
    void anomalousDimension(DoubleMatrix & gEE, DoubleMatrix & gLL,
                            DoubleMatrix & gQQ, DoubleMatrix & gUU,
                            DoubleMatrix & gDD, DoubleVector & dg, 
                            double & gH1H1, double & gH2H2, 
                            sBrevity & a) const; 
  };
  
  class MssmSusyRGE: public RGE, public MssmSusy {
  private:
  public:
    MssmSusyRGE(); 
    MssmSusyRGE(const MssmSusyRGE &); 
    MssmSusyRGE(const MssmSusy &); 
    MssmSusyRGE(const DoubleMatrix & u, const DoubleMatrix & d, const
                DoubleMatrix & e, const DoubleVector & v, double m,
                double tb, double MU, int l, int t, double h, int mix);
    virtual ~MssmSusyRGE() {}; 
    
    const MssmSusyRGE & operator=(const MssmSusyRGE & s);
    void setMssmSusyRGE(const MssmSusyRGE &s);
    void set(const DoubleVector &);
    
    inline const MssmSusy & displayMssmSusyRGE() const;
    DoubleVector beta() const;
    const DoubleVector display() const;
   
  };
  
  
  
  ostream & operator <<(ostream &, const MssmSusy &);
  ostream & operator <<(ostream &, const MssmSusyRGE &);
  istream & operator >>(istream &left, MssmSusy &s);
  istream & operator >>(istream &left, MssmSusyRGE &s);
  void setBetas(DoubleMatrix &, DoubleVector  &, DoubleVector  &, DoubleVector
                &, DoubleVector  &);
  
  void setBetasThreeLoop(Tensor &, DoubleMatrix &, DoubleMatrix &, 
                         DoubleMatrix &, DoubleVector &, DoubleVector &, DoubleVector &,
                         DoubleVector &, DoubleVector &, DoubleVector &, DoubleVector &,  
                         DoubleVector &); 
  inline const MssmSusy & MssmSusy::displayMssmSusy() const { return *this; }
  
  inline void MssmSusy::setGaugeCoupling(int i, double f) { g(i) = f; }
  
  inline void MssmSusy::setAllGauge(const DoubleVector & v) { 
    if (v.displayStart() != 1 || v.displayEnd() !=3) {
      ostringstream ii;
      ii << 
        "Initialising SUSY params gauge function with vector NOT 1..3\n" <<
        v;
      throw ii.str();
    }
    g = v; 
  }
  
  inline double MssmSusy::displayHvev() const { return hVev; } 
  
  inline void MssmSusy::setHvev(double h) { hVev = h; }
  inline void MssmSusy::setSusyMu(double f) { smu = f; }
  inline void MssmSusy::setTanb(double f) { tanb = f; }
  inline DoubleVector MssmSusy::displayGauge() const { return g; }
  inline double MssmSusy::displayGaugeCoupling(int i) const { 
    return g.display(i); 
  }
  inline double MssmSusy::displaySusyMu() const { return smu; }
  
} // namespace softsusy
 
#endif