G4PolarizedBremsstrahlungXS Class Reference

#include <G4PolarizedBremsstrahlungXS.hh>

Inheritance diagram for G4PolarizedBremsstrahlungXS:

Public Member Functions
	G4PolarizedBremsstrahlungXS ()
	~G4PolarizedBremsstrahlungXS () override
void	Initialize (G4double eps, G4double X, G4double phi, const G4StokesVector &p0, const G4StokesVector &p1, G4int flag=0) override
G4double	XSection (const G4StokesVector &pol2, const G4StokesVector &pol3) override
G4StokesVector	GetPol2 () override
G4StokesVector	GetPol3 () override
G4PolarizedBremsstrahlungXS &	operator= (const G4PolarizedBremsstrahlungXS &right)=delete
	G4PolarizedBremsstrahlungXS (const G4PolarizedBremsstrahlungXS &)=delete
Public Member Functions inherited from G4VPolarizedXS
	G4VPolarizedXS ()
virtual	~G4VPolarizedXS ()
virtual G4double	TotalXSection (G4double xmin, G4double xmax, G4double y, const G4StokesVector &pol0, const G4StokesVector &pol1)
G4double	GetYmin ()
virtual G4double	GetXmin (G4double y)
virtual G4double	GetXmax (G4double y)
void	SetMaterial (G4double A, G4double Z, G4double coul)
G4VPolarizedXS &	operator= (const G4VPolarizedXS &right)=delete
	G4VPolarizedXS (const G4VPolarizedXS &)=delete

Additional Inherited Members
Protected Member Functions inherited from G4VPolarizedXS
void	SetXmin (G4double xmin)
void	SetXmax (G4double xmax)
void	SetYmin (G4double ymin)
Protected Attributes inherited from G4VPolarizedXS
G4double	fXmin
G4double	fXmax
G4double	fYmin
G4double	fA
G4double	fZ
G4double	fCoul

Detailed Description

Definition at line 44 of file G4PolarizedBremsstrahlungXS.hh.

Constructor & Destructor Documentation

G4PolarizedBremsstrahlungXS() [1/2]

G4PolarizedBremsstrahlungXS::G4PolarizedBremsstrahlungXS

(

)

Definition at line 45 of file G4PolarizedBremsstrahlungXS.cc.

{
  fFinalLeptonPolarization = G4StokesVector::ZERO;
  fFinalGammaPolarization  = G4StokesVector::ZERO;
}

~G4PolarizedBremsstrahlungXS()

G4PolarizedBremsstrahlungXS::~G4PolarizedBremsstrahlungXS ( )

override

Definition at line 51 of file G4PolarizedBremsstrahlungXS.cc.

{}

G4PolarizedBremsstrahlungXS() [2/2]

G4PolarizedBremsstrahlungXS::G4PolarizedBremsstrahlungXS ( const G4PolarizedBremsstrahlungXS & )

delete

Member Function Documentation

GetPol2()

G4StokesVector G4PolarizedBremsstrahlungXS::GetPol2 ( )

overridevirtual

Reimplemented from G4VPolarizedXS.

Definition at line 188 of file G4PolarizedBremsstrahlungXS.cc.

{
  // electron/positron
  return fFinalLeptonPolarization;
}

GetPol3()

G4StokesVector G4PolarizedBremsstrahlungXS::GetPol3 ( )

overridevirtual

Reimplemented from G4VPolarizedXS.

Definition at line 194 of file G4PolarizedBremsstrahlungXS.cc.

{
  // photon
  return fFinalGammaPolarization;
}

Initialize()

void G4PolarizedBremsstrahlungXS::Initialize ( G4double eps, G4double X, G4double phi, const G4StokesVector & p0, const G4StokesVector & p1, G4int flag = 0 )

overridevirtual

Implements G4VPolarizedXS.

Definition at line 53 of file G4PolarizedBremsstrahlungXS.cc.

