Geant4  10.03.p03
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4OrlicLiXsModel Class Reference

#include <G4OrlicLiXsModel.hh>

Public Member Functions

 G4OrlicLiXsModel ()
 
virtual ~G4OrlicLiXsModel ()
 
G4double CalculateL1CrossSection (G4int zTarget, G4double energyIncident)
 
G4double CalculateL2CrossSection (G4int zTarget, G4double energyIncident)
 
G4double CalculateL3CrossSection (G4int zTarget, G4double energyIncident)
 

Detailed Description

Definition at line 54 of file G4OrlicLiXsModel.hh.

Constructor & Destructor Documentation

G4OrlicLiXsModel::G4OrlicLiXsModel ( )

Definition at line 52 of file G4OrlicLiXsModel.cc.

53 {
54 
55  transitionManager = G4AtomicTransitionManager::Instance();
56 
57 }
static G4AtomicTransitionManager * Instance()

Here is the call graph for this function:

G4OrlicLiXsModel::~G4OrlicLiXsModel ( )
virtual

Definition at line 59 of file G4OrlicLiXsModel.cc.

60 {
61 
62 }

Member Function Documentation

G4double G4OrlicLiXsModel::CalculateL1CrossSection ( G4int  zTarget,
G4double  energyIncident 
)

Definition at line 70 of file G4OrlicLiXsModel.cc.

