rpvsusypars.h

Go to the documentation of this file.

 
#ifndef RPVSUSYPARS_H
#define RPVSUSYPARS_H
 
#include <iostream>
#include <cmath>
#include <fstream>
#include "linalg.h"
#include "tensor.h"
 
namespace softsusy {
 
typedef enum {LU=1, LD, LE} RpvCouplings;
 
class RpvSusyPars {
private:
  Tensor lu, ld, le; 
  DoubleVector kappa; 
  
public:
  RpvSusyPars();
  RpvSusyPars(const RpvSusyPars &);
  RpvSusyPars(const Tensor & hu, const Tensor & hd, const
              Tensor & he, const DoubleVector & d);
 
  const RpvSusyPars & operator=(const RpvSusyPars & s);
 
  virtual ~RpvSusyPars() {};
  
  inline void setLam(int i, int j, int k, double f);
  inline void setLamPrime(int i, int j, int k, double f);
  inline void setLamPrimePrime(int i, int j, int k, double f);
  inline void setKappa(int, double);
  void setLambda(RpvCouplings, int, int, int, double);
  inline void setKappa(const DoubleVector & k) { kappa = k; }
  void setLambda(const RpvCouplings & r, const Tensor & t);
  void set(const DoubleVector & v, int & k);
  void setRpvSusyPars(const RpvSusyPars & s) { *this = s; };
  
  const Tensor & displayLambda(RpvCouplings) const;
  inline const DoubleVector & displayKappa() const { return kappa; }
  inline double displayLam(int i, int j, int k) const;
  inline double displayLamPrime(int i, int j, int k) const;
  inline double displayLamPrimePrime(int i, int j, int k) const;
  inline const RpvSusyPars & displayRpvSusy() const;
  void display(DoubleVector & v, int & k) const;
  void checkOut(double tol) const;
};
 
DoubleVector boundaryCondition(double m0, double m12, double a0, 
                               const RpvSusyPars & r);
 
inline void RpvSusyPars::setKappa(int i, double f) { kappa(i) = f; }
 
inline double RpvSusyPars::displayLam(int i, int j, int k) const
{ return displayLambda(LE).display(k, i, j); }
inline double RpvSusyPars::displayLamPrime(int i, int j, int k) const
{ return displayLambda(LD).display(k, i, j); }
inline double RpvSusyPars::displayLamPrimePrime(int i, int j, int k) const
{ return displayLambda(LU).display(i, j, k); }
inline void RpvSusyPars::setLam(int i, int j, int k, double f) 
{ setLambda(LE, k, i, j, f); }
inline void RpvSusyPars::setLamPrime(int i, int j, int k, double f) 
{ setLambda(LD, k, i, j, f); }
inline void RpvSusyPars::setLamPrimePrime(int i, int j, int k, double f) 
{ setLambda(LU, i, j, k, f); }
 
inline RpvSusyPars::RpvSusyPars(const Tensor & hu, const Tensor & hd, const
                                Tensor & he, const DoubleVector & d) 
  : lu(hu), ld(hd), le(he), kappa(d) {}
 
inline const RpvSusyPars & RpvSusyPars::displayRpvSusy() const { return *this; }
 
ostream & operator << (ostream &, const RpvSusyPars &);
 
class RpvSoftPars {
private:
  DoubleVector mH1lsq; 
  Tensor hur, hdr, her; 
  DoubleVector dr; 
  
public:
  RpvSoftPars(); 
  RpvSoftPars(const RpvSoftPars &);
  RpvSoftPars(const DoubleVector &m, const Tensor & hu, const Tensor & hd,
              const Tensor & he, const DoubleVector & d); 
  virtual ~RpvSoftPars() {};
  const RpvSoftPars & operator=(const RpvSoftPars & s);
  
  inline void setDr(const DoubleVector & V);
  inline void setD(int, double);
  inline void setMh1lSquared(int i, double f) { mH1lsq(i) = f; };
  inline void setMh1lSquared(const DoubleVector & v) { mH1lsq = v; };
  void setHr(RpvCouplings, int, int, int, double);
  void setHr(RpvCouplings, const Tensor &);
  void set(const DoubleVector & v, int & k);
  void setRpvSoftPars(const RpvSoftPars & s) { *this = s; };
  const RpvSoftPars & displayRpvSoft() const { return *this; };
 
  const Tensor & displayHr(RpvCouplings) const;
  inline const DoubleVector & displayMh1lSquared() const { return mH1lsq; }
  inline const DoubleVector & displayDr() const;
  void checkOut(double tol) const;
  
  void display(DoubleVector & v, int & k) const;
};
 
inline void RpvSoftPars::setDr(const DoubleVector & V) { dr = V; }
 
inline void RpvSoftPars::setD(int i, double f) { dr(i) = f; }
 
inline const DoubleVector & RpvSoftPars::displayDr() const { return dr; }
 
inline RpvSoftPars::RpvSoftPars(const DoubleVector & m, const Tensor & hu,
                                const Tensor & hd, const Tensor & he, const
                                DoubleVector & d) 
  : mH1lsq(m), hur(hu), hdr(hd), her(he), dr(d) {}
 
ostream & operator << (ostream &, const RpvSoftPars &);
 
} // namespace softsusy
 
#endif