StandardModelBase.h

// -*- C++ -*-
//
// StandardModelBase.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2007 Leif Lonnblad
//
// ThePEG is licenced under version 2 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:


  double alphaEM() const { 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();

protected:

  virtual IBPtr clone() const;

  virtual IBPtr fullclone() const;


protected:


  virtual void doinit();

private:

  unsigned int theFamilies;

  double theAlphaEM;

  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;


private:

  static ClassDescription<StandardModelBase> initStandardModelBase;

  StandardModelBase & operator=(const StandardModelBase &);

};

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 */

---