physpars.h

Go to the documentation of this file.

 
#ifndef PHYSPARSH
#define PHYSPARSH
 
#include <iostream>
#include "linalg.h"
#include "utils.h"
using namespace std;
 
namespace softsusy {
  typedef enum {none=0, selectron, smuon, stau, sup, scharm, stop, sdown, 
             sstrange, sbottom, h0, A0, hpm, snue, snumu, snutau, W, Z} 
  tachyonType;
 
  const static char* tachyonNames[18] = {
   "none", "selectron", "smuon", "stau", "sup", "scharm", "stop", "sdown", 
   "sstrange", "sbottom", "h0", "A0", "hpm", "snue", "snumu", "snutau", 
   "W", "Z"};
 
struct sPhysical {
  DoubleVector mh0, mA0;
  double mHpm;
  DoubleVector msnu;
  DoubleVector mch, mneut;
  double mGluino;
  DoubleMatrix mixNeut;
   double thetaL, thetaR, thetat, thetab, thetatau, thetamu;
  DoubleMatrix mu, md, me;
   double thetaH, thetaA0;
  DoubleMatrix mixh0;
  
  sPhysical(); 
  sPhysical(const sPhysical &); 
  const sPhysical & displaysPhysical() const { return *this; };
  void setsPhysical(const sPhysical &s) { *this = s; };
  const sPhysical & operator = (const sPhysical & s);
  
  void display(double *a) const;
  DoubleVector display() const;
  int size() const;
  void set(const DoubleVector&);
}; 
 
std::ostream & operator <<(std::ostream &, const sPhysical &); 
 
struct sProblem {
  bool mgutOutOfBounds;
  bool badConvergence; 
  bool irqfp; 
  bool noRhoConvergence; 
  bool noConvergence; 
  tachyonType tachyon; 
  tachyonType tachyonWarning; 
  bool muSqWrongSign; 
  bool m3sq; 
  bool higgsUfb; 
  bool notGlobalMin; 
  bool nonperturbative; 
  bool noMuConvergence; 
  bool inaccurateHiggsMass; 
  bool problemThrown;
  bool test() const 
  {return (mgutOutOfBounds || irqfp || noConvergence || tachyon || 
           muSqWrongSign || higgsUfb || notGlobalMin || nonperturbative || 
           noRhoConvergence || noMuConvergence || m3sq || badConvergence || 
           inaccurateHiggsMass || problemThrown || tachyonWarning);}; 
  bool testSeriousProblem() const 
  {return (irqfp || tachyon || muSqWrongSign || higgsUfb || 
           nonperturbative || noRhoConvergence || noMuConvergence || m3sq || 
           badConvergence || mgutOutOfBounds || problemThrown);}; 
 
  inline sProblem(); 
  inline sProblem(const sProblem & s);
  const sProblem & operator = (const sProblem &);
  
};
std::ostream & operator <<(std::ostream &st, const sProblem & p);
std::istream & operator >>(std::istream & left, sPhysical &s);
 
struct drBarPars: public sPhysical { 
  double mz, mw;       
  double mt, mb, mtau; 
  double ht, hb, htau; 
  double ut, ub, utau; 
  ComplexMatrix nBpmz, uBpmz, vBpmz; 
  DoubleVector mnBpmz, mchBpmz; 
 
  inline drBarPars(); 
  inline drBarPars(const drBarPars &); 
  const drBarPars & operator = (const drBarPars &s);
 
  void mpzNeutralinos(); 
  void mpzCharginos();
};
 
std::ostream & operator <<(std::ostream &, const drBarPars &); 
 
// ---------------------- inline class members ------------------------
inline drBarPars::drBarPars()
  : sPhysical(), mz(0.0), mw(0.0), 
    mt(0.0), mb(0.0), mtau(0.0), ht(0.0), hb(0.0), htau(0.0), 
    ut(0.0), ub(0.0), utau(0.0),
    nBpmz(4, 4), uBpmz(2, 2), 
    vBpmz(2, 2), mnBpmz(4), mchBpmz(2)
{}
 
inline drBarPars::drBarPars(const drBarPars &s)
  : sPhysical(s.displaysPhysical()), mz(s.mz), mw(s.mw),
    mt(s.mt), mb(s.mb), mtau(s.mtau), ht(s.ht), hb(s.hb), htau(s.htau),
    ut(s.ut), ub(s.ub), utau(s.utau),
    nBpmz(s.nBpmz), uBpmz(s.uBpmz), vBpmz(s.vBpmz), mnBpmz(s.mnBpmz), 
    mchBpmz(s.mchBpmz)
{}
 
inline sPhysical::sPhysical()
  : mh0(2), mA0(1), mHpm(0.), msnu(3), mch(2), mneut(4), 
    mGluino(0.0),
    mixNeut(4, 4), thetaL(0.0), thetaR(0.0), thetat(0.0), thetab(0.0),
                 thetatau(0.0), thetamu(0.0), mu(2, 3), md(2, 3), me(2, 3), thetaH(0.0), 
                 thetaA0(0.0), mixh0(2,2)
{}
 
inline sPhysical::sPhysical(const sPhysical & s)
  : mh0(s.mh0), mA0(s.mA0), mHpm(s.mHpm), msnu(s.msnu), mch(s.mch), 
    mneut(s.mneut), mGluino(s.mGluino), mixNeut(s.mixNeut), thetaL(s.thetaL),
                 thetaR(s.thetaR), thetat(s.thetat), thetab(s.thetab), 
    thetatau(s.thetatau), thetamu(s.thetamu), mu(s.mu), md(s.md), me(s.me), 
                 thetaH(s.thetaH), thetaA0(s.thetaA0), mixh0(s.mixh0)
{}
 
inline sProblem::sProblem()
  : mgutOutOfBounds(false), badConvergence(false), 
    irqfp(false), noRhoConvergence(false), noConvergence(false),
    tachyon(none), tachyonWarning(none),
    muSqWrongSign(false), m3sq(false), higgsUfb(false), 
    notGlobalMin(false), nonperturbative(false), noMuConvergence(false),     
    inaccurateHiggsMass(false), problemThrown(false)
{}
 
inline sProblem::sProblem(const sProblem & s)
  : mgutOutOfBounds(s.mgutOutOfBounds), badConvergence(s.badConvergence), 
    irqfp(s.irqfp), noRhoConvergence(s.noRhoConvergence), 
    noConvergence(s.noConvergence),
    tachyon(s.tachyon), tachyonWarning(s.tachyon),
    muSqWrongSign(s.muSqWrongSign), m3sq(s.m3sq),
    higgsUfb(s.higgsUfb), notGlobalMin(s.notGlobalMin), 
    nonperturbative(s.nonperturbative), noMuConvergence(s.noMuConvergence), 
    inaccurateHiggsMass(s.inaccurateHiggsMass), problemThrown(s.problemThrown)
{}
 
} // namespace softsusy
 
double sTfn(double sTins, double sTouts);
 
// class drBarPars;
class DoubleVector;
void sumTol(const softsusy::drBarPars & a, const softsusy::drBarPars & b, DoubleVector & sT);
 
#endif