flavoursoft.h

Go to the documentation of this file.

 
#ifndef FLAVOURSOFT_H
#define FLAVOURSOFT_H
 
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <cstdlib>
#include <cmath>
#include "utils.h"
#include "numerics.h"
#include "physpars.h"
#include "lowe.h"
#include "softpars.h"
#include "twoloophiggs.h"
#include "softsusy.h"
 
namespace softsusy {
 
void convertFromWolfenstein(double lambdaW, double A, double rhobar, 
                            double etabar, double & sin12, double & sin23, 
                            double & sin13);
 
int positionOfSym(int i, int j);
 
struct flavourPhysical {
  DoubleMatrix dSqMix, uSqMix;
  DoubleVector msD, msU;
  DoubleMatrix eSqMix, nuSqMix;
  DoubleVector msE, msNu;
 
  flavourPhysical(); 
  flavourPhysical(const flavourPhysical &); 
  const flavourPhysical & displayFlavourPhysical() const { return *this; };
  void setFlavourPhysical(const flavourPhysical &s) { *this = s; };
  const flavourPhysical & operator = (const flavourPhysical & s);
};
 
ostream & operator <<(ostream &, const flavourPhysical &); 
istream & operator >>(istream & left, flavourPhysical &s);
 
inline flavourPhysical::flavourPhysical()
  : dSqMix(6, 6), uSqMix(6, 6), msD(6), msU(6), 
    eSqMix(6, 6), nuSqMix(3, 3), msE(6), msNu(3)
{}
 
inline flavourPhysical::flavourPhysical(const flavourPhysical & s)
  : dSqMix(s.dSqMix), uSqMix(s.uSqMix), msD(s.msD), msU(s.msU),
    eSqMix(s.eSqMix), nuSqMix(s.nuSqMix), 
    msE(s. msE), msNu(s.msNu)
{}
 
class FlavourMssmSoftsusy; 
class FlavourMssmSoftsusy: public MssmSoftsusy {
private:
  flavourPhysical fv; 
  double theta12, theta23, theta13, deltaCkm; 
  double thetaB12, thetaB23, thetaB13; 
  double mNuE, mNuMu, mNuTau; 
  double md2GeV, mu2GeV, ms2GeV, mcMc; 
  double mePole, mmuPole; 
public:
  inline FlavourMssmSoftsusy();
  inline FlavourMssmSoftsusy(const FlavourMssmSoftsusy & s);
  const FlavourMssmSoftsusy & operator=(const FlavourMssmSoftsusy & s);
 
  inline double displayTheta12() const { return theta12; };
  inline double displayTheta13() const { return theta13; };
  inline double displayTheta23() const { return theta23; };
  inline double displayDelta() const { return deltaCkm; };  
  inline double displayThetaB12() const { return thetaB12; };
  inline double displayThetaB13() const { return thetaB13; };
  inline double displayThetaB23() const { return thetaB23; };
  inline double displayMnuE()   const { return mNuE; };
  inline double displayMnuMu()  const { return mNuMu; };
  inline double displayPoleMe()   const { return mePole;  };
  inline double displayPoleMmu()  const { return mmuPole; };
  inline double displayMd2GeV()   const { return md2GeV;  };
  inline double displayMu2GeV()   const { return mu2GeV;  };
  inline double displayMs2GeV()   const { return ms2GeV;  };
  inline double displayMcMc()   const { return mcMc;  };
  inline double displayMnuTau() const { return mNuTau; };
  const flavourPhysical & displayFlavourPhysical() const { return fv; };
  const FlavourMssmSoftsusy & displayFlavourSoftsusy() const { return *this; };
  
  inline void setFlavourSoftsusy(const FlavourMssmSoftsusy & s) { *this = s; }
  inline void setTheta12(double d)  { theta12 = d; };
  inline void setTheta13(double d)  { theta13 = d; };
  inline void setTheta23(double d)  { theta23 = d; };
  inline void setDelta(double d)    { deltaCkm = d; };
  inline void setThetaB12(double d) { thetaB12 = d; };
  inline void setThetaB13(double d) { thetaB13 = d; };
  inline void setThetaB23(double d) { thetaB23 = d; };
  inline void setMnuE(double d)     { mNuE = d; };
  inline void setMnuMu(double d)    { mNuMu = d; };
  inline void setMnuTau(double d)   { mNuTau = d; };
  inline void setPoleMe(double d)   { mePole = d;  };
  inline void setPoleMmu(double d)  { mmuPole = d; };
  inline void setMd2GeV(double d)   { md2GeV = d; };
  inline void setMu2GeV(double d)   { mu2GeV = d; };
  inline void setMs2GeV(double d)   { ms2GeV = d; };
  inline void setMcMc(double d)   { mcMc = d; };
  void setFlavourPhys(const flavourPhysical & s) { fv = s; };
  inline void setInitialData(const QedQcd & r) {
    md2GeV = r.displayMass(mDown);     mu2GeV = r.displayMass(mUp);
    ms2GeV = r.displayMass(mStrange);  mcMc   = r.displayMass(mCharm);
    mePole = r.displayMass(mElectron); mmuPole = r.displayMass(mMuon);
  }
 
