EdbPhysics Class Reference

#include <EdbPhys.h>

Inheritance diagram for EdbPhysics:

Collaboration diagram for EdbPhysics:

Public Member Functions
	EdbPhysics ()
virtual	~EdbPhysics ()

Static Public Member Functions
static double	DeAveragePb (float p, float mass, float dx)
static double	DeAveragePbFast (float p, float mass, float dx)
static void	DeAveragePbFastSet (float p, float mass)
static double	DeLandauPb (float p, float mass, float dx)
static float	kX0_Cell ()
static float	kX0_Em ()
static float	kX0_Pb ()
static double	ThetaMCS (float p, float mass, float dx, float x0)
static double	ThetaMS2 (float p, float mass, float dx, float X0)
static double	ThetaPb2 (float p, float mass, float dx)

Constructor & Destructor Documentation

EdbPhysics()

EdbPhysics::EdbPhysics ( )

inline

{}

~EdbPhysics()

virtual EdbPhysics::~EdbPhysics ( )

inlinevirtual

{}

Member Function Documentation

DeAveragePb()

double EdbPhysics::DeAveragePb ( float  p, float  mass, float  dx  )

static

{
  using namespace Pb_CONST;
    if (xmicrons == 0.) return 0.;
    if (pf       <= 0.) return 0.;
    if (massf    <= 0.) return 0.;
    double p=(double)pf;
    double mass=(double)massf;
    double x=TMath::Abs((double)xmicrons/10000.);
    double e=TMath::Sqrt(p*p+mass*mass);
    double beta=p/e;
    double gamma=e/mass;
    double emax=(2.*me*beta*beta*gamma*gamma)/
        (1.+2.*gamma*me/mass+(me/mass)*(me/mass));
    double eta=gamma*beta;
    double eta2=eta*eta;
    double eta4=eta2*eta2;
    double eta6=eta2*eta4;
    double X=TMath::Log(gamma*gamma*beta*beta)/4.606;
 
    double delta;
    if      (X < X0) delta = 0;
    else if (X < X1) delta = 4.606*X+C+aa*TMath::Power((X1-X),mm);
    else         delta = 4.606*X+C;
    double Ce=(0.42237/eta2+0.0304/eta4-0.00038/eta6)*1.E-6*I*I +
          (3.85800/eta2-0.1668/eta4+0.00158/eta6)*1.E-9*I*I*I;
 
    double de_aver=x*ro*(D*Z/(A*beta*beta))*
               (TMath::Log(2.*me*beta*beta*gamma*gamma*emax/(I*I*1.E-18))-
           2.*beta*beta-delta-2.*Ce/Z);
         
    return de_aver;
}

DeAveragePbFast()

double EdbPhysics::DeAveragePbFast ( float  p, float  mass, float  dx  )

static

{
  using namespace Pb_CONST;
    if (pf       <= 0.) return 0.;
    if (massf    <= 0.) return 0.;
    if (xmicrons <= 0.) return 0.;
    double x=TMath::Abs((double)xmicrons/10000.);
    double de_aver=x*eDe_aver_fact;
    return de_aver;
}

DeAveragePbFastSet()

void EdbPhysics::DeAveragePbFastSet ( float  p, float  mass  )

static

{
  using namespace Pb_CONST;
    if (pf       <= 0.) return;
    if (massf    <= 0.) return;
    eP=(double)pf;
    eMass=(double)massf;
    eE=TMath::Sqrt(eP*eP+eMass*eMass);
    eBeta=eP/eE;
    eGamma=eE/eMass;
    eEmax=(2.*me*eBeta*eBeta*eGamma*eGamma)/
        (1.+2.*eGamma*me/eMass+(me/eMass)*(me/eMass));
    eEta=eGamma*eBeta;
    eEta2=eEta*eEta;
    eEta4=eEta2*eEta2;
    eEta6=eEta2*eEta4;
    eX=TMath::Log(eGamma*eGamma*eBeta*eBeta)/4.606;
 
    if      (eX < X0) eDelta = 0;
    else if (eX < X1) eDelta = 4.606*eX+C+aa*TMath::Power((X1-eX),mm);
    else          eDelta = 4.606*eX+C;
    eCe=(0.42237/eEta2+0.0304/eEta4-0.00038/eEta6)*1.E-6*I*I +
    (3.85800/eEta2-0.1668/eEta4+0.00158/eEta6)*1.E-9*I*I*I;
 
    eDe_aver_fact=ro*(D*Z/(A*eBeta*eBeta))*
               (TMath::Log(2.*me*eBeta*eBeta*eGamma*eGamma*eEmax/(I*I*1.E-18))-
           2.*eBeta*eBeta-eDelta-2.*eCe/Z);
         
    return;
}

