SUSY.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2012 HEPfit Collaboration
 *
 *
 * For the licensing terms see doc/COPYING.
 */
 
#ifndef SUSY_H
#define SUSY_H
 
#include <gslpp.h>
#include <StandardModel.h>
#include "SUSYMatching.h"
 
#define FEYNHIGGS false
 
class EWSUSY; // forward reference to EWSUSY class
/* BEGIN: REMOVE FROM THE PACKAGE */
#if FEYNHIGGS
class FeynHiggsWrapper; // forward reference to FeynHiggsWrapper class
#endif
/* END: REMOVE FROM THE PACKAGE */
class SUSYSpectrum; // forward reference to Spectrum class
 
class SUSY: public StandardModel {
public:
 
    static const int NSUSYvars = 10;
    static const std::string SUSYvars[NSUSYvars];
    
    friend class SUSYSpectrum;
/* BEGIN: REMOVE FROM THE PACKAGE */
    friend class FeynHiggsWrapper;
/* END: REMOVE FROM THE PACKAGE */
 
    SUSY();
 
    ~SUSY();
    // Initialization
 
    virtual bool InitializeModel();
    
/* BEGIN: REMOVE FROM THE PACKAGE */
#if FEYNHIGGS    
    FeynHiggsWrapper* getMyFH() const
    {
        return myFH;
    }
#endif
/* END: REMOVE FROM THE PACKAGE */    
 
    virtual SUSYMatching& getMatching() const
    {
        return SUSYM.getObj();
    }
    
    // Parameters 
 
    virtual bool Init(const std::map<std::string, double>& DPars);
 
    virtual bool PreUpdate();
 
    virtual bool Update(const std::map<std::string, double>& DPars);
 
    virtual bool PostUpdate();
 
    virtual bool CheckParameters(const std::map<std::string, double>& DPars);
 
    
    // Flags
 
    virtual bool setFlag(const std::string, const bool);
 
    bool IsFlag_h() const
    {
        return flag_h;
    }
 
    bool IsFlag_g() const
    {
        return flag_g;
    }
 
    bool IsFlag_ch() const
    {
        return flag_ch;
    }
 
    bool IsFlag_ne() const
    {
        return flag_ne;
    }
    
    bool IsFlag_FH() const
    {
        return flag_fh;
    }
 
 
    // functions for the input parameters of SUSY model
 
    gslpp::complex getM1() const
    {
        return m1;
    }
 
    gslpp::complex getM2() const
    {
        return m2;
    }
 
    const double getM3() const
    {
        return m3;
    }
 
    const double getMHptree() const
    {
        return mHptree;
    }
 
    gslpp::complex getMuH() const
    {
        return muH;
    }
 
    const double getTanb() const
    {
        return tanb;
    }
 
    const double getQ_SUSY() const
    {
        return Q_SUSY;
    }
 
 
    // functions for the parameters in the Higgs sector.
 
    double v1() const;
 
    double v2() const;
    
    const double getSinb() const
    {
        return sinb;
    }
 
    const double getCosb() const
    {
        return cosb;
    }
 
    gslpp::complex getSaeff() const
    {
        return saeff;
    }
 
    virtual const double getMHl() const
    {
        return mh[0];
    }
 
    const double getMHh() const
    {
        return mh[1];
    }
 
    const double getMHa() const
    {
        return mh[2];
    }
 
    const double getMHp() const
    {
        return mh[3];
    }
 
 
    // functions for the parameters in the gaugino sector.
 
    const double getMGl() const;
 
    
    // functions for the parameters in the chargino sector.
 
    gslpp::vector<double> getMch() const
    {
        return mch;
    }
 
    gslpp::matrix<gslpp::complex> getU() const
    {
        return U;
    }
 
    gslpp::matrix<gslpp::complex> getV() const
    {
        return V;
    }
 
 
    // functions for the parameters in the neutralino sector.
    
    gslpp::vector<double> getMneu() const
    {
        return mneu;
    }
 
    gslpp::matrix<gslpp::complex> getN() const
    {
        return N;
    }
 
 
    // functions for the parameters in the squark sector.
 
    gslpp::matrix<gslpp::complex> getMsQhat2() const
    {
        return msQhat2;
    }
 
    gslpp::matrix<gslpp::complex> getMsUhat2() const
    {
        return msUhat2;
    }
 
    gslpp::matrix<gslpp::complex> getMsDhat2() const
    {
        return msDhat2;
    }
 
    gslpp::matrix<gslpp::complex> getTUhat() const
    {
        return TUhat;
    }
 
