TPhoton.h

Go to the documentation of this file.

#ifndef RAD_TPhoton
#define RAD_TPhoton
 
#include "TRadGlobal.h"
#include "TRandom.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