TPhoton.h

Go to the documentation of this file.

#ifndef RAD_TPhoton
#define RAD_TPhoton
 
#include "TRandom.h"
#include "TRadGlobal.h"
 
class TPhoton{
protected:
  double fNorm; // normalization factor
  double fP0;   // auxilary parameter 0
  double fP1;   // auxilary parameter 1
  double fP2;   // auxilary parameter 2
  double fP3;   // auxilary parameter 3
  double fxmin; // minimum emitted energy
  double fxmax; // maximum emitted energy
  double fX;    // emitted energy
  double fCosTheta; // cosine of photon on a big angle
  double fLnD;  // ln((1-beta*c1)/(1+beta*c1))
  double fBetaI;  // velocity of final particles
  double fiBetaI; // inverse velocity of final particles
  double fLnD_n;  // ln((1-beta*c1)/(1+beta*c1)*(1+beta*c2)/(1-beta*c2))
  double fBt;     // (1+beta*c1)/(1-beta*c1)
  double fLnD_n2; // ln((1-beta*c1)/(1-beta*c2))
  double fBt2;    // (1-beta*c1)
public:
  TPhoton(){Init();};
  virtual ~TPhoton(){};
  virtual void Init(){};
  double GetMinimum(){return fxmin;}
  double GetMaximum(){return fxmax;}
 
  virtual inline double GetCosTheta(){
    double d = exp(fLnD*(2*gRandom->Rndm() - 1));
    fCosTheta = (d - 1)/(fBetaI*(d + 1));
    return fCosTheta;
  }
  virtual inline double GetThNorm(){
    double k = fBetaI*fCosTheta;
    return fLnD*(1 - k*k);
  }
 
  virtual inline double GetCosThetaF(){
    double d = fBt*exp(fLnD_n*gRandom->Rndm());
    fCosTheta = (d - 1)/(fBetaI*(d + 1));
    return fCosTheta;
  }
  virtual inline double GetThNormF(){
    double k = fBetaI*fCosTheta;
    return -0.5*fiBetaI*fLnD_n*(1 - k*k);
  }
 
  virtual inline double GetCosThetaF2(){
    double d = fBt2*exp(fLnD_n2*gRandom->Rndm());
    fCosTheta = (1-d)*fiBetaI;
    return fCosTheta;
  }
  virtual inline double GetThNormF2(){
    double k = fBetaI*fCosTheta;
    return fiBetaI*fLnD_n2*(1 - k);
  }
 
  static double GetPhi(){
    return 2*gRandom->Rndm()*M_PI;
  }
  static double GetPhiNorm(){return 2*M_PI;}
 
  inline double GetPhE(){return fX;}
  inline double GetPhC(){return fCosTheta;}
  virtual inline double GetENorm(){return 1;};
  virtual inline double GetEnergy(){return 0;};
  
  void SetCosTheta(const double& x){fCosTheta = x;}
  void SetEnergy(const double& x){fX = x;}
};
 
// photons in Initial state
// by distribution 1/x/(1-x)
class TPhotonI:public TPhoton{
public:
  TPhotonI():TPhoton(){};
  void Init();
  inline double GetEnergy(){
    double d = fP0*exp(gRandom->Rndm()*fP1);
    fX = d/(1+d);
    return fX;
  }
  inline double GetENorm(){return fNorm*fX*(1-fX);}
};
 
// photons in final state
// by distribution 1/x
class TPhotonF:public TPhoton{
public:
  TPhotonF():TPhoton(){};
  void Init();
  inline double GetEnergy(){
    fX = fP0*exp(gRandom->Rndm()*fP1);
    return fX;
  }
  inline double GetENorm(){return fNorm*fX;}
};
 
 
// photons in final state
// with uniform angle distribution
class TPhotonFS:public TPhotonF{
protected:
  double fCosThetaMin;
public:
  TPhotonFS():TPhotonF(){
    fCosThetaMin = 0.995;
  };
  inline double GetCosTheta(){
    fCosTheta = (2*gRandom->Rndm()-1)*fCosThetaMin;
    return fCosTheta;
  }
  inline double GetThNorm(){
    return 2*fCosThetaMin;
  }  
};
 
 
// soft and virtual photons
// by distribution 1/x^b/2 from 0 to Delta_E
class TPhotonS:public TPhoton{
protected:
  double fP2, fP3;
public:
  TPhotonS():TPhoton(){};
  void Init();
  void Init(const double&, const double&);
  inline double GetEnergy(){return 0;};
  inline void GetEnergy(double &x1, double &x2, double &x3, double &x4){
    double t1 = log(gRandom->Rndm())*fP1;
    x1 = fP0*exp(t1);
 
    double t2 = log(gRandom->Rndm())*fP1;
    x2 = fP0*exp(t2);
 
    double t3 = log(gRandom->Rndm())*fP1;
    x3 = fP0*exp(t3);
 
    double t4 = log(gRandom->Rndm())*fP1;
    x4 = fP0*exp(t4);
 
    fX = t1 + t2 + t3 + t4;
    
  }
  inline double GetENorm(){return fNorm;}
  inline double GetXNorm(){return fP2*exp(fP3*fX);}
  inline double GetX(){return fX;}
};
 
// soft and virtual photons
// by distribution 1/x^b/2 from 0 to Delta_E
class TPhotonD:public TPhoton{
public:
  TPhotonD():TPhoton(){};
  void Init();
  void Init(const double&, const double&);
  inline double GetEnergy(){
    double t1 = log(gRandom->Rndm())*fP1;
    fX = fP0*exp(t1);
    return fX;
  }
  
  inline double GetEnergy(const double &delta, const double &b2){
    fNorm = pow(delta,b2);
    fX    = delta*exp(log(gRandom->Rndm())/b2);
    return fX;
  }
  
  inline double GetENorm(){return fNorm;}
};
 
#endif //#ifndef RAD_TPhoton