DeLandauPb()

double EdbPhysics::DeLandauPb ( float  p, float  mass, float  dx  )

static

{
  using namespace Pb_CONST;
  //if (!r)
  //{
  //r=new TRandom();
  //}
    if (xmicrons == 0.) return 0.;
    if (pf       <= 0.) return 0.;
    if (massf    <= 0.) return 0.;
    double p=(double)pf;
    double mass=(double)massf;
    double x=TMath::Abs((double)xmicrons/10000.);
    double e=TMath::Sqrt(p*p+mass*mass);
    double beta=p/e;
    double gamma=e/mass;
    double emax=(2.*me*beta*beta*gamma*gamma)/
        (1.+2.*gamma*me/mass+(me/mass)*(me/mass));
    double eta=gamma*beta;
    double eta2=eta*eta;
    double eta4=eta2*eta2;
    double eta6=eta2*eta4;
    double X=TMath::Log(gamma*gamma*beta*beta)/4.606;
 
    double dzeta=153.4*Z*ro*x/(beta*beta*A)/1000000.; // GeV
    double k=dzeta/emax;
    double delta;
    if      (X < X0) delta = 0;
    else if (X < X1) delta = 4.606*X+C+aa*TMath::Power((X1-X),mm);
    else         delta = 4.606*X+C;
    double Ce=(0.42237/eta2+0.0304/eta4-0.00038/eta6)*1.E-6*I*I +
          (3.85800/eta2-0.1668/eta4+0.00158/eta6)*1.E-9*I*I*I;
 
    double de_aver=x*ro*(D*Z/(A*beta*beta))*
               (TMath::Log(2.*me*beta*beta*gamma*gamma*emax/(I*I*1.E-18))-
           2.*beta*beta-delta-2.*Ce/Z);
         
    double lambda_aver=-geu1-beta*beta-TMath::Log(k);
    double lambda_max=0.60715+1.1934*lambda_aver+(0.67794+0.052382*lambda_aver)
        *TMath::Exp(0.94753+0.74442*lambda_aver);
    double lambda=0.;
    double de;
    for (int i=0;i<100000;i++)
    {
    lambda=gRandom->Landau(0.,1.);
    if (lambda<lambda_max)
    {
        de = de_aver + dzeta*(lambda-geu1+beta*beta+TMath::Log(dzeta/emax));
        return de;
    }
    }
    return 0.;
}

kX0_Cell()

static float EdbPhysics::kX0_Cell ( )

inlinestatic

{ return 5810.;}

kX0_Em()

static float EdbPhysics::kX0_Em ( )

inlinestatic

{ return 286000.;}

kX0_Pb()

static float EdbPhysics::kX0_Pb ( )

inlinestatic

{ return  5600.; }

ThetaMCS()

double EdbPhysics::ThetaMCS ( float  p, float  mass, float  dx, float  x0  )

static

                                                               {
    double radLen=dz/x0;
    double beta=(m>0)?1./TMath::Sqrt(1+m*m/(p*p)):1;
    return 0.0136/(beta*p)*TMath::Sqrt(radLen)*(1+0.038*TMath::Log(radLen));
}

ThetaMS2()

double EdbPhysics::ThetaMS2 ( float  p, float  mass, float  dx, float  X0  )

static

{
  // calculate the square of multiple scattering angle theta (in one projection)
  // after the distance dx [microns] in the media with radiation length X0
 
  double p = pr;
  if (p < 0.001) p = 0.001;
  double k = 0.0136*0.0136;    // [GeV]*[GeV]
  double p2 = p*p;
  double p4 = p2*p2;
  double e2 = mass*mass+p2;
  double dxx = TMath::Abs(dx/X0);
  double fact = 1.+0.0383*TMath::Log(dxx);
  if (fact < 0.01) fact = 0.01;
  double teta2 = k*e2*dxx/p4*fact*fact;
  if (teta2 <= 1.) return teta2;
  else         return 1.;
}

ThetaPb2()

double EdbPhysics::ThetaPb2 ( float  p, float  mass, float  dx  )

static

    { return ThetaMS2(p,mass,dx, kX0_Pb()); }

---

The documentation for this class was generated from the following files:

• src/libEphys/EdbPhys.h
• src/libEphys/EdbPhys.cxx