Geant4 11.2.2
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Member Functions | List of all members
G4PAIxSection Class Reference

#include <G4PAIxSection.hh>

Public Member Functions

 G4PAIxSection ()
 
 G4PAIxSection (G4MaterialCutsCouple *matCC)
 
 G4PAIxSection (G4int materialIndex, G4double maxEnergyTransfer)
 
 G4PAIxSection (G4int materialIndex, G4double maxEnergyTransfer, G4double betaGammaSq, G4double **photoAbsCof, G4int intNumber)
 
 G4PAIxSection (G4int materialIndex, G4double maxEnergyTransfer, G4double betaGammaSq)
 
 ~G4PAIxSection ()
 
void Initialize (const G4Material *material, G4double maxEnergyTransfer, G4double betaGammaSq, G4SandiaTable *)
 
void ComputeLowEnergyCof (const G4Material *material)
 
void ComputeLowEnergyCof ()
 
void InitPAI ()
 
void NormShift (G4double betaGammaSq)
 
void SplainPAI (G4double betaGammaSq)
 
G4double RutherfordIntegral (G4int intervalNumber, G4double limitLow, G4double limitHigh)
 
G4double ImPartDielectricConst (G4int intervalNumber, G4double energy)
 
G4double GetPhotonRange (G4double energy)
 
G4double GetElectronRange (G4double energy)
 
G4double RePartDielectricConst (G4double energy)
 
G4double DifPAIxSection (G4int intervalNumber, G4double betaGammaSq)
 
G4double PAIdNdxCerenkov (G4int intervalNumber, G4double betaGammaSq)
 
G4double PAIdNdxMM (G4int intervalNumber, G4double betaGammaSq)
 
G4double PAIdNdxPlasmon (G4int intervalNumber, G4double betaGammaSq)
 
G4double PAIdNdxResonance (G4int intervalNumber, G4double betaGammaSq)
 
void IntegralPAIxSection ()
 
void IntegralCerenkov ()
 
void IntegralMM ()
 
void IntegralPlasmon ()
 
void IntegralResonance ()
 
G4double SumOverInterval (G4int intervalNumber)
 
G4double SumOverIntervaldEdx (G4int intervalNumber)
 
G4double SumOverInterCerenkov (G4int intervalNumber)
 
G4double SumOverInterMM (G4int intervalNumber)
 
G4double SumOverInterPlasmon (G4int intervalNumber)
 
G4double SumOverInterResonance (G4int intervalNumber)
 
G4double SumOverBorder (G4int intervalNumber, G4double energy)
 
G4double SumOverBorderdEdx (G4int intervalNumber, G4double energy)
 
G4double SumOverBordCerenkov (G4int intervalNumber, G4double energy)
 
G4double SumOverBordMM (G4int intervalNumber, G4double energy)
 
G4double SumOverBordPlasmon (G4int intervalNumber, G4double energy)
 
G4double SumOverBordResonance (G4int intervalNumber, G4double energy)
 
G4double GetStepEnergyLoss (G4double step)
 
G4double GetStepCerenkovLoss (G4double step)
 
G4double GetStepMMLoss (G4double step)
 
G4double GetStepPlasmonLoss (G4double step)
 
G4double GetStepResonanceLoss (G4double step)
 
G4double GetEnergyTransfer ()
 
G4double GetCerenkovEnergyTransfer ()
 
G4double GetMMEnergyTransfer ()
 
G4double GetPlasmonEnergyTransfer ()
 
G4double GetResonanceEnergyTransfer ()
 
G4double GetRutherfordEnergyTransfer ()
 
G4int GetNumberOfGammas () const
 
G4int GetSplineSize () const
 
G4int GetIntervalNumber () const
 
G4double GetEnergyInterval (G4int i)
 
G4double GetDifPAIxSection (G4int i)
 
G4double GetPAIdNdxCerenkov (G4int i)
 
G4double GetPAIdNdxMM (G4int i)
 
G4double GetPAIdNdxPlasmon (G4int i)
 
G4double GetPAIdNdxResonance (G4int i)
 
G4double GetMeanEnergyLoss () const
 
G4double GetMeanCerenkovLoss () const
 
G4double GetMeanMMLoss () const
 
G4double GetMeanPlasmonLoss () const
 
G4double GetMeanResonanceLoss () const
 
G4double GetNormalizationCof () const
 
G4double GetLowEnergyCof () const
 
G4double GetLorentzFactor (G4int i) const
 
void SetVerbose (G4int v)
 
G4double GetPAItable (G4int i, G4int j) const
 
G4double GetSplineEnergy (G4int i) const
 
G4double GetIntegralPAIxSection (G4int i) const
 
G4double GetIntegralPAIdEdx (G4int i) const
 
G4double GetIntegralCerenkov (G4int i) const
 
G4double GetIntegralMM (G4int i) const
 
G4double GetIntegralPlasmon (G4int i) const
 
G4double GetIntegralResonance (G4int i) const
 
G4PAIxSection & operator= (const G4PAIxSection &right)=delete
 
 G4PAIxSection (const G4PAIxSection &)=delete
 

Detailed Description

Definition at line 64 of file G4PAIxSection.hh.

Constructor & Destructor Documentation

◆ G4PAIxSection() [1/6]

G4PAIxSection::G4PAIxSection ( )

Definition at line 90 of file G4PAIxSection.cc.

91{
92 fSandia = nullptr;
93 fMatSandiaMatrix = nullptr;
94 fDensity = fElectronDensity = fNormalizationCof = fLowEnergyCof = 0.0;
95 fIntervalNumber = fSplineNumber = 0;
96 fVerbose = 0;
97
98 fSplineEnergy = G4DataVector(fMaxSplineSize,0.0);
99 fRePartDielectricConst = G4DataVector(fMaxSplineSize,0.0);
100 fImPartDielectricConst = G4DataVector(fMaxSplineSize,0.0);
101 fIntegralTerm = G4DataVector(fMaxSplineSize,0.0);
102 fDifPAIxSection = G4DataVector(fMaxSplineSize,0.0);
103 fdNdxCerenkov = G4DataVector(fMaxSplineSize,0.0);
104 fdNdxPlasmon = G4DataVector(fMaxSplineSize,0.0);
105 fdNdxMM = G4DataVector(fMaxSplineSize,0.0);
106 fdNdxResonance = G4DataVector(fMaxSplineSize,0.0);
107 fIntegralPAIxSection = G4DataVector(fMaxSplineSize,0.0);
108 fIntegralPAIdEdx = G4DataVector(fMaxSplineSize,0.0);
109 fIntegralCerenkov = G4DataVector(fMaxSplineSize,0.0);
110 fIntegralPlasmon = G4DataVector(fMaxSplineSize,0.0);
111 fIntegralMM = G4DataVector(fMaxSplineSize,0.0);
112 fIntegralResonance = G4DataVector(fMaxSplineSize,0.0);
113
114 fMaterialIndex = 0;
115
116 for( G4int i = 0; i < 500; ++i )
117 {
118 for( G4int j = 0; j < 112; ++j ) fPAItable[i][j] = 0.0;
119 }
120}
G4int
int G4int
Definition G4Types.hh:85

◆ G4PAIxSection() [2/6]

G4PAIxSection::G4PAIxSection ( G4MaterialCutsCouple * matCC)

Definition at line 127 of file G4PAIxSection.cc.

128{
129 fDensity = matCC->GetMaterial()->GetDensity();
130 G4int matIndex = (G4int)matCC->GetMaterial()->GetIndex();
131 fMaterialIndex = matIndex;
132
133 const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
134 fSandia = (*theMaterialTable)[matIndex]->GetSandiaTable();
135
136 fVerbose = 0;
137
138 G4int i, j;
139 fMatSandiaMatrix = new G4OrderedTable();
140
141 for (i = 0; i < fSandia->GetMaxInterval()-1; ++i)
142 {
143 fMatSandiaMatrix->push_back(new G4DataVector(5,0.));
144 }
145 for (i = 0; i < fSandia->GetMaxInterval()-1; ++i)
146 {
147 (*(*fMatSandiaMatrix)[i])[0] = fSandia->GetSandiaMatTable(i,0);
148
149 for(j = 1; j < 5; ++j)
150 {
151 (*(*fMatSandiaMatrix)[i])[j] = fSandia->GetSandiaMatTable(i,j)*fDensity;
152 }
153 }
154 ComputeLowEnergyCof();
155 // fEnergyInterval = fA1 = fA2 = fA3 = fA4 = 0;
156}
G4MaterialTable
std::vector< G4Material * > G4MaterialTable
Definition G4MaterialTable.hh:33
G4MaterialCutsCouple::GetMaterial
const G4Material * GetMaterial() const
Definition G4MaterialCutsCouple.hh:166
G4Material::GetDensity
G4double GetDensity() const
Definition G4Material.hh:174
G4Material::GetIndex
std::size_t GetIndex() const
Definition G4Material.hh:239
G4Material::GetMaterialTable
static G4MaterialTable * GetMaterialTable()
Definition G4Material.cc:645
G4PAIxSection::ComputeLowEnergyCof
void ComputeLowEnergyCof()
Definition G4PAIxSection.cc:779
G4SandiaTable::GetMaxInterval
G4int GetMaxInterval() const
Definition G4SandiaTable.cc:650
G4SandiaTable::GetSandiaMatTable
G4double GetSandiaMatTable(G4int, G4int) const
Definition G4SandiaTable.cc:932

◆ G4PAIxSection() [3/6]

G4PAIxSection::G4PAIxSection ( G4int materialIndex,
G4double maxEnergyTransfer )

Definition at line 160 of file G4PAIxSection.cc.

162{
163 fSandia = nullptr;
164 fMatSandiaMatrix = nullptr;
165 fVerbose = 0;
166 const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
167 G4int i, j;
168
169 fMaterialIndex = materialIndex;
170 fDensity = (*theMaterialTable)[materialIndex]->GetDensity();
171 fElectronDensity = (*theMaterialTable)[materialIndex]->
172 GetElectronDensity();
173 fIntervalNumber = (*theMaterialTable)[materialIndex]->
174 GetSandiaTable()->GetMatNbOfIntervals();
175 fIntervalNumber--;
176 // G4cout<<fDensity<<"\t"<<fElectronDensity<<"\t"<<fIntervalNumber<<G4endl;
177
178 fEnergyInterval = G4DataVector(fIntervalNumber+2,0.0);
179 fA1 = G4DataVector(fIntervalNumber+2,0.0);
180 fA2 = G4DataVector(fIntervalNumber+2,0.0);
181 fA3 = G4DataVector(fIntervalNumber+2,0.0);
182 fA4 = G4DataVector(fIntervalNumber+2,0.0);
183
184 for(i = 1; i <= fIntervalNumber; i++ )
185 {
186 if(((*theMaterialTable)[materialIndex]->
187 GetSandiaTable()->GetSandiaCofForMaterial(i-1,0) >= maxEnergyTransfer) ||
188 i > fIntervalNumber )
189 {
190 fEnergyInterval[i] = maxEnergyTransfer;
191 fIntervalNumber = i;
192 break;
193 }
194 fEnergyInterval[i] = (*theMaterialTable)[materialIndex]->
195 GetSandiaTable()->GetSandiaCofForMaterial(i-1,0);
196 fA1[i] = (*theMaterialTable)[materialIndex]->
197 GetSandiaTable()->GetSandiaCofForMaterial(i-1,1);
198 fA2[i] = (*theMaterialTable)[materialIndex]->
199 GetSandiaTable()->GetSandiaCofForMaterial(i-1,2);
200 fA3[i] = (*theMaterialTable)[materialIndex]->
201 GetSandiaTable()->GetSandiaCofForMaterial(i-1,3);
202 fA4[i] = (*theMaterialTable)[materialIndex]->
203 GetSandiaTable()->GetSandiaCofForMaterial(i-1,4);
204 // G4cout<<i<<"\t"<<fEnergyInterval[i]<<"\t"<<fA1[i]<<"\t"<<fA2[i]<<"\t"
205 // <<fA3[i]<<"\t"<<fA4[i]<<"\t"<<G4endl;
206 }
207 if(fEnergyInterval[fIntervalNumber] != maxEnergyTransfer)
208 {
209 fIntervalNumber++;
210 fEnergyInterval[fIntervalNumber] = maxEnergyTransfer;
211 }
212
213 // Now checking, if two borders are too close together
214
215 for(i=1;i<fIntervalNumber;i++)
216 {
217 if(fEnergyInterval[i+1]-fEnergyInterval[i] >
218 1.5*fDelta*(fEnergyInterval[i+1]+fEnergyInterval[i]))
219 {
220 continue;
221 }
222 else
223 {
224 for(j=i;j<fIntervalNumber;j++)
225 {
226 fEnergyInterval[j] = fEnergyInterval[j+1];
227 fA1[j] = fA1[j+1];
228 fA2[j] = fA2[j+1];
229 fA3[j] = fA3[j+1];
230 fA4[j] = fA4[j+1];
231 }
232 fIntervalNumber--;
233 i--;
234 }
235 }
236
237
238 /* *********************************
239
240 fSplineEnergy = new G4double[fMaxSplineSize];
241 fRePartDielectricConst = new G4double[fMaxSplineSize];
242 fImPartDielectricConst = new G4double[fMaxSplineSize];
243 fIntegralTerm = new G4double[fMaxSplineSize];
244 fDifPAIxSection = new G4double[fMaxSplineSize];
245 fIntegralPAIxSection = new G4double[fMaxSplineSize];
246
247 for(i=0;i<fMaxSplineSize;i++)
248 {
249 fSplineEnergy[i] = 0.0;
250 fRePartDielectricConst[i] = 0.0;
251 fImPartDielectricConst[i] = 0.0;
252 fIntegralTerm[i] = 0.0;
253 fDifPAIxSection[i] = 0.0;
254 fIntegralPAIxSection[i] = 0.0;
255 }
256 ************************************************** */
257 ComputeLowEnergyCof();
258 InitPAI(); // create arrays allocated above
259 /*
260 delete[] fEnergyInterval;
261 delete[] fA1;
262 delete[] fA2;
263 delete[] fA3;
264 delete[] fA4;
265 */
266}

◆ G4PAIxSection() [4/6]

G4PAIxSection::G4PAIxSection ( G4int materialIndex,
G4double maxEnergyTransfer,
G4double betaGammaSq,
G4double ** photoAbsCof,
G4int intNumber )

Definition at line 272 of file G4PAIxSection.cc.