72 {
73 
74  if ( /*(energyIncident < 0.1*MeV || energyIncident > 10*MeV) ||*/ zTarget < 41 )//fixed: no control on z!
75 
76  {
77  //G4cout << "WARNING: L1 Cross-Section exist only for ZTarget between 41 and 92, zero returned " << G4endl;
78  //G4cout << "energyIncident(MeV): " << energyIncident/MeV << G4endl;
79  //G4cout << "zTarget: " << zTarget << G4endl;
80  return 0;
81  }
82 
83 
84  /*
85  G4double massIncident;
86  G4Proton* aProtone = G4Proton::Proton();
87  massIncident = aProtone->GetPDGMass();
88  */
89 
90  G4double l1BindingEnergy = transitionManager->Shell(zTarget,1)->BindingEnergy()/keV;
91 // G4double l1BindingEnergy = (transitionManager->Shell(zTarget,1)->BindingEnergy())/keV;
92 
93  G4double lamda = 1836.109; //massIncident/electron_mass_c2;
94 
95  G4double normalizedEnergy = (energyIncident/keV)/(lamda*l1BindingEnergy);
96 
97  G4double x = std::log(normalizedEnergy);
98 
99  G4double a0 = 0.;
100  G4double a1 = 0.;
101  G4double a2 = 0.;
102  G4double a3 = 0.;
103  G4double a4 = 0.;
104  G4double a5 = 0.;
105  G4double a6 = 0.;
106  G4double a7 = 0.;
107  G4double a8 = 0.;
108  G4double a9 = 0.;
109 
110 
111  if ( (zTarget>=41 && zTarget<=50) && (normalizedEnergy>=0.013 && normalizedEnergy<=1) )
112  {
113 
114  //G4cout << "Energy1 (keV) = " << normalizedEnergy * lamda*l1BindingEnergy << G4endl; //debug
115 
116  a0=11.274881;
117  a1=-0.187401;
118  a2=-0.943341;
119  a3=-1.47817;
120  a4=-1.282343;
121  a5=-0.386544;
122  a6=-0.037932;
123  a7=0.;
124  a8=0.;
125  a9=0.;
126  }
127 
128  else if ( (zTarget>=51 && zTarget<=60) && (normalizedEnergy>=0.012 && normalizedEnergy<=0.95))
129  {
130 
131  // G4cout << "Energy2 (keV) = " << normalizedEnergy * lamda*l1BindingEnergy << G4endl; //debug
132 
133  a0=11.242637;
134  a1=-0.162515;
135  a2=1.035774;
136  a3=3.970908;
137  a4=3.968233;
138  a5=1.655714;
139  a6=0.058885;
140  a7=-0.155743;
141  a8=-0.042228;
142  a9=-0.003371;
143  }
144 
145  else if ( (zTarget>=61 && zTarget<=70) && (normalizedEnergy>=0.01 && normalizedEnergy<=0.6) )
146  {
147 
148  // G4cout << "Energy3 (keV) = " << normalizedEnergy * lamda*l1BindingEnergy << G4endl; //debug
149 
150  a0=6.476722;
151  a1=-25.804787;
152  a2=-54.061629;
153  a3=-56.684589;
154  a4=-33.223367;
155  a5=-11.034979;
156  a6=-2.042851;
157  a7=-0.194075;
158  a8=-0.007252;
159  a9=0.;
160  }
161  else if ( (zTarget>=71 && zTarget<=80) && (normalizedEnergy>=0.01 && normalizedEnergy<=0.45) )
162  {
163 
164  // G4cout << "Energy4 (keV) = " << normalizedEnergy * lamda*l1BindingEnergy << G4endl; //debug
165 
166  a0=12.776794;
167  a1=6.562907;
168  a2=10.158703;
169  a3=7.432592;
170  a4=2.332036;
171  a5=0.317946;
172  a6=0.014479;
173  a7=0.;
174  a8=0.;
175  a9=0.;
176  }
177  else if ( (zTarget>=81 && zTarget<=92) && (normalizedEnergy>=0.008 && normalizedEnergy<=0.3) )
178  {
179 
180  // G4cout << "Energy5 (keV) = " << normalizedEnergy * lamda*l1BindingEnergy << G4endl; //debug
181 
182  a0=28.243087;
183  a1=50.199585;
184  a2=58.281684;
185  a3=34.130538;
186  a4=10.268531;
187  a5=1.525302;
188  a6=0.08835;
189  a7=0.;
190  a8=0.;
191  a9=0.;
192  }
193  else {return 0;}
194 
195 
196 G4double analyticalFunction = a0 + (a1*x)+(a2*x*x)+(a3*std::pow(x,3))+(a4*std::pow(x,4))+(a5*std::pow(x,5))+(a6*std::pow(x,6))+
197  (a7*std::pow(x,7))+(a8*std::pow(x,8))+(a9*std::pow(x,9));
198 
199 
200 
201  G4double L1crossSection = G4Exp(analyticalFunction)/(l1BindingEnergy*l1BindingEnergy);
202 
203 
204  if (L1crossSection >= 0) {
205  return L1crossSection * barn;
206  }
207  else {return 0;}
208 
209 }
const G4double a0
tuple x
Definition: test.py:50
G4double BindingEnergy() const
G4double G4Exp(G4double initial_x)
Exponential Function double precision.
Definition: G4Exp.hh:183
double G4double
Definition: G4Types.hh:76
static constexpr double barn
Definition: G4SIunits.hh:105
static constexpr double keV
Definition: G4SIunits.hh:216
G4AtomicShell * Shell(G4int Z, size_t shellIndex) const

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4OrlicLiXsModel::CalculateL2CrossSection ( G4int  zTarget,
G4double  energyIncident 
)

Definition at line 214 of file G4OrlicLiXsModel.cc.

