Models/StandardModel/StandardModel.h

0001 // -*- C++ -*-
0002 //
0003 // StandardModel.h is a part of Herwig - A multi-purpose Monte Carlo event generator
0004 // Copyright (C) 2002-2019 The Herwig Collaboration
0005 //
0006 // Herwig is licenced under version 3 of the GPL, see COPYING for details.
0007 // Please respect the MCnet academic guidelines, see GUIDELINES for details.
0008 //
0009 #ifndef HERWIG_StandardModel_H
0010 #define HERWIG_StandardModel_H
0011 //
0012 // This is the declaration of the StandardModel class.
0013
0014 #include "ThePEG/StandardModel/StandardModelBase.h"
0015 #include "Herwig/Models/StandardModel/RunningMassBase.h"
0016 #include "ThePEG/Helicity/Vertex/AbstractFFVVertex.h"
0017 #include "ThePEG/Helicity/Vertex/AbstractVVVVertex.h"
0018 #include "ThePEG/Helicity/Vertex/AbstractFFSVertex.h"
0019 #include "ThePEG/Helicity/Vertex/AbstractVVSVertex.h"
0020 #include "ThePEG/Helicity/Vertex/AbstractVVVVVertex.h"
0021 #include "ThePEG/Helicity/Vertex/AbstractSSSVertex.h"
0022 #include "ThePEG/Helicity/Vertex/AbstractVVSSVertex.h"
0023 #include "ThePEG/Helicity/Vertex/AbstractSSSSVertex.h"
0024 #include "Herwig/Models/General/ModelGenerator.fh"
0025 #include "StandardModel.fh"
0026
0027 namespace Herwig {
0028 using namespace ThePEG;
0029 using namespace ThePEG::Helicity;
0030
0031 /** \ingroup Models
0032  *
0033  *  This is the Herwig StandardModel class which inherits from ThePEG
0034  *  Standard Model class and implements additional Standard Model couplings,
0035  *  access to vertices for helicity amplitude calculations etc.
0036  *
0037  *  @see StandardModelBase
0038  */
0039 class StandardModel: public StandardModelBase {
0040
0041   /**
0042    * Some typedefs for the pointers.
0043    */
0044   //@{
0045
0046   /**
0047    * Pointer to the RunningMassBase object
0048    */
0049   typedef Ptr<Herwig::RunningMassBase>::pointer runPtr;
0050
0051   /**
0052    * Transient pointer to the RunningMassBase object
0053    */
0054   typedef Ptr<Herwig::RunningMassBase>::transient_pointer trunPtr;
0055   //@}
0056
0057 public:
0058
0059   /** @name Standard constructors and destructors. */
0060   //@{
0061   /**
0062    * Default constructor
0063    */
0064   StandardModel();
0065
0066   /**
0067    * Copy-constructor.
0068    */
0069   StandardModel(const StandardModel &);
0070
0071   /**
0072    * Destructor
0073    */
0074   virtual ~StandardModel();
0075   //@}
0076
0077 public:
0078
0079   /** @name Functions used by the persistent I/O system. */
0080   //@{
0081   /**
0082    * Function used to write out object persistently.
0083    * @param os the persistent output stream written to.
0084    */
0085   void persistentOutput(PersistentOStream & os) const;
0086
0087   /**
0088    * Function used to read in object persistently.
0089    * @param is the persistent input stream read from.
0090    * @param version the version number of the object when written.
0091    */
0092   void persistentInput(PersistentIStream & is, int version);
0093   //@}
0094
0095   /**
0096    * Standard Init function used to initialize the interfaces.
0097    */
0098   static void Init();
0099
0100 protected:
0101   /**
0102    * Should the default vertices be considered for generic diagrams
0103    */
0104   virtual bool registerDefaultVertices() const { return true; }
0105
0106 public:
0107
0108   /**
0109    * The left and right couplings of the Z^0 including sin and cos theta_W.
0110    */
0111   //@{
0112   /**
0113    *  The left-handed coupling of a neutrino
0114    */
0115   double lnu() const {
0116     return 0.25/sqrt(sin2ThetaW()*(1.-sin2ThetaW()))*(vnu()+anu());
0117   }
0118
0119   /**
0120    *  The left-handed coupling of a charged lepton.
0121    */
0122   double le() const {
0123     return 0.25/sqrt(sin2ThetaW()*(1.-sin2ThetaW()))*(ve()+ae());
0124   }
0125
0126   /**
0127    *  The left-handed coupling of an up type quark.
0128    */
0129   double lu() const {
0130     return 0.25/sqrt(sin2ThetaW()*(1.-sin2ThetaW()))*(vu()+au());
0131   }
0132
0133   /**
0134    *  The left-handed coupling of a down type quark.
0135    */
0136   double ld() const {
0137     return 0.25/sqrt(sin2ThetaW()*(1.-sin2ThetaW()))*(vd()+ad());
0138   }
0139
0140   /**
0141    *  The right-handed coupling of a neutrino
0142    */
0143   double rnu() const {
0144     return 0.25/sqrt(sin2ThetaW()*(1.-sin2ThetaW()))*(vnu()-anu());
0145   }
0146
0147   /**
0148    *  The right-handed coupling of a charged lepton.
0149    */
0150   double re() const {
0151     return 0.25/sqrt(sin2ThetaW()*(1.-sin2ThetaW()))*(ve()-ae());
0152   }
0153
0154   /**
0155    *  The right-handed coupling of an up type quark.
0156    */
0157   double ru() const {
0158     return 0.25/sqrt(sin2ThetaW()*(1.-sin2ThetaW()))*(vu()-au());
0159   }
0160
0161   /**
0162    *  The right-handed coupling of a down type quark.
0163    */
0164   double rd() const {
0165     return 0.25/sqrt(sin2ThetaW()*(1.-sin2ThetaW()))*(vd()-ad());
0166   }
0167   //@}
0168
0169   /**
0170    * Pointers to the objects handling the vertices.
0171    */
0172   //@{
0173   /**
0174    * Pointer to the fermion-fermion-Z vertex
0175    */
0176   virtual tAbstractFFVVertexPtr  vertexFFZ() const {
0177     return FFZVertex_;
0178   }
0179
0180   /**
0181    * Pointer to the fermion-fermion-photon vertex
0182    */
0183   virtual tAbstractFFVVertexPtr  vertexFFP() const {
0184     return FFPVertex_;
0185   }
0186
0187   /**
0188    * Pointer to the fermion-fermion-gluon vertex
0189    */
0190   virtual tAbstractFFVVertexPtr  vertexFFG() const {
0191     return FFGVertex_;
0192   }
0193
0194   /**
0195    * Pointer to the fermion-fermion-W vertex
0196    */
0197   virtual tAbstractFFVVertexPtr  vertexFFW() const {
0198     return FFWVertex_;
0199   }
0200
0201   /**
0202    * Pointer to the fermion-fermion-Higgs vertex
0203    */
0204   virtual tAbstractFFSVertexPtr  vertexFFH() const {
0205     return FFHVertex_;
0206   }
0207
0208   /**
0209    * Pointer to the triple gluon vertex
0210    */
0211   virtual tAbstractVVVVertexPtr  vertexGGG() const {
0212     return GGGVertex_;
0213   }
0214
0215   /**
0216    * Pointer to the triple electroweak gauge boson vertex.
0217    */
0218   virtual tAbstractVVVVertexPtr  vertexWWW() const {
0219     return WWWVertex_;
0220   }
0221
0222   /**
0223    * Pointer to the two electroweak gauge boson Higgs vertex.
0224    */
0225   virtual tAbstractVVSVertexPtr  vertexWWH() const {
0226     return WWHVertex_;
0227   }
0228
0229   /**
0230    * Pointer to the quartic electroweak gauge boson vertex.
0231    */
0232   virtual tAbstractVVVVVertexPtr vertexWWWW() const {
0233     return WWWWVertex_;
0234   }
0235
0236   /**
0237    * Pointer to the quartic gluon vertex
0238    */
0239   virtual tAbstractVVVVVertexPtr vertexGGGG() const {
0240     return GGGGVertex_;
0241   }
0242
0243   /**
0244    * Pointer to the quartic gluon vertex
0245    */
0246   virtual tAbstractVVSVertexPtr vertexHGG() const {
0247     return HGGVertex_;
0248   }
0249
0250   /**
0251    * Pointer to the quartic gluon vertex
0252    */
0253   virtual tAbstractVVSVertexPtr vertexHPP() const {
0254     return HPPVertex_;
0255   }
0256
0257   /**
0258    * Pointer to the triple Higgs vertex
0259    */
0260   virtual tAbstractSSSVertexPtr vertexHHH() const {
0261     return HHHVertex_;
0262   }
0263
0264   /**
0265    * Pointer to the WWHH vertex
0266    */
0267   virtual tAbstractVVSSVertexPtr vertexWWHH() const {
0268     return WWHHVertex_;
0269   }
0270
0271   /**
0272    *  Total number of vertices
0273    */
0274   unsigned int numberOfVertices() const {
0275     return vertexList_.size() + extraVertices_.size();
0276   }
0277
0278   /**
0279    * Access to a vertex from the list
0280    */
0281   tVertexBasePtr vertex(size_t ix) const {
0282     const size_t S = vertexList_.size();
0283     if ( ix < S )
0284       return vertexList_[ix];
0285     else
0286       return extraVertices_[ix - S];
0287   }
0288   //@}
0289
0290   /**
0291    * Return the running mass for a given scale \f$q^2\f$ and particle type.
0292    * @param scale The scale \f$q^2\f$.
0293    * @param part The ParticleData object for the particle
0294    */
0295   Energy mass(Energy2 scale,tcPDPtr part) const {
0296     return runningMass_->value(scale,part);
0297   }
0298
0299   /**
0300    * Return a pointer to the object handling the running mass.
0301    */
0302   trunPtr massPtr() const {
0303     return runningMass_;
0304   }
0305
0306   /**
0307    *  Set the couplings in the model
0308    */
0309   const map<string,pair<unsigned int,int> > & couplings() const {
0310     return couplings_;
0311   }
0312
0313 protected:
0314
0315   /** @name Clone Methods. */
0316   //@{
0317   /**
0318    * Make a simple clone of this object.
0319    * @return a pointer to the new object.
0320    */
0321   virtual IBPtr clone() const;
0322
0323   /** Make a clone of this object, possibly modifying the cloned object
0324    * to make it sane.
0325    * @return a pointer to the new object.
0326    */
0327   virtual IBPtr fullclone() const;
0328   //@}
0329
0330 protected:
0331
0332   /**
0333    * Initialize this object after the setup phase before saving and
0334    * EventGenerator to disk.
0335    * @throws InitException if object could not be initialized properly.
0336    */
0337   virtual void doinit();
0338   //@}
0339
0340 protected:
0341
0342   /**
0343    *  Add a vertex to the list
0344    */
0345   void addVertex(VertexBasePtr in) {
0346     if ( in )
0347       vertexList_.push_back(in);
0348   }
0349
0350   /**
0351    *  Helper function to reset the mass of a ParticleData object
0352    *  in BSM models.
0353    */
0354   void resetMass(long id, Energy mass,tPDPtr particle=tPDPtr());
0355
0356 protected:
0357
0358   /**
0359    *  Set the couplings in the model
0360    */
0361   void setCouplings(string name,pair<unsigned int,int> vals) {
0362     couplings_[name] = vals;
0363   }
0364
0365 private:
0366
0367   /**
0368    * Private and non-existent assignment operator.
0369    */
0370   StandardModel & operator=(const StandardModel &) = delete;
0371
0372 private:
0373
0374   /**
0375    * Pointers to the vertices for Standard Model helicity amplitude
0376    * calculations.
0377    */
0378   //@{
0379   /**
0380    * Pointer to the fermion-fermion-Z vertex
0381    */
0382   AbstractFFVVertexPtr FFZVertex_;
0383
0384   /**
0385    * Pointer to the fermion-fermion-photon vertex
0386    */
0387   AbstractFFVVertexPtr FFPVertex_;
0388
0389   /**
0390    * Pointer to the fermion-fermion-gluon vertex
0391    */
0392   AbstractFFVVertexPtr FFGVertex_;
0393
0394   /**
0395    * Pointer to the fermion-fermion-W vertex
0396    */
0397   AbstractFFVVertexPtr FFWVertex_;
0398
0399   /**
0400    * Pointer to the fermion-fermion-Higgs vertex
0401    */
0402   AbstractFFSVertexPtr FFHVertex_;
0403
0404   /**
0405    * Pointer to the two electroweak gauge boson Higgs vertex.
0406    */
0407   AbstractVVSVertexPtr WWHVertex_;
0408
0409   /**
0410    * Pointer to the triple gluon vertex
0411    */
0412   AbstractVVVVertexPtr GGGVertex_;
0413
0414   /**
0415    * Pointer to the triple electroweak gauge boson vertex.
0416    */
0417   AbstractVVVVertexPtr WWWVertex_;
0418
0419   /**
0420    * Pointer to the quartic gluon vertex
0421    */
0422   AbstractVVVVVertexPtr GGGGVertex_;
0423
0424   /**
0425    * Pointer to the quartic electroweak gauge boson vertex.
0426    */
0427   AbstractVVVVVertexPtr WWWWVertex_;
0428
0429   /**
0430    * Pointer to higgs-gluon-gluon vertex
0431    */
0432   AbstractVVSVertexPtr HGGVertex_;
0433
0434   /**
0435    * Pointer to higgs-gamma-gamma vertex
0436    */
0437   AbstractVVSVertexPtr HPPVertex_;
0438
0439   /**
0440    * Pointer to triple Higgs vertex
0441    */
0442   AbstractSSSVertexPtr HHHVertex_;
0443
0444   /**
0445    * Pointer to  WWHH vertex
0446    */
0447   AbstractVVSSVertexPtr WWHHVertex_;
0448
0449   /**
0450    *  Full list of vertices as a vector to allow searching
0451    */
0452   vector<VertexBasePtr> vertexList_;
0453
0454   /**
0455    * Additional vertices to be considered in automatic ME construction
0456    */
0457   vector<VertexBasePtr> extraVertices_;
0458   //@}
0459
0460   /**
0461    * The running mass.
0462    */
0463   runPtr runningMass_;
0464
0465   /**
0466    * Pointer to ModelGenerator Class
0467    */
0468   ModelGeneratorPtr modelGenerator_;
0469
0470   /**
0471    *  Couplings in the model
0472    */
0473   map<string,pair<unsigned int,int> > couplings_;
0474 };
0475
0476 }
0477
0478 #endif /* HERWIG_StandardModel_H */