softsusy is hosted by Hepforge, IPPP Durham
SOFTSUSY  4.1
softsusy.h
Go to the documentation of this file.
1 
15 #ifndef SOFTSUSY_H
16 #define SOFTSUSY_H
17 
18 #include <iostream>
19 #include <fstream>
20 #include <sstream>
21 #include <cstring>
22 #include <cstdlib>
23 #include <cmath>
24 #include "def.h"
25 #include "utils.h"
26 #include "numerics.h"
27 #include "physpars.h"
28 #include "lowe.h"
29 #include "softpars.h"
30 #include "twoloophiggs.h"
31 #include "mssmUtils.h"
32 #include "higher_order.h"
33 #include "mssmjacobian.h"
34 
35 #define HR "----------------------------------------------------------"
36 
37 namespace softsusy {
38 
41  DeltaQpole = 1,
42  DeltaQmatch = 2,
43  DeltaMt = 4,
44  DeltaAlphaS = 8,
45  DeltaAlphaEm = 16,
46  DeltaAll = DeltaQpole + DeltaQmatch + DeltaMt + DeltaAlphaS + DeltaAlphaEm
47  };
48 
50  const double mxDefault = 1.9e16;
51 
53  class AltEwsbMssm {
54  private:
57  double mAcond, muCond;
58  public:
59  void setAltEwsb(double ma, double mu) { mAcond = ma; muCond = mu; };
60  void setAltEwsbMssm(const AltEwsbMssm & s) { *this = s; };
61 
62  // int displayConditionStyle() { return conditionStyle; };
63  double displayMaCond() const { return mAcond; };
64  double displayMuCond() const { return muCond; };
65  const AltEwsbMssm & displayAltEwsbMssm() const { return *this; };
66 
67  void setMaCond(double maInput) { mAcond = maInput; };
68  void setMuCond(double muInput) { muCond = muInput; };
69  };
70 
72  class MssmSoftsusy: public MssmSusy, public MssmSoftPars, public AltEwsbMssm,
73  public Approx, public RGE {
83  private:
84  sPhysical physpars;
85  drBarPars forLoops;
86  sProblem problem;
87  double msusy;
88  double minV;
89  double mw;
90  QedQcd dataSet;
91  double fracDiff;
92  bool setTbAtMX;
93  bool altEwsb;
95  bool altMt;
96  bool altAlphaS;
97  bool altAlphaEm;
98  double predMzSq;
99  double t1OV1Ms, t2OV2Ms;
100  double t1OV1Ms1loop, t2OV2Ms1loop;
101  double qewsb;
106 
107  protected:
108  void setT1OV1Ms(double t1) { t1OV1Ms = t1; }
109  void setT2OV2Ms(double t2) { t2OV2Ms = t2; }
110  void setT1OV1Ms1loop(double t1) { t1OV1Ms1loop = t1; }
111  void setT2OV2Ms1loop(double t2) { t2OV2Ms1loop = t2; }
112  double mxBC;
113 
114  void check_flags();
115  DoubleMatrix calcHiggs3L(bool is_bottom);
116  public:
117  using TMSSMBoundaryCondition = void(*)(MssmSoftsusy&, const DoubleVector&);
118 
121 
122  // void (*boundaryCondition)(Softsusy &, const DoubleVector &);
124  MssmSoftsusy();
126  MssmSoftsusy(const MssmSusyRGE &);
128 
129  MssmSoftsusy(const MssmSoftsusy &);
134  MssmSoftsusy(const MssmSusy &, const MssmSoftPars & s,
135  const sPhysical & sp, double mu, int l,
136  int t, double hv);
137 
139  const MssmSoftsusy & operator=(const MssmSoftsusy & s);
140 
142  virtual const DoubleVector display() const;
143 
145  const MssmSoftsusy & displayMssmSoft() const;
146 
148  const sPhysical & displayPhys() const;
149 
151  sPhysical displayPhysUncertainty(
152  TMSSMBoundaryCondition boundaryCondition,
153  double mxGuess,
154  const DoubleVector & pars, int sgnMu, double tanb,
155  const QedQcd & oneset, bool gaugeUnification,
156  bool ewsbBCscale = false,
157  int contributions = DeltaAll) const;
159  sPhysical displayPhysUncertaintyScaleVariation() const;
160 
163  const drBarPars & displayDrBarPars() const;
165  const sProblem & displayProblem() const {return problem; };
167  const QedQcd & displayDataSet() const;
169  double displaySoftA(trilinears, int, int) const;
170 
172  double displayFracDiff() const { return fracDiff; };
173  double displayMinpot() const;
174  double displayMsusy() const;
175  double displayMw() const;
176  double displayMwRun() const;
179  double displayMzRun() const;
180  double displayTadpole1Ms() const;
181  double displayTadpole2Ms() const;
182  double displayTadpole1Ms1loop() const;
183  double displayTadpole2Ms1loop() const;
184  double displayMxBC() const { return mxBC; };
185  const MssmSoftsusy & displaySoftsusy() const { return *this; }
188  double displayMz() const { return double(MZ); }
190  bool displaySetTbAtMX() const { return setTbAtMX; }
191  bool displayAltEwsb() const { return altEwsb; }
192  bool displayAltMt() const { return altMt; }
193  bool displayAltAlphaS() const { return altAlphaS; }
194  bool displayAltAlphaEm() const { return altAlphaEm; }
195  double displayPredMzSq() const { return predMzSq; }
196  double displayQewsb() const { return qewsb; }
197  double displayMatchingScale() const { return displayDataSet().displayMu(); }
198 
200  void flagMgutOutOfBounds(bool a) { problem.mgutOutOfBounds = a; };
202  void flagIrqfp(bool a) { problem.irqfp = a; };
204  void flagNonperturbative(bool a) { problem.nonperturbative = a; };
206  void flagTachyon(tachyonType a) {
209  if (close(displayMu(), MZ, 1.0e-6)) problem.tachyonWarning = a;
210  else { problem.tachyon = a;
211  if (PRINTOUT > 2) cout << tachyonNames[a] << " tachyon ";
212  }
213  };
214  void flagTachyonWarning(tachyonType a) { problem.tachyonWarning = a; }
216  void flagM3sq(bool a) { problem.m3sq = a; };
218  void flagNoConvergence(bool a) { problem.noConvergence = a; };
220  void flagNoMuConvergence(bool a) { problem.noMuConvergence = a; };
222  void flagNoRhoConvergence(bool a) { problem.noRhoConvergence = a; };
224  void flagMusqwrongsign(bool a) { problem.muSqWrongSign = a; };
227  void flagInaccurateHiggsMass(bool a) { problem.inaccurateHiggsMass = a; };
229  void flagHiggsufb(bool a) { problem.higgsUfb = a; };
231  void flagNotGlobalMin(bool a) { problem.notGlobalMin = a; };
233  void flagAllProblems(bool a, tachyonType b) { problem.irqfp = a;
234  problem.tachyon = b; problem.tachyonWarning = b;
235  problem.m3sq = a; problem.badConvergence = a;
236  problem.noConvergence = a; problem.higgsUfb = a; problem.notGlobalMin = a;
237  problem.nonperturbative = a; problem.noRhoConvergence = a;
238  problem.noMuConvergence = a; problem.muSqWrongSign = a;
239  problem.inaccurateHiggsMass = b; problem.mgutOutOfBounds = a; }
241  void flagProblemThrown(bool a) { problem.problemThrown = a; }
243  void setProblem(const sProblem a) { problem = a; }
244 
246  void setSoftsusy(const MssmSoftsusy & s) { *this = s; };
248  void setData(const QedQcd & r) { dataSet = r; };
250  void setMinpot(double);
253  void setMsusy(double);
255  void setMw(double);
257  void setPhys(const sPhysical & s) { physpars = s; };
259  void setMxBC(double mx) { mxBC = mx; };
261  void setDrBarPars(const drBarPars & s) { forLoops = s; };
263  void setSetTbAtMX(bool a) { setTbAtMX = a; }
265  void useAlternativeEwsb() { altEwsb = true; }
267  void useAlternativeMt() { altMt = true; }
269  void useAlternativeAlphaS() { altAlphaS = true; }
271  void useAlternativeAlphaEm() { altAlphaEm = true; }
273  void setPredMzSq(double a) { predMzSq = a; }
275  void set(const DoubleVector &);
277  void setQewsb(double q) { qewsb = q; };
278 
281  void setTwoLoopAlphasThresholds(bool sw);
283  void setTwoLoopMtThresholds(bool sw);
289  void setTwoLoopMbMtauThresholds(bool sw);
291  void setAllTwoLoopThresholds(bool sw);
292 
294  DoubleVector beta() const {
295  sBrevity a;
296  DoubleVector y(MssmSusy::beta(a).display());
297  DoubleVector x(MssmSoftPars::beta(displayMssmSusy()));
298  int i; for (i=1; i<=y.displayEnd(); i++) x(i) = y(i);
299  return x;
300  };
301 
303  void setFracDiff(double fD) { fracDiff = fD; };
305  //for use in doCalcTadpole1oneLoop
306  void H1SfSfCouplings(DoubleMatrix & lTS1Lr, DoubleMatrix & lBS1Lr,
307  DoubleMatrix & lTauS1Lr, double gmzOcthW, double mu,
308  double cosb, double v1) const;
310  //for use in doCalcTadpole1oneLoop
311  void H2SfSfCouplings(DoubleMatrix & lTS2Lr, DoubleMatrix & lBS2Lr,
312  DoubleMatrix & lTauS2Lr, double gmzOcthW, double mu,
313  double sinb) const;
315  double doCalcTad1Sfermions(DoubleMatrix lTS1Lr, DoubleMatrix lBS1Lr,
316  DoubleMatrix lTauS1Lr, double costhDRbar) const;
318  double doCalcTad2Sfermions(DoubleMatrix lTS2Lr, DoubleMatrix lBS2Lr,
319  DoubleMatrix lTauS2Lr, double costhDRbar) const;
321  //for use in doCalcTadpole1oneLoop
322  double doCalcTad1fermions(double q, double v1) const;
324  //for use in doCalcTadpole1oneLoop
325  double doCalcTad2fermions(double q) const;
327  // Follwing BPMZ Goldstone bosons are not included in this.
328  double doCalcTad1Higgs(double q, double costhDRbar2, double g,
329  double tanb) const;
330  //one loop H2 tadpole contributions from Higgs bosons in the loops
331  // Follwing BPMZ Goldstone bosons are not included in this.
332  double doCalcTad2Higgs(double q, double costhDRbar2, double g,
333  double tanb) const;
335  double doCalcTad1Neutralinos(double q, double costhDRbar, double g,
336  double cosb) const;
338  double doCalcTad2Neutralinos(double q, double costhDRbar, double g,
339  double sinb) const;
341  double doCalcTad1Charginos(double q, double g, double cosb) const;
342 
343  double doCalcTad2Charginos(double q, double g, double sinb) const;
344 
346  double doCalcTad1GaugeBosons(double q, double costhDRbar2, double g,
347  double tanb) const;
348 
349  double doCalcTad2GaugeBosons(double q, double costhDRbar2,
350  double g, double tanb) const;
352  void doTadpoles(double mt, double sinthDRbar);
354  virtual double doCalcTadpole1oneLoop(double mt, double sinthDRbar);
356  virtual double doCalcTadpole2oneLoop(double mt, double sinthDRbar);
359  virtual void calcTadpole1Ms1loop(double mt, double sinthDRbar);
362  virtual void calcTadpole2Ms1loop(double mt, double sinthDRbar);
366  DoubleMatrix addStopQCD(double p, double mt, DoubleMatrix & strong);
370  DoubleMatrix addStopStop(double p, double mt, DoubleMatrix & stop);
374  DoubleMatrix addStopSbottom(double p, double mt, DoubleMatrix & sbottom);
378  DoubleMatrix addStopHiggs(double p, double mt, DoubleMatrix & higgs);
382  DoubleMatrix addStopEweak(double p, DoubleMatrix & electroweak);
386  DoubleMatrix addStopNeutralino(double p, double mt,
387  DoubleMatrix & neutralino);
391  DoubleMatrix addStopChargino(double p, DoubleMatrix & chargino);
395  virtual void addStopCorrection(double p, DoubleMatrix & mass, double mt);
399  DoubleMatrix addSdownQCD(double p1, double p2, int family,
400  DoubleMatrix & strong);
404  DoubleMatrix addSdownHiggs(double p1, double p2, int family,
405  DoubleMatrix & higgs);
409  DoubleMatrix addSdownEweak(double p1, double p2, int family,
410  DoubleMatrix & electroweak);
414  DoubleMatrix addSdownNeutralino(double p1, double p2, int family,
415  DoubleMatrix & neutralino);
419  DoubleMatrix addSdownChargino(double p1, double p2, int family,
420  DoubleMatrix & chargino);
424  virtual void addSdownCorrection(DoubleMatrix & mass, int family);
428  DoubleMatrix addSbotQCD(double p, double mt, DoubleMatrix & strong);
432  void addSbotSfermion(double p, double mt, DoubleMatrix & stop,
433  DoubleMatrix & sbottom);
437  DoubleMatrix addSbotHiggs(double p, double mt, DoubleMatrix & higgs);
441  DoubleMatrix addSbotEweak(double p, DoubleMatrix & electroweak);
445  DoubleMatrix addSbotNeutralino(double p, double mt,
446  DoubleMatrix & neutralino);
450  DoubleMatrix addSbotChargino(double p, double mt, DoubleMatrix & chargino);
454  virtual void addSbotCorrection(double p, DoubleMatrix & mass, double mb);
458  DoubleMatrix addSlepHiggs(double p1, double p2, int family,
459  DoubleMatrix & higgs);
463  DoubleMatrix addSlepEweak(double p1, double p2, int family,
464  DoubleMatrix & electroweak);
468  void addSlepGaugino(double p1, double p2, int family,
469  DoubleMatrix & chargino, DoubleMatrix & neutralino);
473  virtual void addSlepCorrection(DoubleMatrix & mass, int family);
476  void addSlepCorrection(double p, DoubleMatrix & mass, int family);
480  void addStauSfermion(double p, double mtau, DoubleMatrix & stop,
481  DoubleMatrix & sbottom);
485  void addStauGaugino(double p, double mtau, DoubleMatrix & chargino,
486  DoubleMatrix & neutralino);
490  DoubleMatrix addStauEweak(double p, double mtau, DoubleMatrix & electroweak);
494  DoubleMatrix addStauHiggs(double p, double mtau, DoubleMatrix & higgs);
498  virtual void addStauCorrection(double p, DoubleMatrix & mass, double mtau);
502  DoubleMatrix addSupQCD(double p1, double p2, int family,
503  DoubleMatrix & strong);
507  DoubleMatrix addSupHiggs(double p1, double p2, int family,
508  DoubleMatrix & higgs);
512  DoubleMatrix addSupEweak(double p1, double p2, int family,
513  DoubleMatrix & electroweak);
517  DoubleMatrix addSupNeutralino(double p1, double p2, int family,
518  DoubleMatrix & neutralino);
522  DoubleMatrix addSupChargino(double p1, double p2, int family,
523  DoubleMatrix & chargino);
527  virtual void addSupCorrection(DoubleMatrix & mass, int family);
530  void addSnuTauSfermion(double p, double & stop, double & sbottom);
533  double addSnuTauHiggs(double p, double & higgs);
536  double addSnuTauEweak(double p, double & electroweak);
540  void addSnuTauGaugino(double p, double & chargino, double & neutralino);
544  virtual void addSnuTauCorrection(double & mass);
548  double addSnuHiggs(double p, int family, double & higgs);
552  double addSnuEweak(double p, int family, double & electroweak);
556  void addSnuGaugino(double p, int family, double & chargino,
557  double & neutralino);
561  virtual void addSnuCorrection(double & mass, int family);
566  void addSquarkCorrection(DoubleMatrix & mass);
571  virtual void doUpSquarks(double mt, double pizztMS, double sinthDRbarMS, int
572  accuracy);
577  virtual void doDownSquarks(double mb, double pizztMS, double sinthDRbarMS,
578  int accuracy, double mt);
583  virtual void doChargedSleptons(double mT, double pizztMS,
584  double sinthDRbarMS, int accuracy);
587  virtual void doSnu(double pizztMS, int accuracy = 0);
593  virtual void treeUpSquark(DoubleMatrix & mass, double mtrun, double pizztMS,
594  double sinthDRbarMS, int family);
600  virtual void treeDownSquark(DoubleMatrix & mass, double mbrun, double pizztMS,
601  double sinthDRbarMS, int family);
607  virtual void treeChargedSlepton(DoubleMatrix & mass, double mTrun,
608  double pizztMS, double sinthDRbarMS,
609  int family);
612  void treeSnu(double & mSq, double pizztMS, int family);
613 
615  virtual void calcDrBarPars();
618  void setNeutCurrCouplings(double sinthDRbar, double & sw2, double & guL,
619  double & gdL, double & geL, double & guR,
620  double & gdR, double & geR );
622  void calcDRTrilinears(drBarPars & eg, double vev, double beta);
623 
624  void calcDrBarHiggs(double beta, double mz2, double mw2,
625  double sinthDRbar, drBarPars & eg);
628  void treeCharginos(DoubleMatrix & mCh, double beta, double mw);
631  void treeNeutralinos(DoubleMatrix & mN, double beta, double mz,
632  double mw, double sinth);
633  // calculates the chargino and neutralino DRbar parameters.
634  //It will fill in the chargino and neutralino
636  void calcDrBarGauginos(double beta, double mw, double mz, double sinth,
637  drBarPars & eg);
641  virtual void sparticleThresholdCorrections(double tb);
642  // const DoubleVector & pars);
646  double qedSusythresh(double alphaEm, double Q) const;
650  double qcdSusythresh(double alphasMSbar, double Q);
654  double calcMs() const;
657  virtual void physical(int accuracy);
659  //to the pole mt for use in calcRunningMt
660  virtual double calcRunMtQCD() const;
662  //to the pole mt for use in calcRunningMt
663  virtual double calcRunMtStopGluino() const;
665  //to the pole mt for use in calcRunningMt
666  virtual double calcRunMtHiggs() const;
667 
669  //to the pole mt for use in calcRunningMt
670  virtual double calcRunMtNeutralinos() const;
672  //to the pole mt for use in calcRunningMt
673  virtual double calcRunMtCharginos() const;
674 
677  virtual double calcRunningMt();
679  virtual double calcRunMtauDrBarConv() const;
680  // Obtains (1 / mTAU) times 1-loop squark-chargino corrections
681  //to mtau for use in calcRunningMtau
682  virtual double calcRunMtauCharginos(double mTauSMMZ) const;
683  // Obtains (1 / mTAU) times 1-loop squark-neutralino corrections
684  //to mtau for use in calcRunningMtau
685  virtual double calcRunMtauNeutralinos(double mTauSMMZ) const;
687  // to mtau for use in calcRunningMtau
688  virtual double calcRunMtauHiggs() const;
691  virtual double calcRunningMtau() ;
692 
694  virtual double calcRunMbDrBarConv() const;
696  //to mb for use in calcRunningMb
697  virtual double calcRunMbSquarkGluino() const;
699  //to mb for use in calcRunningMb
700  virtual double calcRunMbChargino() const;
702  // to mb for use in calcRunningMb
703  virtual double calcRunMbHiggs() const;
705  // to mb for use in calcRunningMb
706  virtual double calcRunMbNeutralinos() const;
709  // rruiz: remove const
710  virtual double calcRunningMb();
711  /*
714  double calcHt(double vev);
717  double calcHb(double vev) const;
720  double calcHtau(double vev) const;
721  */
723  double calcSinthdrbar() const;
725  double getVev();
728  double getVev(double pizzt);
732  virtual void charginos(int accuracy, double piwwt);
735  virtual void addChaLoopSfermion(double p, DoubleMatrix & sigmaL, DoubleMatrix & sigmaR, DoubleMatrix & sigmaS) const;
738  virtual void addChaLoopGauge(double p, DoubleMatrix & sigmaL,
739  DoubleMatrix & sigmaR, DoubleMatrix & sigmaS,
740  DoubleMatrix b1pCha, DoubleMatrix b0pCha,
741  DoubleMatrix b1pNeut,
742  DoubleMatrix b0pNeut) const;
745  virtual void addChaLoopHiggs(double p, DoubleMatrix & sigmaL,
746  DoubleMatrix & sigmaR, DoubleMatrix & sigmaS,
747  DoubleMatrix b1pCha, DoubleMatrix b0pCha,
748  DoubleMatrix b1pNeut,
749  DoubleMatrix b0pNeut) const;
751  virtual void addCharginoLoop(double p, DoubleMatrix &);
756  virtual void neutralinos(int accuracy, double piwwt, double pizzt);
760  void addNeutLoopSfermion(double p, DoubleMatrix & sigmaL,
761  DoubleMatrix & sigmaR, DoubleMatrix & sigmaS);
763  void getNeutPassarinoVeltman(double p, double q, DoubleMatrix & b0fn,
764  DoubleMatrix & b1fn);
768  void addNeutLoopGauge(double p, DoubleMatrix & sigmaL,
769  DoubleMatrix & sigmaR, DoubleMatrix & sigmaS);
773  void addNeutLoopHiggs(double p, DoubleMatrix & sigmaL,
774  DoubleMatrix & sigmaR, DoubleMatrix & sigmaS);
776  virtual void addNeutralinoLoop(double p, DoubleMatrix &);
778  virtual void gluino(int accuracy);
781  void calcHiggsAtScale(int accuracy, double & mt, double & sinthDRbar,
782  double & piwwtMS, double & pizztMS, double q = 0.);
789  bool higgs(int accuracy, double piwwt, double pizzt);
795  // virtual void newhiggs(int accuracy, double piwwt, double pizzt);
799  virtual int rewsbMu(int sgnMu, double & mu) const;
802  virtual int rewsbM3sq(double, double &) const;
805  int rewsbM3sqTree(double, double &) const;
807  void alternativeEwsb(double mt);
815  virtual void rewsb(int sgnMu, double mt, const DoubleVector & pars,
816  double muOld = -6.66e66, double eps = 0.);
819  virtual void rewsbTreeLevel(int sgnMu);
822  double treeLevelMuSq();
832  void iterateMu(double & munew, int sgnMu, double mt,
833  int maxTries, double pizztMS, double sinthDRbar, double tol,
834  int & err);
837  double predTanb(double muSusy = -6.66e66) const;
840  double predMzsq(double & tanb, double muOld = -6.66e66, double eps = 0.);
842  double deltaEW() const;
843 
845  double ewsbCondition1TreeLevel() const;
846  double ewsbCondition2TreeLevel() const;
850  void ewsbConditions(DoubleVector & values) const;
853  void predVevs(DoubleVector & vevs, int & err);
854 
862  DoubleVector fineTune(void (*boundaryCondition)(MssmSoftsusy &,
863  const DoubleVector &),
864  const DoubleVector & bcPars, double MX,
865  bool doTop = false);
869  double it1par(int numPar, const DoubleVector & bcPars);
873  double ufb3sl(double);
876  double realMinMs() const;
878  double calcBayesianNaturalness() const;
879 
881  //for p=external momentum, Q=renormalisation scale
882  virtual double piZZTHiggs(double p, double Q, double thetaWDRbar) const;
884  //for p=external momentum, Q=renormalisation scale
885  virtual double piZZTsfermions(double p, double Q) const;
888  virtual double piZZTfermions(double p, double Q, bool usePoleMt) const;
891  virtual double piZZTNeutralinos(double p, double Q, double thetaWDRbar) const;
894  virtual double piZZTCharginos(double p, double q, double thetaWDRbar) const;
897  virtual double piZZT(double p, double Q, bool usePoleMt = false) const;
900  virtual double piWWTHiggs(double p, double q, double thetaWDRbar) const;
903  virtual double piWWTfermions(double p, double Q, bool usePoleMt) const;
906  virtual double piWWTsfermions(double p, double Q) const;
909  virtual double piWWTgauginos(double p, double Q, double thetaWDRbar) const;
912  virtual double piWWT(double p, double Q, bool usePoleMt = false) const;
915  virtual void getNeutralinoCharginoHpmCoup(ComplexMatrix & apph1,
916  ComplexMatrix & apph2,
917  ComplexMatrix & bpph1,
918  ComplexMatrix & bpph2) const;
921  double piHpHmFermions(double p, double q) const;
925  double piHpHmSfermions(double p, double q, double mu) const;
928  double piHpHmGauge(double p, double q) const;
931  double piHpHmHiggs(double p, double q) const;
934  double piHpHmGauginos(double p, double q) const;
937  virtual double piHpHm(double p, double Q) const;
940  double piZGT(double p, double Q) const;
943  virtual double piAA(double p, double Q) const;
945  //self-energy: for p=external momentum, q=renormalisation scale
946  Complex pis1s1Sfermions(double p, double q, DoubleMatrix ls1tt,
947  DoubleMatrix ls1bb, DoubleMatrix ls1tautau) const;
950  Complex pis1s2Sfermions(double p, double q, DoubleMatrix ls1tt,
951  DoubleMatrix ls1bb, DoubleMatrix ls1tautau,
952  DoubleMatrix ls2tt, DoubleMatrix ls2bb,
953  DoubleMatrix ls2tautau) const;
956  Complex pis2s2Sfermions(double p, double q, DoubleMatrix ls2tt,
957  DoubleMatrix ls2bb, DoubleMatrix ls2tautau) const;
960  Complex pis1s1Fermions(double p, double q) const;
963  Complex pis2s2Fermions(double p, double q) const;
966  Complex pis1s1Higgs(double p, double q) const;
969  Complex pis1s2Higgs(double p, double q) const;
972  Complex pis2s2Higgs(double p, double q) const;
975  Complex pis1s1Neutralinos(double p, double q) const;
978  Complex pis1s2Neutralinos(double p, double q) const;
981  Complex pis2s2Neutralinos(double p, double q) const;
984  Complex pis1s1Charginos(double p, double q) const;
987  Complex pis1s2Charginos(double p, double q) const;
990  Complex pis2s2Charginos(double p, double q) const;
993  Complex pis1s1(double p, double q) const;
996  Complex pis1s2(double p, double q) const;
999  Complex pis2s2(double p, double q) const;
1001  double sinSqThetaEff();
1003  virtual double h1s2Mix();
1012  virtual void rhohat(double & outrho, double & outsin, double alphaMZDRbar,
1013  double pizztMZ, double piwwt0, double piwwtMW,
1014  double tol, int maxTries);
1018  virtual double deltaVb(double outrho, double outsin, double alphaDRbar,
1019  double pizztMZ) const;
1023  virtual double dRho(double outrho, double outsin, double alphaDRbar,
1024  double pizztMZ, double piwwtMW);
1028  virtual double dR(double outrho, double outsin, double alphaDRbar,
1029  double pizztMZ, double piwwt0);
1031  double maxMass() const;
1036  int lsp(double & mass, int & posi, int & posj) const;
1041  int nlsp(double & mass, int & posi, int & posj) const;
1042 
1044  string printShort() const;
1046  string printLong();
1048  string printLongDrbar();
1049 
1051  virtual void printObj() {
1052  cout << this->displayMssmSusy() << this->displayMssmSoftPars();
1053  };
1054 
1056  double thet(double a, double b, double c = 0.0);
1057 
1078  void fixedPointIteration(TMSSMBoundaryCondition boundaryCondition,
1079  double mxGuess,
1080  const DoubleVector & pars, int sgnMu, double tanb,
1081  const QedQcd & oneset, bool gaugeUnification,
1082  bool ewsbBCscale = false);
1086  double lowOrg(void (*boundaryCondition)
1087  (MssmSoftsusy &, const DoubleVector &),
1088  double mxGuess,
1089  const DoubleVector & pars, int sgnMu, double tanb,
1090  const QedQcd & oneset, bool gaugeUnification,
1091  bool ewsbBCscale = false) {
1092  fixedPointIteration(boundaryCondition, mxGuess, pars, sgnMu, tanb, oneset,
1093  gaugeUnification, ewsbBCscale);
1094  return displayMxBC();
1095  };
1096 
1106 
1107  void itLowsoft(int maxTries, int sgnMu, double tol,
1108  double tanb, void (*boundaryCondition)(MssmSoftsusy &,
1109  const DoubleVector &),
1110  const DoubleVector & pars, bool gaugeUnification,
1111  bool ewsbBCscale);
1112 
1116  virtual void rpvSet(const DoubleVector & parameters);
1117 
1121  virtual void methodBoundaryCondition(const DoubleVector & pars);
1122 
1139  void isajetNumbers764
1140  (double & mtopPole, double & mGPole, double & smu, double & mA,
1141  double & tanb, double & mq1l, double & mdr, double & mur, double & meL,
1142  double & meR, double & mql3, double & mdr3, double & mur3, double & mtauL,
1143  double & mtauR, double & at, double & ab, double & atau, double & mq2l,
1144  double & msr, double & mcr, double & mmuL, double & mmuR, double & m1,
1145  double & m2) const;
1147  void isajetInterface764(const char fname[80]) const;
1150  void ssrunInterface764Inside(const char fname [80], fstream & ) const;
1154  void ssrunInterface764(const char fname [80], const char softfname [80]) const;
1158  void isawigInterface764(const char fnamein [80], const char fnameout [80],
1159  const char fnamesoft[80]) const;
1172  virtual void lesHouchesAccordOutput(ostream & out, const char model[],
1173  const DoubleVector & pars,
1174  int sgnMu, double tanb, double qMax,
1175  int numPoints,
1176  bool ewsbBCscale);
1177  /* void slha1(ostream & out, const char model[], const DoubleVector & pars,
1178  int sgnMu, double tanb, double qMax, int numPoints,
1179  bool ewsbBCscale);*/
1183  virtual void setEwsbConditions(const DoubleVector & inputs);
1186  void headerSLHA(ostream & out);
1188  virtual void spinfoSLHA(ostream & out);
1190  void modselSLHA(ostream & out, const char model[]);
1192  void sminputsSLHA(ostream & out);
1194  void minparSLHA(ostream & out, const char model [],
1195  const DoubleVector & pars, double tanb, int sgnMu,
1196  bool ewsbBCscale);
1198  virtual void extparSLHA(ostream & out, const DoubleVector & pars,
1199  bool ewsbBCscale);
1201  void massSLHA(ostream & out);
1203  virtual void higgsMSLHA(ostream & out);
1205  virtual void neutralinoCharginoMSLHA(ostream & out);
1207  virtual void sfermionsSLHA(ostream & out);
1209  void sfermionmixSLHA(ostream & out);
1211  virtual void neutralinoMixingSLHA(ostream & out);
1213  void inomixingSLHA(ostream & out);
1215  virtual void softsusySLHA(ostream & out);
1217  void alphaSLHA(ostream & out);
1219  virtual void hmixSLHA(ostream & out);
1221  void gaugeSLHA(ostream & out);
1223  virtual void yukawasSLHA(ostream & out);
1225  virtual void msoftSLHA(ostream & out);
1227  virtual void drbarSLHA(ostream & out, int numPoints, double qMax, int n);
1228 
1232  void doUfb3(double mgut);
1233 
1237  void assignHiggs(DoubleVector & higgsm, DoubleVector & higgsc,
1238  DoubleVector & dnu, DoubleVector & dnd,
1239  DoubleVector & cn, double beta) const;
1240 
1243  void assignHiggs(DoubleVector & higgsm, DoubleVector & higgsc) const;
1244 
1249  void assignHiggsSfermions(DoubleVector & higgsm, DoubleVector & higgsc,
1250  DoubleVector & dnu, DoubleVector & dnd,
1251  DoubleVector & cn, double beta) const;
1252 
1255  double smPredictionMW() const;
1256 
1259  double twoLoopGm2(double amu1Loop) const;
1260 
1263  double twoLpMt() const;
1264  double twoLpMb() const;
1265 
1270  virtual void doQuarkMixing(DoubleMatrix & mDon, DoubleMatrix & mUpq);
1271 
1276  virtual MssmSusyRGE guessAtSusyMt(double tanb, const QedQcd & oneset);
1277  };
1278 
1279  std::istream& operator>>(std::istream& left, MssmSoftsusy& s);
1280 
1282  void printShortInitialise();
1284  double rho2(double r);
1285 
1290  double minimufb3(double);
1291 
1293  double gEff(double x);
1295  double fEff(double x);
1296 
1298  double lep2Likelihood(double mh);
1301  DoubleVector mhIntegrand(double mh, const DoubleVector & y);
1304  double lnLHiggs(double mh);
1305 
1306 }
1307 
1308 #endif
1309 
1310 
1311 
global variable declaration
Definition: def.cpp:13
DoubleVector boundaryCondition(double m0, double m12, double a0, const RpvSusyPars &r)
Definition: rpvsusypars.cpp:373
void flagMgutOutOfBounds(bool a)
Flags weird mgut-type problems.
Definition: softsusy.h:200
void useAlternativeAlphaEm()
Use alernative alpha_em(MSSM,DR-bar) calculation.
Definition: softsusy.h:271
DoubleVector is of variable length, and contains double precision.
Definition: linalg.h:35
Provides routines for calculating Jacobian fine-tuning.
void setDrBarPars(const drBarPars &s)
Sets tree-level DRbar parameters.
Definition: softsusy.h:261
Masses of the physical particles.
Definition: physpars.h:32
DRbar values of masses and mixings in MSSM.
Definition: physpars.h:120
bool inaccurateHiggsMass
Higgs mass is potentially inaccurate and cant be trusted.
Definition: physpars.h:93
int displayEnd() const
returns end of dimension
Definition: linalg.h:94
void setQewsb(double q)
Sets user-set scale qewsb.
Definition: softsusy.h:277
DoubleVector beta() const
Returns double vector containing numerical beta functions of parameters.
Definition: softsusy.h:294
switches (options) and parameters such as default fermion masses, required accuracy etc ...
EPoleUncertainties
uncertainty flags
Definition: softsusy.h:40
double displayMz() const
Returns value of pole MZ being used.
Definition: softsusy.h:188
bool muSqWrongSign
mu^2 came out with wrong sign; no REWSB
Definition: physpars.h:86
double rho2(double r)
Two-loop Standard Model corrections to rho parameter.
Definition: softsusy.cpp:9233
void setProblem(const sProblem a)
Sets all problem flags.
Definition: softsusy.h:243
bool noRhoConvergence
Couldn&#39;t calculate electroweak rho parameter.
Definition: physpars.h:79
bool nonperturbative
Running went non-perturbative.
Definition: physpars.h:90
mass
used to give order of quark masses stored
Definition: lowe.h:46
double minimufb3(double lnH2)
Definition: softsusy.cpp:6954
QedQcd object contains Standard Model quark and lepton masses. It integrates them using 3 loop qcd x ...
bool displaySetTbAtMX() const
Is tan beta set at the user defined SUSY breaking scale?
Definition: softsusy.h:190
tachyonType tachyonWarning
Definition: physpars.h:85
Contains all supersymmetric RPC-MSSM parameters.
Definition: susy.h:71
void flagInaccurateHiggsMass(bool a)
Definition: softsusy.h:227
int PRINTOUT
no verbose debug output
Definition: def.cpp:15
bool irqfp
Infra-red quasi fixed point breached.
Definition: physpars.h:78
DoubleVector beta(const MssmSusy &) const
Returns double vector containing numerical beta functions of parameters.
Definition: softpars.cpp:2858
Quark and lepton masses and gauge couplings in QEDxQCD effective theory.
Definition: lowe.h:55
bool badConvergence
Nowhere near a decent solution.
Definition: physpars.h:77
void flagIrqfp(bool a)
Flags Infra-red quasi fixed point breach problem.
Definition: softsusy.h:202
void flagTachyon(tachyonType a)
Flags a negative-mass squared scalar (really a CCB problem)
Definition: softsusy.h:206
numerical routines - differential equation solver, differentiator and function minimiser for instance...
A few handy bits and pieces - little mathematical functions and the like.
void useAlternativeMt()
Use alernative mt(MSSM,DR-bar) calculation.
Definition: softsusy.h:267
void setData(const QedQcd &r)
Sets low energy Standard Model fermion mass and gauge coupling data.
Definition: softsusy.h:248
int included_thresholds
Flag allowing to choose which two-loop thresholds have to be included.
Definition: softsusy.h:120
void setPhys(const sPhysical &s)
Sets all physical parameters.
Definition: softsusy.h:257
bool m3sq
m3sq came out with wrong sign; no REWSB
Definition: physpars.h:87
bool noConvergence
Iteration did not converge: not always serious.
Definition: physpars.h:80
void setPredMzSq(double a)
Set MZ^2 predicted after iteration.
Definition: softsusy.h:273
void setMxBC(double mx)
Sets the scale at which high-scale boundary conditions are applied.
Definition: softsusy.h:259
matrix of complex double values dimensions (rows x cols)
Definition: linalg.h:608
tachyonType tachyon
Definition: physpars.h:81
istream & operator>>(istream &left, flavourPhysical &s)
Formatted input of physical parameters.
Definition: flavoursoft.cpp:1220
Interface to higher loop corrections.
double fEff(double x)
function used for calculating sin theta_eff
Definition: softsusy.cpp:9253
void flagAllProblems(bool a, tachyonType b)
Sets all problems equal to either true or false (contained in a)
Definition: softsusy.h:233
Contains data needed in beta function calculation to make it faster.
Definition: susy.h:31
double gEff(double x)
function used for calculating sin theta_eff
Definition: softsusy.cpp:9260
const sProblem & displayProblem() const
Returns any problem flags associated with the object.
Definition: softsusy.h:165
void flagNotGlobalMin(bool a)
LCT: Flags problem if not in global minimum of Higgs potential.
Definition: softsusy.h:231
void setFracDiff(double fD)
sets fracDiff, needed for access by NmssmSoftsusy methods
Definition: softsusy.h:303
Various boolean values to flag any problems with the parameter point.
Definition: physpars.h:75
double mxBC
Scale at which SUSY breaking boundary conditions set.
Definition: softsusy.h:112
double sw2
Some parameters used in the computation.
Definition: def.cpp:51
void flagM3sq(bool a)
Flags problem with Higgs potential minimum.
Definition: softsusy.h:216
Describes a set of parameters and RGEs in general.
Definition: rge.h:49
void flagHiggsufb(bool a)
Flags an inconsistent Higgs minimum.
Definition: softsusy.h:229
Matrix from 1..rows, 1..cols of double values.
Definition: linalg.h:214
A different REWSB condition - given by mu and MA instead of mh1,2.
Definition: softsusy.h:53
A few handy routines for the MSSM: SUSY breaking conditions etc.
virtual void printObj()
Prints whole object to standard output.
Definition: softsusy.h:1051
Contains two-loop routines from Slavich et al.
DoubleVector mhIntegrand(double mh, const DoubleVector &)
Definition: softsusy.cpp:10696
double displayMu() const
Return renomalisation scale.
Definition: rge.h:67
Flags for potential problems in sProblem structure, and structure for containing physical MSSM parame...
void useAlternativeAlphaS()
Use alernative alpha_s(MSSM,DR-bar) calculation.
Definition: softsusy.h:269
double displayFracDiff() const
Displays iteration accuracy attained.
Definition: softsusy.h:172
void flagNoMuConvergence(bool a)
Flags fact that mu sub iteration didn&#39;t converge.
Definition: softsusy.h:220
void setSoftsusy(const MssmSoftsusy &s)
Sets whole object equal to another.
Definition: softsusy.h:246
void flagMusqwrongsign(bool a)
Flags point inconsistent with electroweak symmetry breaking.
Definition: softsusy.h:224
Soft SUSY breaking parameters.
double m1
decay global variable declarations
Definition: decays.cpp:14
Definition: rge.h:23
Contains all supersymmetric MSSM parameters, incorporating R_p MSSM.
Definition: softsusy.h:72
bool close(double m1, double m2, double tol)
Definition: utils.cpp:68
bool notGlobalMin
Not in global minimum of Higgs potential.
Definition: physpars.h:89
void setSetTbAtMX(bool a)
Sets the setTbAtMX flag.
Definition: softsusy.h:263
double lowOrg(void(*boundaryCondition)(MssmSoftsusy &, const DoubleVector &), double mxGuess, const DoubleVector &pars, int sgnMu, double tanb, const QedQcd &oneset, bool gaugeUnification, bool ewsbBCscale=false)
Definition: softsusy.h:1086
trilinears
SUSY breaking trilinear parameters.
Definition: softpars.h:25
Soft SUSY breaking parameters and beta functions.
Definition: softpars.h:31
void printShortInitialise()
Prints out header line for print-short output.
Definition: softsusy.cpp:1530
MssmSusy beta(sBrevity &) const
Definition: susy.cpp:300
const double accuracy
Approximate accuracy with which 3 body decays are calculated.
Definition: threeBodyDecays.h:38
void flagNonperturbative(bool a)
Flags non-perturbative RG evolution.
Definition: softsusy.h:204
bool higgsUfb
Higgs potential inconsistent with a good minimum.
Definition: physpars.h:88
void useAlternativeEwsb()
Use alernative EWSB conditions: set mu and MA(pole)
Definition: softsusy.h:265
Contains all supersymmetric RPC-MSSM parameters.
Definition: susy.h:218
void flagNoConvergence(bool a)
Flags fact that calculation hasn&#39;t acheived required accuracy.
Definition: softsusy.h:218
double MZ
global pole mass of MZ in GeV - MZCENT is defined in def.h
Definition: def.cpp:31
void flagProblemThrown(bool a)
Flags a numerical exception eg number too big/small.
Definition: softsusy.h:241
void flagNoRhoConvergence(bool a)
Flags fact that rho parameter sub iteration didn&#39;t converge.
Definition: softsusy.h:222
bool noMuConvergence
Definition: physpars.h:91
double lep2Likelihood(double mh)
Fit to LEP2 Standard Model results.
Definition: softsusy.cpp:10685
double lnLHiggs(double mh)
returns the smeared log likelihood coming from LEP2 Higgs mass bounds
Definition: softsusy.cpp:10705
drop-in replacement for the original home-grown Complex class
Definition: mycomplex.h:17