277{
278 fSandia = nullptr;
279 fDensity = fElectronDensity = fNormalizationCof = fLowEnergyCof = 0.0;
280 fIntervalNumber = fSplineNumber = 0;
281 fVerbose = 0;
282
283 fSplineEnergy = G4DataVector(500,0.0);
284 fRePartDielectricConst = G4DataVector(500,0.0);
285 fImPartDielectricConst = G4DataVector(500,0.0);
286 fIntegralTerm = G4DataVector(500,0.0);
287 fDifPAIxSection = G4DataVector(500,0.0);
288 fdNdxCerenkov = G4DataVector(500,0.0);
289 fdNdxPlasmon = G4DataVector(500,0.0);
290 fdNdxMM = G4DataVector(500,0.0);
291 fdNdxResonance = G4DataVector(500,0.0);
292 fIntegralPAIxSection = G4DataVector(500,0.0);
293 fIntegralPAIdEdx = G4DataVector(500,0.0);
294 fIntegralCerenkov = G4DataVector(500,0.0);
295 fIntegralPlasmon = G4DataVector(500,0.0);
296 fIntegralMM = G4DataVector(500,0.0);
297 fIntegralResonance = G4DataVector(500,0.0);
298
299 for( G4int i = 0; i < 500; ++i )
300 {
301 for( G4int j = 0; j < 112; ++j ) fPAItable[i][j] = 0.0;
302 }
303
304 fSandia = nullptr;
305 fMatSandiaMatrix = nullptr;
306 const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
307 G4int i, j;
308
309 fMaterialIndex = materialIndex;
310 fDensity = (*theMaterialTable)[materialIndex]->GetDensity();
311 fElectronDensity = (*theMaterialTable)[materialIndex]->GetElectronDensity();
312
313 fIntervalNumber = intNumber;
314 fIntervalNumber--;
315 // G4cout<<fDensity<<"\t"<<fElectronDensity<<"\t"<<fIntervalNumber<<G4endl;
316
317 fEnergyInterval = G4DataVector(fIntervalNumber+2,0.0);
318 fA1 = G4DataVector(fIntervalNumber+2,0.0);
319 fA2 = G4DataVector(fIntervalNumber+2,0.0);
320 fA3 = G4DataVector(fIntervalNumber+2,0.0);
321 fA4 = G4DataVector(fIntervalNumber+2,0.0);
322
323
324 /*
325 fEnergyInterval = new G4double[fIntervalNumber+2];
326 fA1 = new G4double[fIntervalNumber+2];
327 fA2 = new G4double[fIntervalNumber+2];
328 fA3 = new G4double[fIntervalNumber+2];
329 fA4 = new G4double[fIntervalNumber+2];
330 */
331 for( i = 1; i <= fIntervalNumber; i++ )
332 {
333 if( ( photoAbsCof[i-1][0] >= maxEnergyTransfer ) ||
334 i > fIntervalNumber )
335 {
336 fEnergyInterval[i] = maxEnergyTransfer;
337 fIntervalNumber = i;
338 break;
339 }
340 fEnergyInterval[i] = photoAbsCof[i-1][0];
341 fA1[i] = photoAbsCof[i-1][1];
342 fA2[i] = photoAbsCof[i-1][2];
343 fA3[i] = photoAbsCof[i-1][3];
344 fA4[i] = photoAbsCof[i-1][4];
345 // G4cout<<i<<"\t"<<fEnergyInterval[i]/keV<<"\t"<<fA1[i]<<"\t"<<fA2[i]<<"\t"
346 // <<fA3[i]<<"\t"<<fA4[i]<<"\t"<<G4endl;
347 }
348 // G4cout<<"i last = "<<i<<"; "<<"fIntervalNumber = "<<fIntervalNumber<<G4endl;
349
350 if(fEnergyInterval[fIntervalNumber] != maxEnergyTransfer)
351 {
352 fIntervalNumber++;
353 fEnergyInterval[fIntervalNumber] = maxEnergyTransfer;
354 }
355 // G4cout<<"after check of max energy transfer"<<G4endl;
356
357 for( i = 1; i <= fIntervalNumber; i++ )
358 {
359 // G4cout<<i<<"\t"<<fEnergyInterval[i]/keV<<"\t"<<fA1[i]<<"\t"<<fA2[i]<<"\t"
360 // <<fA3[i]<<"\t"<<fA4[i]<<"\t"<<G4endl;
361 }
362 // Now checking, if two borders are too close together
363
364 for( i = 1; i < fIntervalNumber; i++ )
365 {
366 if(fEnergyInterval[i+1]-fEnergyInterval[i] >
367 1.5*fDelta*(fEnergyInterval[i+1]+fEnergyInterval[i]))
368 {
369 continue;
370 }
371 else
372 {
373 for(j=i;j<fIntervalNumber;j++)
374 {
375 fEnergyInterval[j] = fEnergyInterval[j+1];
376 fA1[j] = fA1[j+1];
377 fA2[j] = fA2[j+1];
378 fA3[j] = fA3[j+1];
379 fA4[j] = fA4[j+1];
380 }
381 fIntervalNumber--;
382 i--;
383 }
384 }
385 // G4cout<<"after check of close borders"<<G4endl;
386
387 for( i = 1; i <= fIntervalNumber; i++ )
388 {
389 // G4cout<<i<<"\t"<<fEnergyInterval[i]/keV<<"\t"<<fA1[i]<<"\t"<<fA2[i]<<"\t"
390 // <<fA3[i]<<"\t"<<fA4[i]<<"\t"<<G4endl;
391 }
392
393 // Preparation of fSplineEnergy array corresponding to min ionisation, G~4
394
395 ComputeLowEnergyCof();
396 G4double betaGammaSqRef =
397 fLorentzFactor[fRefGammaNumber]*fLorentzFactor[fRefGammaNumber] - 1;
398
399 NormShift(betaGammaSqRef);
400 SplainPAI(betaGammaSqRef);
401
402 // Preparation of integral PAI cross section for input betaGammaSq
403
404 for(i = 1; i <= fSplineNumber; i++)
405 {
406 fdNdxCerenkov[i] = PAIdNdxCerenkov(i,betaGammaSq);
407 fdNdxMM[i] = PAIdNdxMM(i,betaGammaSq);
408 fdNdxPlasmon[i] = PAIdNdxPlasmon(i,betaGammaSq);
409 fdNdxResonance[i] = PAIdNdxResonance(i,betaGammaSq);
410 fDifPAIxSection[i] = DifPAIxSection(i,betaGammaSq);
411
412 // G4cout<<i<<"; dNdxC = "<<fdNdxCerenkov[i]<<"; dNdxP = "<<fdNdxPlasmon[i]
413 // <<"; dNdxPAI = "<<fDifPAIxSection[i]<<G4endl;
414 }
415 IntegralCerenkov();
416 IntegralMM();
417 IntegralPlasmon();
418 IntegralResonance();
419 IntegralPAIxSection();
420 /*
421 delete[] fEnergyInterval;
422 delete[] fA1;
423 delete[] fA2;
424 delete[] fA3;
425 delete[] fA4;
426 */
427}
G4double
double G4double
Definition G4Types.hh:83
G4PAIxSection::PAIdNdxMM
G4double PAIdNdxMM(G4int intervalNumber, G4double betaGammaSq)
Definition G4PAIxSection.cc:1340
G4PAIxSection::DifPAIxSection
G4double DifPAIxSection(G4int intervalNumber, G4double betaGammaSq)
Definition G4PAIxSection.cc:1221
G4PAIxSection::PAIdNdxCerenkov
G4double PAIdNdxCerenkov(G4int intervalNumber, G4double betaGammaSq)
Definition G4PAIxSection.cc:1282
G4PAIxSection::PAIdNdxResonance
G4double PAIdNdxResonance(G4int intervalNumber, G4double betaGammaSq)
Definition G4PAIxSection.cc:1427
G4PAIxSection::SplainPAI
void SplainPAI(G4double betaGammaSq)
Definition G4PAIxSection.cc:950
G4PAIxSection::NormShift
void NormShift(G4double betaGammaSq)
Definition G4PAIxSection.cc:873
G4PAIxSection::PAIdNdxPlasmon
G4double PAIdNdxPlasmon(G4int intervalNumber, G4double betaGammaSq)
Definition G4PAIxSection.cc:1390
G4PAIxSection::IntegralPAIxSection
void IntegralPAIxSection()
Definition G4PAIxSection.cc:1466

◆ G4PAIxSection() [5/6]

G4PAIxSection::G4PAIxSection ( G4int materialIndex,
G4double maxEnergyTransfer,
G4double betaGammaSq )

Definition at line 433 of file G4PAIxSection.cc.

436{
437 fSandia = nullptr;
438 fMatSandiaMatrix = nullptr;
439 fVerbose = 0;
440 const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
441
442 G4int i, j, numberOfElements;
443
444 fMaterialIndex = materialIndex;
445 fDensity = (*theMaterialTable)[materialIndex]->GetDensity();
446 fElectronDensity = (*theMaterialTable)[materialIndex]->GetElectronDensity();
447 numberOfElements = (G4int)(*theMaterialTable)[materialIndex]->GetNumberOfElements();
448
449 G4int* thisMaterialZ = new G4int[numberOfElements];
450
451 for( i = 0; i < numberOfElements; ++i )
452 {
453 thisMaterialZ[i] = (G4int)(*theMaterialTable)[materialIndex]->
454 GetElement(i)->GetZ();
455 }
456 // fSandia = new G4SandiaTable(materialIndex);
457 fSandia = (*theMaterialTable)[materialIndex]->GetSandiaTable();
458 G4SandiaTable thisMaterialSandiaTable(materialIndex);
459 fIntervalNumber = thisMaterialSandiaTable.SandiaIntervals(thisMaterialZ,
460 numberOfElements);
461 fIntervalNumber = thisMaterialSandiaTable.SandiaMixing
462 ( thisMaterialZ ,
463 (*theMaterialTable)[materialIndex]->GetFractionVector() ,
464 numberOfElements,fIntervalNumber);
465
466 fIntervalNumber--;
467
468 fEnergyInterval = G4DataVector(fIntervalNumber+2,0.0);
469 fA1 = G4DataVector(fIntervalNumber+2,0.0);
470 fA2 = G4DataVector(fIntervalNumber+2,0.0);
471 fA3 = G4DataVector(fIntervalNumber+2,0.0);
472 fA4 = G4DataVector(fIntervalNumber+2,0.0);
473
474 /*
475 fEnergyInterval = new G4double[fIntervalNumber+2];
476 fA1 = new G4double[fIntervalNumber+2];
477 fA2 = new G4double[fIntervalNumber+2];
478 fA3 = new G4double[fIntervalNumber+2];
479 fA4 = new G4double[fIntervalNumber+2];
480 */
481 for( i = 1; i <= fIntervalNumber; i++ )
482 {
483 if((thisMaterialSandiaTable.GetPhotoAbsorpCof(i,0) >= maxEnergyTransfer) ||
484 i > fIntervalNumber)
485 {
486 fEnergyInterval[i] = maxEnergyTransfer;
487 fIntervalNumber = i;
488 break;
489 }
490 fEnergyInterval[i] = thisMaterialSandiaTable.GetPhotoAbsorpCof(i,0);
491 fA1[i] = thisMaterialSandiaTable.GetPhotoAbsorpCof(i,1)*fDensity;
492 fA2[i] = thisMaterialSandiaTable.GetPhotoAbsorpCof(i,2)*fDensity;
493 fA3[i] = thisMaterialSandiaTable.GetPhotoAbsorpCof(i,3)*fDensity;
494 fA4[i] = thisMaterialSandiaTable.GetPhotoAbsorpCof(i,4)*fDensity;
495
496 }
497 if(fEnergyInterval[fIntervalNumber] != maxEnergyTransfer)
498 {
499 fIntervalNumber++;
500 fEnergyInterval[fIntervalNumber] = maxEnergyTransfer;
501 fA1[fIntervalNumber] = fA1[fIntervalNumber-1];
502 fA2[fIntervalNumber] = fA2[fIntervalNumber-1];
503 fA3[fIntervalNumber] = fA3[fIntervalNumber-1];
504 fA4[fIntervalNumber] = fA4[fIntervalNumber-1];
505 }
506 for(i=1;i<=fIntervalNumber;i++)
507 {
508 // G4cout<<fEnergyInterval[i]<<"\t"<<fA1[i]<<"\t"<<fA2[i]<<"\t"
509 // <<fA3[i]<<"\t"<<fA4[i]<<"\t"<<G4endl;
510 }
511 // Now checking, if two borders are too close together
512
513 for( i = 1; i < fIntervalNumber; i++ )
514 {
515 if(fEnergyInterval[i+1]-fEnergyInterval[i] >
516 1.5*fDelta*(fEnergyInterval[i+1]+fEnergyInterval[i]))
517 {
518 continue;
519 }
520 else
521 {
522 for( j = i; j < fIntervalNumber; j++ )
523 {
524 fEnergyInterval[j] = fEnergyInterval[j+1];
525 fA1[j] = fA1[j+1];
526 fA2[j] = fA2[j+1];
527 fA3[j] = fA3[j+1];
528 fA4[j] = fA4[j+1];
529 }
530 fIntervalNumber--;
531 i--;
532 }
533 }
534
535 /* *********************************
536 fSplineEnergy = new G4double[fMaxSplineSize];
537 fRePartDielectricConst = new G4double[fMaxSplineSize];
538 fImPartDielectricConst = new G4double[fMaxSplineSize];
539 fIntegralTerm = new G4double[fMaxSplineSize];
540 fDifPAIxSection = new G4double[fMaxSplineSize];
541 fIntegralPAIxSection = new G4double[fMaxSplineSize];
542
543 for(i=0;i<fMaxSplineSize;i++)
544 {
545 fSplineEnergy[i] = 0.0;
546 fRePartDielectricConst[i] = 0.0;
547 fImPartDielectricConst[i] = 0.0;
548 fIntegralTerm[i] = 0.0;
549 fDifPAIxSection[i] = 0.0;
550 fIntegralPAIxSection[i] = 0.0;
551 }
552 */ ////////////////////////
553
554 // Preparation of fSplineEnergy array corresponding to min ionisation, G~4
555
556 ComputeLowEnergyCof();
557 G4double betaGammaSqRef =
558 fLorentzFactor[fRefGammaNumber]*fLorentzFactor[fRefGammaNumber] - 1;
559
560 NormShift(betaGammaSqRef);
561 SplainPAI(betaGammaSqRef);
562
563 // Preparation of integral PAI cross section for input betaGammaSq
564
565 for(i = 1; i <= fSplineNumber; i++)
566 {
567 fDifPAIxSection[i] = DifPAIxSection(i,betaGammaSq);
568 fdNdxCerenkov[i] = PAIdNdxCerenkov(i,betaGammaSq);
569 fdNdxMM[i] = PAIdNdxMM(i,betaGammaSq);
570 fdNdxPlasmon[i] = PAIdNdxPlasmon(i,betaGammaSq);
571 fdNdxResonance[i] = PAIdNdxResonance(i,betaGammaSq);
572 }
573 IntegralPAIxSection();
574 IntegralCerenkov();
575 IntegralMM();
576 IntegralPlasmon();
577 IntegralResonance();
578}

