nmssmsusy.h

Go to the documentation of this file.

 
#ifndef NMSSMSUSY_H
#define NMSSMSUSY_H
 
#include "susy.h"
 
namespace softsusy {  
  const static int numNMssmPars = numSusyPars + 5;
  
  struct nmsBrevity : public sBrevity {
    double lsq, ksq, l4, k4;
    
    nmsBrevity();
    nmsBrevity(const nmsBrevity&);
    const nmsBrevity & operator=(const nmsBrevity &);
    const nmsBrevity & operator=(const sBrevity &);
    
    void calculate(const DoubleMatrix & yu, const DoubleMatrix & yd, const
                   DoubleMatrix & ye, const DoubleVector & g,
                   const double & lam, const double & kap);
  }; 
  
  inline nmsBrevity::nmsBrevity()
    : sBrevity()
    , lsq(0.0), ksq(0.0), l4(0.0), k4(0.0)
  {}
  
  inline nmsBrevity::nmsBrevity(const nmsBrevity &s)
    : sBrevity(s)
    , lsq(s.lsq), ksq(s.ksq), l4(s.l4), k4(s.k4)
  {}
  class NmssmSusyPars; class NmssmSusy;
  void addOneLpAnomNmssm(double & gH1H1, double & gH2H2, double & gSS, 
                         double lambda, double kappa);
  void addTwoLpAnomNmssm(DoubleMatrix & gEE, DoubleMatrix & gLL,
                         DoubleMatrix & gQQ, DoubleMatrix & gDD,
                         DoubleMatrix & gUU, double & gH1H1, double &
                         gH2H2, double & gSS, nmsBrevity & a);
  void anomalousDimensionNmssmSusy(const MssmSusy & s, const NmssmSusyPars & n,
                                   DoubleMatrix & gEE, 
                                   DoubleMatrix & gLL,DoubleMatrix & gQQ, 
                                   DoubleMatrix & gUU,
                                   DoubleMatrix & gDD, DoubleVector & dg, 
                                   double & gH1H1, double & gH2H2,
                                   double & gSS, nmsBrevity & a);
  NmssmSusy betaNmssmSusy(nmsBrevity & a, const MssmSusy & s, 
                          const NmssmSusyPars & n);
  void nmsetBetas(DoubleMatrix &, DoubleVector  &, DoubleVector  &, DoubleVector
                  &, DoubleVector  &, DoubleVector  & );
  void setBetaLambda(DoubleVector&);
  class NmssmSusyPars {
  private:
    double lambda, kappa, sVev;
    double xiF, mupr;
  public:
    NmssmSusyPars(); 
    NmssmSusyPars(const NmssmSusyPars & );
    NmssmSusyPars(double sv, double lambda, double kappa, double xiF, 
                  double mupr);
    const NmssmSusyPars & operator=(const NmssmSusyPars & s);
    virtual ~NmssmSusyPars() {};
 
    void setSvev(double s) { sVev = s; };
    void setLambda(double l) { lambda = l; };
    void setKappa(double k) { kappa = k; };
    void setMupr(double m) { mupr = m; };
    void setXiF(double x) { xiF = x; };
    void setNmssmSusyPars(const NmssmSusyPars &s);
    void setNmssmSusyPars(const DoubleVector & y);
    void set(const DoubleVector & y, int & k);
 
    double displaySvev() const { return sVev; };
    double displayLambda() const { return lambda; };
    double displayKappa() const { return kappa; };
    double displayMupr() const { return mupr; };
    double displayXiF() const { return xiF; };
    const NmssmSusyPars & displayNmssmSusyPars() const { return *this; };
    void display(DoubleVector & y, int & k) const; 
 
    void getOneLpAnom(DoubleMatrix & gEE, DoubleMatrix & gLL,
                      DoubleMatrix & gQQ, DoubleMatrix & gDD,
                      DoubleMatrix & gUU, double & gH1H1, double &
                      gH2H2, double & gSS, nmsBrevity & a, int loops) const;
    void getTwoLpAnom(DoubleMatrix & gEE, DoubleMatrix & gLL,
                      DoubleMatrix & gQQ, DoubleMatrix & gDD,
                      DoubleMatrix & gUU, double & gH1H1, double &
                      gH2H2, double & gSS, nmsBrevity & a, int loops) const;
    void anomalousDimension
    (const MssmSusy & s, DoubleMatrix & gEE, DoubleMatrix & gLL,
     DoubleMatrix & gQQ, DoubleMatrix & gUU, DoubleMatrix & gDD, 
     DoubleVector & dg, double & gH1H1, double & gH2H2, double & gSS, 
     nmsBrevity & a, int loops)  const {
      anomalousDimensionNmssmSusy(s, displayNmssmSusyPars(), gEE, gLL, gQQ, gUU,
                                  gDD, dg, gH1H1, gH2H2, gSS, a);
    };
  }; 
 
