rpvneut.h

Go to the documentation of this file.

 
#ifndef RPVNEUT_H
#define RPVNEUT_H
 
#include <iostream>
#include <math.h>
#include <cstring>
#include <sstream>
#include <fstream>
#include <vector>
#include "softsusy.h"
#include "linalg.h"
#include "rpvsusypars.h"
#include "lowe.h"
#include "rpvsoft.h"
#include "numerics.h"
 
namespace softsusy {
 
class RpvNeutrino : public RpvSoftsusy {
  DoubleVector physNuMasses;
  DoubleMatrix uPmns;
  DoubleMatrix physNeutMix;
  bool invertedOutput;
  DoubleVector CPEmasses, CPOmasses;
  DoubleMatrix CPEscalars, CPOscalars;
  DoubleMatrix CPEscalarMixing, CPOscalarMixing;
public:  
  RpvNeutrino();
  RpvNeutrino(const RpvNeutrino &);
  const RpvNeutrino & operator = (const RpvNeutrino &);
 
  inline const DoubleVector & displayPhysNuMasses() const { 
    return physNuMasses; 
  }
  inline const DoubleMatrix & displayUpmns() const { return uPmns; }
  inline const DoubleMatrix & displayPhysNeutMix() const { 
    return physNeutMix;  }
  inline bool displayInvertedOutput() const { return invertedOutput; }
  inline const DoubleVector & displayCPEMasses() const { return CPEmasses; }
  inline const DoubleVector & displayCPOMasses() const { return CPOmasses; }
  inline const DoubleMatrix & displayCPEMassSq() const { return CPEscalars; }
  inline const DoubleMatrix & displayCPOMassSq() const { return CPOscalars; }
  inline const DoubleMatrix & displayCPEMix() const { return CPEscalarMixing; }
  inline const DoubleMatrix & displayCPOMix() const { return CPOscalarMixing; }
 
  inline void setInvertedOutput() { invertedOutput = true; }
  inline void setNormalOutput() { invertedOutput = false; }
  inline void setCPEMasses(const DoubleVector & a) { CPEmasses = a; }
  inline void setCPOMasses(const DoubleVector & a) { CPOmasses = a; }
  inline void setCPEMassSq(const DoubleMatrix & a) { CPEscalars = a; }
  inline void setCPOMassSq(const DoubleMatrix & a) { CPOscalars = a; }
  inline void setCPEMix(const DoubleMatrix & a) { CPEscalarMixing = a; }
  inline void setCPOMix(const DoubleMatrix & a) { CPOscalarMixing = a; }
  inline void setUpmns(const DoubleMatrix & a) { uPmns = a; }
 
  DoubleVector calculateSneutrinoVevs(const DoubleVector & sneutrinoVevs, 
                                      double tol, double snuSq, double v1, 
                                      double v2);
        
  DoubleVector calculateSneutrinoTadpoles(double sinthDRbar);
  virtual double doCalcTadpole1oneLoop(double mt, double sinthDRbar);
  virtual double doCalcTadpole2oneLoop(double mt, double sinthDRbar);
        
  void calculateLNVNeutralScalarMassMatrix(double sinthDRbar);
        
  DoubleMatrix calculateLNVSleptonMassMatrix(double sinthDRbar);
  
  DoubleMatrix calculateLNVDownSquarkMassMatrix(double sinthDRbar);
        
  DoubleMatrix calculateLNVUpSquarkMassMatrix(double sinthDRbar);
        
  DoubleMatrix neutrinoSeesaw();
 
  void neutrinoData();
                
  void AnalyticDiagonalise(DoubleMatrix & Mass, DoubleMatrix & MassMix, 
                           DoubleMatrix & MassMix0, DoubleMatrix & MassMix1, 
                           DoubleMatrix & MassMix2);
  void Positivise(DoubleMatrix & A);
  void FermionMassSym(DoubleMatrix & MM, ComplexMatrix & Z, 
                      DoubleVector & MassVector, 
                      DoubleVector & PositiveMassVector, 
                      DoubleVector & SquaredVector, DoubleMatrix & mix);
  void FermionMassAsym(DoubleMatrix & MM, ComplexMatrix & M, 
                       ComplexMatrix & P, DoubleVector & MassVector, 
                       DoubleVector & PositiveMassVector, 
                       DoubleVector & SquaredVector, DoubleMatrix & mixM, 
                       DoubleMatrix & mixP);
  void ScalarMass(DoubleMatrix & MM, ComplexMatrix & Z, 
                  DoubleVector & MassVector, 
                  DoubleVector & PositiveMassVector, 
                  DoubleVector & SquaredVector, DoubleMatrix & mix);
        
  void neutrino(DoubleVector & neutrino, DoubleMatrix & mixMnu, 
                DoubleMatrix & mNeutrino);
 
  void sparticleThresholdCorrections(double tb, const DoubleVector & pars);
  virtual void physical(int accuracy);
  //  virtual void rpvSet(const DoubleVector & parameters) { RpvSoftsusy::rpvSet(parameters); };
 
  virtual void lesHouchesAccordOutput(ostream & out, const char model[], 
                                      const DoubleVector & pars, 
                                      int sgnMu, double tanb, double qMax, 
                                      int numPoints, 
                                      bool ewsbBCscale); 
  void spinfoSLHA(ostream & out);
  void headerSLHA(ostream & out);
  void modselSLHA(ostream & out, const char model[]);
  void massSLHA(ostream & out);
  void inomixingSLHA(ostream & out);
  void rvhmixSLHA(ostream & out); 
  void rvamixSLHA(ostream & out);
  virtual void selmixSLHA(ostream & out);
  virtual void snumixSLHA(ostream & out);
  virtual void hmixSLHA(ostream & out);
  virtual void higgsMSLHA(ostream & out);
  virtual void sleptonsSLHA(ostream & out);
};
 
inline RpvNeutrino::RpvNeutrino()
  : RpvSoftsusy(), physNuMasses(3), uPmns(3, 3), physNeutMix(7, 7), 
    invertedOutput(false), CPEmasses(5), CPOmasses(5), 
    CPEscalars(5, 5), CPOscalars(5, 5), 
    CPEscalarMixing(5, 5), CPOscalarMixing(5, 5) {};
 
inline RpvNeutrino::RpvNeutrino(const RpvNeutrino & s) 
  : RpvSoftsusy(s.displayRpvSoftsusy()), 
    physNuMasses(s.displayPhysNuMasses()),
    uPmns(s.displayUpmns()),
    physNeutMix(s.displayPhysNeutMix()), 
    invertedOutput(s.displayInvertedOutput()), 
    CPEmasses(s.displayCPEMasses()), CPOmasses(s.displayCPOMasses()),
    CPEscalars(s.displayCPEMassSq()), CPOscalars(s.displayCPOMassSq()),
    CPEscalarMixing(s.displayCPEMix()), CPOscalarMixing(s.displayCPOMix())
{};
 
ostream & operator <<(ostream &left, const RpvNeutrino & r);
 
} // namespace softsusy
 
#endif