G4PolarizedGammaConversionXS Class Reference

#include <G4PolarizedGammaConversionXS.hh>

Inheritance diagram for G4PolarizedGammaConversionXS:

Public Member Functions
	G4PolarizedGammaConversionXS ()
	~G4PolarizedGammaConversionXS () 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
G4PolarizedGammaConversionXS &	operator= (const G4PolarizedGammaConversionXS &right)=delete
	G4PolarizedGammaConversionXS (const G4PolarizedGammaConversionXS &)=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 38 of file G4PolarizedGammaConversionXS.hh.

Constructor & Destructor Documentation

G4PolarizedGammaConversionXS() [1/2]

G4PolarizedGammaConversionXS::G4PolarizedGammaConversionXS

(

)

Definition at line 43 of file G4PolarizedGammaConversionXS.cc.

{
  fFinalElectronPolarization = G4StokesVector::ZERO;
  fFinalPositronPolarization = G4StokesVector::ZERO;
}

Referenced by G4PolarizedGammaConversionXS(), and operator=().

~G4PolarizedGammaConversionXS()

G4PolarizedGammaConversionXS::~G4PolarizedGammaConversionXS ( )

override

Definition at line 49 of file G4PolarizedGammaConversionXS.cc.

{}

G4PolarizedGammaConversionXS() [2/2]

G4PolarizedGammaConversionXS::G4PolarizedGammaConversionXS ( const G4PolarizedGammaConversionXS & )

delete

Member Function Documentation

GetPol2()

G4StokesVector G4PolarizedGammaConversionXS::GetPol2 ( )

overridevirtual

Reimplemented from G4VPolarizedXS.

Definition at line 176 of file G4PolarizedGammaConversionXS.cc.

{
  // electron/positron
  return fFinalElectronPolarization;
}

GetPol3()

G4StokesVector G4PolarizedGammaConversionXS::GetPol3 ( )

overridevirtual

Reimplemented from G4VPolarizedXS.

Definition at line 182 of file G4PolarizedGammaConversionXS.cc.

{
  // photon
  return fFinalPositronPolarization;
}

Initialize()

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

overridevirtual

Implements G4VPolarizedXS.

Definition at line 51 of file G4PolarizedGammaConversionXS.cc.

{
  G4double aLept1E = aGammaE - aLept0E;
 
  G4double Stokes_P3 = beamPol.z();
 
  G4double Lept0E  = aLept0E / CLHEP::electron_mass_c2 + 1.;
  G4double Lept0E2 = Lept0E * Lept0E;
  G4double GammaE  = aGammaE / CLHEP::electron_mass_c2;
  G4double Lept1E  = aLept1E / CLHEP::electron_mass_c2 - 1.;
  G4double Lept1E2 = Lept1E * Lept1E;
 
  // *******  Gamma Transvers 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_Lepton = (Lept0E2 + Lept1E2) * (3 + 2 * GG) +
                      2. * Lept0E * Lept1E * (1. + 4. * u2 * Xsi2 * GG);
 
  G4double L_Lepton1 = GammaE *
                       ((Lept0E - Lept1E) * (3. + 2. * GG) +
                        2 * Lept1E * (1. + 4. * u2 * Xsi2 * GG)) /
                       I_Lepton;
 
  G4double T_Lepton1 =
    4. * GammaE * Lept1E * Xsi * u * (1. - 2. * Xsi) * GG / I_Lepton;
 
  G4double Stokes_S1 = (Stokes_P3 * T_Lepton1);
  G4double Stokes_S2 = 0.;
  G4double Stokes_S3 = (Stokes_P3 * L_Lepton1);
 
  fFinalElectronPolarization.setX(Stokes_S1);
  fFinalElectronPolarization.setY(Stokes_S2);
  fFinalElectronPolarization.setZ(Stokes_S3);
 
  if(fFinalElectronPolarization.mag2() > 1.)
  {
    G4ExceptionDescription ed;
    ed << "\t" << fFinalElectronPolarization << "\t GG\t" << GG << "\t delta\t"
       << delta << "\n";
    G4Exception("G4PolarizedGammaConversionXS::Initialize", "pol022",
                JustWarning, ed);
    fFinalElectronPolarization.setX(0.);
    fFinalElectronPolarization.setY(0.);
    fFinalElectronPolarization.setZ(Stokes_S3);
    if(Stokes_S3 > 1.)
      fFinalElectronPolarization.setZ(1.);
  }
 
  G4double L_Lepton2 = GammaE *
                       ((Lept1E - Lept0E) * (3. + 2. * GG) +
                        2 * Lept0E * (1. + 4. * u2 * Xsi2 * GG)) /
                       I_Lepton;
 
  G4double T_Lepton2 =
    4. * GammaE * Lept0E * Xsi * u * (1. - 2. * Xsi) * GG / I_Lepton;
 
  G4double Stokes_SS1 = (Stokes_P3 * T_Lepton2);
  G4double Stokes_SS2 = 0.;
  G4double Stokes_SS3 = (Stokes_P3 * L_Lepton2);
 
  fFinalPositronPolarization.SetPhoton();
 
  fFinalPositronPolarization.setX(Stokes_SS1);
  fFinalPositronPolarization.setY(Stokes_SS2);
  fFinalPositronPolarization.setZ(Stokes_SS3);
 
  if(fFinalPositronPolarization.mag2() > 1.)
  {
    G4ExceptionDescription ed;
    ed << "\t" << fFinalPositronPolarization << "\t GG\t" << GG << "\t delta\t"
       << delta << "\n";
    G4Exception("G4PolarizedGammaConversionXS::Initialize", "pol023",
                JustWarning, ed);
  }
}

operator=()

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

delete

XSection()

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

overridevirtual

Implements G4VPolarizedXS.

Definition at line 164 of file G4PolarizedGammaConversionXS.cc.

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

---

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

• G4PolarizedGammaConversionXS.hh
• G4PolarizedGammaConversionXS.cc