◆ ~G4PAIxSection()

G4PAIxSection::~G4PAIxSection ( )

Definition at line 584 of file G4PAIxSection.cc.

585{
586 /* ************************
587 delete[] fSplineEnergy ;
588 delete[] fRePartDielectricConst;
589 delete[] fImPartDielectricConst;
590 delete[] fIntegralTerm ;
591 delete[] fDifPAIxSection ;
592 delete[] fIntegralPAIxSection ;
593 */ ////////////////////////
594 delete fMatSandiaMatrix;
595}

◆ G4PAIxSection() [6/6]

G4PAIxSection::G4PAIxSection ( const G4PAIxSection & )
delete

Member Function Documentation

◆ ComputeLowEnergyCof() [1/2]

void G4PAIxSection::ComputeLowEnergyCof ( )

Definition at line 779 of file G4PAIxSection.cc.

780{
781 const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
782 G4int i, numberOfElements = (G4int)(*theMaterialTable)[fMaterialIndex]->GetNumberOfElements();
783 G4double sumZ = 0., sumCof = 0.;
784
785 const G4double p0 = 1.20923e+00;
786 const G4double p1 = 3.53256e-01;
787 const G4double p2 = -1.45052e-03;
788
789 G4double* thisMaterialZ = new G4double[numberOfElements];
790 G4double* thisMaterialCof = new G4double[numberOfElements];
791
792 for( i = 0; i < numberOfElements; ++i )
793 {
794 thisMaterialZ[i] = (*theMaterialTable)[fMaterialIndex]->GetElement(i)->GetZ();
795 sumZ += thisMaterialZ[i];
796 thisMaterialCof[i] = p0+p1*thisMaterialZ[i]+p2*thisMaterialZ[i]*thisMaterialZ[i];
797 }
798 for( i = 0; i < numberOfElements; ++i )
799 {
800 sumCof += thisMaterialCof[i]*thisMaterialZ[i]/sumZ;
801 }
802 fLowEnergyCof = sumCof;
803 // G4cout<<"fLowEnergyCof = "<<fLowEnergyCof<<G4endl;
804 delete [] thisMaterialZ;
805 delete [] thisMaterialCof;
806}

Referenced by G4PAIxSection(), G4PAIxSection(), G4PAIxSection(), G4PAIxSection(), and Initialize().

◆ ComputeLowEnergyCof() [2/2]

void G4PAIxSection::ComputeLowEnergyCof ( const G4Material * material)

Definition at line 746 of file G4PAIxSection.cc.

747{
748 G4int i, numberOfElements = (G4int)material->GetNumberOfElements();
749 G4double sumZ = 0., sumCof = 0.;
750
751 static const G4double p0 = 1.20923e+00;
752 static const G4double p1 = 3.53256e-01;
753 static const G4double p2 = -1.45052e-03;
754
755 G4double* thisMaterialZ = new G4double[numberOfElements];
756 G4double* thisMaterialCof = new G4double[numberOfElements];
757
758 for( i = 0; i < numberOfElements; ++i )
759 {
760 thisMaterialZ[i] = material->GetElement(i)->GetZ();
761 sumZ += thisMaterialZ[i];
762 thisMaterialCof[i] = p0+p1*thisMaterialZ[i]+p2*thisMaterialZ[i]*thisMaterialZ[i];
763 }
764 for( i = 0; i < numberOfElements; ++i )
765 {
766 sumCof += thisMaterialCof[i]*thisMaterialZ[i]/sumZ;
767 }
768 fLowEnergyCof = sumCof;
769 delete [] thisMaterialZ;
770 delete [] thisMaterialCof;
771 // G4cout<<"fLowEnergyCof = "<<fLowEnergyCof<<G4endl;
772}
G4Element::GetZ
G4double GetZ() const
Definition G4Element.hh:119
G4Material::GetElement
const G4Element * GetElement(G4int iel) const
Definition G4Material.hh:192
G4Material::GetNumberOfElements
std::size_t GetNumberOfElements() const
Definition G4Material.hh:180

◆ DifPAIxSection()

G4double G4PAIxSection::DifPAIxSection ( G4int intervalNumber,
G4double betaGammaSq )

Definition at line 1221 of file G4PAIxSection.cc.

1222{
1223 G4double cof,x1,x2,x3,x4,x5,x6,x7,x8,result;
1224
1225 G4double betaBohr = fine_structure_const;
1226 G4double be2 = betaGammaSq/(1 + betaGammaSq);
1227 G4double beta = std::sqrt(be2);
1228
1229 cof = 1.;
1230 x1 = std::log(2*electron_mass_c2/fSplineEnergy[i]);
1231
1232 if( betaGammaSq < 0.01 ) x2 = std::log(be2);
1233 else
1234 {
1235 x2 = -log( (1/betaGammaSq - fRePartDielectricConst[i])*
1236 (1/betaGammaSq - fRePartDielectricConst[i]) +
1237 fImPartDielectricConst[i]*fImPartDielectricConst[i] )/2;
1238 }
1239 if( fImPartDielectricConst[i] == 0.0 ||betaGammaSq < 0.01 )
1240 {
1241 x6 = 0.;
1242 }
1243 else
1244 {
1245 x3 = -fRePartDielectricConst[i] + 1/betaGammaSq;
1246 x5 = -1 - fRePartDielectricConst[i] +
1247 be2*((1 +fRePartDielectricConst[i])*(1 + fRePartDielectricConst[i]) +
1248 fImPartDielectricConst[i]*fImPartDielectricConst[i]);
1249
1250 x7 = atan2(fImPartDielectricConst[i],x3);
1251 x6 = x5 * x7;
1252 }
1253
1254 x4 = ((x1 + x2)*fImPartDielectricConst[i] + x6)/hbarc;
1255
1256 x8 = (1 + fRePartDielectricConst[i])*(1 + fRePartDielectricConst[i]) +
1257 fImPartDielectricConst[i]*fImPartDielectricConst[i];
1258
1259 result = (x4 + cof*fIntegralTerm[i]/fSplineEnergy[i]/fSplineEnergy[i]);
1260
1261 if( result < 1.0e-8 ) result = 1.0e-8;
1262
1263 result *= fine_structure_const/be2/pi;
1264
1265 // low energy correction
1266
1267 G4double lowCof = fLowEnergyCof; // 6.0 ; // Ar ~ 4.; -> fLowCof as f(Z1,Z2)?
1268
1269 result *= (1 - std::exp(-beta/betaBohr/lowCof));
1270 if(x8 >= 0.0)
1271 {
1272 result /= x8;
1273 }
1274 return result;
1275
1276} // end of DifPAIxSection

Referenced by G4PAIxSection(), G4PAIxSection(), Initialize(), InitPAI(), NormShift(), and SplainPAI().

◆ GetCerenkovEnergyTransfer()

G4double G4PAIxSection::GetCerenkovEnergyTransfer ( )

Definition at line 2312 of file G4PAIxSection.cc.

2313{
2314 G4int iTransfer ;
2315
2316 G4double energyTransfer, position;
2317
2318 position = fIntegralCerenkov[1]*G4UniformRand();
2319
2320 for( iTransfer = 1; iTransfer <= fSplineNumber; iTransfer++ )
2321 {
2322 if( position >= fIntegralCerenkov[iTransfer] ) break;
2323 }
2324 if(iTransfer > fSplineNumber) iTransfer--;
2325
2326 energyTransfer = fSplineEnergy[iTransfer];
2327
2328 if(iTransfer > 1)
2329 {
2330 energyTransfer -= (fSplineEnergy[iTransfer]-fSplineEnergy[iTransfer-1])*G4UniformRand();
2331 }
2332 return energyTransfer;
2333}
G4UniformRand
#define G4UniformRand()
Definition Randomize.hh:52

Referenced by GetStepCerenkovLoss().

◆ GetDifPAIxSection()

G4double G4PAIxSection::GetDifPAIxSection ( G4int i)
inline

Definition at line 176 of file G4PAIxSection.hh.

176{ return fDifPAIxSection[i]; }

◆ GetElectronRange()

G4double G4PAIxSection::GetElectronRange ( G4double energy)

Definition at line 1125 of file G4PAIxSection.cc.

1126{
1127 G4double range;
1128 /*
1129 const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
1130
1131 G4double Z = (*theMaterialTable)[fMaterialIndex]->GetIonisation()->GetZeffective();
1132 G4double A = (*theMaterialTable)[fMaterialIndex]->GetA();
1133
1134 energy /= keV; // energy in keV in parametrised formula
1135
1136 if (energy < 10.)
1137 {
1138 range = 3.872e-3*A/Z;
1139 range *= pow(energy,1.492);
1140 }
1141 else
1142 {
1143 range = 6.97e-3*pow(energy,1.6);
1144 }
1145 */
1146 // Blum&Rolandi Particle Detection with Drift Chambers, p. 7
1147
1148 G4double cofA = 5.37e-4*g/cm2/keV;
1149 G4double cofB = 0.9815;
1150 G4double cofC = 3.123e-3/keV;
1151 // energy /= keV;
1152
1153 range = cofA*energy*( 1 - cofB/(1 + cofC*energy) );
1154
1155 // range *= g/cm2;
1156 range /= fDensity;
1157
1158 return range;
1159}
G4INCL::KinematicsUtils::energy
G4double energy(const ThreeVector &p, const G4double m)
Definition G4INCLKinematicsUtils.cc:185

◆ GetEnergyInterval()

G4double G4PAIxSection::GetEnergyInterval ( G4int i)
inline

Definition at line 174 of file G4PAIxSection.hh.

174{ return fEnergyInterval[i]; }

◆ GetEnergyTransfer()

G4double G4PAIxSection::GetEnergyTransfer ( )

Definition at line 2231 of file G4PAIxSection.cc.

2232{
2233 G4int iTransfer ;
2234
2235 G4double energyTransfer, position;
2236
2237 position = fIntegralPAIxSection[1]*G4UniformRand();
2238
2239 for( iTransfer = 1; iTransfer <= fSplineNumber; iTransfer++ )
2240 {
2241 if( position >= fIntegralPAIxSection[iTransfer] ) break;
2242 }
2243 if(iTransfer > fSplineNumber) iTransfer--;
2244
2245 energyTransfer = fSplineEnergy[iTransfer];
2246
2247 if(iTransfer > 1)
2248 {
2249 energyTransfer -= (fSplineEnergy[iTransfer]-fSplineEnergy[iTransfer-1])*G4UniformRand();
2250 }
2251 return energyTransfer;
2252}

Referenced by GetStepEnergyLoss().

◆ GetIntegralCerenkov()

G4double G4PAIxSection::GetIntegralCerenkov ( G4int i) const
inline

Definition at line 298 of file G4PAIxSection.hh.

299{
300 if(i < 1 || i > fSplineNumber) { CallError(i, "GetIntegralCerenkov"); }
301 return fIntegralCerenkov[i];
302}

Referenced by G4PAIPhotData::Initialise().

◆ GetIntegralMM()

G4double G4PAIxSection::GetIntegralMM ( G4int i) const
inline

Definition at line 304 of file G4PAIxSection.hh.

305{
306 if(i < 1 || i > fSplineNumber) { CallError(i, "GetIntegralMM"); }
307 return fIntegralMM[i];
308}

◆ GetIntegralPAIdEdx()

G4double G4PAIxSection::GetIntegralPAIdEdx ( G4int i) const
inline

Definition at line 292 of file G4PAIxSection.hh.

293{
294 if(i < 1 || i > fSplineNumber) { CallError(i, "GetIntegralPAIdEdx"); }
295 return fIntegralPAIdEdx[i];
296}

Referenced by G4PAIPhotData::Initialise().

◆ GetIntegralPAIxSection()

G4double G4PAIxSection::GetIntegralPAIxSection ( G4int i) const
inline

Definition at line 286 of file G4PAIxSection.hh.

287{
288 if(i < 1 || i > fSplineNumber) { CallError(i, "GetIntegralPAIxSection"); }
289 return fIntegralPAIxSection[i];
290}

Referenced by G4PAIPhotData::Initialise().

◆ GetIntegralPlasmon()

G4double G4PAIxSection::GetIntegralPlasmon ( G4int i) const
inline

Definition at line 310 of file G4PAIxSection.hh.

311{
312 if(i < 1 || i > fSplineNumber) { CallError(i, "GetIntegralPlasmon"); }
313 return fIntegralPlasmon[i];
314}

Referenced by G4PAIPhotData::Initialise().

◆ GetIntegralResonance()

G4double G4PAIxSection::GetIntegralResonance ( G4int i) const
inline

Definition at line 316 of file G4PAIxSection.hh.

317{
318 if(i < 1 || i > fSplineNumber) { CallError(i, "GetIntegralResonance"); }
319 return fIntegralResonance[i];
320}

◆ GetIntervalNumber()

G4int G4PAIxSection::GetIntervalNumber ( ) const
inline

Definition at line 172 of file G4PAIxSection.hh.

172{ return fIntervalNumber; }

◆ GetLorentzFactor()

G4double G4PAIxSection::GetLorentzFactor ( G4int i) const

Definition at line 597 of file G4PAIxSection.cc.

598{
599 return fLorentzFactor[j];
600}

◆ GetLowEnergyCof()

G4double G4PAIxSection::GetLowEnergyCof ( ) const
inline

Definition at line 190 of file G4PAIxSection.hh.

190{ return fLowEnergyCof; }

◆ GetMeanCerenkovLoss()

G4double G4PAIxSection::GetMeanCerenkovLoss ( ) const
inline

Definition at line 183 of file G4PAIxSection.hh.

183{return fIntegralCerenkov[0]; }

◆ GetMeanEnergyLoss()

G4double G4PAIxSection::GetMeanEnergyLoss ( ) const
inline

Definition at line 182 of file G4PAIxSection.hh.

182{return fIntegralPAIxSection[0]; }

Referenced by G4PAIPhotData::Initialise().

◆ GetMeanMMLoss()

G4double G4PAIxSection::GetMeanMMLoss ( ) const
inline

Definition at line 184 of file G4PAIxSection.hh.

184{return fIntegralMM[0]; }

◆ GetMeanPlasmonLoss()

G4double G4PAIxSection::GetMeanPlasmonLoss ( ) const
inline

Definition at line 185 of file G4PAIxSection.hh.

185{return fIntegralPlasmon[0]; }

◆ GetMeanResonanceLoss()

G4double G4PAIxSection::GetMeanResonanceLoss ( ) const
inline

Definition at line 186 of file G4PAIxSection.hh.

186{return fIntegralResonance[0]; }

◆ GetMMEnergyTransfer()

G4double G4PAIxSection::GetMMEnergyTransfer ( )

Definition at line 2339 of file G4PAIxSection.cc.

