StandardModelBase.h

// -*- C++ -*-
//
// StandardModelBase.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 Leif Lonnblad
//
// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef ThePEG_StandardModelBase_H
#define ThePEG_StandardModelBase_H
// This is the declaration of the StandardModelBase class.
 
#include "ThePEG/Config/ThePEG.h"
#include "AlphaEMBase.h"
#include "CKMBase.h"
#include "AlphaSBase.h"
// #include "StandardModelBase.fh"
// #include "StandardModelBase.xh"
 
namespace ThePEG {
 
class StandardModelBase: public Interfaced {
 
  typedef Ptr<AlphaEMBase>::pointer AEMPtr;
  typedef Ptr<AlphaSBase>::pointer ASPtr;
  typedef Ptr<CKMBase>::pointer CKMPtr;
  typedef Ptr<AlphaEMBase>::transient_pointer tAEMPtr;
  typedef Ptr<AlphaSBase>::transient_pointer tASPtr;
  typedef Ptr<CKMBase>::transient_pointer tCKMPtr;
 
public:
 
  StandardModelBase();
 
  virtual ~StandardModelBase();
 
public:
 
  unsigned int families() const { return theFamilies; }
 
public:
 
 
  unsigned int ewScheme() const { return theElectroWeakScheme; }
 
  void ewScheme(unsigned int s) { theElectroWeakScheme = s; }
 
 
  double alphaEM() const { return theAlphaEM; }
 
  double alphaEMMZ() const { return theAlphaEMMZ; }
 
  double alphaEMME(Energy2 scale) const {
    if(theElectroWeakScheme==0)
      return alphaEM(scale);
    else if(scale>1e-6*GeV2)
      return theAlphaEMMZ;
    else
      return theAlphaEM;
  }
 
  double alphaEM(Energy2 scale) const {
    return theRunningAlphaEM->value(scale, *this);
  }
 
  tAEMPtr alphaEMPtr() const { return theRunningAlphaEM; }
 
  double sin2ThetaW() const { return theSin2ThetaW; }
 
  InvEnergy2 fermiConstant() const {return theGF;}
 
  double enu() const { return theEnu; }
 
  double ee() const { return theEe; }
 
  double eu() const { return theEu; }
 
  double ed() const { return theEd; }
 
  double vnu() const { return theVnu; }
 
  double ve() const { return theVe; }
 
  double vu() const { return theVu; }
 
  double vd() const { return theVd; }
 
  double anu() const { return theAnu; }
 
  double ae() const { return theAe; }
 
  double au() const { return theAu; }
 
  double ad() const { return theAd; }
 
  tCKMPtr CKM() const { return theCKM; }
 
  double CKM(unsigned int uf, unsigned int df) const;
 
  double CKM(const ParticleData & uType,
                    const ParticleData & dType) const;
 
public:
 
  unsigned int Nc() const { return theNc; }
 
  unsigned int Nf(Energy2 scale) const {
    return theRunningAlphaS->Nf(scale);
  }
 
  double alphaS() const { return theAlphaS; }
 
  double alphaS(Energy2 scale) const {
    return theRunningAlphaS->value(scale, *this);
  }
 
  tASPtr alphaSPtr() const {
    return theRunningAlphaS;
  }
 
  Energy LambdaQCD(unsigned int nflav) const {
    return theRunningAlphaS->LambdaQCD(nflav);
  }
 
  Energy LambdaQCD(Energy2 scale) const { return LambdaQCD(Nf(scale)); }
 
public:
 
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
  virtual bool preInitialize() const {
    return true;
  }
 
protected:
 
  virtual IBPtr clone() const;
 
  virtual IBPtr fullclone() const;
 
 
protected:
 
 
  virtual void doinit();
 
private:
 
  unsigned int theFamilies;
 
  double theAlphaEM;
 
  double theAlphaEMMZ;
 
  AEMPtr theRunningAlphaEM;
 
  double theSin2ThetaW;
 
  InvEnergy2 theGF;
 
  double theEnu;
 
  double theEe;
 
  double theEu;
 
  double theEd;
 
  double theVnu;
 
  double theVe;
 
  double theVu;
 
  double theVd;
 
  double theAnu;
 
  double theAe;
 
  double theAu;
 
  double theAd;
 
  long recalculateEW;
 
  CKMPtr theCKM;
 
  mutable vector< vector<double> > theCKM2Matrix;
 
  unsigned int theNc;
 
  double theAlphaS;
 
  ASPtr theRunningAlphaS;
 
  unsigned int theElectroWeakScheme;
 
  unsigned int theBosonWidthOption;
 
private:
 
  static ClassDescription<StandardModelBase> initStandardModelBase;
 
  StandardModelBase & operator=(const StandardModelBase &) = delete;
 
};
 
template <>
struct BaseClassTrait<StandardModelBase,1>: public ClassTraitsType {
  typedef Interfaced NthBase;
};
 
template <>
struct ClassTraits<StandardModelBase>:
    public ClassTraitsBase<StandardModelBase> {
  static string className() { return "ThePEG::StandardModelBase"; }
};
 
}
 
#endif /* ThePEG_StandardModelBase_H */