  const DoubleMatrix displayCkm() const;
  const ComplexMatrix displayComplexCkm() const;
  const DoubleMatrix displayMns() const;
 
  virtual void lesHouchesAccordOutput(ostream & out, const char model[], 
                                      const DoubleVector & pars, 
                                      int sgnMu, double tanb, double qMax, 
                                      int numPoints, bool ewsbBCscale);
  void modselSLHA(ostream & out, const char model[]);
  void sminputsSLHA(ostream & out);
  void vckminSLHA(ostream & out);
  void minparSLHA(ostream & out, const char model [], 
                  const DoubleVector & pars, double tanb, int sgnMu, 
                  bool ewsbBCscale);
  virtual void extparSLHA(ostream & out, const DoubleVector & pars, 
                          bool ewsbBCscale);
  virtual void sfermionsSLHA(ostream & out);
  virtual void sleptonsSLHA(ostream & out);
  virtual void sfermionmixSLHA(ostream & out);
  virtual void selmixSLHA(ostream & out);
  virtual void snumixSLHA(ostream & out);
  virtual void yukawasSLHA(ostream & out);
  virtual void msoftSLHA(ostream & out);
 
 
  virtual void doUpSquarks(double mt, double pizztMS, double sinthDRbarMS, int
                      accuracy); 
  virtual void doDownSquarks(double mb, double pizztMS, double sinthDRbarMS, 
                             int accuracy, double mt); 
  virtual void doChargedSleptons(double mT, double pizztMS, 
                         double sinthDRbarMS, int accuracy);
  virtual void doSnu(double pizztMS, int accuracy = 0);
 
  virtual void doQuarkMixing(DoubleMatrix & mDon, DoubleMatrix & mUpq);
 
  virtual void calcDrBarPars(); 
 
  virtual MssmSusyRGE guessAtSusyMt(double tanb, const QedQcd & oneset);
 
 
  void setAngles(double lambdaW, double aCkm, double rhobar, double etabar);
 
  void sCkm(DoubleMatrix & deltaULL, DoubleMatrix & deltaURR, 
            DoubleMatrix & deltaULR, DoubleMatrix & deltaDLL, 
            DoubleMatrix & deltaDRR, DoubleMatrix & deltaDLR) const;
 
 
  void sCkmAnalytic(double m32, double & deltaULL23, double & deltaULR23,
                    double & deltaULL12, double & deltaDLL23, 
                    double & deltaDLR23, double & deltaDLL12) const;
 
  void sCkmRunning
  (DoubleMatrix & deltaULL, DoubleMatrix & deltaURR, DoubleMatrix & deltaULR, 
   DoubleMatrix & deltaDLL, DoubleMatrix & deltaDRR, DoubleMatrix & deltaDLR);
};
 
inline FlavourMssmSoftsusy::FlavourMssmSoftsusy()
  : MssmSoftsusy(), fv(), theta12(0.), theta23(0.), theta13(0.), deltaCkm(0.),
    thetaB12(0.), thetaB23(0.), thetaB13(0.), mNuE(0.), mNuMu(0.), mNuTau(0.),
    md2GeV(0.), mu2GeV(0.), ms2GeV(0.), mcMc(0.), mePole(0.), mmuPole(0.)
{}
 
inline FlavourMssmSoftsusy::FlavourMssmSoftsusy(const FlavourMssmSoftsusy & s)
  : MssmSoftsusy(s.displaySoftsusy()), fv(s.displayFlavourPhysical()), 
    theta12(s.displayTheta12()), theta23(s.displayTheta23()), 
    theta13(s.displayTheta13()), deltaCkm(s.displayDelta()),
    thetaB12(s.displayThetaB12()), thetaB23(s.displayThetaB23()), 
    thetaB13(s.displayThetaB13()), mNuE(s.displayMnuE()), 
    mNuMu(s.displayMnuMu()), mNuTau(s.displayMnuTau()),
    md2GeV(s.displayMd2GeV()), mu2GeV(s.displayMu2GeV()), 
    ms2GeV(s.displayMs2GeV()), mcMc(s.displayMcMc()), 
    mePole(s.displayPoleMe()), mmuPole(s.displayPoleMmu()) { 
}
 
ostream & operator <<(ostream &, const FlavourMssmSoftsusy &); 
 
void flavourBcs(MssmSoftsusy & m, const DoubleVector & inputParameters);
 
void ckmNormalise(DoubleMatrix & Vu, DoubleMatrix & Vd, DoubleMatrix & Uu,
                  DoubleMatrix & Ud);
 
} // namespace softsusy
 
#endif