SUSYMassInsertion.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2012 HEPfit Collaboration
 *
 *
 * For the licensing terms see doc/COPYING.
 */
 
#ifndef SUSYMASSINSERTION_H
#define SUSYMASSINSERTION_H
 
#include <gslpp.h>
#include <StandardModel.h>
#include "SUSYMassInsertionMatching.h" 
 
class SUSYMassInsertion: public StandardModel {
public:
    static const int NSusyMIvars = 3 + 144;
    static const std::string SusyMIvars[NSusyMIvars];
 
    SUSYMassInsertion();
 
    virtual ~SUSYMassInsertion();
    
    virtual bool InitializeModel();
    
    virtual SUSYMassInsertionMatching& getMatching() const
    {
        return SUSYMIM.getObj();
    }
 
//    virtual void setMatching(SUSYMassInsertionMatching& SUSYMIMr)
//    {
//        SUSYMIM.setObj(SUSYMIMr);
//    }
 
    // 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);
    
    
    // functions for the input parameters of SUSY MIA model
    double getM3() const {
        return m3;
    }
    
    void setM3(double m3) {
        this->m3 = m3;
    }
 
    double getMsq() const {
        return Msq;
    }
 
    void setMsq(double Msq) {
        this->Msq = Msq;
    }
 
    gslpp::matrix<gslpp::complex> getDu_LL() const {
        return Du_LL;
    }
 
    void setDu_LL(gslpp::matrix<gslpp::complex> Du_LL) {
        this->Du_LL = Du_LL;
    }
 
    gslpp::matrix<gslpp::complex> getDu_LR() const {
        return Du_LR;
    }
 
    void setDu_LR(gslpp::matrix<gslpp::complex> Du_LR) {
        this->Du_LR = Du_LR;
    }
 
    gslpp::matrix<gslpp::complex> getDu_RL() const {
        return Du_RL;
    }
 
    void setDu_RL(gslpp::matrix<gslpp::complex> Du_RL) {
        this->Du_RL = Du_RL;
    }
 
    gslpp::matrix<gslpp::complex> getDu_RR() const {
        return Du_RR;
    }
 
    void setDu_RR(gslpp::matrix<gslpp::complex> Du_RR) {
        this->Du_RR = Du_RR;
    }
 
    gslpp::matrix<gslpp::complex> getDd_LL() const {
        return Dd_LL;
    }
 
    void setDd_LL(gslpp::matrix<gslpp::complex> Dd_LL) {
        this->Dd_LL = Dd_LL;
    }
 
    gslpp::matrix<gslpp::complex> getDd_LR() const {
        return Dd_LR;
    }
 
    void setDd_LR(gslpp::matrix<gslpp::complex> Dd_LR) {
        this->Dd_LR = Dd_LR;
    }
 
    gslpp::matrix<gslpp::complex> getDd_RL() const {
        return Dd_RL;
    }
 
    void setDd_RL(gslpp::matrix<gslpp::complex> Dd_RL) {
        this->Dd_RL = Dd_RL;
    }
 
    gslpp::matrix<gslpp::complex> getDd_RR() const {
        return Dd_RR;
    }
 
    void setDd_RR(gslpp::matrix<gslpp::complex> Dd_RR) {
        this->Dd_RR = Dd_RR;
    }
 
    double getMuM() const{
        return MuM;
    }
 
    void setMuM(double MuM){
        this->MuM = MuM;
    }
    
protected:
 
    virtual void setParameter(const std::string, const double&);
 
    gslpp::matrix<gslpp::complex> Du_LL, Du_LR, Du_RL, Du_RR;
    gslpp::matrix<gslpp::complex> Dd_LL, Dd_LR, Dd_RL, Dd_RR;
    double Msq, m3, MuM;
    
    double rDULL11, rDULL12, rDULL13, rDULL21, rDULL22, rDULL23, rDULL31, rDULL32, rDULL33;
    double iDULL11, iDULL12, iDULL13, iDULL21, iDULL22, iDULL23, iDULL31, iDULL32, iDULL33;
    
    double rDURL11, rDURL12, rDURL13, rDURL21, rDURL22, rDURL23, rDURL31, rDURL32, rDURL33;
    double iDURL11, iDURL12, iDURL13, iDURL21, iDURL22, iDURL23, iDURL31, iDURL32, iDURL33;
    
    double rDULR11, rDULR12, rDULR13, rDULR21, rDULR22, rDULR23, rDULR31, rDULR32, rDULR33;
    double iDULR11, iDULR12, iDULR13, iDULR21, iDULR22, iDULR23, iDULR31, iDULR32, iDULR33;
    
    double rDURR11, rDURR12, rDURR13, rDURR21, rDURR22, rDURR23, rDURR31, rDURR32, rDURR33;
    double iDURR11, iDURR12, iDURR13, iDURR21, iDURR22, iDURR23, iDURR31, iDURR32, iDURR33;
    
    double rDDLL11, rDDLL12, rDDLL13, rDDLL21, rDDLL22, rDDLL23, rDDLL31, rDDLL32, rDDLL33;
    double iDDLL11, iDDLL12, iDDLL13, iDDLL21, iDDLL22, iDDLL23, iDDLL31, iDDLL32, iDDLL33;
    
    double rDDRL11, rDDRL12, rDDRL13, rDDRL21, rDDRL22, rDDRL23, rDDRL31, rDDRL32, rDDRL33;
    double iDDRL11, iDDRL12, iDDRL13, iDDRL21, iDDRL22, iDDRL23, iDDRL31, iDDRL32, iDDRL33;
    
    double rDDLR11, rDDLR12, rDDLR13, rDDLR21, rDDLR22, rDDLR23, rDDLR31, rDDLR32, rDDLR33;
    double iDDLR11, iDDLR12, iDDLR13, iDDLR21, iDDLR22, iDDLR23, iDDLR31, iDDLR32, iDDLR33;
    
    double rDDRR11, rDDRR12, rDDRR13, rDDRR21, rDDRR22, rDDRR23, rDDRR31, rDDRR32, rDDRR33;
    double iDDRR11, iDDRR12, iDDRR13, iDDRR21, iDDRR22, iDDRR23, iDDRR31, iDDRR32, iDDRR33;
 
    mutable Matching<SUSYMassInsertionMatching,SUSYMassInsertion> SUSYMIM;
 
};        
 
#endif  /* SUSYMASSINSERTION_H */