2340{
2341 G4int iTransfer ;
2342
2343 G4double energyTransfer, position;
2344
2345 position = fIntegralMM[1]*G4UniformRand();
2346
2347 for( iTransfer = 1; iTransfer <= fSplineNumber; iTransfer++ )
2348 {
2349 if( position >= fIntegralMM[iTransfer] ) break;
2350 }
2351 if(iTransfer > fSplineNumber) iTransfer--;
2352
2353 energyTransfer = fSplineEnergy[iTransfer];
2354
2355 if(iTransfer > 1)
2356 {
2357 energyTransfer -= (fSplineEnergy[iTransfer]-fSplineEnergy[iTransfer-1])*G4UniformRand();
2358 }
2359 return energyTransfer;
2360}

Referenced by GetStepMMLoss().

◆ GetNormalizationCof()

G4double G4PAIxSection::GetNormalizationCof ( ) const
inline

Definition at line 188 of file G4PAIxSection.hh.

188{ return fNormalizationCof; }

◆ GetNumberOfGammas()

G4int G4PAIxSection::GetNumberOfGammas ( ) const
inline

Definition at line 168 of file G4PAIxSection.hh.

168{ return fNumberOfGammas; }

◆ GetPAIdNdxCerenkov()

G4double G4PAIxSection::GetPAIdNdxCerenkov ( G4int i)
inline

Definition at line 177 of file G4PAIxSection.hh.

177{ return fdNdxCerenkov[i]; }

◆ GetPAIdNdxMM()

G4double G4PAIxSection::GetPAIdNdxMM ( G4int i)
inline

Definition at line 178 of file G4PAIxSection.hh.

178{ return fdNdxMM[i]; }

◆ GetPAIdNdxPlasmon()

G4double G4PAIxSection::GetPAIdNdxPlasmon ( G4int i)
inline

Definition at line 179 of file G4PAIxSection.hh.

179{ return fdNdxPlasmon[i]; }

◆ GetPAIdNdxResonance()

G4double G4PAIxSection::GetPAIdNdxResonance ( G4int i)
inline

Definition at line 180 of file G4PAIxSection.hh.

180{ return fdNdxResonance[i]; }

◆ GetPAItable()

G4double G4PAIxSection::GetPAItable ( G4int i,
G4int j ) const
inline

Definition at line 275 of file G4PAIxSection.hh.

276{
277 return fPAItable[i][j];
278}

◆ GetPhotonRange()

G4double G4PAIxSection::GetPhotonRange ( G4double energy)

Definition at line 1096 of file G4PAIxSection.cc.

1097{
1098 G4int i;
1099 G4double energy2, energy3, energy4, result, lambda;
1100
1101 energy2 = energy1*energy1;
1102 energy3 = energy2*energy1;
1103 energy4 = energy3*energy1;
1104
1105 for( i = 1; i <= fIntervalNumber; i++ )
1106 {
1107 if( energy1 < fEnergyInterval[i]) break;
1108 }
1109 i--;
1110 if(i == 0) i = 1;
1111
1112 result = fA1[i]/energy1+fA2[i]/energy2+fA3[i]/energy3+fA4[i]/energy4;
1113
1114 if( result > DBL_MIN ) lambda = 1./result;
1115 else lambda = DBL_MAX;
1116
1117 return lambda;
1118}
DBL_MIN
#define DBL_MIN
Definition templates.hh:54
DBL_MAX
#define DBL_MAX
Definition templates.hh:62

◆ GetPlasmonEnergyTransfer()

G4double G4PAIxSection::GetPlasmonEnergyTransfer ( )

Definition at line 2393 of file G4PAIxSection.cc.

2394{
2395 G4int iTransfer ;
2396
2397 G4double energyTransfer, position;
2398
2399 position = fIntegralPlasmon[1]*G4UniformRand();
2400
2401 for( iTransfer = 1; iTransfer <= fSplineNumber; iTransfer++ )
2402 {
2403 if( position >= fIntegralPlasmon[iTransfer] ) break;
2404 }
2405 if(iTransfer > fSplineNumber) iTransfer--;
2406
2407 energyTransfer = fSplineEnergy[iTransfer];
2408
2409 if(iTransfer > 1)
2410 {
2411 energyTransfer -= (fSplineEnergy[iTransfer]-fSplineEnergy[iTransfer-1])*G4UniformRand();
2412 }
2413 return energyTransfer;
2414}

Referenced by GetStepPlasmonLoss().

◆ GetResonanceEnergyTransfer()

G4double G4PAIxSection::GetResonanceEnergyTransfer ( )

Definition at line 2448 of file G4PAIxSection.cc.

2449{
2450 G4int iTransfer ;
2451
2452 G4double energyTransfer, position;
2453
2454 position = fIntegralResonance[1]*G4UniformRand();
2455
2456 for( iTransfer = 1; iTransfer <= fSplineNumber; iTransfer++ )
2457 {
2458 if( position >= fIntegralResonance[iTransfer] ) break;
2459 }
2460 if(iTransfer > fSplineNumber) iTransfer--;
2461
2462 energyTransfer = fSplineEnergy[iTransfer];
2463
2464 if(iTransfer > 1)
2465 {
2466 energyTransfer -= (fSplineEnergy[iTransfer]-fSplineEnergy[iTransfer-1])*G4UniformRand();
2467 }
2468 return energyTransfer;
2469}

Referenced by GetStepResonanceLoss().

◆ GetRutherfordEnergyTransfer()

G4double G4PAIxSection::GetRutherfordEnergyTransfer ( )

Definition at line 2476 of file G4PAIxSection.cc.

2477{
2478 G4int iTransfer ;
2479
2480 G4double energyTransfer, position;
2481
2482 position = (fIntegralPlasmon[1]-fIntegralResonance[1])*G4UniformRand();
2483
2484 for( iTransfer = 1; iTransfer <= fSplineNumber; iTransfer++ )
2485 {
2486 if( position >= (fIntegralPlasmon[iTransfer]-fIntegralResonance[iTransfer]) ) break;
2487 }
2488 if(iTransfer > fSplineNumber) iTransfer--;
2489
2490 energyTransfer = fSplineEnergy[iTransfer];
2491
2492 if(iTransfer > 1)
2493 {
2494 energyTransfer -= (fSplineEnergy[iTransfer]-fSplineEnergy[iTransfer-1])*G4UniformRand();
2495 }
2496 return energyTransfer;
2497}

◆ GetSplineEnergy()

G4double G4PAIxSection::GetSplineEnergy ( G4int i) const
inline

Definition at line 280 of file G4PAIxSection.hh.

281{
282 if(i < 1 || i > fSplineNumber) { CallError(i, "GetSplineEnergy"); }
283 return fSplineEnergy[i];
284}

Referenced by G4PAIPhotData::Initialise().

◆ GetSplineSize()

G4int G4PAIxSection::GetSplineSize ( ) const
inline

Definition at line 170 of file G4PAIxSection.hh.

170{ return fSplineNumber; }

Referenced by G4PAIPhotData::Initialise().

◆ GetStepCerenkovLoss()

G4double G4PAIxSection::GetStepCerenkovLoss ( G4double step)

Definition at line 2258 of file G4PAIxSection.cc.

2259{
2260 G4long numOfCollisions;
2261 G4double meanNumber, loss = 0.0;
2262
2263 // G4cout<<" G4PAIxSection::GetStepCerenkovLoss "<<G4endl;
2264
2265 meanNumber = fIntegralCerenkov[1]*step;
2266 numOfCollisions = G4Poisson(meanNumber);
2267
2268 // G4cout<<"numOfCollisions = "<<numOfCollisions<<G4endl;
2269
2270 while(numOfCollisions)
2271 {
2272 loss += GetCerenkovEnergyTransfer();
2273 numOfCollisions--;
2274 // Loop checking, 03-Aug-2015, Vladimir Ivanchenko
2275 }
2276 // G4cout<<"PAI Cerenkov loss = "<<loss/keV<<" keV"<<G4endl;
2277
2278 return loss;
2279}
G4Poisson
G4long G4Poisson(G4double mean)
Definition G4Poisson.hh:50
G4long
long G4long
Definition G4Types.hh:87
G4PAIxSection::GetCerenkovEnergyTransfer
G4double GetCerenkovEnergyTransfer()
Definition G4PAIxSection.cc:2312

◆ GetStepEnergyLoss()

G4double G4PAIxSection::GetStepEnergyLoss ( G4double step)

Definition at line 2204 of file G4PAIxSection.cc.

2205{
2206 G4long numOfCollisions;
2207 G4double meanNumber, loss = 0.0;
2208
2209 // G4cout<<" G4PAIxSection::GetStepEnergyLoss "<<G4endl;
2210
2211 meanNumber = fIntegralPAIxSection[1]*step;
2212 numOfCollisions = G4Poisson(meanNumber);
2213
2214 // G4cout<<"numOfCollisions = "<<numOfCollisions<<G4endl;
2215
2216 while(numOfCollisions)
2217 {
2218 loss += GetEnergyTransfer();
2219 numOfCollisions--;
2220 // Loop checking, 03-Aug-2015, Vladimir Ivanchenko
2221 }
2222 // G4cout<<"PAI energy loss = "<<loss/keV<<" keV"<<G4endl;
2223
2224 return loss;
2225}
G4PAIxSection::GetEnergyTransfer
G4double GetEnergyTransfer()
Definition G4PAIxSection.cc:2231

◆ GetStepMMLoss()

G4double G4PAIxSection::GetStepMMLoss ( G4double step)

Definition at line 2285 of file G4PAIxSection.cc.

2286{
2287 G4long numOfCollisions;
2288 G4double meanNumber, loss = 0.0;
2289
2290 // G4cout<<" G4PAIxSection::GetStepMMLoss "<<G4endl;
2291
2292 meanNumber = fIntegralMM[1]*step;
2293 numOfCollisions = G4Poisson(meanNumber);
2294
2295 // G4cout<<"numOfCollisions = "<<numOfCollisions<<G4endl;
2296
2297 while(numOfCollisions)
2298 {
2299 loss += GetMMEnergyTransfer();
2300 numOfCollisions--;
2301 // Loop checking, 03-Aug-2015, Vladimir Ivanchenko
2302 }
2303 // G4cout<<"PAI MM-Cerenkov loss = "<<loss/keV<<" keV"<<G4endl;
2304
2305 return loss;
2306}
G4PAIxSection::GetMMEnergyTransfer
G4double GetMMEnergyTransfer()
Definition G4PAIxSection.cc:2339

◆ GetStepPlasmonLoss()

G4double G4PAIxSection::GetStepPlasmonLoss ( G4double step)

Definition at line 2366 of file G4PAIxSection.cc.

2367{
2368 G4long numOfCollisions;
2369 G4double meanNumber, loss = 0.0;
2370
2371 // G4cout<<" G4PAIxSection::GetStepPlasmonLoss "<<G4endl;
2372
2373 meanNumber = fIntegralPlasmon[1]*step;
2374 numOfCollisions = G4Poisson(meanNumber);
2375
2376 // G4cout<<"numOfCollisions = "<<numOfCollisions<<G4endl;
2377
2378 while(numOfCollisions)
2379 {
2380 loss += GetPlasmonEnergyTransfer();
2381 numOfCollisions--;
2382 // Loop checking, 03-Aug-2015, Vladimir Ivanchenko
2383 }
2384 // G4cout<<"PAI Plasmon loss = "<<loss/keV<<" keV"<<G4endl;
2385
2386 return loss;
2387}
G4PAIxSection::GetPlasmonEnergyTransfer
G4double GetPlasmonEnergyTransfer()
Definition G4PAIxSection.cc:2393

◆ GetStepResonanceLoss()

G4double G4PAIxSection::GetStepResonanceLoss ( G4double step)

Definition at line 2420 of file G4PAIxSection.cc.

2421{
2422 G4long numOfCollisions;
2423 G4double meanNumber, loss = 0.0;
2424
2425 // G4cout<<" G4PAIxSection::GetStepCreLosnkovs "<<G4endl;
2426
2427 meanNumber = fIntegralResonance[1]*step;
2428 numOfCollisions = G4Poisson(meanNumber);
2429
2430 // G4cout<<"numOfCollisions = "<<numOfCollisions<<G4endl;
2431
2432 while(numOfCollisions)
2433 {
2434 loss += GetResonanceEnergyTransfer();
2435 numOfCollisions--;
2436 // Loop checking, 03-Aug-2015, Vladimir Ivanchenko
2437 }
2438 // G4cout<<"PAI resonance loss = "<<loss/keV<<" keV"<<G4endl;
2439
2440 return loss;
2441}
G4PAIxSection::GetResonanceEnergyTransfer
G4double GetResonanceEnergyTransfer()
Definition G4PAIxSection.cc:2448

◆ ImPartDielectricConst()

G4double G4PAIxSection::ImPartDielectricConst ( G4int intervalNumber,
G4double energy )

Definition at line 1076 of file G4PAIxSection.cc.

1078{
1079 G4double energy2,energy3,energy4,result;
1080
1081 energy2 = energy1*energy1;
1082 energy3 = energy2*energy1;
1083 energy4 = energy3*energy1;
1084
1085 result = fA1[k]/energy1+fA2[k]/energy2+fA3[k]/energy3+fA4[k]/energy4;
1086 result *=hbarc/energy1;
1087
1088 return result;
1089
1090} // end of ImPartDielectricConst

Referenced by NormShift(), and SplainPAI().

◆ Initialize()

void G4PAIxSection::Initialize ( const G4Material * material,
G4double maxEnergyTransfer,
G4double betaGammaSq,
G4SandiaTable * sandia )

Definition at line 606 of file G4PAIxSection.cc.

