source: trunk/source/processes/electromagnetic/lowenergy/src/G4DNARuddIonisationModel.cc

Last change on this file was 1347, checked in by garnier, 14 years ago

geant4 tag 9.4
File size: 30.2 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer                                           *
4// *                                                                  *
5// * The  Geant4 software  is  copyright of the Copyright Holders  of *
6// * the Geant4 Collaboration.  It is provided  under  the terms  and *
7// * conditions of the Geant4 Software License,  included in the file *
8// * LICENSE and available at  http://cern.ch/geant4/license .  These *
9// * include a list of copyright holders.                             *
10// *                                                                  *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work  make  any representation or  warranty, express or implied, *
14// * regarding  this  software system or assume any liability for its *
15// * use.  Please see the license in the file  LICENSE  and URL above *
16// * for the full disclaimer and the limitation of liability.         *
17// *                                                                  *
18// * This  code  implementation is the result of  the  scientific and *
19// * technical work of the GEANT4 collaboration.                      *
20// * By using,  copying,  modifying or  distributing the software (or *
21// * any work based  on the software)  you  agree  to acknowledge its *
22// * use  in  resulting  scientific  publications,  and indicate your *
23// * acceptance of all terms of the Geant4 Software license.          *
24// ********************************************************************
25//
26// $Id: G4DNARuddIonisationModel.cc,v 1.21 2010/11/04 14:52:17 sincerti Exp $
27// GEANT4 tag $Name: geant4-09-04-ref-00 $
28//
29
30#include "G4DNARuddIonisationModel.hh"
31//#include "G4DynamicMolecule.hh"
32
33//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
34
35using namespace std;
36
37//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
38
39G4DNARuddIonisationModel::G4DNARuddIonisationModel(const G4ParticleDefinition*,
40                                             const G4String& nam)
41:G4VEmModel(nam),isInitialised(false)
42{
43  lowEnergyLimitForZ1 = 0 * eV; 
44  lowEnergyLimitForZ2 = 0 * eV; 
45  lowEnergyLimitOfModelForZ1 = 100 * eV; 
46  lowEnergyLimitOfModelForZ2 = 1 * keV; 
47  killBelowEnergyForZ1 = lowEnergyLimitOfModelForZ1; 
48  killBelowEnergyForZ2 = lowEnergyLimitOfModelForZ2; 
49
50  verboseLevel= 0;
51  // Verbosity scale:
52  // 0 = nothing
53  // 1 = warning for energy non-conservation
54  // 2 = details of energy budget
55  // 3 = calculation of cross sections, file openings, sampling of atoms
56  // 4 = entering in methods
57 
58  if( verboseLevel>0 ) 
59  { 
60    G4cout << "Rudd ionisation model is constructed " << G4endl;
61  }
62}
63
64//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
65
66G4DNARuddIonisationModel::~G4DNARuddIonisationModel()
67{ 
68  // Cross section
69 
70  std::map< G4String,G4DNACrossSectionDataSet*,std::less<G4String> >::iterator pos;
71  for (pos = tableData.begin(); pos != tableData.end(); ++pos)
72  {
73    G4DNACrossSectionDataSet* table = pos->second;
74    delete table;
75  }
76 
77}
78
79//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
80
81void G4DNARuddIonisationModel::Initialise(const G4ParticleDefinition* particle,
82                                       const G4DataVector& /*cuts*/)
83{
84
85  if (verboseLevel > 3)
86    G4cout << "Calling G4DNARuddIonisationModel::Initialise()" << G4endl;
87
88  // Energy limits
89
90  G4String fileProton("dna/sigma_ionisation_p_rudd");
91  G4String fileHydrogen("dna/sigma_ionisation_h_rudd");
92  G4String fileAlphaPlusPlus("dna/sigma_ionisation_alphaplusplus_rudd");
93  G4String fileAlphaPlus("dna/sigma_ionisation_alphaplus_rudd");
94  G4String fileHelium("dna/sigma_ionisation_he_rudd");
95
96  G4DNAGenericIonsManager *instance;
97  instance = G4DNAGenericIonsManager::Instance();
98  G4ParticleDefinition* protonDef = G4Proton::ProtonDefinition();
99  G4ParticleDefinition* hydrogenDef = instance->GetIon("hydrogen");
100  G4ParticleDefinition* alphaPlusPlusDef = instance->GetIon("alpha++");
101  G4ParticleDefinition* alphaPlusDef = instance->GetIon("alpha+");
102  G4ParticleDefinition* heliumDef = instance->GetIon("helium");
103
104  G4String proton;
105  G4String hydrogen;
106  G4String alphaPlusPlus;
107  G4String alphaPlus;
108  G4String helium;
109
110  G4double scaleFactor = 1 * m*m;
111
112  if (protonDef != 0)
113  {
114    proton = protonDef->GetParticleName();
115    tableFile[proton] = fileProton;
116
117    lowEnergyLimit[proton] = lowEnergyLimitForZ1;
118    highEnergyLimit[proton] = 500. * keV;
119
120    // Cross section
121
122    G4DNACrossSectionDataSet* tableProton = new G4DNACrossSectionDataSet(new G4LogLogInterpolation, 
123                                                                           eV,
124                                                                           scaleFactor );
125    tableProton->LoadData(fileProton);
126    tableData[proton] = tableProton;
127  }
128  else
129  {
130    G4Exception("G4DNARuddIonisationModel::Initialise: proton is not defined");
131  }
132
133  if (hydrogenDef != 0)
134  {
135    hydrogen = hydrogenDef->GetParticleName();
136    tableFile[hydrogen] = fileHydrogen;
137
138    lowEnergyLimit[hydrogen] = lowEnergyLimitForZ1;
139    highEnergyLimit[hydrogen] = 100. * MeV;
140
141    // Cross section
142
143    G4DNACrossSectionDataSet* tableHydrogen = new G4DNACrossSectionDataSet(new G4LogLogInterpolation,
144                                                                             eV,
145                                                                             scaleFactor );
146    tableHydrogen->LoadData(fileHydrogen);
147     
148    tableData[hydrogen] = tableHydrogen;
149  }
150  else
151  {
152    G4Exception("G4DNARuddIonisationModel::Initialise: hydrogen is not defined");
153  }
154
155  if (alphaPlusPlusDef != 0)
156  {
157    alphaPlusPlus = alphaPlusPlusDef->GetParticleName();
158    tableFile[alphaPlusPlus] = fileAlphaPlusPlus;
159
160    lowEnergyLimit[alphaPlusPlus] = lowEnergyLimitForZ2;
161    highEnergyLimit[alphaPlusPlus] = 400. * MeV;
162
163    // Cross section
164
165    G4DNACrossSectionDataSet* tableAlphaPlusPlus = new G4DNACrossSectionDataSet(new G4LogLogInterpolation, 
166                                                                                  eV,
167                                                                                  scaleFactor );
168    tableAlphaPlusPlus->LoadData(fileAlphaPlusPlus);
169     
170    tableData[alphaPlusPlus] = tableAlphaPlusPlus;
171  }
172  else
173  {
174    G4Exception("G4DNARuddIonisationModel::Initialise: alphaPlusPlus is not defined");
175  }
176
177  if (alphaPlusDef != 0)
178  {
179    alphaPlus = alphaPlusDef->GetParticleName();
180    tableFile[alphaPlus] = fileAlphaPlus;
181
182    lowEnergyLimit[alphaPlus] = lowEnergyLimitForZ2;
183    highEnergyLimit[alphaPlus] = 400. * MeV;
184
185    // Cross section
186
187    G4DNACrossSectionDataSet* tableAlphaPlus = new G4DNACrossSectionDataSet(new G4LogLogInterpolation, 
188                                                                              eV,
189                                                                              scaleFactor );
190    tableAlphaPlus->LoadData(fileAlphaPlus);
191    tableData[alphaPlus] = tableAlphaPlus;
192  }
193  else
194  {
195    G4Exception("G4DNARuddIonisationModel::Initialise: alphaPlus is not defined");
196  }
197
198  if (heliumDef != 0)
199  {
200    helium = heliumDef->GetParticleName();
201    tableFile[helium] = fileHelium;
202
203    lowEnergyLimit[helium] = lowEnergyLimitForZ2;
204    highEnergyLimit[helium] = 400. * MeV;
205
206    // Cross section
207
208    G4DNACrossSectionDataSet* tableHelium = new G4DNACrossSectionDataSet(new G4LogLogInterpolation, 
209                                                                           eV,
210                                                                           scaleFactor );
211    tableHelium->LoadData(fileHelium);
212    tableData[helium] = tableHelium;
213    }
214  else
215  {
216    G4Exception("G4DNARuddIonisationModel::Initialise: helium is not defined");
217  }
218
219  if (particle==protonDef) 
220  {
221    SetLowEnergyLimit(lowEnergyLimit[proton]);
222    SetHighEnergyLimit(highEnergyLimit[proton]);
223  }
224
225  if (particle==hydrogenDef) 
226  {
227    SetLowEnergyLimit(lowEnergyLimit[hydrogen]);
228    SetHighEnergyLimit(highEnergyLimit[hydrogen]);
229  }
230
231  if (particle==heliumDef) 
232  {
233    SetLowEnergyLimit(lowEnergyLimit[helium]);
234    SetHighEnergyLimit(highEnergyLimit[helium]);
235  }
236
237  if (particle==alphaPlusDef) 
238  {
239    SetLowEnergyLimit(lowEnergyLimit[alphaPlus]);
240    SetHighEnergyLimit(highEnergyLimit[alphaPlus]);
241  }
242
243  if (particle==alphaPlusPlusDef) 
244  {
245    SetLowEnergyLimit(lowEnergyLimit[alphaPlusPlus]);
246    SetHighEnergyLimit(highEnergyLimit[alphaPlusPlus]);
247  }
248
249  if( verboseLevel>0 ) 
250  { 
251    G4cout << "Rudd ionisation model is initialized " << G4endl
252           << "Energy range: "
253           << LowEnergyLimit() / eV << " eV - "
254           << HighEnergyLimit() / keV << " keV for "
255           << particle->GetParticleName()
256           << G4endl;
257  }
258
259  //
260 
261  if(!isInitialised) 
262  {
263    isInitialised = true;
264 
265    if(pParticleChange)
266      fParticleChangeForGamma = reinterpret_cast<G4ParticleChangeForGamma*>(pParticleChange);
267    else
268      fParticleChangeForGamma = new G4ParticleChangeForGamma();
269  }   
270
271  // InitialiseElementSelectors(particle,cuts);
272
273}
274
275//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
276
277G4double G4DNARuddIonisationModel::CrossSectionPerVolume(const G4Material* material,
278                                           const G4ParticleDefinition* particleDefinition,
279                                           G4double k,
280                                           G4double,
281                                           G4double)
282{
283  if (verboseLevel > 3)
284    G4cout << "Calling CrossSectionPerVolume() of G4DNARuddIonisationModel" << G4endl;
285
286 // Calculate total cross section for model
287
288  G4DNAGenericIonsManager *instance;
289  instance = G4DNAGenericIonsManager::Instance();
290
291  if (
292      particleDefinition != G4Proton::ProtonDefinition()
293      &&
294      particleDefinition != instance->GetIon("hydrogen")
295      &&
296      particleDefinition != instance->GetIon("alpha++")
297      &&
298      particleDefinition != instance->GetIon("alpha+")
299      &&
300      particleDefinition != instance->GetIon("helium")
301     )
302           
303    return 0;
304
305  G4double lowLim = 0;
306 
307  if (     particleDefinition == G4Proton::ProtonDefinition()
308       ||  particleDefinition == instance->GetIon("hydrogen")
309     )
310       
311       lowLim = lowEnergyLimitOfModelForZ1;
312       
313  if (     particleDefinition == instance->GetIon("alpha++")
314       ||  particleDefinition == instance->GetIon("alpha+")
315       ||  particleDefinition == instance->GetIon("helium")
316     )
317       
318       lowLim = lowEnergyLimitOfModelForZ2;
319
320  G4double highLim = 0;
321  G4double sigma=0;
322
323  if (material->GetName() == "G4_WATER")
324  {
325    const G4String& particleName = particleDefinition->GetParticleName();
326   
327    // SI - the following is useless since lowLim is already defined
328    /*
329    std::map< G4String,G4double,std::less<G4String> >::iterator pos1;
330    pos1 = lowEnergyLimit.find(particleName);
331
332    if (pos1 != lowEnergyLimit.end())
333    {
334      lowLim = pos1->second;
335    }
336    */
337
338    std::map< G4String,G4double,std::less<G4String> >::iterator pos2;
339    pos2 = highEnergyLimit.find(particleName);
340
341    if (pos2 != highEnergyLimit.end())
342    {
343      highLim = pos2->second;
344    }
345
346    if (k < highLim)
347    {
348     
349      //SI : XS must not be zero otherwise sampling of secondaries method ignored
350
351      if (k < lowLim) k = lowLim;
352
353      //     
354     
355      std::map< G4String,G4DNACrossSectionDataSet*,std::less<G4String> >::iterator pos;
356      pos = tableData.find(particleName);
357       
358      if (pos != tableData.end())
359      {
360         G4DNACrossSectionDataSet* table = pos->second;
361         if (table != 0)
362         {
363              sigma = table->FindValue(k);
364
365         }
366      }
367      else
368      {
369        G4Exception("G4DNARuddIonisationModel::CrossSectionPerVolume: attempting to calculate cross section for wrong particle");
370      }
371 
372    } // if (k >= lowLim && k < highLim)
373   
374    if (verboseLevel > 3)
375    {
376      G4cout << "---> Kinetic energy(eV)=" << k/eV << G4endl;
377      G4cout << " - Cross section per water molecule (cm^2)=" << sigma/cm/cm << G4endl;
378      G4cout << " - Cross section per water molecule (cm^-1)=" << sigma*
379      material->GetAtomicNumDensityVector()[1]/(1./cm) << G4endl;
380    } 
381 
382  } // if (waterMaterial)
383 
384 return sigma*material->GetAtomicNumDensityVector()[1];           
385
386}
387
388//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
389
390void G4DNARuddIonisationModel::SampleSecondaries(std::vector<G4DynamicParticle*>* fvect,
391                                              const G4MaterialCutsCouple* /*couple*/,
392                                              const G4DynamicParticle* particle,
393                                              G4double,
394                                              G4double)
395{
396  if (verboseLevel > 3)
397    G4cout << "Calling SampleSecondaries() of G4DNARuddIonisationModel" << G4endl;
398
399  G4double lowLim = 0;
400  G4double highLim = 0;
401
402  G4DNAGenericIonsManager *instance;
403  instance = G4DNAGenericIonsManager::Instance();
404
405  if (     particle->GetDefinition() == G4Proton::ProtonDefinition()
406       ||  particle->GetDefinition() == instance->GetIon("hydrogen")
407     )
408       
409       lowLim = killBelowEnergyForZ1;
410       
411  if (     particle->GetDefinition() == instance->GetIon("alpha++")
412       ||  particle->GetDefinition() == instance->GetIon("alpha+")
413       ||  particle->GetDefinition() == instance->GetIon("helium")
414     )
415       
416       lowLim = killBelowEnergyForZ2;
417
418  G4double k = particle->GetKineticEnergy();
419
420  const G4String& particleName = particle->GetDefinition()->GetParticleName();
421
422  // SI - the following is useless since lowLim is already defined
423  /*
424  std::map< G4String,G4double,std::less<G4String> >::iterator pos1;
425  pos1 = lowEnergyLimit.find(particleName);
426
427  if (pos1 != lowEnergyLimit.end())
428  {
429    lowLim = pos1->second;
430  }
431  */
432
433  std::map< G4String,G4double,std::less<G4String> >::iterator pos2;
434  pos2 = highEnergyLimit.find(particleName);
435
436  if (pos2 != highEnergyLimit.end())
437  {
438    highLim = pos2->second;
439  }
440
441  if (k >= lowLim && k < highLim)
442  {
443      G4ParticleDefinition* definition = particle->GetDefinition();
444      G4ParticleMomentum primaryDirection = particle->GetMomentumDirection();
445      /*
446      G4double particleMass = definition->GetPDGMass();
447      G4double totalEnergy = k + particleMass;
448      G4double pSquare = k*(totalEnergy+particleMass);
449      G4double totalMomentum = std::sqrt(pSquare);
450      */
451
452      G4int ionizationShell = RandomSelect(k,particleName);
453 
454      G4double secondaryKinetic = RandomizeEjectedElectronEnergy(definition,k,ionizationShell);
455 
456      G4double bindingEnergy = waterStructure.IonisationEnergy(ionizationShell);
457
458      G4double cosTheta = 0.;
459      G4double phi = 0.; 
460      RandomizeEjectedElectronDirection(definition, k,secondaryKinetic, cosTheta, phi);
461
462      G4double sinTheta = std::sqrt(1.-cosTheta*cosTheta);
463      G4double dirX = sinTheta*std::cos(phi);
464      G4double dirY = sinTheta*std::sin(phi);
465      G4double dirZ = cosTheta;
466      G4ThreeVector deltaDirection(dirX,dirY,dirZ);
467      deltaDirection.rotateUz(primaryDirection);
468
469      // Ignored for ions on electrons
470      /*
471      G4double deltaTotalMomentum = std::sqrt(secondaryKinetic*(secondaryKinetic + 2.*electron_mass_c2 ));
472
473      G4double finalPx = totalMomentum*primaryDirection.x() - deltaTotalMomentum*deltaDirection.x();
474      G4double finalPy = totalMomentum*primaryDirection.y() - deltaTotalMomentum*deltaDirection.y();
475      G4double finalPz = totalMomentum*primaryDirection.z() - deltaTotalMomentum*deltaDirection.z();
476      G4double finalMomentum = std::sqrt(finalPx*finalPx+finalPy*finalPy+finalPz*finalPz);
477      finalPx /= finalMomentum;
478      finalPy /= finalMomentum;
479      finalPz /= finalMomentum;
480
481      G4ThreeVector direction;
482      direction.set(finalPx,finalPy,finalPz);
483
484      fParticleChangeForGamma->ProposeMomentumDirection(direction.unit()) ;
485      */
486      fParticleChangeForGamma->ProposeMomentumDirection(primaryDirection);
487
488      fParticleChangeForGamma->SetProposedKineticEnergy(k-bindingEnergy-secondaryKinetic);
489      fParticleChangeForGamma->ProposeLocalEnergyDeposit(bindingEnergy);
490
491      G4DynamicParticle* dp = new G4DynamicParticle (G4Electron::Electron(),deltaDirection,secondaryKinetic) ;
492      fvect->push_back(dp);
493
494  }
495
496  // SI - not useful since low energy of model is 0 eV
497 
498  if (k < lowLim) 
499  { 
500    fParticleChangeForGamma->ProposeTrackStatus(fStopAndKill);
501    fParticleChangeForGamma->ProposeLocalEnergyDeposit(k);
502  }
503
504}
505
506//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
507
508G4double G4DNARuddIonisationModel::RandomizeEjectedElectronEnergy(G4ParticleDefinition* particleDefinition, 
509                                                                    G4double k, 
510                                                                    G4int shell)
511{
512  G4double maximumKineticEnergyTransfer = 0.;
513 
514  G4DNAGenericIonsManager *instance;
515  instance = G4DNAGenericIonsManager::Instance();
516
517  if (particleDefinition == G4Proton::ProtonDefinition() 
518      || particleDefinition == instance->GetIon("hydrogen"))
519  { 
520      maximumKineticEnergyTransfer= 4.* (electron_mass_c2 / proton_mass_c2) * k;
521  }
522
523  if (particleDefinition == instance->GetIon("helium") 
524      || particleDefinition == instance->GetIon("alpha+")
525      || particleDefinition == instance->GetIon("alpha++"))
526  { 
527      maximumKineticEnergyTransfer= 4.* (0.511 / 3728) * k;
528  }
529
530  G4double crossSectionMaximum = 0.;
531 
532  for(G4double value=waterStructure.IonisationEnergy(shell); value<=5.*waterStructure.IonisationEnergy(shell) && k>=value ; value+=0.1*eV)
533  {
534      G4double differentialCrossSection = DifferentialCrossSection(particleDefinition, k, value, shell);
535      if(differentialCrossSection >= crossSectionMaximum) crossSectionMaximum = differentialCrossSection;
536  }
537 
538 
539  G4double secElecKinetic = 0.;
540 
541  do
542  {
543    secElecKinetic = G4UniformRand() * maximumKineticEnergyTransfer;
544  } while(G4UniformRand()*crossSectionMaximum > DifferentialCrossSection(particleDefinition, 
545                                                                         k,
546                                                                         secElecKinetic+waterStructure.IonisationEnergy(shell),
547                                                                         shell));
548
549  return(secElecKinetic);
550}
551
552//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
553
554
555void G4DNARuddIonisationModel::RandomizeEjectedElectronDirection(G4ParticleDefinition* particleDefinition, 
556                                                                   G4double k, 
557                                                                   G4double secKinetic, 
558                                                                   G4double & cosTheta, 
559                                                                   G4double & phi )
560{
561  G4DNAGenericIonsManager *instance;
562  instance = G4DNAGenericIonsManager::Instance();
563
564  G4double maxSecKinetic = 0.;
565 
566  if (particleDefinition == G4Proton::ProtonDefinition() 
567      || particleDefinition == instance->GetIon("hydrogen")) 
568  { 
569      maxSecKinetic = 4.* (electron_mass_c2 / proton_mass_c2) * k;
570  }
571 
572  if (particleDefinition == instance->GetIon("helium") 
573      || particleDefinition == instance->GetIon("alpha+")
574      || particleDefinition == instance->GetIon("alpha++"))
575  { 
576      maxSecKinetic = 4.* (0.511 / 3728) * k;
577  }
578 
579  phi = twopi * G4UniformRand();
580 
581  //cosTheta = std::sqrt(secKinetic / maxSecKinetic);
582
583  // Restriction below 100 eV from Emfietzoglou (2000)
584
585  if (secKinetic>100*eV) cosTheta = std::sqrt(secKinetic / maxSecKinetic);
586  else cosTheta = (2.*G4UniformRand())-1.;
587 
588}
589
590//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
591
592
593G4double G4DNARuddIonisationModel::DifferentialCrossSection(G4ParticleDefinition* particleDefinition, 
594                                                              G4double k, 
595                                                              G4double energyTransfer, 
596                                                              G4int ionizationLevelIndex)
597{
598  // Shells ids are 0 1 2 3 4 (4 is k shell)
599  // !!Attention, "energyTransfer" here is the energy transfered to the electron which means
600  //             that the secondary kinetic energy is w = energyTransfer - bindingEnergy
601  //
602  //   ds            S                F1(nu) + w * F2(nu)
603  //  ---- = G(k) * ----     -------------------------------------------
604  //   dw            Bj       (1+w)^3 * [1 + exp{alpha * (w - wc) / nu}]
605  //
606  // w is the secondary electron kinetic Energy in eV
607  //
608  // All the other parameters can be found in Rudd's Papers
609  //
610  // M.Eugene Rudd, 1988, User-Friendly model for the energy distribution of
611  // electrons from protons or electron collisions. Nucl. Tracks Rad. Meas.Vol 16 N0 2/3 pp 219-218
612  //
613
614  const G4int j=ionizationLevelIndex;
615
616  G4double A1 ; 
617  G4double B1 ; 
618  G4double C1 ; 
619  G4double D1 ; 
620  G4double E1 ;
621  G4double A2 ; 
622  G4double B2 ; 
623  G4double C2 ; 
624  G4double D2 ; 
625  G4double alphaConst ;
626
627//  const G4double Bj[5] = {12.61*eV, 14.73*eV, 18.55*eV, 32.20*eV, 539.7*eV};
628// The following values are provided by M. dingfelder (priv. comm)
629  const G4double Bj[5] = {12.60*eV, 14.70*eV, 18.40*eV, 32.20*eV, 540*eV};
630
631  if (j == 4) 
632  {
633      //Data For Liquid Water K SHELL from Dingfelder (Protons in Water)
634      A1 = 1.25; 
635      B1 = 0.5; 
636      C1 = 1.00; 
637      D1 = 1.00; 
638      E1 = 3.00; 
639      A2 = 1.10; 
640      B2 = 1.30;
641      C2 = 1.00; 
642      D2 = 0.00; 
643      alphaConst = 0.66;
644  }
645  else 
646  {
647      //Data For Liquid Water from Dingfelder (Protons in Water)
648      A1 = 1.02; 
649      B1 = 82.0; 
650      C1 = 0.45; 
651      D1 = -0.80; 
652      E1 = 0.38; 
653      A2 = 1.07; 
654      // Value provided by M. Dingfelder (priv. comm)
655      B2 = 11.6;
656      //
657      C2 = 0.60; 
658      D2 = 0.04; 
659      alphaConst = 0.64;
660  }
661 
662  const G4double n = 2.;
663  const G4double Gj[5] = {0.99, 1.11, 1.11, 0.52, 1.};
664
665  G4DNAGenericIonsManager* instance;
666  instance = G4DNAGenericIonsManager::Instance();
667
668  G4double wBig = (energyTransfer - waterStructure.IonisationEnergy(ionizationLevelIndex));
669  if (wBig<0) return 0.;
670
671  G4double w = wBig / Bj[ionizationLevelIndex];
672  // Note that the following (j==4) cases are provided by   M. Dingfelder (priv. comm)
673  if (j==4) w = wBig / waterStructure.IonisationEnergy(ionizationLevelIndex);
674
675  G4double Ry = 13.6*eV;
676
677  G4double tau = 0.;
678
679  if (particleDefinition == G4Proton::ProtonDefinition() 
680      || particleDefinition == instance->GetIon("hydrogen")) 
681  {
682      tau = (electron_mass_c2/proton_mass_c2) * k ;
683  }
684   
685  if ( particleDefinition == instance->GetIon("helium") 
686       || particleDefinition == instance->GetIon("alpha+")
687       || particleDefinition == instance->GetIon("alpha++")) 
688  {
689      tau = (0.511/3728.) * k ;
690  }
691
692  G4double S = 4.*pi * Bohr_radius*Bohr_radius * n * std::pow((Ry/Bj[ionizationLevelIndex]),2);
693  if (j==4) S = 4.*pi * Bohr_radius*Bohr_radius * n * std::pow((Ry/waterStructure.IonisationEnergy(ionizationLevelIndex)),2);
694
695  G4double v2 = tau / Bj[ionizationLevelIndex];
696  if (j==4) v2 = tau / waterStructure.IonisationEnergy(ionizationLevelIndex);
697
698  G4double v = std::sqrt(v2);
699  G4double wc = 4.*v2 - 2.*v - (Ry/(4.*Bj[ionizationLevelIndex]));
700  if (j==4) wc = 4.*v2 - 2.*v - (Ry/(4.*waterStructure.IonisationEnergy(ionizationLevelIndex)));
701
702  G4double L1 = (C1* std::pow(v,(D1))) / (1.+ E1*std::pow(v, (D1+4.)));
703  G4double L2 = C2*std::pow(v,(D2));
704  G4double H1 = (A1*std::log(1.+v2)) / (v2+(B1/v2));
705  G4double H2 = (A2/v2) + (B2/(v2*v2));
706
707  G4double F1 = L1+H1;
708  G4double F2 = (L2*H2)/(L2+H2);
709
710  G4double sigma = CorrectionFactor(particleDefinition, k) 
711    * Gj[j] * (S/Bj[ionizationLevelIndex]) 
712    * ( (F1+w*F2) / ( std::pow((1.+w),3) * ( 1.+std::exp(alphaConst*(w-wc)/v))) );
713
714  if (j==4) sigma = CorrectionFactor(particleDefinition, k) 
715    * Gj[j] * (S/waterStructure.IonisationEnergy(ionizationLevelIndex)) 
716    * ( (F1+w*F2) / ( std::pow((1.+w),3) * ( 1.+std::exp(alphaConst*(w-wc)/v))) );
717
718  if ( (particleDefinition == instance->GetIon("hydrogen")) && (ionizationLevelIndex==4)) 
719
720//    sigma = Gj[j] * (S/Bj[ionizationLevelIndex])
721    sigma = Gj[j] * (S/waterStructure.IonisationEnergy(ionizationLevelIndex)) 
722    * ( (F1+w*F2) / ( std::pow((1.+w),3) * ( 1.+std::exp(alphaConst*(w-wc)/v))) );
723
724  if (    particleDefinition == G4Proton::ProtonDefinition() 
725          || particleDefinition == instance->GetIon("hydrogen")
726          ) 
727  {
728      return(sigma);
729  }
730
731  if (particleDefinition == instance->GetIon("alpha++") ) 
732  {
733      slaterEffectiveCharge[0]=0.;
734      slaterEffectiveCharge[1]=0.;
735      slaterEffectiveCharge[2]=0.;
736      sCoefficient[0]=0.;
737      sCoefficient[1]=0.;
738      sCoefficient[2]=0.;
739  }
740
741  if (particleDefinition == instance->GetIon("alpha+") ) 
742  {
743      slaterEffectiveCharge[0]=2.0;
744      // The following values are provided by M. Dingfelder (priv. comm)   
745      slaterEffectiveCharge[1]=2.0;
746      slaterEffectiveCharge[2]=2.0;
747      //
748      sCoefficient[0]=0.7;
749      sCoefficient[1]=0.15;
750      sCoefficient[2]=0.15;
751  }
752
753  if (particleDefinition == instance->GetIon("helium") ) 
754  {
755      slaterEffectiveCharge[0]=1.7;
756      slaterEffectiveCharge[1]=1.15;
757      slaterEffectiveCharge[2]=1.15;
758      sCoefficient[0]=0.5;
759      sCoefficient[1]=0.25;
760      sCoefficient[2]=0.25;
761  }
762 
763  if (    particleDefinition == instance->GetIon("helium") 
764          || particleDefinition == instance->GetIon("alpha+")
765          || particleDefinition == instance->GetIon("alpha++")
766          ) 
767  {
768      sigma = Gj[j] * (S/Bj[ionizationLevelIndex]) * ( (F1+w*F2) / ( std::pow((1.+w),3) * ( 1.+std::exp(alphaConst*(w-wc)/v))) );
769   
770      if (j==4) sigma = Gj[j] * (S/waterStructure.IonisationEnergy(ionizationLevelIndex)) 
771                              * ( (F1+w*F2) / ( std::pow((1.+w),3) * ( 1.+std::exp(alphaConst*(w-wc)/v))) );
772
773      G4double zEff = particleDefinition->GetPDGCharge() / eplus + particleDefinition->GetLeptonNumber();
774 
775      zEff -= ( sCoefficient[0] * S_1s(k, energyTransfer, slaterEffectiveCharge[0], 1.) +
776                sCoefficient[1] * S_2s(k, energyTransfer, slaterEffectiveCharge[1], 2.) +
777                sCoefficient[2] * S_2p(k, energyTransfer, slaterEffectiveCharge[2], 2.) );
778           
779      return zEff * zEff * sigma ;
780  } 
781 
782  return 0;
783}
784
785//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
786
787G4double G4DNARuddIonisationModel::S_1s(G4double t, 
788                                          G4double energyTransferred, 
789                                          G4double slaterEffectiveChg, 
790                                          G4double shellNumber)
791{
792  // 1 - e^(-2r) * ( 1 + 2 r + 2 r^2)
793  // Dingfelder, in Chattanooga 2005 proceedings, formula (7)
794 
795  G4double r = R(t, energyTransferred, slaterEffectiveChg, shellNumber);
796  G4double value = 1. - std::exp(-2 * r) * ( ( 2. * r + 2. ) * r + 1. );
797 
798  return value;
799}
800
801//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
802
803G4double G4DNARuddIonisationModel::S_2s(G4double t,
804                                          G4double energyTransferred, 
805                                          G4double slaterEffectiveChg, 
806                                          G4double shellNumber)
807{
808  // 1 - e^(-2 r) * ( 1 + 2 r + 2 r^2 + 2 r^4)
809  // Dingfelder, in Chattanooga 2005 proceedings, formula (8)
810
811  G4double r = R(t, energyTransferred, slaterEffectiveChg, shellNumber);
812  G4double value =  1. - std::exp(-2 * r) * (((2. * r * r + 2.) * r + 2.) * r + 1.);
813
814  return value;
815 
816}
817
818//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
819
820G4double G4DNARuddIonisationModel::S_2p(G4double t, 
821                                          G4double energyTransferred,
822                                          G4double slaterEffectiveChg, 
823                                          G4double shellNumber)
824{
825  // 1 - e^(-2 r) * ( 1 + 2 r + 2 r^2 + 4/3 r^3 + 2/3 r^4)
826  // Dingfelder, in Chattanooga 2005 proceedings, formula (9)
827
828  G4double r = R(t, energyTransferred, slaterEffectiveChg, shellNumber);
829  G4double value =  1. - std::exp(-2 * r) * (((( 2./3. * r + 4./3.) * r + 2.) * r + 2.) * r  + 1.);
830
831  return value;
832}
833
834//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
835
836G4double G4DNARuddIonisationModel::R(G4double t,
837                                       G4double energyTransferred,
838                                       G4double slaterEffectiveChg,
839                                       G4double shellNumber) 
840{
841  // tElectron = m_electron / m_alpha * t
842  // Dingfelder, in Chattanooga 2005 proceedings, p 4
843
844  G4double tElectron = 0.511/3728. * t;
845  // The following values are provided by M. Dingfelder (priv. comm)   
846  G4double H = 2.*13.60569172 * eV;
847  G4double value = std::sqrt ( 2. * tElectron / H ) / ( energyTransferred / H ) *  (slaterEffectiveChg/shellNumber);
848 
849  return value;
850}
851
852//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
853
854G4double G4DNARuddIonisationModel::CorrectionFactor(G4ParticleDefinition* particleDefinition, G4double k) 
855{
856  G4DNAGenericIonsManager *instance;
857  instance = G4DNAGenericIonsManager::Instance();
858
859  if (particleDefinition == G4Proton::Proton()) 
860  {
861      return(1.);
862  }
863  else 
864    if (particleDefinition == instance->GetIon("hydrogen")) 
865    { 
866        G4double value = (std::log10(k/eV)-4.2)/0.5;
867        // The following values are provided by M. Dingfelder (priv. comm)   
868        return((0.6/(1+std::exp(value))) + 0.9);
869    }
870    else 
871    {   
872        return(1.);
873    }
874}
875
876//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
877
878G4int G4DNARuddIonisationModel::RandomSelect(G4double k, const G4String& particle )
879{   
880 
881  // BEGIN PART 1/2 OF ELECTRON CORRECTION
882
883  // add ONE or TWO electron-water ionisation for alpha+ and helium
884   
885  G4DNAGenericIonsManager *instance;
886  instance = G4DNAGenericIonsManager::Instance();
887 
888  G4int level = 0;
889
890  // Retrieve data table corresponding to the current particle type 
891
892  std::map< G4String,G4DNACrossSectionDataSet*,std::less<G4String> >::iterator pos;
893  pos = tableData.find(particle);
894
895  if (pos != tableData.end())
896  {
897      G4DNACrossSectionDataSet* table = pos->second;
898
899      if (table != 0)
900      {
901          G4double* valuesBuffer = new G4double[table->NumberOfComponents()];
902           
903          const size_t n(table->NumberOfComponents());
904          size_t i(n);
905          G4double value = 0.;
906           
907          while (i>0)
908          { 
909              i--;
910              valuesBuffer[i] = table->GetComponent(i)->FindValue(k);
911              value += valuesBuffer[i];
912          }
913           
914          value *= G4UniformRand();
915           
916          i = n;
917           
918          while (i > 0)
919          {
920              i--;
921             
922               
923              if (valuesBuffer[i] > value)
924              {
925                  delete[] valuesBuffer;
926                  return i;
927              }
928              value -= valuesBuffer[i];
929          }
930           
931          if (valuesBuffer) delete[] valuesBuffer;
932           
933      }
934  }
935  else
936  {
937    G4Exception("G4DNARuddIonisationModel::RandomSelect: attempting to calculate cross section for wrong particle");
938  }
939
940  return level;
941}
942
943//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
944
945G4double G4DNARuddIonisationModel::PartialCrossSection(const G4Track& track )
946{
947  G4double sigma = 0.;
948
949  const G4DynamicParticle* particle = track.GetDynamicParticle();
950  G4double k = particle->GetKineticEnergy();
951 
952  G4double lowLim = 0;
953  G4double highLim = 0;
954
955  const G4String& particleName = particle->GetDefinition()->GetParticleName();
956
957  std::map< G4String,G4double,std::less<G4String> >::iterator pos1;
958  pos1 = lowEnergyLimit.find(particleName);
959
960  if (pos1 != lowEnergyLimit.end())
961  {
962    lowLim = pos1->second;
963  }
964
965  std::map< G4String,G4double,std::less<G4String> >::iterator pos2;
966  pos2 = highEnergyLimit.find(particleName);
967
968  if (pos2 != highEnergyLimit.end())
969  {
970    highLim = pos2->second;
971  }
972
973  if (k >= lowLim && k <= highLim)
974  {
975      std::map< G4String,G4DNACrossSectionDataSet*,std::less<G4String> >::iterator pos;
976      pos = tableData.find(particleName);
977       
978      if (pos != tableData.end())
979      {
980          G4DNACrossSectionDataSet* table = pos->second;
981          if (table != 0)
982          {
983              sigma = table->FindValue(k);
984          }
985      }
986      else
987      {
988          G4Exception("G4DNARuddIonisationModel::PartialCrossSection: attempting to calculate cross section for wrong particle");
989      }
990  }
991
992  return sigma;
993}
994
995//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
996
997G4double G4DNARuddIonisationModel::Sum(G4double /* energy */, const G4String& /* particle */)
998{
999  return 0;
1000}
1001
Note: See TracBrowser for help on using the repository browser.