rpvsoft.h

Go to the documentation of this file.

 
#ifndef RPVSOFT_H
#define RPVSOFT_H
 
#include <iostream>
#include <math.h>
#include <cstring>
#include <sstream>
#include <fstream>
#include "flavoursoft.h"
#include "softsusy.h"
#include "linalg.h"
#include "rpvsusypars.h"
 
namespace softsusy {
 
static const int numRpvSoftPars = 99 + numSoftParsMssm; 
 
class RpvSoftsusy: public FlavourMssmSoftsusy, public RpvSoftPars, 
                   public RpvSusyPars {
private:
  DoubleVector snuVevs;
  DoubleVector nuMasses;
  DoubleMatrix neutralFermMixing;
  DoubleMatrix Uch, Vch;
  int numRpcBcs;
public:
  RpvSoftsusy();
  RpvSoftsusy(const RpvSoftsusy &);
  const RpvSoftsusy & operator = (const RpvSoftsusy &);
 
  const DoubleVector display() const;
  void set(const DoubleVector & v);
  DoubleVector beta() const;
  RpvSoftsusy beta2() const;
 
  inline const RpvSoftsusy & displayRpvSoftsusy() const { return *this; }  
  void setRpvSoftsusy(const RpvSoftsusy & s) { *this = s; };
 
  void rpvDisplay(DoubleVector & parameters) const;
  
  virtual void rpvSet(const DoubleVector & parameters);
 
  const DoubleVector & displaySneutrinoVevs() const { return snuVevs; };
  const DoubleVector & displayNeutrinoMasses() const { return nuMasses; };
  const DoubleMatrix & displayNeutralMixing() const { 
    return neutralFermMixing; };
  const DoubleMatrix & displayUch() const { return Uch; };
  const DoubleMatrix & displayVch() const { return Vch; };
  int displayNumRpcBcs() const { return numRpcBcs; };
 
  void setNumRpcBcs(int pos) { numRpcBcs = pos; };
  void setSneutrinoVevs(DoubleVector & v) { snuVevs = v; };
  void setNeutrinoMasses(DoubleVector & v) { nuMasses = v; };
  void setNeutralMixing(DoubleMatrix & v) { neutralFermMixing = v; };
  void setUch(DoubleMatrix & v) { Uch = v; };
  void setVch(DoubleMatrix & v) { Vch = v; }; 
  void check(const DoubleVector & sneutrinoVevs) const;
  void rpvAnomalousDimension(DoubleMatrix & gEE, DoubleMatrix & gLL,
                          DoubleMatrix & gQQ, DoubleMatrix & gUU,
                          DoubleMatrix & gDD, 
                          double & gH1H1, double & gH2H2,
                          DoubleVector & gH1L)  const;
 
  void rpvAnomalousDeriv(DoubleMatrix & gEE, DoubleMatrix & gLL,
                         DoubleMatrix & gQQ, DoubleMatrix & gUU,
                         DoubleMatrix & gDD, 
                         double & gH1H1, double & gH2H2,
                         DoubleVector & gH1L) const;
 
  void rpvyTildes(DoubleMatrix & ye, DoubleMatrix & yd, Tensor & letilde,
                  Tensor & ldtilde, Tensor & lutilde) const;
 
  virtual void rewsb(int sgnMu, double mt, const DoubleVector & pars, 
                     double muOld = -6.66e66, double eps = 0.);
  void iterateRewsb(double & mu, double & m3sq, DoubleVector & sneutrinoVevs,
                     int sgnMu, int & numTries, int maxTries, double tol, 
                    double mt, double oldMu, double eps);
  double calculateMu(const DoubleVector & sneutrinoVevs, int sgnMu,
                     double v1, double v2);  
  virtual void higgs(int accuracy, double piwwtMS, double pizztMS);  
  double calculateM3sq(const DoubleVector & sneutrinoVevs,
                       double snuSq, double v1, double v2);
  virtual DoubleVector calculateSneutrinoVevs(const DoubleVector & 
                                              sneutrinoVevs,
                                              double tol,
                                              double snuSq, double v1, 
                                              double v2);
  void rotateAwayVevs(DoubleVector & snVevs);
 
  // Returns some functions of VEVs, gives 1 if there's a problem with the
  // sneutrino VEVs (if they are incompatible with the W and Z masses)
  // quadrature), v1 and
  // inputs vSM and sneutrinoVevs.
  int usefulVevs(double vSM, const DoubleVector & sneutrinoVevs, 
                 double & snuSq, double & v1, double & v2) const; 
 
  void standardSugra(double m0,  double m12, double a0);
  
  DoubleMatrix neutralinoMassMatrix() const;
 
  void neutralinos(int accuracy, double piwwtMS, double pizztMS);
  void methodBoundaryCondition(const DoubleVector & v);
  virtual void sparticleThresholdCorrections(double tb);
 
  DoubleMatrix chargedLeptons(double vev);
  void iterateChargedLeptons(double vev, DoubleMatrix & yeOld, double tol, 
                             int maxTries, int & err, double mtau);
 
  void isawigInterface764(char herwigInputFile [80], 
                          char isajetOutputFile [80],
                          char softOutputFile [80], double eps = 0.) const; 
  void outputNonZeroInputs(ostream & out);
  void slha1(ostream & out, const char model[], 
             const DoubleVector & pars, int sgnMu, 
             double tanb, double qMax, int numPoints, bool ewsbBCscale);
  void drbarRpv(ostream & out);
  bool leptonNumberViolation() const;
};
 
ostream & operator <<(ostream &left, const RpvSoftsusy & r);
 
double neutrinoSum(const RpvSoftsusy & r);
 
inline RpvSoftsusy::RpvSoftsusy()
  : FlavourMssmSoftsusy(), RpvSoftPars(), RpvSusyPars(), snuVevs(3), 
    nuMasses(3), neutralFermMixing(7, 7), Uch(5, 5), Vch(5, 5), numRpcBcs(10) {
      setPars(numRpvSoftPars);
      setMu(0.0);
      setLoops(2);
      setThresholds(0);
}
 
inline RpvSoftsusy::RpvSoftsusy(const RpvSoftsusy & s)
  : FlavourMssmSoftsusy(s.displayFlavourSoftsusy()), 
    RpvSoftPars(s.displayRpvSoft()), 
    RpvSusyPars(s.displayRpvSusy()), snuVevs(s.displaySneutrinoVevs()),
    nuMasses(s.displayNeutrinoMasses()), 
    neutralFermMixing(s.displayNeutralMixing()), 
    Uch(s.displayUch()),
    Vch(s.displayVch()), numRpcBcs(s.displayNumRpcBcs()) {
 
  setPars(numRpvSoftPars);
  setMu(s.displayMu()); 
  setLoops(s.displayLoops());
  setThresholds(s.displayThresholds());
}
 
void rpvSugraBcs(MssmSoftsusy & m, const DoubleVector & inputParameters);
void rpvAmsbBcs(MssmSoftsusy & m, const DoubleVector & inputParameters);
void rpvGmsbBcs(MssmSoftsusy & m, const DoubleVector & inputParameters);
void rpvExtendedSugraBcs(MssmSoftsusy & m, 
                         const DoubleVector & inputParameters);
 
} // namespace softsusy
 
#endif