610{
611 if(fVerbose > 0)
612 {
613 G4cout<<G4endl;
614 G4cout<<"G4PAIxSection::Initialize(...,G4SandiaTable* sandia)"<<G4endl;
615 G4cout<<G4endl;
616 }
617 G4int i, j;
618
619 fSandia = sandia;
620 fIntervalNumber = sandia->GetMaxInterval();
621 fDensity = material->GetDensity();
622 fElectronDensity = material->GetElectronDensity();
623
624 // fIntervalNumber--;
625
626 if( fVerbose > 0 )
627 {
628 G4cout<<"fDensity = "<<fDensity<<"\t"<<fElectronDensity<<"\t fIntervalNumber = "<<fIntervalNumber<<G4endl;
629 }
630 fEnergyInterval = G4DataVector(fIntervalNumber+2,0.0);
631 fA1 = G4DataVector(fIntervalNumber+2,0.0);
632 fA2 = G4DataVector(fIntervalNumber+2,0.0);
633 fA3 = G4DataVector(fIntervalNumber+2,0.0);
634 fA4 = G4DataVector(fIntervalNumber+2,0.0);
635
636 for( i = 1; i <= fIntervalNumber; i++ )
637 {
638 if ( sandia->GetSandiaMatTablePAI(i-1,0) < 1.*eV && sandia->GetLowerI1() == false)
639 {
640 fIntervalNumber--;
641 continue;
642 }
643 if( ( sandia->GetSandiaMatTablePAI(i-1,0) >= maxEnergyTransfer ) || i >= fIntervalNumber )
644 {
645 fEnergyInterval[i] = maxEnergyTransfer;
646 fIntervalNumber = i;
647 break;
648 }
649 fEnergyInterval[i] = sandia->GetSandiaMatTablePAI(i-1,0);
650 fA1[i] = sandia->GetSandiaMatTablePAI(i-1,1);
651 fA2[i] = sandia->GetSandiaMatTablePAI(i-1,2);
652 fA3[i] = sandia->GetSandiaMatTablePAI(i-1,3);
653 fA4[i] = sandia->GetSandiaMatTablePAI(i-1,4);
654
655 if( fVerbose > 0 )
656 {
657 G4cout<<i<<"\t"<<fEnergyInterval[i]/keV<<"\t"<<fA1[i]<<"\t"<<fA2[i]<<"\t"
658 <<fA3[i]<<"\t"<<fA4[i]<<"\t"<<G4endl;
659 }
660 }
661 if( fVerbose > 0 ) G4cout<<"last i = "<<i<<"; "<<"fIntervalNumber = "<<fIntervalNumber<<G4endl;
662
663 if( fEnergyInterval[fIntervalNumber] != maxEnergyTransfer )
664 {
665 fIntervalNumber++;
666 fEnergyInterval[fIntervalNumber] = maxEnergyTransfer;
667 }
668 if( fVerbose > 0 )
669 {
670 for( i = 1; i <= fIntervalNumber; i++ )
671 {
672 G4cout<<i<<"\t"<<fEnergyInterval[i]/keV<<"\t"<<fA1[i]<<"\t"<<fA2[i]<<"\t"
673 <<fA3[i]<<"\t"<<fA4[i]<<"\t"<<G4endl;
674 }
675 }
676 if( fVerbose > 0 ) G4cout<<"Now checking, if two borders are too close together"<<G4endl;
677
678 for( i = 1; i < fIntervalNumber; i++ )
679 {
680 if( fEnergyInterval[i+1]-fEnergyInterval[i] >
681 1.5*fDelta*(fEnergyInterval[i+1]+fEnergyInterval[i]) && fEnergyInterval[i] > 0.) continue;
682 else
683 {
684 if( fVerbose > 0 ) G4cout<<i<<"\t"<<fEnergyInterval[i]/keV<<"\t"<<fEnergyInterval[i+1]/keV;
685
686 for( j = i; j < fIntervalNumber; j++ )
687 {
688 fEnergyInterval[j] = fEnergyInterval[j+1];
689 fA1[j] = fA1[j+1];
690 fA2[j] = fA2[j+1];
691 fA3[j] = fA3[j+1];
692 fA4[j] = fA4[j+1];
693 }
694 fIntervalNumber--;
695 i--;
696 }
697 }
698 if( fVerbose > 0 )
699 {
700 for( i = 1; i <= fIntervalNumber; i++ )
701 {
702 G4cout<<i<<"\t"<<fEnergyInterval[i]/keV<<"\t"<<fA1[i]<<"\t"<<fA2[i]<<"\t"
703 <<fA3[i]<<"\t"<<fA4[i]<<"\t"<<G4endl;
704 }
705 }
706 // Preparation of fSplineEnergy array corresponding to min ionisation, G~4
707
708 ComputeLowEnergyCof(material);
709
710 G4double betaGammaSqRef =
711 fLorentzFactor[fRefGammaNumber]*fLorentzFactor[fRefGammaNumber] - 1;
712
713 NormShift(betaGammaSqRef);
714 SplainPAI(betaGammaSqRef);
715
716 // Preparation of integral PAI cross section for input betaGammaSq
717
718 for( i = 1; i <= fSplineNumber; i++ )
719 {
720 fDifPAIxSection[i] = DifPAIxSection(i,betaGammaSq);
721
722
723 fdNdxCerenkov[i] = PAIdNdxCerenkov(i,betaGammaSq);
724 fdNdxMM[i] = PAIdNdxMM(i,betaGammaSq);
725 fdNdxPlasmon[i] = PAIdNdxPlasmon(i,betaGammaSq);
726 fdNdxResonance[i] = PAIdNdxResonance(i,betaGammaSq);
727 }
728 IntegralPAIxSection();
729 IntegralCerenkov();
730 IntegralMM();
731 IntegralPlasmon();
732 IntegralResonance();
733
734 for( i = 1; i <= fSplineNumber; i++ )
735 {
736 if(fVerbose>0) G4cout<<i<<"; w = "<<fSplineEnergy[i]/keV<<" keV; dN/dx_>w = "<<fIntegralPAIxSection[i]<<" 1/mm"<<G4endl;
737 }
738}
G4endl
#define G4endl
Definition G4ios.hh:67
G4cout
G4GLOB_DLL std::ostream G4cout
G4Material::GetElectronDensity
G4double GetElectronDensity() const
Definition G4Material.hh:203
G4SandiaTable::GetSandiaMatTablePAI
G4double GetSandiaMatTablePAI(G4int, G4int) const
Definition G4SandiaTable.cc:949
G4SandiaTable::GetLowerI1
G4bool GetLowerI1()
Definition G4SandiaTable.hh:106

Referenced by G4PAIPhotData::Initialise().

◆ InitPAI()

void G4PAIxSection::InitPAI ( )

Definition at line 813 of file G4PAIxSection.cc.

814{
815 G4int i;
816 G4double betaGammaSq = fLorentzFactor[fRefGammaNumber]*
817 fLorentzFactor[fRefGammaNumber] - 1;
818
819 // Preparation of integral PAI cross section for reference gamma
820
821 NormShift(betaGammaSq);
822 SplainPAI(betaGammaSq);
823
824 IntegralPAIxSection();
825 IntegralCerenkov();
826 IntegralMM();
827 IntegralPlasmon();
828 IntegralResonance();
829
830 for(i = 0; i<= fSplineNumber; i++)
831 {
832 fPAItable[i][fRefGammaNumber] = fIntegralPAIxSection[i];
833 if(i != 0)
834 {
835 fPAItable[i][0] = fSplineEnergy[i];
836 }
837 }
838 fPAItable[0][0] = fSplineNumber;
839
840 for(G4int j = 1; j < 112; j++) // for other gammas
841 {
842 if( j == fRefGammaNumber ) continue;
843
844 betaGammaSq = fLorentzFactor[j]*fLorentzFactor[j] - 1;
845
846 for(i = 1; i <= fSplineNumber; i++)
847 {
848 fDifPAIxSection[i] = DifPAIxSection(i,betaGammaSq);
849 fdNdxCerenkov[i] = PAIdNdxCerenkov(i,betaGammaSq);
850 fdNdxMM[i] = PAIdNdxMM(i,betaGammaSq);
851 fdNdxPlasmon[i] = PAIdNdxPlasmon(i,betaGammaSq);
852 fdNdxResonance[i] = PAIdNdxResonance(i,betaGammaSq);
853 }
854 IntegralPAIxSection();
855 IntegralCerenkov();
856 IntegralMM();
857 IntegralPlasmon();
858 IntegralResonance();
859
860 for(i = 0; i <= fSplineNumber; i++)
861 {
862 fPAItable[i][j] = fIntegralPAIxSection[i];
863 }
864 }
865
866}

Referenced by G4PAIxSection().

◆ IntegralCerenkov()

void G4PAIxSection::IntegralCerenkov ( )

Definition at line 1498 of file G4PAIxSection.cc.

1499{
1500 G4int i, k;
1501 fIntegralCerenkov[fSplineNumber] = 0;
1502 fIntegralCerenkov[0] = 0;
1503 k = fIntervalNumber -1;
1504
1505 for( i = fSplineNumber-1; i >= 1; i-- )
1506 {
1507 if(fSplineEnergy[i] >= fEnergyInterval[k])
1508 {
1509 fIntegralCerenkov[i] = fIntegralCerenkov[i+1] + SumOverInterCerenkov(i);
1510 // G4cout<<"int: i = "<<i<<"; sumC = "<<fIntegralCerenkov[i]<<G4endl;
1511 }
1512 else
1513 {
1514 fIntegralCerenkov[i] = fIntegralCerenkov[i+1] +
1515 SumOverBordCerenkov(i+1,fEnergyInterval[k]);
1516 k--;
1517 // G4cout<<"bord: i = "<<i<<"; sumC = "<<fIntegralCerenkov[i]<<G4endl;
1518 }
1519 }
1520
1521} // end of IntegralCerenkov
G4PAIxSection::SumOverInterCerenkov
G4double SumOverInterCerenkov(G4int intervalNumber)
Definition G4PAIxSection.cc:1698
G4PAIxSection::SumOverBordCerenkov
G4double SumOverBordCerenkov(G4int intervalNumber, G4double energy)
Definition G4PAIxSection.cc:1972

Referenced by G4PAIxSection(), G4PAIxSection(), Initialize(), and InitPAI().

◆ IntegralMM()

void G4PAIxSection::IntegralMM ( )

Definition at line 1529 of file G4PAIxSection.cc.

1530{
1531 G4int i, k;
1532 fIntegralMM[fSplineNumber] = 0;
1533 fIntegralMM[0] = 0;
1534 k = fIntervalNumber -1;
1535
1536 for( i = fSplineNumber-1; i >= 1; i-- )
1537 {
1538 if(fSplineEnergy[i] >= fEnergyInterval[k])
1539 {
1540 fIntegralMM[i] = fIntegralMM[i+1] + SumOverInterMM(i);
1541 // G4cout<<"int: i = "<<i<<"; sumC = "<<fIntegralMM[i]<<G4endl;
1542 }
1543 else
1544 {
1545 fIntegralMM[i] = fIntegralMM[i+1] +
1546 SumOverBordMM(i+1,fEnergyInterval[k]);
1547 k--;
1548 // G4cout<<"bord: i = "<<i<<"; sumC = "<<fIntegralMM[i]<<G4endl;
1549 }
1550 }
1551
1552} // end of IntegralMM
G4PAIxSection::SumOverInterMM
G4double SumOverInterMM(G4int intervalNumber)
Definition G4PAIxSection.cc:1736
G4PAIxSection::SumOverBordMM
G4double SumOverBordMM(G4int intervalNumber, G4double energy)
Definition G4PAIxSection.cc:2032

Referenced by G4PAIxSection(), G4PAIxSection(), Initialize(), and InitPAI().

◆ IntegralPAIxSection()

void G4PAIxSection::IntegralPAIxSection ( )

Definition at line 1466 of file G4PAIxSection.cc.

1467{
1468 fIntegralPAIxSection[fSplineNumber] = 0;
1469 fIntegralPAIdEdx[fSplineNumber] = 0;
1470 fIntegralPAIxSection[0] = 0;
1471 G4int i, k = fIntervalNumber -1;
1472
1473 for( i = fSplineNumber-1; i >= 1; i--)
1474 {
1475 if(fSplineEnergy[i] >= fEnergyInterval[k])
1476 {
1477 fIntegralPAIxSection[i] = fIntegralPAIxSection[i+1] + SumOverInterval(i);
1478 fIntegralPAIdEdx[i] = fIntegralPAIdEdx[i+1] + SumOverIntervaldEdx(i);
1479 }
1480 else
1481 {
1482 fIntegralPAIxSection[i] = fIntegralPAIxSection[i+1] +
1483 SumOverBorder(i+1,fEnergyInterval[k]);
1484 fIntegralPAIdEdx[i] = fIntegralPAIdEdx[i+1] +
1485 SumOverBorderdEdx(i+1,fEnergyInterval[k]);
1486 k--;
1487 }
1488 if(fVerbose>0) G4cout<<"i = "<<i<<"; k = "<<k<<"; intPAIxsc[i] = "<<fIntegralPAIxSection[i]<<G4endl;
1489 }
1490} // end of IntegralPAIxSection
G4PAIxSection::SumOverIntervaldEdx
G4double SumOverIntervaldEdx(G4int intervalNumber)
Definition G4PAIxSection.cc:1662
G4PAIxSection::SumOverBorderdEdx
G4double SumOverBorderdEdx(G4int intervalNumber, G4double energy)
Definition G4PAIxSection.cc:1917
G4PAIxSection::SumOverInterval
G4double SumOverInterval(G4int intervalNumber)
Definition G4PAIxSection.cc:1614
G4PAIxSection::SumOverBorder
G4double SumOverBorder(G4int intervalNumber, G4double energy)
Definition G4PAIxSection.cc:1844

Referenced by G4PAIxSection(), G4PAIxSection(), Initialize(), and InitPAI().

◆ IntegralPlasmon()

void G4PAIxSection::IntegralPlasmon ( )

Definition at line 1560 of file G4PAIxSection.cc.

1561{
1562 fIntegralPlasmon[fSplineNumber] = 0;
1563 fIntegralPlasmon[0] = 0;
1564 G4int k = fIntervalNumber -1;
1565 for(G4int i=fSplineNumber-1;i>=1;i--)
1566 {
1567 if(fSplineEnergy[i] >= fEnergyInterval[k])
1568 {
1569 fIntegralPlasmon[i] = fIntegralPlasmon[i+1] + SumOverInterPlasmon(i);
1570 }
1571 else
1572 {
1573 fIntegralPlasmon[i] = fIntegralPlasmon[i+1] +
1574 SumOverBordPlasmon(i+1,fEnergyInterval[k]);
1575 k--;
1576 }
1577 }
1578
1579} // end of IntegralPlasmon
G4PAIxSection::SumOverInterPlasmon
G4double SumOverInterPlasmon(G4int intervalNumber)
Definition G4PAIxSection.cc:1775
G4PAIxSection::SumOverBordPlasmon
G4double SumOverBordPlasmon(G4int intervalNumber, G4double energy)
Definition G4PAIxSection.cc:2096

Referenced by G4PAIxSection(), G4PAIxSection(), Initialize(), and InitPAI().

◆ IntegralResonance()

void G4PAIxSection::IntegralResonance ( )

Definition at line 1587 of file G4PAIxSection.cc.

1588{
1589 fIntegralResonance[fSplineNumber] = 0;
1590 fIntegralResonance[0] = 0;
1591 G4int k = fIntervalNumber -1;
1592 for(G4int i=fSplineNumber-1;i>=1;i--)
1593 {
1594 if(fSplineEnergy[i] >= fEnergyInterval[k])
1595 {
1596 fIntegralResonance[i] = fIntegralResonance[i+1] + SumOverInterResonance(i);
1597 }
1598 else
1599 {
1600 fIntegralResonance[i] = fIntegralResonance[i+1] +
1601 SumOverBordResonance(i+1,fEnergyInterval[k]);
1602 k--;
1603 }
1604 }
1605
1606} // end of IntegralResonance
G4PAIxSection::SumOverBordResonance
G4double SumOverBordResonance(G4int intervalNumber, G4double energy)
Definition G4PAIxSection.cc:2150
G4PAIxSection::SumOverInterResonance
G4double SumOverInterResonance(G4int intervalNumber)
Definition G4PAIxSection.cc:1810

