Geant4-11
Public Member Functions | Protected Member Functions | Protected Attributes | Private Attributes
G4PolarizedIonisationMollerXS Class Reference

#include <G4PolarizedIonisationMollerXS.hh>

Inheritance diagram for G4PolarizedIonisationMollerXS:
G4VPolarizedXS

Public Member Functions

 G4PolarizedIonisationMollerXS ()
 
 G4PolarizedIonisationMollerXS (const G4PolarizedIonisationMollerXS &)=delete
 
G4StokesVector GetPol2 () override
 
G4StokesVector GetPol3 () override
 
virtual G4double GetXmax (G4double y)
 
virtual G4double GetXmin (G4double y)
 
G4double GetYmin ()
 
void Initialize (G4double x, G4double y, G4double phi, const G4StokesVector &p0, const G4StokesVector &p1, G4int flag=0) override
 
G4PolarizedIonisationMollerXS & operator= (const G4PolarizedIonisationMollerXS &right)=delete
 
void SetMaterial (G4double A, G4double Z, G4double coul)
 
G4double TotalXSection (G4double xmin, G4double xmax, G4double y, const G4StokesVector &pol0, const G4StokesVector &pol1) override
 
G4double XSection (const G4StokesVector &pol2, const G4StokesVector &pol3) override
 
 ~G4PolarizedIonisationMollerXS () override
 

Protected Member Functions

void SetXmax (G4double xmax)
 
void SetXmin (G4double xmin)
 
void SetYmin (G4double ymin)
 

Protected Attributes

G4double fA
 
G4double fCoul
 
G4double fXmax
 
G4double fXmin
 
G4double fYmin
 
G4double fZ
 

Private Attributes

G4double fPhi0
 
G4ThreeVector fPhi2
 
G4ThreeVector fPhi3
 

Detailed Description

Definition at line 46 of file G4PolarizedIonisationMollerXS.hh.

Constructor & Destructor Documentation

◆ G4PolarizedIonisationMollerXS() [1/2]

G4PolarizedIonisationMollerXS::G4PolarizedIonisationMollerXS ( )

Definition at line 47 of file G4PolarizedIonisationMollerXS.cc.

48 : fPhi0(0.)
49{
50 SetXmax(.5);
51 fPhi2 = G4ThreeVector(0., 0., 0.);
52 fPhi3 = G4ThreeVector(0., 0., 0.);
53}
G4ThreeVector
CLHEP::Hep3Vector G4ThreeVector
Definition: G4ThreeVector.hh:36
G4VPolarizedXS::SetXmax
void SetXmax(G4double xmax)
Definition: G4VPolarizedXS.hh:84

References fPhi2, fPhi3, and G4VPolarizedXS::SetXmax().

◆ ~G4PolarizedIonisationMollerXS()

G4PolarizedIonisationMollerXS::~G4PolarizedIonisationMollerXS ( )
override

Definition at line 55 of file G4PolarizedIonisationMollerXS.cc.

55{}

◆ G4PolarizedIonisationMollerXS() [2/2]

G4PolarizedIonisationMollerXS::G4PolarizedIonisationMollerXS ( const G4PolarizedIonisationMollerXS &  )
delete

Member Function Documentation

◆ GetPol2()

G4StokesVector G4PolarizedIonisationMollerXS::GetPol2 ( )
overridevirtual

Reimplemented from G4VPolarizedXS.

Definition at line 282 of file G4PolarizedIonisationMollerXS.cc.

283{
284 // Note, mean polarization can not contain correlation effects.
285 return G4StokesVector(1. / fPhi0 * fPhi2);
286}

References fPhi0, and fPhi2.

◆ GetPol3()

G4StokesVector G4PolarizedIonisationMollerXS::GetPol3 ( )
overridevirtual

Reimplemented from G4VPolarizedXS.

Definition at line 287 of file G4PolarizedIonisationMollerXS.cc.