216 {
217 
218 
219  if ( /*(energyIncident < 0.1*MeV || energyIncident > 10*MeV) ||*/zTarget < 41) //fixed: no control on z!)
220 
221  {
222  //G4cout << "WARNING: L2 Cross-Section exist only for ZTarget between 41 and 92, zero returned " << G4endl;
223  // G4cout << "energyIncident(MeV): " << energyIncident/MeV << G4endl;
224  //G4cout << "zTarget: " << zTarget << G4endl;
225  return 0;
226  }
227 
228 
229 
230  G4double massIncident;
231 
232  G4Proton* aProtone = G4Proton::Proton();
233 
234  massIncident = aProtone->GetPDGMass();
235 
236  G4double L2crossSection;
237 
238  G4double l2BindingEnergy = (transitionManager->Shell(zTarget,2)->BindingEnergy())/keV;
239 
240  G4double lamda = massIncident/electron_mass_c2;
241 
242  G4double normalizedEnergy = (energyIncident/keV)/(lamda*l2BindingEnergy);
243 
244  G4double x = std::log(normalizedEnergy);
245 
246  G4double a0 = 0.;
247  G4double a1 = 0.;
248  G4double a2 = 0.;
249  G4double a3 = 0.;
250  G4double a4 = 0.;
251  G4double a5 = 0.;
252 
253  if ( (zTarget>=41 && zTarget<=50) && (normalizedEnergy>=0.015 && normalizedEnergy<=1.5))
254  {
255  a0=11.194798;
256  a1=0.178807;
257  a2=-0.449865;
258  a3=-0.063528;
259  a4=-0.015364;
260  a5=0.;
261  }
262 
263  else if ( (zTarget>=51 && zTarget<=60) && (normalizedEnergy>=0.012 && normalizedEnergy<=1.0))
264  {
265  a0=11.241409;
266  a1=0.149635;
267  a2=-0.633269;
268  a3=-0.17834;
269  a4=-0.034743;
270  a5=0.006474; // a little bit better if this is zero (respect to ecpssr)
271 
272  }
273 
274  else if ( (zTarget>=61 && zTarget<=70) && (normalizedEnergy>=0.01 && normalizedEnergy<=0.65))
275  {
276  a0=11.247424;
277  a1=0.203051;
278  a2=-0.219083;
279  a3=0.164514;
280  a4=0.058692;
281  a5=0.007866;
282  }
283  else if ( (zTarget>=71 && zTarget<=80) && (normalizedEnergy>=0.01 && normalizedEnergy<=0.47))
284  {
285  a0=11.229924;
286  a1=-0.087241;
287  a2=-0.753908;
288  a3=-0.181546;
289  a4=-0.030406;
290  a5=0.;
291  }
292  else if ( (zTarget>=81 && zTarget<=92) && (normalizedEnergy>=0.01 && normalizedEnergy<=0.35))
293  {
294  a0=11.586671;
295  a1=0.730838;
296  a2=-0.056713;
297  a3=0.053262;
298  a4=-0.003672;
299  a5=0.;
300  }
301  else {return 0;}
302 
303  G4double analyticalFunction = a0 + (a1*x)+(a2*x*x)+(a3*std::pow(x,3))+(a4*std::pow(x,4))+(a5*std::pow(x,5));
304 
305 
306  L2crossSection = G4Exp(analyticalFunction)/(l2BindingEnergy*l2BindingEnergy);
307 
308 
309 
310  if (L2crossSection >= 0) {
311  return L2crossSection * barn;
312  }
313  else {return 0;}
314 
315 }
const G4double a0
tuple x
Definition: test.py:50
G4double BindingEnergy() const
static G4Proton * Proton()
Definition: G4Proton.cc:93
float electron_mass_c2
Definition: hepunit.py:274
G4double G4Exp(G4double initial_x)
Exponential Function double precision.
Definition: G4Exp.hh:183
G4double GetPDGMass() const
double G4double
Definition: G4Types.hh:76
static constexpr double barn
Definition: G4SIunits.hh:105
static constexpr double keV
Definition: G4SIunits.hh:216
G4AtomicShell * Shell(G4int Z, size_t shellIndex) const

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4OrlicLiXsModel::CalculateL3CrossSection ( G4int  zTarget,
G4double  energyIncident 
)

Definition at line 320 of file G4OrlicLiXsModel.cc.