Referenced by G4PAIxSection(), G4PAIxSection(), Initialize(), and InitPAI().

◆ NormShift()

void G4PAIxSection::NormShift ( G4double betaGammaSq)

Definition at line 873 of file G4PAIxSection.cc.

874{
875 G4int i, j;
876
877 if(fVerbose>0) G4cout<<" G4PAIxSection::NormShift call "<<G4endl;
878
879
880 for( i = 1; i <= fIntervalNumber-1; i++ )
881 {
882 for( j = 1; j <= 2; j++ )
883 {
884 fSplineNumber = (i-1)*2 + j;
885
886 if( j == 1 ) fSplineEnergy[fSplineNumber] = fEnergyInterval[i ]*(1+fDelta);
887 else fSplineEnergy[fSplineNumber] = fEnergyInterval[i+1]*(1-fDelta);
888 if(fVerbose>0) G4cout<<"cn = "<<fSplineNumber<<"; "<<"w = "<<fSplineEnergy[fSplineNumber]/keV<<" keV"<<G4endl;
889 }
890 }
891 fIntegralTerm[1]=RutherfordIntegral(1,fEnergyInterval[1],fSplineEnergy[1]);
892
893 j = 1;
894
895 for( i = 2; i <= fSplineNumber; i++ )
896 {
897 if( fSplineEnergy[i]<fEnergyInterval[j+1] )
898 {
899 fIntegralTerm[i] = fIntegralTerm[i-1] +
900 RutherfordIntegral(j,fSplineEnergy[i-1],
901 fSplineEnergy[i] );
902 }
903 else
904 {
905 G4double x = RutherfordIntegral(j,fSplineEnergy[i-1],
906 fEnergyInterval[j+1] );
907 j++;
908 fIntegralTerm[i] = fIntegralTerm[i-1] + x +
909 RutherfordIntegral(j,fEnergyInterval[j],
910 fSplineEnergy[i] );
911 }
912 if(fVerbose>0) G4cout<<i<<" Shift: w = "<<fSplineEnergy[i]/keV<<" keV \t"<<fIntegralTerm[i]<<"\n"<<G4endl;
913 }
914 fNormalizationCof = 2*pi*pi*hbarc*hbarc*fine_structure_const/electron_mass_c2;
915 fNormalizationCof *= fElectronDensity/fIntegralTerm[fSplineNumber];
916
917 // G4cout<<"fNormalizationCof = "<<fNormalizationCof<<G4endl;
918
919 // Calculation of PAI differrential cross-section (1/(keV*cm))
920 // in the energy points near borders of energy intervals
921
922 for(G4int k = 1; k <= fIntervalNumber-1; k++ )
923 {
924 for( j = 1; j <= 2; j++ )
925 {
926 i = (k-1)*2 + j;
927 fImPartDielectricConst[i] = fNormalizationCof*
928 ImPartDielectricConst(k,fSplineEnergy[i]);
929 fRePartDielectricConst[i] = fNormalizationCof*
930 RePartDielectricConst(fSplineEnergy[i]);
931 fIntegralTerm[i] *= fNormalizationCof;
932
933 fDifPAIxSection[i] = DifPAIxSection(i,betaGammaSq);
934 fdNdxCerenkov[i] = PAIdNdxCerenkov(i,betaGammaSq);
935 fdNdxMM[i] = PAIdNdxMM(i,betaGammaSq);
936 fdNdxPlasmon[i] = PAIdNdxPlasmon(i,betaGammaSq);
937 fdNdxResonance[i] = PAIdNdxResonance(i,betaGammaSq);
938 if(fVerbose>0) G4cout<<i<<" Shift: w = "<<fSplineEnergy[i]/keV<<" keV, xsc = "<<fDifPAIxSection[i]<<"\n"<<G4endl;
939 }
940 }
941
942} // end of NormShift
G4PAIxSection::RutherfordIntegral
G4double RutherfordIntegral(G4int intervalNumber, G4double limitLow, G4double limitHigh)
Definition G4PAIxSection.cc:1055
G4PAIxSection::ImPartDielectricConst
G4double ImPartDielectricConst(G4int intervalNumber, G4double energy)
Definition G4PAIxSection.cc:1076
G4PAIxSection::RePartDielectricConst
G4double RePartDielectricConst(G4double energy)
Definition G4PAIxSection.cc:1167

Referenced by G4PAIxSection(), G4PAIxSection(), Initialize(), and InitPAI().

◆ operator=()

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

◆ PAIdNdxCerenkov()

G4double G4PAIxSection::PAIdNdxCerenkov ( G4int intervalNumber,
G4double betaGammaSq )

Definition at line 1282 of file G4PAIxSection.cc.

1284{
1285 G4double logarithm, x3, x5, argument, modul2, dNdxC;
1286 G4double be2, betaBohr2, cofBetaBohr;
1287
1288 cofBetaBohr = 4.0;
1289 betaBohr2 = fine_structure_const*fine_structure_const;
1290 G4double betaBohr4 = betaBohr2*betaBohr2*cofBetaBohr;
1291
1292 be2 = betaGammaSq/(1 + betaGammaSq);
1293 G4double be4 = be2*be2;
1294
1295 if( betaGammaSq < 0.01 ) logarithm = std::log(1.0+betaGammaSq); // 0.0;
1296 else
1297 {
1298 logarithm = -log( (1/betaGammaSq - fRePartDielectricConst[i])*
1299 (1/betaGammaSq - fRePartDielectricConst[i]) +
1300 fImPartDielectricConst[i]*fImPartDielectricConst[i] )*0.5;
1301 logarithm += log(1+1.0/betaGammaSq);
1302 }
1303
1304 if( fImPartDielectricConst[i] == 0.0 || betaGammaSq < 0.01 )
1305 {
1306 argument = 0.0;
1307 }
1308 else
1309 {
1310 x3 = -fRePartDielectricConst[i] + 1.0/betaGammaSq;
1311 x5 = -1.0 - fRePartDielectricConst[i] +
1312 be2*((1.0 +fRePartDielectricConst[i])*(1.0 + fRePartDielectricConst[i]) +
1313 fImPartDielectricConst[i]*fImPartDielectricConst[i]);
1314 if( x3 == 0.0 ) argument = 0.5*pi;
1315 else argument = std::atan2(fImPartDielectricConst[i],x3);
1316 argument *= x5 ;
1317 }
1318 dNdxC = ( logarithm*fImPartDielectricConst[i] + argument )/hbarc;
1319
1320 if(dNdxC < 1.0e-8) dNdxC = 1.0e-8;
1321
1322 dNdxC *= fine_structure_const/be2/pi;
1323
1324 dNdxC *= (1-std::exp(-be4/betaBohr4));
1325
1326 modul2 = (1.0 + fRePartDielectricConst[i])*(1.0 + fRePartDielectricConst[i]) +
1327 fImPartDielectricConst[i]*fImPartDielectricConst[i];
1328 if(modul2 >= 0.0)
1329 {
1330 dNdxC /= modul2;
1331 }
1332 return dNdxC;
1333
1334} // end of PAIdNdxCerenkov

Referenced by G4PAIxSection(), G4PAIxSection(), Initialize(), InitPAI(), NormShift(), and SplainPAI().

◆ PAIdNdxMM()

G4double G4PAIxSection::PAIdNdxMM ( G4int intervalNumber,
G4double betaGammaSq )

Definition at line 1340 of file G4PAIxSection.cc.

1342{
1343 G4double logarithm, x3, x5, argument, dNdxC;
1344 G4double be2, be4, betaBohr2,betaBohr4,cofBetaBohr;
1345
1346 cofBetaBohr = 4.0;
1347 betaBohr2 = fine_structure_const*fine_structure_const;
1348 betaBohr4 = betaBohr2*betaBohr2*cofBetaBohr;
1349
1350 be2 = betaGammaSq/(1 + betaGammaSq);
1351 be4 = be2*be2;
1352
1353 if( betaGammaSq < 0.01 ) logarithm = log(1.0+betaGammaSq); // 0.0;
1354 else
1355 {
1356 logarithm = -log( (1/betaGammaSq - fRePartDielectricConst[i])*
1357 (1/betaGammaSq - fRePartDielectricConst[i]) +
1358 fImPartDielectricConst[i]*fImPartDielectricConst[i] )*0.5;
1359 logarithm += log(1+1.0/betaGammaSq);
1360 }
1361
1362 if( fImPartDielectricConst[i] == 0.0 || betaGammaSq < 0.01 )
1363 {
1364 argument = 0.0;
1365 }
1366 else
1367 {
1368 x3 = -fRePartDielectricConst[i] + 1.0/betaGammaSq;
1369 x5 = be2*( 1.0 + fRePartDielectricConst[i] ) - 1.0;
1370 if( x3 == 0.0 ) argument = 0.5*pi;
1371 else argument = atan2(fImPartDielectricConst[i],x3);
1372 argument *= x5 ;
1373 }
1374 dNdxC = ( logarithm*fImPartDielectricConst[i]*be2 + argument )/hbarc;
1375
1376 if(dNdxC < 1.0e-8) dNdxC = 1.0e-8;
1377
1378 dNdxC *= fine_structure_const/be2/pi;
1379
1380 dNdxC *= (1-std::exp(-be4/betaBohr4));
1381 return dNdxC;
1382
1383} // end of PAIdNdxMM

Referenced by G4PAIxSection(), G4PAIxSection(), Initialize(), InitPAI(), NormShift(), and SplainPAI().

◆ PAIdNdxPlasmon()

G4double G4PAIxSection::PAIdNdxPlasmon ( G4int intervalNumber,
G4double betaGammaSq )

Definition at line 1390 of file G4PAIxSection.cc.

1392{
1393 G4double resonance, modul2, dNdxP, cof = 1.;
1394 G4double be2, betaBohr;
1395
1396 betaBohr = fine_structure_const;
1397 be2 = betaGammaSq/(1 + betaGammaSq);
1398
1399 G4double beta = std::sqrt(be2);
1400
1401 resonance = std::log(2*electron_mass_c2*be2/fSplineEnergy[i]);
1402 resonance *= fImPartDielectricConst[i]/hbarc;
1403
1404 dNdxP = ( resonance + cof*fIntegralTerm[i]/fSplineEnergy[i]/fSplineEnergy[i] );
1405
1406 if( dNdxP < 1.0e-8 ) dNdxP = 1.0e-8;
1407
1408 dNdxP *= fine_structure_const/be2/pi;
1409
1410 dNdxP *= (1 - std::exp(-beta/betaBohr/fLowEnergyCof));
1411
1412 modul2 = (1 + fRePartDielectricConst[i])*(1 + fRePartDielectricConst[i]) +
1413 fImPartDielectricConst[i]*fImPartDielectricConst[i];
1414 if( modul2 >= 0.0 )
1415 {
1416 dNdxP /= modul2;
1417 }
1418 return dNdxP;
1419
1420} // end of PAIdNdxPlasmon

Referenced by G4PAIxSection(), G4PAIxSection(), Initialize(), InitPAI(), NormShift(), and SplainPAI().

◆ PAIdNdxResonance()

G4double G4PAIxSection::PAIdNdxResonance ( G4int intervalNumber,
G4double betaGammaSq )

Definition at line 1427 of file G4PAIxSection.cc.

1429{
1430 G4double resonance, modul2, dNdxP;
1431 G4double be2, be4, betaBohr2, betaBohr4, cofBetaBohr;
1432
1433 cofBetaBohr = 4.0;
1434 betaBohr2 = fine_structure_const*fine_structure_const;
1435 betaBohr4 = betaBohr2*betaBohr2*cofBetaBohr;
1436
1437 be2 = betaGammaSq/(1 + betaGammaSq);
1438 be4 = be2*be2;
1439
1440 resonance = log(2*electron_mass_c2*be2/fSplineEnergy[i]);
1441 resonance *= fImPartDielectricConst[i]/hbarc;
1442
1443 dNdxP = resonance;
1444
1445 if( dNdxP < 1.0e-8 ) dNdxP = 1.0e-8;
1446
1447 dNdxP *= fine_structure_const/be2/pi;
1448 dNdxP *= (1 - std::exp(-be4/betaBohr4));
1449
1450 modul2 = (1 + fRePartDielectricConst[i])*(1 + fRePartDielectricConst[i]) +
1451 fImPartDielectricConst[i]*fImPartDielectricConst[i];
1452 if( modul2 >= 0.0 )
1453 {
1454 dNdxP /= modul2;
1455 }
1456 return dNdxP;
1457
1458} // end of PAIdNdxResonance

Referenced by G4PAIxSection(), G4PAIxSection(), Initialize(), InitPAI(), NormShift(), and SplainPAI().

◆ RePartDielectricConst()

G4double G4PAIxSection::RePartDielectricConst ( G4double energy)

Definition at line 1167 of file G4PAIxSection.cc.

1168{
1169 G4double x0, x02, x03, x04, x05, x1, x2, xx1 ,xx2 , xx12,
1170 c1, c2, c3, cof1, cof2, xln1, xln2, xln3, result;
1171
1172 x0 = enb;
1173 result = 0;
1174
1175 for(G4int i=1;i<=fIntervalNumber-1;i++)
1176 {
1177 x1 = fEnergyInterval[i];
1178 x2 = fEnergyInterval[i+1];
1179 xx1 = x1 - x0;
1180 xx2 = x2 - x0;
1181 xx12 = xx2/xx1;
1182
1183 if(xx12<0)
1184 {
1185 xx12 = -xx12;
1186 }
1187 xln1 = log(x2/x1);
1188 xln2 = log(xx12);
1189 xln3 = log((x2 + x0)/(x1 + x0));
1190 x02 = x0*x0;
1191 x03 = x02*x0;
1192 x04 = x03*x0;
1193 x05 = x04*x0;
1194 c1 = (x2 - x1)/x1/x2;
1195 c2 = (x2 - x1)*(x2 +x1)/x1/x1/x2/x2;
1196 c3 = (x2 -x1)*(x1*x1 + x1*x2 + x2*x2)/x1/x1/x1/x2/x2/x2;
1197
1198 result -= (fA1[i]/x02 + fA3[i]/x04)*xln1;
1199 result -= (fA2[i]/x02 + fA4[i]/x04)*c1;
1200 result -= fA3[i]*c2/2/x02;
1201 result -= fA4[i]*c3/3/x02;
1202
1203 cof1 = fA1[i]/x02 + fA3[i]/x04;
1204 cof2 = fA2[i]/x03 + fA4[i]/x05;
1205
1206 result += 0.5*(cof1 +cof2)*xln2;
1207 result += 0.5*(cof1 - cof2)*xln3;
1208 }
1209 result *= 2*hbarc/pi;
1210
1211 return result;
1212
1213} // end of RePartDielectricConst