288{
289 // Note, mean polarization can not contain correlation effects.
290 return G4StokesVector(1. / fPhi0 * fPhi3);
291}

References fPhi0, and fPhi3.

◆ GetXmax()

G4double G4VPolarizedXS::GetXmax ( G4double  y)
virtualinherited

Reimplemented in G4PolarizedAnnihilationXS.

Definition at line 84 of file G4VPolarizedXS.cc.

84{ return fXmax; }

References G4VPolarizedXS::fXmax.

◆ GetXmin()

G4double G4VPolarizedXS::GetXmin ( G4double  y)
virtualinherited

Reimplemented in G4PolarizedAnnihilationXS.

Definition at line 81 of file G4VPolarizedXS.cc.

81{ return fXmin; }

References G4VPolarizedXS::fXmin.

◆ GetYmin()

G4double G4VPolarizedXS::GetYmin ( )
inlineinherited

Definition at line 65 of file G4VPolarizedXS.hh.

65{ return fYmin; }

References G4VPolarizedXS::fYmin.

◆ Initialize()

void G4PolarizedIonisationMollerXS::Initialize ( G4double  x,
G4double  y,
G4double  phi,
const G4StokesVector &  p0,
const G4StokesVector &  p1,
G4int  flag = 0 
)
overridevirtual

Implements G4VPolarizedXS.

Definition at line 57 of file G4PolarizedIonisationMollerXS.cc.