    gslpp::matrix<gslpp::complex> getTDhat() const
    {
        return TDhat;
    }
 
    gslpp::vector<double> getMsu2() const
    {
        return m_su2;
    }
 
    gslpp::vector<double> getMsd2() const
    {
        return m_sd2;
    }
 
    gslpp::vector<double> getMsdresum2() const
    {
        return m_sdresum2;
    }
 
    gslpp::matrix<gslpp::complex> getRu() const
    {
        return Ru;
    }
 
    gslpp::matrix<gslpp::complex> getRd() const
    {
        return Rd;
    }
 
    gslpp::matrix<gslpp::complex> getRdresum() const
    {
        return Rdresum;
    }
 
    // functions for the parameters in the slepton sector.
 
    gslpp::matrix<gslpp::complex> getMsLhat2() const
    {
        return msLhat2;
    }
 
    gslpp::matrix<gslpp::complex> getMsNhat2() const
    {
        return msNhat2;
    }
 
    gslpp::matrix<gslpp::complex> getMsEhat2() const
    {
        return msEhat2;
    }
 
    gslpp::matrix<gslpp::complex> getTNhat() const
    {
        return TNhat;
    }
 
    gslpp::matrix<gslpp::complex> getTEhat() const
    {
        return TEhat;
    }
 
    gslpp::vector<double> getMsn2() const
    {
        return m_sn2;
    }
 
    gslpp::vector<double> getMse2() const
    {
        return m_se2;
    }
 
    gslpp::matrix<gslpp::complex> getRn() const
    {
        return Rn;
    }
 
    gslpp::matrix<gslpp::complex> getRl() const
    {
        return Rl;
    }
 
    
    // functions for SM fermions
 
    double Mq_Q(const quark q) const
    {
        switch (q) {
            case UP:
            case CHARM:
            case TOP:
                return mu_Q[(int)(q - UP)/2];
            case DOWN:
            case STRANGE:
            case BOTTOM:
                return md_Q[((int)(q - DOWN))/2];
            default:
                throw std::runtime_error("SUSY::Mq_Q(): Error!");
        }
    }
 
    double Ml_Q(const lepton l) const
    {
        switch (l) {
            case ELECTRON:
            case MU:
            case TAU:
                return me_Q[(int)(l - ELECTRON)/2];
            case NEUTRINO_1:
            case NEUTRINO_2:
            case NEUTRINO_3:
                return mn_Q[((int)(l - NEUTRINO_1))/2];
            default:
                throw std::runtime_error("SUSY::Ml_Q(): Error!");
        }
    }
 
 
    // EW precision observables
 
    virtual const double Mw() const;
 
    double Mw_dRho() const;
 
 
protected:
    virtual void setParameter(const std::string name , const double& value);
    virtual void SetTanb(const double tanb);
    virtual void computeYukawas();
    virtual void SetSoftTerms();
/* BEGIN: REMOVE FROM THE PACKAGE */
#if FEYNHIGGS
    FeynHiggsWrapper* myFH;
#endif
/* END: REMOVE FROM THE PACKAGE */
 
    SUSYSpectrum* mySUSYSpectrum;
 
    // model parameters at scale Q
    gslpp::complex m1, m2, muH;
    double m3, mHptree, tanb, Q_SUSY;
 
    // sinb and cosb computed with setTanb()
    double sinb, cosb;
 
    // soft-breaking parameters associated with squark and slepton mass terms and
    // trilinear couplings in the SCKM basis, which will be set with SetSoftTerms()
    gslpp::matrix<gslpp::complex> msQhat2, msUhat2, msDhat2, msLhat2, msNhat2, msEhat2;
    gslpp::matrix<gslpp::complex> TUhat, TDhat, TNhat, TEhat;
 
    // soft-breaking parameters computed with FeynHiggs
    double mHp, mh[4];
    gslpp::complex saeff;
    gslpp::vector<double> mch, mneu;
    gslpp::vector<double> m_su2, m_sd2, m_sdresum2, m_sn2, m_se2;
 
    // rotation matrices
    gslpp::matrix<gslpp::complex> U, V, N, Ru, Rd, Rdresum, Rn, Rl;
 
    // quark and lepton masses at scale Q, computed in setYukawas()
    double mu_Q[3], md_Q[3], me_Q[3], mn_Q[3];
    
private:    
    bool flag_h, flag_g, flag_ch, flag_ne, flag_fh;
    mutable Matching<SUSYMatching,SUSY>  SUSYM;
    EWSUSY* myEWSUSY;
 
};
 
#endif  /* SUSY_H */