TRadGlobal.h

Go to the documentation of this file.

#ifndef RAD_TRadGlobal
#define RAD_TRadGlobal
 
#include "TConstants.h"
 
class TRadGlobal {
protected:
  double fE;           // Beam energy
  double fs;           // s = 4*E*E
  double fdE;          // soft and virtual photons border absolute units
  double fdE_Rel;      // soft and virtual photons border absolute units
  double fXMin;        // soft and virtual photons border relative units
  double fLnXMin;      // logarithm of previous border
  double fXMax;        // maximum emmited energy
  double fLnXMax;      // logarithm of maximum emitted energy
  double fLnR;         // logarithm of ratio of maximum and mininum
                       // possible emitted energy
  double fMI;          // mass of initial particles
  double fMI2;         // squared mass of initial particles
  double fBetaI;       // velocity of initial particles
  double fGammaI;      // gamma of initial particles
  double fMF;          // mass of final particles
  double fMF2;         // squared mass of final particles
  double fBetaF;       // velocity of final particles
  double fGammaF;      // gamma of initial particles
  double fThetaMin;    // minimum angle we use symmetric angles only
  double fCosThetaMin; // minimum angle we use symmetric angles only
  double fL;           // big logarithm
  double fBeta;        // beta from D-functions
  double fTheta0;      // collinear region
  double fTheta0_Rel;  // collinear region
  double fCosTheta0;   // collinear region
  double fLnD;         // lnd
  double fb;           // D function integral with fXMin upper limit
  double fbRed;        // D function integral with fInfraRedCut upper limit
  double fD0;
  double fCosThetaInt;
  double fThetaInt;      // theta intermediate
  double fInfraRedCut;   //  double fInfraRedNorm;
  double fTotalError;    // total error of cross section
  double fRelativeError; // relative error of each part of cross section
  int    fType;          // process type
 
  std::string fDatadir;
  std::string fVpolFname;
  std::string fIntFname;
 
public:
  TRadGlobal();
  ~TRadGlobal();
  inline double Get_E() { return fE; }
  inline double Get_s() { return fs; }
  inline double Get_de() { return fdE; }
  inline double Get_ThetaMin() { return fThetaMin; }
  inline double Get_CosThetaMin() { return fCosThetaMin; }
  inline double Get_CosThetaInt() { return fCosThetaInt; }
  inline double Get_XMin() { return fXMin; }
  inline double Get_XMax() { return fXMax; }
  inline double Get_LnDelta() { return fLnXMin; }
  inline double Get_LnXMax() { return fLnXMax; }
  inline double Get_LnR() { return fLnR; }
  inline double Get_MI2() { return fMI2; }
  inline double Get_MF2() { return fMF2; }
  inline double Get_BetaF() { return fBetaF; }
  inline double Get_BetaI() { return fBetaI; }
  inline double Get_GammaF() { return fGammaF; }
  inline double Get_GammaI() { return fGammaI; }
  inline double Get_L() { return fL; }
  inline double Get_Beta() { return fBeta; }
  inline double Get_Theta0() { return fTheta0; }
  inline double Get_CosTheta0() { return fCosTheta0; }
  inline double Get_LnD() { return fLnD; }
  inline double Get_b() { return fb; }
  inline double Get_bRed() { return fbRed; }
  inline double Get_bRed( const double& Beta2, const double& D0 ) {
    return pow( fInfraRedCut, Beta2 ) * D0;
  }
  inline double Get_InfraRedCut() { return fInfraRedCut; }
  //  inline double Get_InfraRedNorm(){return fInfraRedNorm;}
  inline double Get_D0() { return fD0; }
  inline double Get_Norm() { return gConst->Alpha2() * gConst->HC2() * 1e7 / Get_s(); }
  inline double Get_TotalError() { return fTotalError; }
  inline double Get_RelativeError() { return fRelativeError; }
 
  inline void Set_E( const double& x ) { fE = x; }
  inline void Set_ThetaMin( const double& x ) { fThetaMin = x; }
  inline void Set_dE_Abs( const double& x ) { fdE = x; }
  inline void Set_dE_Rel( const double& x ) { fdE_Rel = x; }
  inline void Set_Theta0_Abs( const double& x ) { fTheta0 = x; }
  inline void Set_Theta0_Rel( const double& x ) { fTheta0_Rel = x; }
  inline void Set_ThetaInt( const double& x ) { fThetaInt = x; }
  inline void Set_Type( const int x ) { fType = x; }
  inline void Set_InfraRedCut( const double& x ) { fInfraRedCut = x; }
  inline void Set_TotalError( const double& x ) { fTotalError = x; }
  inline void Set_RelativeError( const double& x ) { fRelativeError = x; }
  void        Init(); // commit & initialization of all parameters
  void        Print( void );
  void        Default();
 
  inline void Get_VarPar( const double& y, double& Beta2, double& D0 ) {
    double dL = 2 * log( y );
    Beta2     = gConst->AlphaPi() * ( fL + dL - 1 );
    //    D0   = 1.+3./4.*Beta2-Beta2*Beta2/24.*(gConst->Pi2() + (fL+dL)/3 - 47./8.);
    D0 = 1. + 3. / 4. * Beta2 + Beta2 * Beta2 / 4. * ( 9. / 8. - gConst->Pi2() / 3 );
  }
 
  inline double Get_Var_b( const double& y ) {
    double Beta2, D0;
    Get_VarPar( y, Beta2, D0 );
    return pow( fXMin, Beta2 ) * D0;
  }
 
  void        SetDatadir( std::string dir ) { fDatadir = dir; }
  void        SetVpolFname( std::string fname ) { fVpolFname = fname; }
  void        SetIntFname( std::string fname ) { fIntFname = fname; }
  std::string GetDatadir() { return fDatadir; }
  std::string GetVpolFname() { return fVpolFname; }
  std::string GetIntFname() { return fIntFname; }
};
 
extern TRadGlobal* gGlobal;
 
#endif // #ifndef RAD_TRadGlobal