62{
63 constexpr G4double re2 = classic_electr_radius * classic_electr_radius;
64 G4double gamma2 = gamma * gamma;
65 G4double gmo = (gamma - 1.);
66 G4double gmo2 = (gamma - 1.) * (gamma - 1.);
67 G4double gpo = (gamma + 1.);
68 G4double pref = gamma2 * re2 / (gmo2 * (gamma + 1.0));
69 constexpr G4double sqrttwo = 1.41421356237309504880; // sqrt(2.)
70 G4double f = (-1. + e);
71 G4double e2 = e * e;
72 G4double f2 = f * f;
73
74 G4bool polarized = (!pol0.IsZero()) || (!pol1.IsZero());
75
76 if(flag == 0)
77 polarized = false;
78 // Unpolarised part of XS
79 fPhi0 = gmo2 / gamma2;
80 fPhi0 += ((1. - 2. * gamma) / gamma2) * (1. / e + 1. / (1. - e));
81 fPhi0 += 1. / (e * e) + 1. / ((1. - e) * (1. - e));
82 fPhi0 *= 0.25;
83 // Initial state polarisarion dependence
84 if(polarized)
85 {
86 G4bool usephi = true;
87 if(flag <= 1)
88 usephi = false;
89 G4double xx = (gamma - f * e * gmo * (3. + gamma)) / (4. * f * e * gamma2);
90 G4double yy = (-1. + f * e * gmo2 + 2. * gamma) / (4. * f * e * gamma2);
91 G4double zz = (-(e * gmo * (3. + gamma)) + e2 * gmo * (3. + gamma) +
92 gamma * (-1. + 2. * gamma)) /
93 (4. * f * e * gamma2);
94
95 fPhi0 += xx * pol0.x() * pol1.x() + yy * pol0.y() * pol1.y() +
96 zz * pol0.z() * pol1.z();
97
98 if(usephi)
99 {
100 G4double xy = 0.;
101 G4double xz = -((-1. + 2. * e) * gmo) /
102 (2. * sqrttwo * gamma2 * std::sqrt(-((f * e) / gpo)));
103 G4double yx = 0.;
104 G4double yz = 0.;
105 G4double zx = -((-1. + 2. * e) * gmo) /
106 (2. * sqrttwo * gamma2 * std::sqrt(-((f * e) / gpo)));
107 G4double zy = 0.;
108 fPhi0 += yx * pol0.y() * pol1.x() + xy * pol0.x() * pol1.y();
109 fPhi0 += zx * pol0.z() * pol1.x() + xz * pol0.x() * pol1.z();
110 fPhi0 += zy * pol0.z() * pol1.y() + yz * pol0.y() * pol1.z();
111 }
112 }
113 // Final state polarisarion dependence
114 fPhi2 = G4ThreeVector();
115 fPhi3 = G4ThreeVector();
116
117 if(flag >= 1)
118 {
119 // Final Electron P1
120 // initial electron K1
121 if(!pol0.IsZero())
122 {
123 G4double xxP1K1 =
124 (std::sqrt(gpo / (1. + e2 * gmo + gamma - 2. * e * gamma)) *
125 (gamma - e * gpo)) /
126 (4. * e2 * gamma);
127 G4double xyP1K1 = 0.;
128 G4double xzP1K1 = (-1. + 2. * e * gamma) /
129 (2. * sqrttwo * f * gamma *
130 std::sqrt(e * e2 * (1. + e + gamma - e * gamma)));
131 G4double yxP1K1 = 0.;
132 G4double yyP1K1 =
133 (-gamma2 + e * (-1. + gamma * (2. + gamma))) / (4. * f * e2 * gamma2);
134 G4double yzP1K1 = 0.;
135 G4double zxP1K1 = (1. + 2. * e2 * gmo - 2. * e * gamma) /
136 (2. * sqrttwo * f * e * gamma *
137 std::sqrt(e * (1. + e + gamma - e * gamma)));
138 G4double zyP1K1 = 0.;
139 G4double zzP1K1 =
140 (-gamma + e * (1. - 2. * e * gmo + gamma)) /
141 (4. * f * e2 * gamma * std::sqrt(1. - (2. * e) / (f * gpo)));
142 fPhi2[0] += xxP1K1 * pol0.x() + xyP1K1 * pol0.y() + xzP1K1 * pol0.z();
143 fPhi2[1] += yxP1K1 * pol0.x() + yyP1K1 * pol0.y() + yzP1K1 * pol0.z();
144 fPhi2[2] += zxP1K1 * pol0.x() + zyP1K1 * pol0.y() + zzP1K1 * pol0.z();
145 }
146 // initial electron K2
147 if(!pol1.IsZero())
148 {
149 G4double xxP1K2 =
150 ((1. + e * (-3. + gamma)) *
151 std::sqrt(gpo / (1. + e2 * gmo + gamma - 2. * e * gamma))) /
152 (4. * f * e * gamma);
153 G4double xyP1K2 = 0.;
154 G4double xzP1K2 =
155 (-2. + 2. * e + gamma) / (2. * sqrttwo * f2 * gamma *
156 std::sqrt(e * (1. + e + gamma - e * gamma)));
157 G4double yxP1K2 = 0.;
158 G4double yyP1K2 = (1. - 2. * gamma + e * (-1. + gamma * (2. + gamma))) /
159 (4. * f2 * e * gamma2);
160 G4double yzP1K2 = 0.;
161 G4double zxP1K2 = (2. * e * (1. + e * gmo - 2. * gamma) + gamma) /
162 (2. * sqrttwo * f2 * gamma *
163 std::sqrt(e * (1. + e + gamma - e * gamma)));
164 G4double zyP1K2 = 0.;
165 G4double zzP1K2 =
166 (1. - 2. * gamma + e * (-1. - 2. * e * gmo + 3. * gamma)) /
167 (4. * f2 * e * gamma * std::sqrt(1. - (2. * e) / (f * gpo)));
168 fPhi2[0] += xxP1K2 * pol1.x() + xyP1K2 * pol1.y() + xzP1K2 * pol1.z();
169 fPhi2[1] += yxP1K2 * pol1.x() + yyP1K2 * pol1.y() + yzP1K2 * pol1.z();
170 fPhi2[2] += zxP1K2 * pol1.x() + zyP1K2 * pol1.y() + zzP1K2 * pol1.z();
171 }
172
173 // Final Electron P2
174 // initial electron K1
175 if(!pol0.IsZero())
176 {
177 G4double xxP2K1 =
178 (-1. + e + e * gamma) /
179 (4. * f2 * gamma * std::sqrt((e * (2. + e * gmo)) / gpo));
180 G4double xyP2K1 = 0.;
181 G4double xzP2K1 =
182 -((1. + 2. * f * gamma) * std::sqrt(f / (-2. + e - e * gamma))) /
183 (2. * sqrttwo * f2 * e * gamma);
184 G4double yxP2K1 = 0.;
185 G4double yyP2K1 = (1. - 2. * gamma + e * (-1. + gamma * (2. + gamma))) /
186 (4. * f2 * e * gamma2);
187 G4double yzP2K1 = 0.;
188 G4double zxP2K1 =
189 (1. + 2. * e * (-2. + e + gamma - e * gamma)) /
190 (2. * sqrttwo * f * e * std::sqrt(-(f * (2. + e * gmo))) * gamma);
191 G4double zyP2K1 = 0.;
192 G4double zzP2K1 =
193 (std::sqrt((e * gpo) / (2. + e * gmo)) *
194 (-3. + e * (5. + 2. * e * gmo - 3. * gamma) + 2. * gamma)) /
195 (4. * f2 * e * gamma);
196
197 fPhi3[0] += xxP2K1 * pol0.x() + xyP2K1 * pol0.y() + xzP2K1 * pol0.z();
198 fPhi3[1] += yxP2K1 * pol0.x() + yyP2K1 * pol0.y() + yzP2K1 * pol0.z();
199 fPhi3[2] += zxP2K1 * pol0.x() + zyP2K1 * pol0.y() + zzP2K1 * pol0.z();
200 }
201 // initial electron K2
202 if(!pol1.IsZero())
203 {
204 G4double xxP2K2 =
205 (-2. - e * (-3. + gamma) + gamma) /
206 (4. * f * e * gamma * std::sqrt((e * (2. + e * gmo)) / gpo));
207 G4double xyP2K2 = 0.;
208 G4double xzP2K2 =
209 ((-2. * e + gamma) * std::sqrt(f / (-2. + e - e * gamma))) /
210 (2. * sqrttwo * f * e2 * gamma);
211 G4double yxP2K2 = 0.;
212 G4double yyP2K2 =
213 (-gamma2 + e * (-1. + gamma * (2. + gamma))) / (4. * f * e2 * gamma2);
214 G4double yzP2K2 = 0.;
215 G4double zxP2K2 =
216 (gamma + 2. * e * (-1. + e - e * gamma)) /
217 (2. * sqrttwo * e2 * std::sqrt(-(f * (2. + e * gmo))) * gamma);
218 G4double zyP2K2 = 0.;
219 G4double zzP2K2 = (std::sqrt((e * gpo) / (2. + e * gmo)) *
220 (-2. + e * (3. + 2. * e * gmo - gamma) + gamma)) /
221 (4. * f * e2 * gamma);
222 fPhi3[0] += xxP2K2 * pol1.x() + xyP2K2 * pol1.y() + xzP2K2 * pol1.z();
223 fPhi3[1] += yxP2K2 * pol1.x() + yyP2K2 * pol1.y() + yzP2K2 * pol1.z();
224 fPhi3[2] += zxP2K2 * pol1.x() + zyP2K2 * pol1.y() + zzP2K2 * pol1.z();
225 }
226 }
227 fPhi0 *= pref;
228 fPhi2 *= pref;
229 fPhi3 *= pref;
230}
e2
static const G4double e2[44]
Definition: G4BarashenkovData.hh:109
G4double
double G4double
Definition: G4Types.hh:83
G4bool
bool G4bool
Definition: G4Types.hh:86
CLHEP::Hep3Vector::x
double x() const
source.hepunit.classic_electr_radius
int classic_electr_radius
Definition: hepunit.py:287