  class NmssmSusy: public MssmSusy, public NmssmSusyPars {
  private:
    Approx nmssmSusyApprox; 
  public:
    NmssmSusy(); 
    NmssmSusy(const NmssmSusy &);
    NmssmSusy(const MssmSusy & m, const NmssmSusyPars & nsp);
    // number of loops in
    NmssmSusy(const DoubleMatrix & u,
              const DoubleMatrix & d, 
              const DoubleMatrix & e, const DoubleVector & v, double m, 
              double tb,  double hv, int mix, int l, int t, double sv,
              double lambda, double kappa, double xiF, 
              double mupr);
    NmssmSusy(double lambda, double kappa, double sv, double xiF, 
              double mupr);
    //    NmssmSusy(const NmssmSusyRGE & nms);
    
    inline const NmssmSusy & displayNmssmSusy() const { return *this; };
    
    virtual ~NmssmSusy(); 
    
    const NmssmSusy & operator=(const NmssmSusy & s);
    
    void setNmssmLoops(double l) { nmssmSusyApprox.setLoops(l); };
    void setNmssmApprox(int l, int t) { nmssmSusyApprox.setLoops(l); 
      nmssmSusyApprox.setThresholds(t); }; 
    void setNmssmApprox(const Approx & a) { nmssmSusyApprox = a; };
    void setNmssmSusy(const NmssmSusy & y) { 
      setNmssmApprox(y.displayNmssmSusyApprox()); 
      setMssmSusy(y.displayMssmSusy());
      setNmssmSusyPars(y.displayNmssmSusyPars());
    };    
 
    int displayNmssmLoops() const { return nmssmSusyApprox.displayLoops(); };
    int displayNmssmThresholds() const { 
      return nmssmSusyApprox.displayThresholds(); 
    };
    Approx displayNmssmSusyApprox() const { return nmssmSusyApprox; };
    const DoubleVector display() const;
 
    void set(const DoubleVector & y, int & k);
    void set(const DoubleVector & y);
    NmssmSusy beta(nmsBrevity &) const;
    void getOneLpAnom(DoubleMatrix & gEE, DoubleMatrix & gLL,
                      DoubleMatrix & gQQ, DoubleMatrix & gDD,
                      DoubleMatrix & gUU, double & gH1H1, double &
                      gH2H2, double & gSS, nmsBrevity & a) const;
    void getTwoLpAnom(DoubleMatrix & gEE, DoubleMatrix & gLL,
                      DoubleMatrix & gQQ, DoubleMatrix & gDD,
                      DoubleMatrix & gUU, double & gH1H1, double &
                      gH2H2, double & gSS, nmsBrevity & a) const;
    double displayMuEff() const { return displaySusyMu() + 
        displayLambda() * displaySvev() / sqrt(2.0); };
  }; 
  
  class NmssmSusyRGE: public RGE, public NmssmSusy {
  private:
  public:
    NmssmSusyRGE(); 
    NmssmSusyRGE(const NmssmSusyRGE &);
    //renormalisation scale MU, number of loops in
    NmssmSusyRGE(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,
                 double s, double lambda, double kappa, double xiF,
                 double mupr);
    
    NmssmSusyRGE(const MssmSusy &m);
    
    virtual ~NmssmSusyRGE(); 
    
    const NmssmSusyRGE & operator=(const NmssmSusyRGE & s);
    const NmssmSusyRGE & operator=(const NmssmSusy & s);
    void setSusy(const NmssmSusyRGE &s);
    void set(const DoubleVector &y);
    
    void setSomePars(const NmssmSusyRGE & s);
 
    inline const NmssmSusyRGE & displaySusy() const { return *this; };
    const DoubleVector display() const;
    
    DoubleVector beta() const;
  }; 
  
  
  ostream & operator <<(ostream &, const NmssmSusyRGE &);
  ostream & operator <<(ostream &, const NmssmSusy &);
  ostream & operator <<(ostream &, const NmssmSusyPars &);
  
  istream & operator >>(istream &left, NmssmSusyRGE &s);
  
} 
 
#endif