{
  G4double aLept1E = aLept0E - aGammaE;
 
  G4double Stokes_S1 = beamPol.x();
  G4double Stokes_S2 = beamPol.y();
  G4double Stokes_S3 = beamPol.z();
 
  G4double Lept0E  = aLept0E / electron_mass_c2 + 1.;
  G4double Lept0E2 = Lept0E * Lept0E;
  G4double GammaE  = aGammaE / electron_mass_c2;
  G4double GammaE2 = GammaE * GammaE;
  G4double Lept1E  = aLept1E / electron_mass_c2 + 1.;
  G4double Lept1E2 = Lept1E * Lept1E;
 
  // *******  Gamma Transverse Momentum
  G4double TMom = std::sqrt(Lept0E2 - 1.) * sintheta;
  G4double u    = TMom;
  G4double u2   = u * u;
  G4double Xsi  = 1. / (1. + u2);
  G4double Xsi2 = Xsi * Xsi;
 
  G4double delta =
    12. * std::pow(fZ, 1. / 3.) * Lept0E * Lept1E * Xsi / (121. * GammaE);
 
  G4double GG = 0.;
  if(delta < 0.5)
  {
    GG = std::log(2. * Lept0E * Lept1E / GammaE) - 2. - fCoul;
  }
  else if(delta < 120)
  {
    for(G4int j = 1; j < 19; ++j)
    {
      if(SCRN[0][j] >= delta)
      {
        GG = std::log(2 * Lept0E * Lept1E / GammaE) - 2 - fCoul -
             (SCRN[1][j - 1] + (delta - SCRN[0][j - 1]) *
                                 (SCRN[1][j] - SCRN[1][j - 1]) /
                                 (SCRN[0][j] - SCRN[0][j - 1]));
        break;
      }
    }
  }
  else
  {
    G4double alpha_sc = (111. * std::pow(fZ, -1. / 3.)) / Xsi;
    GG                = std::log(alpha_sc) - 2. - fCoul;
  }
 
  if(GG < -1.)
    GG = -1.;
 
  G4double I_Lept = (Lept0E2 + Lept1E2) * (3. + 2. * GG) -
                    2 * Lept0E * Lept1E * (1. + 4. * u2 * Xsi2 * GG);
  G4double F_Lept =
    Lept1E * 4. * GammaE * u * Xsi * (1. - 2 * Xsi) * GG / I_Lept;
  G4double E_Lept =
    Lept0E * 4. * GammaE * u * Xsi * (2. * Xsi - 1.) * GG / I_Lept;
  G4double M_Lept =
    4. * Lept0E * Lept1E * (1. + GG - 2. * Xsi2 * u2 * GG) / I_Lept;
  G4double P_Lept =
    GammaE2 * (1. + 8. * GG * (Xsi - 0.5) * (Xsi - 0.5)) / I_Lept;
 
  G4double Stokes_SS1 = M_Lept * Stokes_S1 + E_Lept * Stokes_S3;
  G4double Stokes_SS2 = M_Lept * Stokes_S2;
  G4double Stokes_SS3 = (M_Lept + P_Lept) * Stokes_S3 + F_Lept * Stokes_S1;
 
  fFinalLeptonPolarization.setX(Stokes_SS1);
  fFinalLeptonPolarization.setY(Stokes_SS2);
  fFinalLeptonPolarization.setZ(Stokes_SS3);
 
  if(fFinalLeptonPolarization.mag2() > 1.)
  {
    G4ExceptionDescription ed;
    ed << " WARNING in pol-brem fFinalLeptonPolarization \n";
    ed << "\t" << fFinalLeptonPolarization << "\t GG\t" << GG << "\t delta\t"
       << delta;
    G4Exception("G4PolarizedBremsstrahlungXS::Initialize", "pol014",
                JustWarning, ed);
    fFinalLeptonPolarization.setX(0);
    fFinalLeptonPolarization.setY(0);
    fFinalLeptonPolarization.setZ(Stokes_SS3);
    if(Stokes_SS3 > 1)
      fFinalLeptonPolarization.setZ(1);
  }
 
  G4double I_Gamma = (Lept0E2 + Lept1E2) * (3. + 2. * GG) -
                     2. * Lept0E * Lept1E * (1. + 4. * u2 * Xsi2 * GG);
  G4double D_Gamma = 8. * Lept0E * Lept1E * u2 * Xsi2 * GG / I_Gamma;
  G4double L_Gamma = GammaE *
                     ((Lept0E + Lept1E) * (3. + 2. * GG) -
                      2. * Lept1E * (1. + 4. * u2 * Xsi2 * GG)) /
                     I_Gamma;
  G4double T_Gamma =
    4. * GammaE * Lept1E * Xsi * u * (2. * Xsi - 1.) * GG / I_Gamma;
 
  G4double Stokes_P1 = D_Gamma;
  G4double Stokes_P2 = 0.;
  G4double Stokes_P3 = (Stokes_S3 * L_Gamma + Stokes_S1 * T_Gamma);
 
  fFinalGammaPolarization.SetPhoton();
 
  fFinalGammaPolarization.setX(Stokes_P1);
  fFinalGammaPolarization.setY(Stokes_P2);
  fFinalGammaPolarization.setZ(Stokes_P3);
 
  if(fFinalGammaPolarization.mag2() > 1.)
  {
    G4ExceptionDescription ed;
    ed << " WARNING in pol-brem fFinalGammaPolarization \n";
    ed << "\t" << fFinalGammaPolarization << "\t GG\t" << GG << "\t delta\t"
       << delta;
    G4Exception("G4PolarizedBremsstrahlungXS::Initialize", "pol015",
                JustWarning, ed);
  }
}

operator=()

G4PolarizedBremsstrahlungXS & G4PolarizedBremsstrahlungXS::operator= ( const G4PolarizedBremsstrahlungXS & right )

delete

XSection()

G4double G4PolarizedBremsstrahlungXS::XSection ( const G4StokesVector & pol2, const G4StokesVector & pol3 )

overridevirtual

Implements G4VPolarizedXS.

Definition at line 175 of file G4PolarizedBremsstrahlungXS.cc.

{
  G4ExceptionDescription ed;
  ed << "ERROR dummy routine G4PolarizedBremsstrahlungXS::XSection "
        "called.\n";
  G4Exception("G4PolarizedBremsstrahlungXS::XSection", "pol016", FatalException,
              ed);
 
  return 0.;
}

---

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

• G4PolarizedBremsstrahlungXS.hh
• G4PolarizedBremsstrahlungXS.cc