nmssmjacobian.h

Go to the documentation of this file.

 
#ifndef NMSSMJACOBIAN_H
#define NMSSMJACOBIAN_H
 
#include "linalg.h"
#include <limits>
#include <utility>
 
namespace softsusy {
 
  class NmssmSoftsusy;
 
  class NmssmJacobian {
  public:
 
    explicit NmssmJacobian(bool doTop = false);
    ~NmssmJacobian();
 
    bool displayIncludeTopFlag() const { return includeTop; }
 
    void setIncludeTopFlag(bool flag) { includeTop = flag; }
 
    bool displayUseRunningMassesFlag() const { return useRunningMasses; }
 
    void setUseRunningMassesFlag(bool flag) { useRunningMasses = flag; }
 
    bool displayUseSugraTrilinearsFlag() const { return useSugraTrilinears; }
 
    void setUseSugraTrilinearsFlag(bool flag) { useSugraTrilinears = flag; }
 
    void resetError() { hasError = false; }
 
    bool displayError() const { return hasError; }
 
    void resetWarnings() {
      failedVevIterationWarning = false;
      inaccurateHiggsMassWarning = false;
    }
 
    bool displayWarning() const {
      return failedVevIterationWarning || inaccurateHiggsMassWarning; }
 
    bool displayFailedVevIterationWarning() const {
      return failedVevIterationWarning;
    }
 
    bool displayInaccurateHiggsMassWarning() const {
      return inaccurateHiggsMassWarning;
    }
 
    double displayWorstCaseHiggsAccuracy() const {
      return worstCaseHiggsAccuracy;
    }
 
    DoubleMatrix displayRGFlowJacobian() const { return jacRGFlow; }
 
    DoubleMatrix displayRGFlowJacobianErrors() const { return jacRGFlowErrors; }
 
    DoubleMatrix displayEWSBJacobian() const { return jacEWSB; }
 
    DoubleMatrix displayEWSBJacobianErrors() const { return jacEWSBErrors; }
 
    DoubleMatrix displayInverseRGFlowJacobian() const { return invJacRGFlow; }
 
    DoubleMatrix displayInverseRGFlowJacobianErrors() const {
      return invJacRGFlowErrors;
    }
 
    DoubleMatrix displayInverseEWSBJacobian() const { return invJacEWSB; }
 
    DoubleMatrix displayInverseEWSBJacobianErrors() const {
      return invJacEWSBErrors;
    }
 
    double calcFTJacobian(const NmssmSoftsusy& m);
 
    double calcFTJacobian(const NmssmSoftsusy& m, double mx);
 
    double calcFTInverseJacobian(const NmssmSoftsusy& m);
 
    double calcFTInverseJacobian(const NmssmSoftsusy& m, double mx);
 
    double calcFTInverseJacobianLogs(const NmssmSoftsusy& m);
 
    double calcFTInverseJacobianLogs(const NmssmSoftsusy& m, double mx);
 
    double calcDeltaJ(const NmssmSoftsusy& m);
 
    double calcDeltaJ(const NmssmSoftsusy& m, double mx);
 
    double calcDeltaJLogs(const NmssmSoftsusy& m);
 
    double calcDeltaJLogs(const NmssmSoftsusy& m, double mx);
 
  private:
    enum Parameters { Mzsq, Tanb, Svev, Mtsq, Lambda, Kappa,
                      SMu, M3Sq, XiS, Mh1Sq, Mh2Sq, MsSq, Yt };
 
    DoubleMatrix jacRGFlow;
    DoubleMatrix jacEWSB;
    DoubleMatrix invJacRGFlow;
    DoubleMatrix invJacEWSB;
 
    DoubleMatrix jacRGFlowErrors;
    DoubleMatrix jacEWSBErrors;
    DoubleMatrix invJacRGFlowErrors;
    DoubleMatrix invJacEWSBErrors;
 
    bool includeTop;
    bool useRunningMasses;
    bool useSugraTrilinears;
    bool hasError;
    bool failedVevIterationWarning;
    bool inaccurateHiggsMassWarning;
 
    double worstCaseHiggsAccuracy;
    
    struct EWSBPars {
      NmssmSoftsusy* model;
      Parameters independent;
      Parameters dependent;
      DoubleVector outputs;
      bool useRunningMasses;
      bool useSugraTrilinears;
      bool failedVevIteration;
      bool inaccurateHiggsMass;
      double higgsMassAccuracy;
 
      EWSBPars()
        : model(0), independent(Mzsq), dependent(Lambda),
          outputs(3), useRunningMasses(false),
          useSugraTrilinears(false), failedVevIteration(false),
          inaccurateHiggsMass(false), higgsMassAccuracy(0.)
        {}
    };
 
    struct RGFlowPars {
      NmssmSoftsusy* model;
      Parameters independent;
      Parameters dependent;
      double toScale;
      bool useSugraTrilinears;
    };
 
    static double calcMz(NmssmSoftsusy& model, bool getRunningMass = false);
    static double calcMt(NmssmSoftsusy& model, bool getRunningMass = false);
 
    static double calcRunningParameter(double x, void* parameters);
    static double calcLogRunningParameter(double x, void* parameters);
    std::pair<double,double> calcRGDerivative(NmssmSoftsusy& model,
                                              Parameters dep, Parameters indep,
                                              double toScale) const;
    std::pair<double,double> calcRGLogDerivative(NmssmSoftsusy& model,
                                                 Parameters dep, Parameters indep,
                                                 double toScale) const;
    double calcRGFlowJacobian(NmssmSoftsusy& model, double startScale,
                              double endScale);
    double calcRGFlowJacobianLogs(NmssmSoftsusy& model, double startScale,
                                  double endScale);
    static int ewsbOutputErrors(const DoubleVector & guess, void* parameters,
                                DoubleVector & errors);
    static void fixEWSBOutputs(EWSBPars* pars, int & err);
    static double calcEWSBParameter(double x, void* parameters);
    static double calcEWSBOutput(double x, void* parameters);
    static double calcLogEWSBOutput(double x, void* parameters);
    std::pair<double,double> calcEWSBOutputDerivative(NmssmSoftsusy& model,
                                                      Parameters dep,
                                                      Parameters indep);
    std::pair<double,double> calcEWSBOutputLogDerivative(NmssmSoftsusy& model,
                                                         Parameters dep,
                                                         Parameters indep);
    std::pair<double,double> calcEWSBParameterDerivative(NmssmSoftsusy& model,
                                                         Parameters dep,
                                                         Parameters indep);
    double calcEWSBJacobian(NmssmSoftsusy& model);
    double calcInverseEWSBJacobian(NmssmSoftsusy& model);
    double calcInverseEWSBJacobianLogs(NmssmSoftsusy& model);
 
    bool checkDerivativeErrors(DoubleMatrix& derivs, const DoubleMatrix& errors,
                               const std::vector<double>& paramValues) const;
  };
 
} 
 
#endif