322 {
323 
324  if ( /*(energyIncident < 0.1*MeV || energyIncident > 10*MeV) ||*/zTarget < 41) //fixed: no control on z!
325 
326  {
327  //G4cout << "WARNING: L3 Cross-Section exist only for ZTarget between 41 and 92, zero returned " << G4endl;
328  //G4cout << "energyIncident(MeV): " << energyIncident/MeV << G4endl;
329  //G4cout << "zTarget: " << zTarget << G4endl;
330  return 0;
331  }
332 
333  G4double massIncident;
334 
335  G4Proton* aProtone = G4Proton::Proton();
336 
337  massIncident = aProtone->GetPDGMass();
338 
339 
340  G4double L3crossSection;
341 
342  G4double l3BindingEnergy = (transitionManager->Shell(zTarget,3)->BindingEnergy())/keV;
343 
344 
345  G4double lamda = massIncident/electron_mass_c2;
346 
347  G4double normalizedEnergy = (energyIncident/keV)/(lamda*l3BindingEnergy);
348 
349  G4double x = std::log(normalizedEnergy);
350 
351 
352  G4double a0 = 0.;
353  G4double a1 = 0.;
354  G4double a2 = 0.;
355  G4double a3 = 0.;
356  G4double a4 = 0.;
357  G4double a5 = 0.;
358 
359  if ( (zTarget>=41 && zTarget<=50 ) && (normalizedEnergy>=0.015 && normalizedEnergy<=1.5))
360  {
361  a0=11.91837;
362  a1=0.03064;
363  a2=-0.657644;
364  a3=-0.14532;
365  a4=-0.026059;
366  //a5=-0.044735; Correction to Orlic model as explained in
367  //Abdelhwahed H Incerti S and Mantero A 2009 Nucl. Instrum. Meth.B 267 37
368  }
369 
370  else if ( (zTarget>=51 && zTarget<=60 ) && (normalizedEnergy>=0.013 && normalizedEnergy<=1.1))
371  {
372  a0=11.909485;
373  a1=0.15918;
374  a2=-0.588004;
375  a3=-0.159466;
376  a4=-0.033184;
377  }
378 
379  else if ( (zTarget>=61 && zTarget<=70 ) && (normalizedEnergy>=0.01 && normalizedEnergy<=0.67))
380  {
381  a0=11.878472;
382  a1=-0.137007;
383  a2=-0.959475;
384  a3=-0.316505;
385  a4=-0.054154;
386  }
387  else if ( (zTarget>=71 && zTarget<=80 ) && (normalizedEnergy>=0.013 && normalizedEnergy<=0.5))
388  {
389  a0=11.802538;
390  a1=-0.371796;
391  a2=-1.052238;
392  a3=-0.28766;
393  a4=-0.042608;
394  }
395  else if ( (zTarget>=81 && zTarget<=92 ) && (normalizedEnergy>=0.01 && normalizedEnergy<=0.35))
396  {
397  a0=11.423712;
398  a1=-1.428823;
399  a2=-1.946979;
400  a3=-0.585198;
401  a4=-0.076467;
402  }
403  else {return 0;}
404 
405 
406  G4double analyticalFunction = a0 + (a1*x)+(a2*x*x)+(a3*std::pow(x,3))+(a4*std::pow(x,4))+(a5*std::pow(x,5));
407 
408 
409  L3crossSection = G4Exp(analyticalFunction)/(l3BindingEnergy*l3BindingEnergy);
410 
411 
412  if (L3crossSection >= 0) {
413  return L3crossSection * barn;
414  }
415  else {return 0;}
416 
417 
418 }
const G4double a0
tuple x
Definition: test.py:50
G4double BindingEnergy() const
static G4Proton * Proton()
Definition: G4Proton.cc:93
float electron_mass_c2
Definition: hepunit.py:274
G4double G4Exp(G4double initial_x)
Exponential Function double precision.
Definition: G4Exp.hh:183
G4double GetPDGMass() const
double G4double
Definition: G4Types.hh:76
static constexpr double barn
Definition: G4SIunits.hh:105
static constexpr double keV
Definition: G4SIunits.hh:216
G4AtomicShell * Shell(G4int Z, size_t shellIndex) const

Here is the call graph for this function:

Here is the caller graph for this function:


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