SUSY.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2012 HEPfit Collaboration
 * All rights reserved.
 *
 * For the licensing terms see doc/COPYING.
 */

#ifndef SUSY_H
#define SUSY_H

#include <gslpp.h>
#include <StandardModel.h>
#include "SUSYMatching.h"

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;
    //friend class FeynHiggsWrapper;

    SUSY();

    ~SUSY();
    // Initialization

    virtual bool InitializeModel();

    virtual SUSYMatching* getMyMatching() const
    {
        return mySUSYMatching;
    }

    
    // 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);

    // functions for the input parameters of SUSY model

    gslpp::complex getM1() const
    {
        return m1;
    }

    gslpp::complex getM2() const
    {
        return m2;
    }

    double getM3() const
    {
        return m3;
    }

    double getMHptree() const
    {
        return mHptree;
    }

    gslpp::complex getMuH() const
    {
        return muH;
    }

    double getTanb() const
    {
        return tanb;
    }

    double getQ_SUSY() const
    {
        return Q_SUSY;
    }


    // functions for the parameters in the Higgs sector.

    double v1() const;

    double v2() const;
    
    double getSinb() const
    {
        return sinb;
    }

    double getCosb() const
    {
        return cosb;
    }

    gslpp::complex getSaeff() const
    {
        return saeff;
    }

    virtual double getMHl() const
    {
        return mh[0];
    }

    double getMHh() const
    {
        return mh[1];
    }

    double getMHa() const
    {
        return mh[2];
    }

    double getMHp() const
    {
        return mh[3];
    }


    // functions for the parameters in the gaugino sector.

    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!");
        }
    }

protected:
    virtual void setParameter(const std::string name , const double& value);
    virtual void SetTanb(const double tanb);
    virtual void computeYukawas();

    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;
    SUSYMatching* mySUSYMatching;

};

#endif  /* SUSY_H */