Referenced by NormShift(), and SplainPAI().

◆ RutherfordIntegral()

G4double G4PAIxSection::RutherfordIntegral ( G4int intervalNumber,
G4double limitLow,
G4double limitHigh )

Definition at line 1055 of file G4PAIxSection.cc.

1058{
1059 G4double c1, c2, c3;
1060 // G4cout<<"RI: x1 = "<<x1<<"; "<<"x2 = "<<x2<<G4endl;
1061 c1 = (x2 - x1)/x1/x2;
1062 c2 = (x2 - x1)*(x2 + x1)/x1/x1/x2/x2;
1063 c3 = (x2 - x1)*(x1*x1 + x1*x2 + x2*x2)/x1/x1/x1/x2/x2/x2;
1064 // G4cout<<" RI: c1 = "<<c1<<"; "<<"c2 = "<<c2<<"; "<<"c3 = "<<c3<<G4endl;
1065
1066 return fA1[k]*log(x2/x1) + fA2[k]*c1 + fA3[k]*c2/2 + fA4[k]*c3/3;
1067
1068} // end of RutherfordIntegral

Referenced by NormShift(), and SplainPAI().

◆ SetVerbose()

void G4PAIxSection::SetVerbose ( G4int v)
inline

Definition at line 194 of file G4PAIxSection.hh.

194{ fVerbose=v; };

◆ SplainPAI()

void G4PAIxSection::SplainPAI ( G4double betaGammaSq)

Definition at line 950 of file G4PAIxSection.cc.

951{
952 G4int j, k = 1, i = 1;
953
954 if(fVerbose>0) G4cout<<" G4PAIxSection::SplainPAI call "<<G4endl;
955
956 while ( (i < fSplineNumber) && (fSplineNumber < fMaxSplineSize-1) )
957 {
958 // if( std::abs(fSplineEnergy[i+1]-fEnergyInterval[k+1]) > (fSplineEnergy[i+1]+fEnergyInterval[k+1])*5.e-7 )
959 if( fSplineEnergy[i+1] > fEnergyInterval[k+1] )
960 {
961 k++; // Here next energy point is in next energy interval
962 i++;
963 if(fVerbose>0) G4cout<<" in if: i = "<<i<<"; k = "<<k<<G4endl;
964 continue;
965 }
966 if(fVerbose>0) G4cout<<" out if: i = "<<i<<"; k = "<<k<<G4endl;
967
968 // Shifting of arrayes for inserting the geometrical
969 // average of 'i' and 'i+1' energy points to 'i+1' place
970 fSplineNumber++;
971
972 for( j = fSplineNumber; j >= i+2; j-- )
973 {
974 fSplineEnergy[j] = fSplineEnergy[j-1];
975 fImPartDielectricConst[j] = fImPartDielectricConst[j-1];
976 fRePartDielectricConst[j] = fRePartDielectricConst[j-1];
977 fIntegralTerm[j] = fIntegralTerm[j-1];
978
979 fDifPAIxSection[j] = fDifPAIxSection[j-1];
980 fdNdxCerenkov[j] = fdNdxCerenkov[j-1];
981 fdNdxMM[j] = fdNdxMM[j-1];
982 fdNdxPlasmon[j] = fdNdxPlasmon[j-1];
983 fdNdxResonance[j] = fdNdxResonance[j-1];
984 }
985 G4double x1 = fSplineEnergy[i];
986 G4double x2 = fSplineEnergy[i+1];
987 G4double yy1 = fDifPAIxSection[i];
988 G4double y2 = fDifPAIxSection[i+1];
989
990 if(fVerbose>0) G4cout<<"Spline: x1 = "<<x1<<"; x2 = "<<x2<<", yy1 = "<<yy1<<"; y2 = "<<y2<<G4endl;
991
992
993 G4double en1 = sqrt(x1*x2);
994 // G4double en1 = 0.5*(x1 + x2);
995
996
997 fSplineEnergy[i+1] = en1;
998
999 // Calculation of logarithmic linear approximation
1000 // in this (enr) energy point, which number is 'i+1' now
1001
1002 G4double a = log10(y2/yy1)/log10(x2/x1);
1003 G4double b = log10(yy1) - a*log10(x1);
1004 G4double y = a*log10(en1) + b;
1005
1006 y = pow(10.,y);
1007
1008 // Calculation of the PAI dif. cross-section at this point
1009
1010 fImPartDielectricConst[i+1] = fNormalizationCof*
1011 ImPartDielectricConst(k,fSplineEnergy[i+1]);
1012 fRePartDielectricConst[i+1] = fNormalizationCof*
1013 RePartDielectricConst(fSplineEnergy[i+1]);
1014 fIntegralTerm[i+1] = fIntegralTerm[i] + fNormalizationCof*
1015 RutherfordIntegral(k,fSplineEnergy[i],
1016 fSplineEnergy[i+1]);
1017
1018 fDifPAIxSection[i+1] = DifPAIxSection(i+1,betaGammaSq);
1019 fdNdxCerenkov[i+1] = PAIdNdxCerenkov(i+1,betaGammaSq);
1020 fdNdxMM[i+1] = PAIdNdxMM(i+1,betaGammaSq);
1021 fdNdxPlasmon[i+1] = PAIdNdxPlasmon(i+1,betaGammaSq);
1022 fdNdxResonance[i+1] = PAIdNdxResonance(i+1,betaGammaSq);
1023
1024 // Condition for next division of this segment or to pass
1025
1026 if(fVerbose>0) G4cout<<"Spline, a = "<<a<<"; b = "<<b<<"; new xsc = "<<y<<"; compxsc = "<<fDifPAIxSection[i+1]<<G4endl;
1027
1028 // to higher energies
1029
1030 G4double x = 2*(fDifPAIxSection[i+1] - y)/(fDifPAIxSection[i+1] + y);
1031
1032 G4double delta = 2.*(fSplineEnergy[i+1]-fSplineEnergy[i])/(fSplineEnergy[i+1]+fSplineEnergy[i]);
1033
1034 if( x < 0 )
1035 {
1036 x = -x;
1037 }
1038 if( x > fError && fSplineNumber < fMaxSplineSize-1 && delta > 2.*fDelta )
1039 {
1040 continue; // next division
1041 }
1042 i += 2; // pass to next segment
1043
1044 // Loop checking, 03-Aug-2015, Vladimir Ivanchenko
1045 } // close 'while'
1046
1047} // end of SplainPAI

Referenced by G4PAIxSection(), G4PAIxSection(), Initialize(), and InitPAI().

◆ SumOverBordCerenkov()

G4double G4PAIxSection::SumOverBordCerenkov ( G4int intervalNumber,
G4double energy )

Definition at line 1972 of file G4PAIxSection.cc.

1973{
1974 G4double x0,x1,y0,yy1,a,b,e0,c,d,result;
1975
1976 e0 = en0;
1977 x0 = fSplineEnergy[i];
1978 x1 = fSplineEnergy[i+1];
1979 y0 = fdNdxCerenkov[i];
1980 yy1 = fdNdxCerenkov[i+1];
1981
1982 //G4cout<<"SumBordC, i = "<<i<<"; en0 = "<<en0<<"; x0 ="<<x0<<"; x1 = "<<x1
1983 //<<"; y0 = "<<y0<<"; yy1 = "<<yy1<<G4endl;
1984 c = x1/x0;
1985 d = e0/x0;
1986 a = log10(yy1/y0)/log10(c);
1987 //G4cout << " a= " << a << " c=" << c << G4endl;
1988
1989 b = 0.0;
1990 if(a < 20.) b = y0/pow(x0,a);
1991
1992 a += 1.0;
1993 if( a == 0 ) result = b*log(x0/e0);
1994 else result = y0*(x0 - e0*pow(d,a-1))/a;
1995 a += 1.0;
1996
1997 if( a == 0 ) fIntegralCerenkov[0] += b*log(x0/e0);
1998 else fIntegralCerenkov[0] += y0*(x0*x0 - e0*e0*pow(d,a-2))/a;
1999
2000 x0 = fSplineEnergy[i - 1];
2001 x1 = fSplineEnergy[i - 2];
2002 y0 = fdNdxCerenkov[i - 1];
2003 yy1 = fdNdxCerenkov[i - 2];
2004
2005 // G4cout<<"x0 ="<<x0<<"; x1 = "<<x1
2006 // <<"; y0 = "<<y0<<"; yy1 = "<<yy1<<G4endl;
2007
2008 c = x1/x0;
2009 d = e0/x0;
2010 a = log10(yy1/y0)/log10(c);
2011
2012 b = 0.0;
2013 if(a < 20.) b = y0/pow(x0,a);
2014
2015 a += 1.0;
2016 if( a == 0 ) result += b*log(e0/x0);
2017 else result += y0*(e0*pow(d,a-1) - x0 )/a;
2018 a += 1.0;
2019
2020 if( a == 0 ) fIntegralCerenkov[0] += b*log(e0/x0);
2021 else fIntegralCerenkov[0] += y0*(e0*e0*pow(d,a-2) - x0*x0)/a;
2022
2023 //G4cout<<" a="<< a <<" b="<< b <<" result="<<result<<G4endl;
2024 return result;
2025}

Referenced by IntegralCerenkov().

◆ SumOverBorder()

G4double G4PAIxSection::SumOverBorder ( G4int intervalNumber,
G4double energy )

Definition at line 1844 of file G4PAIxSection.cc.

1846{
1847 G4double x0,x1,y0,yy1,a,b,/*c,*/d,e0,result;
1848
1849 e0 = en0;
1850 x0 = fSplineEnergy[i];
1851 x1 = fSplineEnergy[i+1];
1852 y0 = fDifPAIxSection[i];
1853 yy1 = fDifPAIxSection[i+1];
1854
1855 //c = x1/x0;
1856 d = e0/x0;
1857 a = log10(yy1/y0)/log10(x1/x0);
1858
1859 if(fVerbose>0) G4cout<<"SumOverBorder, a = "<<a<<G4endl;
1860
1861 b = 0.0;
1862 if(a < 20.) b = y0/pow(x0,a);
1863
1864 a += 1.;
1865 if( std::abs(a) < 1.e-6 )
1866 {
1867 result = b*log(x0/e0);
1868 }
1869 else
1870 {
1871 result = y0*(x0 - e0*pow(d,a-1))/a;
1872 }
1873 a += 1.;
1874 if( std::abs(a) < 1.e-6 )
1875 {
1876 fIntegralPAIxSection[0] += b*log(x0/e0);
1877 }
1878 else
1879 {
1880 fIntegralPAIxSection[0] += y0*(x0*x0 - e0*e0*pow(d,a-2))/a;
1881 }
1882 x0 = fSplineEnergy[i - 1];
1883 x1 = fSplineEnergy[i - 2];
1884 y0 = fDifPAIxSection[i - 1];
1885 yy1 = fDifPAIxSection[i - 2];
1886
1887 d = e0/x0;
1888 a = log10(yy1/y0)/log10(x1/x0);
1889
1890 b = 0.0;
1891 if(a < 20.) b = y0/pow(x0,a);
1892
1893 a += 1.;
1894 if( std::abs(a) < 1.e-6 )
1895 {
1896 result += b*log(e0/x0);
1897 }
1898 else
1899 {
1900 result += y0*(e0*pow(d,a-1) - x0)/a;
1901 }
1902 a += 1.;
1903 if( std::abs(a) < 1.e-6 )
1904 {
1905 fIntegralPAIxSection[0] += b*log(e0/x0);
1906 }
1907 else
1908 {
1909 fIntegralPAIxSection[0] += y0*(e0*e0*pow(d,a-2) - x0*x0)/a;
1910 }
1911 return result;
1912
1913}

Referenced by IntegralPAIxSection().

◆ SumOverBorderdEdx()

G4double G4PAIxSection::SumOverBorderdEdx ( G4int intervalNumber,
G4double energy )

Definition at line 1917 of file G4PAIxSection.cc.

1918{
1919 G4double x0,x1,y0,yy1,a,b,d,e0,result;
1920
1921 e0 = en0;
1922 x0 = fSplineEnergy[i];
1923 x1 = fSplineEnergy[i+1];
1924 y0 = fDifPAIxSection[i];
1925 yy1 = fDifPAIxSection[i+1];
1926
1927 d = e0/x0;
1928 a = log10(yy1/y0)/log10(x1/x0);
1929
1930 b = 0.0;
1931 if(a < 20.) b = y0/pow(x0,a);
1932
1933 a += 2;
1934 if(a == 0)
1935 {
1936 result = b*log(x0/e0);
1937 }
1938 else
1939 {
1940 result = y0*(x0*x0 - e0*e0*pow(d,a-2))/a;
1941 }
1942 x0 = fSplineEnergy[i - 1];
1943 x1 = fSplineEnergy[i - 2];
1944 y0 = fDifPAIxSection[i - 1];
1945 yy1 = fDifPAIxSection[i - 2];
1946
1947 // c = x1/x0;
1948 d = e0/x0;
1949 a = log10(yy1/y0)/log10(x1/x0);
1950
1951 b = 0.0;
1952 if(a < 20.) b = y0/pow(x0,a);
1953
1954 a += 2;
1955 if(a == 0)
1956 {
1957 result += b*log(e0/x0);
1958 }
1959 else
1960 {
1961 result += y0*(e0*e0*pow(d,a-2) - x0*x0)/a;
1962 }
1963 return result;
1964
1965}

Referenced by IntegralPAIxSection().

◆ SumOverBordMM()

G4double G4PAIxSection::SumOverBordMM ( G4int intervalNumber,
G4double energy )

Definition at line 2032 of file G4PAIxSection.cc.

