SusyBase.h

// -*- C++ -*-
//
// SusyBase.h is a part of Herwig - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2019 The Herwig Collaboration
//
// Herwig is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef HERWIG_SusyBase_H
#define HERWIG_SusyBase_H
//
// This is the declaration of the SusyBase class.
//
 
#include "Herwig/Models/General/BSMModel.h"
#include "MixingMatrix.h"
#include "ThePEG/Utilities/CFileLineReader.h"
#include "ThePEG/Helicity/Vertex/AbstractVSSVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractSSSVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractVVSSVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractRFSVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractRFVVertex.h"
#include "SusyBase.fh"
 
namespace Herwig {
using namespace ThePEG;
 
  /*@name Some convenient typedefs. */
 
  typedef map<long, double> ParamMap;
 
  typedef map<long,string> StringMap;
 
class SusyBase: public BSMModel {
  
public:
 
  SusyBase();
 
public:
 
  double tanBeta() const { return tanBeta_; }
 
  Energy muParameter() const { return mu_; }
 
  const MixingMatrixPtr & neutralinoMix() const { 
    return NMix_;
  }
 
  const MixingMatrixPtr & charginoUMix() const {
    return UMix_;
  }
 
  const MixingMatrixPtr & charginoVMix() const {
    return VMix_;
  }
 
  const Complex & gluinoPhase() const {return gluinoPhase_;}
 
  bool majoranaNeutrinos() const {return majoranaNeutrinos_;}
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
public:
 
  const Energy & M1() const {return M1_;}
  
  const Energy & M2() const {return M2_;}
 
  const Energy & M3() const {return M3_;}
 
  const Energy2 & Mh12() const {return mH12_;}
 
  const Energy2 & Mh22() const {return mH22_;}
 
  const Energy & MeL() const {return meL_;}
 
  const Energy & MmuL() const {return mmuL_;}
 
  const Energy & MtauL() const {return mtauL_;} 
 
  const Energy & MeR() const {return meR_;}
 
  const Energy & MmuR() const {return mmuR_;}
 
  const Energy & MtauR() const {return mtauR_;} 
 
  const Energy & Mq1L() const {return mq1L_;}
 
  const Energy & Mq2L() const {return mq2L_;}
 
  const Energy & Mq3L() const {return mq3L_;}
 
  const Energy & MdR() const {return mdR_;}
 
  const Energy & MuR() const {return muR_;}
 
  const Energy & MsR() const {return msR_;}
 
  const Energy & McR() const {return mcR_;}
 
  const Energy & MbR() const {return mbR_;}
 
  const Energy & MtR() const {return mtR_;}
 
  const Energy & MPlanck() const {return MPlanck_;}
 
protected:
 
  virtual void readSetup(istream & is);
 
private:
  
  void readBlock(CFileLineReader & ifs,string name,string line,
                 bool stringBlock);
 
  const MixingVector readMatrix(CFileLineReader & ifs, unsigned int & row,
                                unsigned int & col);
 
protected:
 
  virtual void createMixingMatrices();
 
  virtual void extractParameters(bool checkmodel=true);
 
  void createMixingMatrix(MixingMatrixPtr & matrix, string name, 
                          const MixingVector & values,
                          MatrixSize size);
 
  void resetRepositoryMasses();
 
  virtual void adjustMixingMatrix(long id);
 
  const map<string,ParamMap> & parameters() const {
    return parameters_;
  }
 
  const map<string,StringMap> & info() const {
    return info_;
  }
 
  const map<string,pair<MatrixSize,MixingVector> > & mixings() const {
    return mixings_;
  }
 
  void neutralinoMix(MixingMatrixPtr nm) { NMix_ = nm; }
 
  void charginoUMix(MixingMatrixPtr um) { UMix_ = um; }
 
  void charginoVMix(MixingMatrixPtr vm) { VMix_ = vm; }
 
  double findValue(const map<string,ParamMap>::const_iterator pit,
                   int iloc, const string & block,
                   const string & name) {
    ParamMap::const_iterator it = pit->second.find(iloc);
    if(it!=pit->second.end()) {
      return it->second;
    }
    else {
      ostringstream message;
      message << "SusyBase::findValue() Parameter " << name << " = " << iloc 
              << " not found in BLOCK " << block << "\n"; 
      if(generator()) 
        generator()->logWarning( Exception(message.str(), Exception::warning) );
      else
        cerr << message.str();
      return 0.;
    }
  }
  
protected:
 
  virtual IBPtr clone() const;
 
  virtual IBPtr fullclone() const;
 
protected:
 
  virtual void doinit();
 
private:
 
  SusyBase & operator=(const SusyBase &) = delete;
 
private:
 
  bool readFile_;
 
  Energy MPlanck_;
 
  bool gravitino_;
 
  bool majoranaNeutrinos_;
 
  /*
   * Storage of the parameters.
   */
 
  map<string,ParamMap> parameters_;
 
  map<string,StringMap> info_;
 
  map<string,pair<MatrixSize, MixingVector> > mixings_;
 
  double tanBeta_;
 
  Energy mu_;
 
  Energy M1_;
  
  Energy M2_;
 
  Energy M3_;
 
  Energy2 mH12_;
 
  Energy2 mH22_;
 
  Energy meL_;
 
  Energy mmuL_;
 
  Energy mtauL_; 
 
  Energy meR_;
 
  Energy mmuR_;
 
  Energy mtauR_; 
 
  Energy mq1L_;
 
  Energy mq2L_;
 
  Energy mq3L_;
 
  Energy mdR_;
 
  Energy muR_;
 
  Energy msR_;
 
  Energy mcR_;
 
  Energy mbR_;
 
  Energy mtR_;
 
  Complex gluinoPhase_;
 
  MixingMatrixPtr NMix_; 
 
  MixingMatrixPtr UMix_; 
 
  MixingMatrixPtr VMix_; 
 
  AbstractVSSVertexPtr WSFSFVertex_;
  
  AbstractVVSSVertexPtr WWSFSFVertex_;
  
  AbstractFFSVertexPtr NFSFVertex_;
  
  AbstractFFSVertexPtr GFSFVertex_;
 
  AbstractSSSVertexPtr HSFSFVertex_;
 
  AbstractFFSVertexPtr CFSFVertex_;
 
  AbstractVSSVertexPtr GSFSFVertex_;
 
  AbstractVVSSVertexPtr GGSQSQVertex_;
 
  AbstractVVSSVertexPtr WGSQSQVertex_;
 
  AbstractFFVVertexPtr GSGSGVertex_; 
 
  AbstractFFVVertexPtr GNGVertex_;
 
  AbstractFFVVertexPtr NNZVertex_;
 
  AbstractFFVVertexPtr NNPVertex_;
 
  AbstractFFVVertexPtr CCZVertex_;
  
  AbstractFFVVertexPtr CNWVertex_;
 
  AbstractFFSVertexPtr GOGOHVertex_;
  
  AbstractVSSVertexPtr WHHVertex_;
 
  AbstractFFSVertexPtr NCTVertex_;
 
  AbstractRFVVertexPtr GVNVVertex_;
 
  AbstractRFSVertexPtr GVNHVertex_;
 
  AbstractRFSVertexPtr GVFSVertex_;
 
  bool allowedToResetSMMasses_;
};
 
}
 
#endif /* HERWIG_SusyBase_H */