StandardModel.h

// -*- C++ -*-
//
// StandardModel.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_StandardModel_H
#define HERWIG_StandardModel_H
//
// This is the declaration of the StandardModel class.
 
#include "ThePEG/StandardModel/StandardModelBase.h"
#include "Herwig/Models/StandardModel/RunningMassBase.h"
#include "ThePEG/Helicity/Vertex/AbstractFFVVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractVVVVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractFFSVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractVVSVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractVVVVVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractSSSVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractVVSSVertex.h"
#include "ThePEG/Helicity/Vertex/AbstractSSSSVertex.h"
#include "Herwig/Models/General/ModelGenerator.fh"
#include "StandardModel.fh"
 
namespace Herwig {
using namespace ThePEG;
using namespace ThePEG::Helicity;
 
class StandardModel: public StandardModelBase {
  
 
  typedef Ptr<Herwig::RunningMassBase>::pointer runPtr;
 
  typedef Ptr<Herwig::RunningMassBase>::transient_pointer trunPtr;
  
public:
  
  StandardModel();
  
  StandardModel(const StandardModel &);
  
  virtual ~StandardModel();
  
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
  
  static void Init();
 
protected:
  virtual bool registerDefaultVertices() const { return true; }
 
public:
  
  double lnu() const {
    return 0.25/sqrt(sin2ThetaW()*(1.-sin2ThetaW()))*(vnu()+anu());
  }
 
  double le() const {
    return 0.25/sqrt(sin2ThetaW()*(1.-sin2ThetaW()))*(ve()+ae());
  }
 
  double lu() const {
    return 0.25/sqrt(sin2ThetaW()*(1.-sin2ThetaW()))*(vu()+au());
  }
 
  double ld() const {
    return 0.25/sqrt(sin2ThetaW()*(1.-sin2ThetaW()))*(vd()+ad());
  }
 
  double rnu() const {
    return 0.25/sqrt(sin2ThetaW()*(1.-sin2ThetaW()))*(vnu()-anu());
  }
 
  double re() const {
    return 0.25/sqrt(sin2ThetaW()*(1.-sin2ThetaW()))*(ve()-ae());
  }
 
  double ru() const {
    return 0.25/sqrt(sin2ThetaW()*(1.-sin2ThetaW()))*(vu()-au());
  }
 
  double rd() const {
    return 0.25/sqrt(sin2ThetaW()*(1.-sin2ThetaW()))*(vd()-ad());
  }
 
  virtual tAbstractFFVVertexPtr  vertexFFZ() const {
    return FFZVertex_;
  }
 
  virtual tAbstractFFVVertexPtr  vertexFFP() const {
    return FFPVertex_;
  }
 
  virtual tAbstractFFVVertexPtr  vertexFFG() const {
    return FFGVertex_;
  }
  
  virtual tAbstractFFVVertexPtr  vertexFFW() const {
    return FFWVertex_;
  }
 
  virtual tAbstractFFSVertexPtr  vertexFFH() const {
    return FFHVertex_;
  }
 
  virtual tAbstractVVVVertexPtr  vertexGGG() const {
    return GGGVertex_;
  }
  
  virtual tAbstractVVVVertexPtr  vertexWWW() const {
    return WWWVertex_;
  }
 
  virtual tAbstractVVSVertexPtr  vertexWWH() const {
    return WWHVertex_;
  }
 
  virtual tAbstractVVVVVertexPtr vertexWWWW() const {
    return WWWWVertex_;
  }
 
  virtual tAbstractVVVVVertexPtr vertexGGGG() const {
    return GGGGVertex_;
  }
  
  virtual tAbstractVVSVertexPtr vertexHGG() const {
    return HGGVertex_;
  }
 
  virtual tAbstractVVSVertexPtr vertexHPP() const {
    return HPPVertex_;
  }
 
  virtual tAbstractSSSVertexPtr vertexHHH() const {
    return HHHVertex_;
  }
 
  virtual tAbstractVVSSVertexPtr vertexWWHH() const {
    return WWHHVertex_;
  }
 
  unsigned int numberOfVertices() const {
    return vertexList_.size() + extraVertices_.size();
  }
 
  tVertexBasePtr vertex(size_t ix) const {
    const size_t S = vertexList_.size();
    if ( ix < S )
      return vertexList_[ix];
    else
      return extraVertices_[ix - S];
  }
 
  Energy mass(Energy2 scale,tcPDPtr part) const {
    return runningMass_->value(scale,part);
  }
  
  trunPtr massPtr() const {
    return runningMass_;
  }
 
  const map<string,pair<unsigned int,int> > & couplings() const {
    return couplings_;
  }
  
protected:
  
  virtual IBPtr clone() const;
 
  virtual IBPtr fullclone() const;
  
protected:
 
  virtual void doinit();
 
protected:
 
  void addVertex(VertexBasePtr in) {
    if ( in )
      vertexList_.push_back(in);
  }
 
  void resetMass(long id, Energy mass,tPDPtr particle=tPDPtr());
 
protected:
 
  void setCouplings(string name,pair<unsigned int,int> vals) {
    couplings_[name] = vals;
  }
 
private:
  
  StandardModel & operator=(const StandardModel &) = delete;
  
private:
 
  AbstractFFVVertexPtr FFZVertex_;
 
  AbstractFFVVertexPtr FFPVertex_;
 
  AbstractFFVVertexPtr FFGVertex_;
 
  AbstractFFVVertexPtr FFWVertex_;
 
  AbstractFFSVertexPtr FFHVertex_;
 
  AbstractVVSVertexPtr WWHVertex_;
 
  AbstractVVVVertexPtr GGGVertex_;
 
  AbstractVVVVertexPtr WWWVertex_;
 
  AbstractVVVVVertexPtr GGGGVertex_;
 
  AbstractVVVVVertexPtr WWWWVertex_;
 
  AbstractVVSVertexPtr HGGVertex_;
 
  AbstractVVSVertexPtr HPPVertex_; 
 
  AbstractSSSVertexPtr HHHVertex_; 
 
  AbstractVVSSVertexPtr WWHHVertex_; 
  
  vector<VertexBasePtr> vertexList_;
 
  vector<VertexBasePtr> extraVertices_;
 
  runPtr runningMass_;
 
  ModelGeneratorPtr modelGenerator_;
 
  map<string,pair<unsigned int,int> > couplings_;
};
 
}
 
#endif /* HERWIG_StandardModel_H */