References source.hepunit::classic_electr_radius, e2, fPhi0, fPhi2, fPhi3, G4StokesVector::IsZero(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

◆ operator=()

G4PolarizedIonisationMollerXS & G4PolarizedIonisationMollerXS::operator= ( const G4PolarizedIonisationMollerXS &  right)
delete

◆ SetMaterial()

void G4VPolarizedXS::SetMaterial ( G4double  A,
G4double  Z,
G4double  coul 
)
inlineinherited

Definition at line 71 of file G4VPolarizedXS.hh.

72 {
73 fA = A;
74 fZ = Z;
75 fCoul = coul;
76 }
Z
const G4int Z[17]
Definition: G4WaterStopping.cc:51
A
const G4double A[17]
Definition: G4WaterStopping.cc:53

References A, G4VPolarizedXS::fA, G4VPolarizedXS::fCoul, G4VPolarizedXS::fZ, and Z.

Referenced by G4PolarizedBremsstrahlungModel::SampleSecondaries(), G4PolarizedGammaConversionModel::SampleSecondaries(), and G4PolarizedPhotoElectricModel::SampleSecondaries().

◆ SetXmax()

void G4VPolarizedXS::SetXmax ( G4double  xmax)
inlineprotectedinherited

Definition at line 84 of file G4VPolarizedXS.hh.

84{ fXmax = xmax; }

References G4VPolarizedXS::fXmax.

Referenced by G4PolarizedIonisationMollerXS(), and G4PolarizedIonisationBhabhaXS::Initialize().

◆ SetXmin()

void G4VPolarizedXS::SetXmin ( G4double  xmin)
inlineprotectedinherited

Definition at line 83 of file G4VPolarizedXS.hh.

83{ fXmin = xmin; }

References G4VPolarizedXS::fXmin.

◆ SetYmin()

void G4VPolarizedXS::SetYmin ( G4double  ymin)
inlineprotectedinherited

Definition at line 85 of file G4VPolarizedXS.hh.

85{ fYmin = ymin; }

References G4VPolarizedXS::fYmin.

Referenced by G4PolarizedComptonXS::G4PolarizedComptonXS().

◆ TotalXSection()

G4double G4PolarizedIonisationMollerXS::TotalXSection ( G4double  xmin,
G4double  xmax,
G4double  y,
const G4StokesVector &  pol0,
const G4StokesVector &  pol1 
)
overridevirtual

Reimplemented from G4VPolarizedXS.

Definition at line 245 of file G4PolarizedIonisationMollerXS.cc.

248{
249 G4double xs = 0.;
250 G4double x = xmin;
251
252 if(xmax != 0.5)
253 {
254 G4ExceptionDescription ed;
255 ed << " warning xmax expected to be 1/2 but is " << xmax << "\n";
256 G4Exception("G4PolarizedIonisationMollerXS::TotalXSection", "pol020",
257 JustWarning, ed);
258 }
259
260 constexpr G4double re2 = classic_electr_radius * classic_electr_radius;
261 G4double gamma2 = gamma * gamma;
262 G4double gmo2 = (gamma - 1.) * (gamma - 1.);
263 G4double logMEM = std::log(1. / x - 1.);
264 G4double pref = twopi * gamma2 * re2 / (gmo2 * (gamma + 1.0));
265 // unpolarised XS
266 G4double sigma0 = (gmo2 / gamma2) * (0.5 - x);
267 sigma0 += ((1. - 2. * gamma) / gamma2) * logMEM;
268 sigma0 += 1. / x - 1. / (1. - x);
269 // longitudinal part
270 G4double sigma2 = ((gamma2 + 2. * gamma - 3.) / gamma2) * (0.5 - x);
271 sigma2 += (1. / gamma - 2.) * logMEM;
272 // transverse part
273 G4double sigma3 = (2. * (1. - gamma) / gamma2) * (0.5 - x);
274 sigma3 += (1. - 3. * gamma) / (2. * gamma2) * logMEM;
275 // total cross section
276 xs += pref * (sigma0 + sigma2 * pol0.z() * pol1.z() +
277 sigma3 * (pol0.x() * pol1.x() + pol0.y() * pol1.y()));
278
279 return xs;
280}
JustWarning
@ JustWarning
Definition: G4ExceptionSeverity.hh:65
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition: G4Exception.cc:35
G4ExceptionDescription
std::ostringstream G4ExceptionDescription
Definition: G4Exception.hh:40
twopi
static constexpr double twopi
Definition: G4SIunits.hh:56
CLHEP::Hep3Vector::z
double z() const
CLHEP::Hep3Vector::y
double y() const

References source.hepunit::classic_electr_radius, G4Exception(), JustWarning, twopi, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

◆ XSection()

G4double G4PolarizedIonisationMollerXS::XSection ( const G4StokesVector &  pol2,
const G4StokesVector &  pol3 
)
overridevirtual

Implements G4VPolarizedXS.

Definition at line 232 of file G4PolarizedIonisationMollerXS.cc.

234{
235 G4double xs = fPhi0;
236
237 G4bool polarized = (!pol2.IsZero()) || (!pol3.IsZero());
238 if(polarized)
239 {
240 xs += fPhi2 * pol2 + fPhi3 * pol3;
241 }
242 return xs;
243}
G4StokesVector::IsZero
G4bool IsZero() const
Definition: G4StokesVector.cc:65

References fPhi0, fPhi2, fPhi3, and G4StokesVector::IsZero().

Field Documentation

◆ fA

G4double G4VPolarizedXS::fA
protectedinherited

Definition at line 90 of file G4VPolarizedXS.hh.

Referenced by G4VPolarizedXS::SetMaterial().

◆ fCoul

G4double G4VPolarizedXS::fCoul
protectedinherited

Definition at line 91 of file G4VPolarizedXS.hh.

Referenced by G4PolarizedBremsstrahlungXS::Initialize(), G4PolarizedGammaConversionXS::Initialize(), and G4VPolarizedXS::SetMaterial().

◆ fPhi0

G4double G4PolarizedIonisationMollerXS::fPhi0
private

Definition at line 77 of file G4PolarizedIonisationMollerXS.hh.

Referenced by GetPol2(), GetPol3(), Initialize(), and XSection().

◆ fPhi2

G4ThreeVector G4PolarizedIonisationMollerXS::fPhi2
private

Definition at line 73 of file G4PolarizedIonisationMollerXS.hh.

Referenced by G4PolarizedIonisationMollerXS(), GetPol2(), Initialize(), and XSection().

◆ fPhi3

G4ThreeVector G4PolarizedIonisationMollerXS::fPhi3
private

Definition at line 75 of file G4PolarizedIonisationMollerXS.hh.

Referenced by G4PolarizedIonisationMollerXS(), GetPol3(), Initialize(), and XSection().

◆ fXmax

G4double G4VPolarizedXS::fXmax
protectedinherited

Definition at line 88 of file G4VPolarizedXS.hh.

Referenced by G4VPolarizedXS::GetXmax(), and G4VPolarizedXS::SetXmax().

◆ fXmin

G4double G4VPolarizedXS::fXmin
protectedinherited

Definition at line 88 of file G4VPolarizedXS.hh.

Referenced by G4VPolarizedXS::GetXmin(), and G4VPolarizedXS::SetXmin().

◆ fYmin

G4double G4VPolarizedXS::fYmin
protectedinherited

Definition at line 88 of file G4VPolarizedXS.hh.

Referenced by G4VPolarizedXS::GetYmin(), and G4VPolarizedXS::SetYmin().

◆ fZ

G4double G4VPolarizedXS::fZ
protectedinherited

Definition at line 90 of file G4VPolarizedXS.hh.

Referenced by G4PolarizedBremsstrahlungXS::Initialize(), G4PolarizedGammaConversionXS::Initialize(), G4VPolarizedXS::SetMaterial(), and G4PolarizedComptonXS::TotalXSection().

The documentation for this class was generated from the following files:
Generated by doxygen 1.9.3