2033{
2034 G4double x0,x1,y0,yy1,a,b,e0,c,d,result;
2035
2036 e0 = en0;
2037 x0 = fSplineEnergy[i];
2038 x1 = fSplineEnergy[i+1];
2039 y0 = fdNdxMM[i];
2040 yy1 = fdNdxMM[i+1];
2041
2042 // G4cout<<"SumBordC, i = "<<i<<"; en0 = "<<en0<<"; x0 ="<<x0<<"; x1 = "<<x1
2043 // <<"; y0 = "<<y0<<"; yy1 = "<<yy1<<G4endl;
2044 c = x1/x0;
2045 d = e0/x0;
2046 a = log10(yy1/y0)/log10(c);
2047
2048 if(a > 20.0) b = 0.0;
2049 else b = y0/pow(x0,a);
2050
2051 a += 1.0;
2052 if( a == 0 ) result = b*log(x0/e0);
2053 else result = y0*(x0 - e0*pow(d,a-1))/a;
2054 a += 1.0;
2055
2056 if( a == 0 ) fIntegralMM[0] += b*log(x0/e0);
2057 else fIntegralMM[0] += y0*(x0*x0 - e0*e0*pow(d,a-2))/a;
2058
2059 // G4cout<<"a = "<<a<<"; b0 = "<<b0<<"; b = "<<b<<"; result = "<<result<<G4endl;
2060
2061 x0 = fSplineEnergy[i - 1];
2062 x1 = fSplineEnergy[i - 2];
2063 y0 = fdNdxMM[i - 1];
2064 yy1 = fdNdxMM[i - 2];
2065
2066 // G4cout<<"x0 ="<<x0<<"; x1 = "<<x1
2067 // <<"; y0 = "<<y0<<"; yy1 = "<<yy1<<G4endl;
2068
2069 c = x1/x0;
2070 d = e0/x0;
2071 a = log10(yy1/y0)/log10(x1/x0);
2072
2073 if(a > 20.0) b = 0.0;
2074 else b = y0/pow(x0,a);
2075
2076 a += 1.0;
2077 if( a == 0 ) result += b*log(e0/x0);
2078 else result += y0*(e0*pow(d,a-1) - x0 )/a;
2079 a += 1.0;
2080
2081 if( a == 0 ) fIntegralMM[0] += b*log(e0/x0);
2082 else fIntegralMM[0] += y0*(e0*e0*pow(d,a-2) - x0*x0)/a;
2083
2084 // G4cout<<"a = "<<a<<"; b0 = "<<b0<<"; b = "
2085 // <<b<<"; result = "<<result<<G4endl;
2086
2087 return result;
2088
2089}

Referenced by IntegralMM().

◆ SumOverBordPlasmon()

G4double G4PAIxSection::SumOverBordPlasmon ( G4int intervalNumber,
G4double energy )

Definition at line 2096 of file G4PAIxSection.cc.

2098{
2099 G4double x0,x1,y0,yy1,a,b,c,d,e0,result;
2100
2101 e0 = en0;
2102 x0 = fSplineEnergy[i];
2103 x1 = fSplineEnergy[i+1];
2104 y0 = fdNdxPlasmon[i];
2105 yy1 = fdNdxPlasmon[i+1];
2106
2107 c = x1/x0;
2108 d = e0/x0;
2109 a = log10(yy1/y0)/log10(c);
2110
2111 if(a > 20.0) b = 0.0;
2112 else b = y0/pow(x0,a);
2113
2114 a += 1.0;
2115 if( a == 0 ) result = b*log(x0/e0);
2116 else result = y0*(x0 - e0*pow(d,a-1))/a;
2117 a += 1.0;
2118
2119 if( a == 0 ) fIntegralPlasmon[0] += b*log(x0/e0);
2120 else fIntegralPlasmon[0] += y0*(x0*x0 - e0*e0*pow(d,a-2))/a;
2121
2122 x0 = fSplineEnergy[i - 1];
2123 x1 = fSplineEnergy[i - 2];
2124 y0 = fdNdxPlasmon[i - 1];
2125 yy1 = fdNdxPlasmon[i - 2];
2126
2127 c = x1/x0;
2128 d = e0/x0;
2129 a = log10(yy1/y0)/log10(c);
2130
2131 if(a > 20.0) b = 0.0;
2132 else b = y0/pow(x0,a);
2133
2134 a += 1.0;
2135 if( a == 0 ) result += b*log(e0/x0);
2136 else result += y0*(e0*pow(d,a-1) - x0)/a;
2137 a += 1.0;
2138
2139 if( a == 0 ) fIntegralPlasmon[0] += b*log(e0/x0);
2140 else fIntegralPlasmon[0] += y0*(e0*e0*pow(d,a-2) - x0*x0)/a;
2141
2142 return result;
2143}

Referenced by IntegralPlasmon().

◆ SumOverBordResonance()

G4double G4PAIxSection::SumOverBordResonance ( G4int intervalNumber,
G4double energy )

Definition at line 2150 of file G4PAIxSection.cc.

2152{
2153 G4double x0,x1,y0,yy1,a,b,c,d,e0,result;
2154
2155 e0 = en0;
2156 x0 = fSplineEnergy[i];
2157 x1 = fSplineEnergy[i+1];
2158 y0 = fdNdxResonance[i];
2159 yy1 = fdNdxResonance[i+1];
2160
2161 c = x1/x0;
2162 d = e0/x0;
2163 a = log10(yy1/y0)/log10(c);
2164
2165 if(a > 20.0) b = 0.0;
2166 else b = y0/pow(x0,a);
2167
2168 a += 1.0;
2169 if( a == 0 ) result = b*log(x0/e0);
2170 else result = y0*(x0 - e0*pow(d,a-1))/a;
2171 a += 1.0;
2172
2173 if( a == 0 ) fIntegralResonance[0] += b*log(x0/e0);
2174 else fIntegralResonance[0] += y0*(x0*x0 - e0*e0*pow(d,a-2))/a;
2175
2176 x0 = fSplineEnergy[i - 1];
2177 x1 = fSplineEnergy[i - 2];
2178 y0 = fdNdxResonance[i - 1];
2179 yy1 = fdNdxResonance[i - 2];
2180
2181 c = x1/x0;
2182 d = e0/x0;
2183 a = log10(yy1/y0)/log10(c);
2184
2185 if(a > 20.0) b = 0.0;
2186 else b = y0/pow(x0,a);
2187
2188 a += 1.0;
2189 if( a == 0 ) result += b*log(e0/x0);
2190 else result += y0*(e0*pow(d,a-1) - x0)/a;
2191 a += 1.0;
2192
2193 if( a == 0 ) fIntegralResonance[0] += b*log(e0/x0);
2194 else fIntegralResonance[0] += y0*(e0*e0*pow(d,a-2) - x0*x0)/a;
2195
2196 return result;
2197
2198}

Referenced by IntegralResonance().

◆ SumOverInterCerenkov()

G4double G4PAIxSection::SumOverInterCerenkov ( G4int intervalNumber)

Definition at line 1698 of file G4PAIxSection.cc.

1699{
1700 G4double x0,x1,y0,yy1,a,b,c,result;
1701
1702 x0 = fSplineEnergy[i];
1703 x1 = fSplineEnergy[i+1];
1704
1705 if(x1+x0 <= 0.0 || std::abs( 2.*(x1-x0)/(x1+x0) ) < 1.e-6) return 0.;
1706
1707 y0 = fdNdxCerenkov[i];
1708 yy1 = fdNdxCerenkov[i+1];
1709 // G4cout<<"SumC, i = "<<i<<"; x0 ="<<x0<<"; x1 = "<<x1
1710 // <<"; y0 = "<<y0<<"; yy1 = "<<yy1<<G4endl;
1711
1712 c = x1/x0;
1713 a = log10(yy1/y0)/log10(c);
1714
1715 if(a > 20.0) b = 0.0;
1716 else b = y0/pow(x0,a);
1717
1718 a += 1.0;
1719 if(a == 0) result = b*log(c);
1720 else result = y0*(x1*pow(c,a-1) - x0)/a;
1721 a += 1.0;
1722
1723 if( a == 0 ) fIntegralCerenkov[0] += b*log(x1/x0);
1724 else fIntegralCerenkov[0] += y0*(x1*x1*pow(c,a-2) - x0*x0)/a;
1725 // G4cout<<"a = "<<a<<"; b = "<<b<<"; result = "<<result<<G4endl;
1726 return result;
1727
1728} // end of SumOverInterCerenkov

Referenced by IntegralCerenkov().

◆ SumOverInterMM()

G4double G4PAIxSection::SumOverInterMM ( G4int intervalNumber)

Definition at line 1736 of file G4PAIxSection.cc.

1737{
1738 G4double x0,x1,y0,yy1,a,b,c,result;
1739
1740 x0 = fSplineEnergy[i];
1741 x1 = fSplineEnergy[i+1];
1742
1743 if(x1+x0 <= 0.0 || std::abs( 2.*(x1-x0)/(x1+x0) ) < 1.e-6) return 0.;
1744
1745 y0 = fdNdxMM[i];
1746 yy1 = fdNdxMM[i+1];
1747 //G4cout<<"SumC, i = "<<i<<"; x0 ="<<x0<<"; x1 = "<<x1
1748 // <<"; y0 = "<<y0<<"; yy1 = "<<yy1<<G4endl;
1749
1750 c = x1/x0;
1751 //G4cout<<" c = "<<c<< " yy1/y0= " << yy1/y0 <<G4endl;
1752 a = log10(yy1/y0)/log10(c);
1753
1754 b = 0.0;
1755 if(a < 20.) b = y0/pow(x0,a);
1756
1757 a += 1.0;
1758 if(a == 0) result = b*log(c);
1759 else result = y0*(x1*pow(c,a-1) - x0)/a;
1760 a += 1.0;
1761
1762 if( a == 0 ) fIntegralMM[0] += b*log(c);
1763 else fIntegralMM[0] += y0*(x1*x1*pow(c,a-2) - x0*x0)/a;
1764 //G4cout<<"a = "<<a<<"; b = "<<b<<"; result = "<<result<<G4endl;
1765 return result;
1766
1767} // end of SumOverInterMM

Referenced by IntegralMM().

◆ SumOverInterPlasmon()

G4double G4PAIxSection::SumOverInterPlasmon ( G4int intervalNumber)

Definition at line 1775 of file G4PAIxSection.cc.

1776{
1777 G4double x0,x1,y0,yy1,a,b,c,result;
1778
1779 x0 = fSplineEnergy[i];
1780 x1 = fSplineEnergy[i+1];
1781
1782 if(x1+x0 <= 0.0 || std::abs( 2.*(x1-x0)/(x1+x0) ) < 1.e-6) return 0.;
1783
1784 y0 = fdNdxPlasmon[i];
1785 yy1 = fdNdxPlasmon[i+1];
1786 c = x1/x0;
1787 a = log10(yy1/y0)/log10(c);
1788
1789 b = 0.0;
1790 if(a < 20.) b = y0/pow(x0,a);
1791
1792 a += 1.0;
1793 if(a == 0) result = b*log(x1/x0);
1794 else result = y0*(x1*pow(c,a-1) - x0)/a;
1795 a += 1.0;
1796
1797 if( a == 0 ) fIntegralPlasmon[0] += b*log(x1/x0);
1798 else fIntegralPlasmon[0] += y0*(x1*x1*pow(c,a-2) - x0*x0)/a;
1799
1800 return result;
1801
1802} // end of SumOverInterPlasmon

Referenced by IntegralPlasmon().

◆ SumOverInterResonance()

G4double G4PAIxSection::SumOverInterResonance ( G4int intervalNumber)

Definition at line 1810 of file G4PAIxSection.cc.

1811{
1812 G4double x0,x1,y0,yy1,a,b,c,result;
1813
1814 x0 = fSplineEnergy[i];
1815 x1 = fSplineEnergy[i+1];
1816
1817 if(x1+x0 <= 0.0 || std::abs( 2.*(x1-x0)/(x1+x0) ) < 1.e-6) return 0.;
1818
1819 y0 = fdNdxResonance[i];
1820 yy1 = fdNdxResonance[i+1];
1821 c =x1/x0;
1822 a = log10(yy1/y0)/log10(c);
1823
1824 b = 0.0;
1825 if(a < 20.) b = y0/pow(x0,a);
1826
1827 a += 1.0;
1828 if(a == 0) result = b*log(x1/x0);
1829 else result = y0*(x1*pow(c,a-1) - x0)/a;
1830 a += 1.0;
1831
1832 if( a == 0 ) fIntegralResonance[0] += b*log(x1/x0);
1833 else fIntegralResonance[0] += y0*(x1*x1*pow(c,a-2) - x0*x0)/a;
1834
1835 return result;
1836
1837} // end of SumOverInterResonance

Referenced by IntegralResonance().

◆ SumOverInterval()

G4double G4PAIxSection::SumOverInterval ( G4int intervalNumber)

Definition at line 1614 of file G4PAIxSection.cc.

1615{
1616 G4double x0,x1,y0,yy1,a,b,c,result;
1617
1618 x0 = fSplineEnergy[i];
1619 x1 = fSplineEnergy[i+1];
1620 if(fVerbose>0) G4cout<<"SumOverInterval i= " << i << " x0 = "<<x0<<"; x1 = "<<x1<<G4endl;
1621
1622 if( x1+x0 <= 0.0 || std::abs( 2.*(x1-x0)/(x1+x0) ) < 1.e-6) return 0.;
1623
1624 y0 = fDifPAIxSection[i];
1625 yy1 = fDifPAIxSection[i+1];
1626
1627 if(fVerbose>0) G4cout<<"x0 = "<<x0<<"; x1 = "<<x1<<", y0 = "<<y0<<"; yy1 = "<<yy1<<G4endl;
1628
1629 c = x1/x0;
1630 a = log10(yy1/y0)/log10(c);
1631
1632 if(fVerbose>0) G4cout<<"SumOverInterval, a = "<<a<<"; c = "<<c<<G4endl;
1633
1634 b = 0.0;
1635 if(a < 20.) b = y0/pow(x0,a);
1636
1637 a += 1.;
1638 if( std::abs(a) < 1.e-6 )
1639 {
1640 result = b*log(x1/x0);
1641 }
1642 else
1643 {
1644 result = y0*(x1*pow(c,a-1) - x0)/a;
1645 }
1646 a += 1.;
1647 if( std::abs(a) < 1.e-6 )
1648 {
1649 fIntegralPAIxSection[0] += b*log(x1/x0);
1650 }
1651 else
1652 {
1653 fIntegralPAIxSection[0] += y0*(x1*x1*pow(c,a-2) - x0*x0)/a;
1654 }
1655 if(fVerbose>0) G4cout<<"SumOverInterval, result = "<<result<<G4endl;
1656 return result;
1657
1658} // end of SumOverInterval

Referenced by IntegralPAIxSection().

◆ SumOverIntervaldEdx()

G4double G4PAIxSection::SumOverIntervaldEdx ( G4int intervalNumber)

Definition at line 1662 of file G4PAIxSection.cc.

1663{
1664 G4double x0,x1,y0,yy1,a,b,c,result;
1665
1666 x0 = fSplineEnergy[i];
1667 x1 = fSplineEnergy[i+1];
1668
1669 if(x1+x0 <= 0.0 || std::abs( 2.*(x1-x0)/(x1+x0) ) < 1.e-6) return 0.;
1670
1671 y0 = fDifPAIxSection[i];
1672 yy1 = fDifPAIxSection[i+1];
1673 c = x1/x0;
1674 a = log10(yy1/y0)/log10(c);
1675
1676 b = 0.0;
1677 if(a < 20.) b = y0/pow(x0,a);
1678
1679 a += 2;
1680 if(a == 0)
1681 {
1682 result = b*log(x1/x0);
1683 }
1684 else
1685 {
1686 result = y0*(x1*x1*pow(c,a-2) - x0*x0)/a;
1687 }
1688 return result;
1689
1690} // end of SumOverInterval

Referenced by IntegralPAIxSection().

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