Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/electromagnetic/lowenergy/include/G4IonParametrisedLossModel.icc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /processes/electromagnetic/lowenergy/include/G4IonParametrisedLossModel.icc (Version 11.3.0) and /processes/electromagnetic/lowenergy/include/G4IonParametrisedLossModel.icc (Version 10.0.p4)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
                                                   >>  26 // $Id: G4IonParametrisedLossModel.icc 66241 2012-12-13 18:34:42Z gunter $
 26 //                                                 27 //
 27 // ===========================================     28 // ===========================================================================
 28 // GEANT4 class                                    29 // GEANT4 class
 29 //                                                 30 //
 30 // Class:                G4IonParametrisedLoss     31 // Class:                G4IonParametrisedLossModel
 31 //                                                 32 //
 32 // Base class:           G4VEmModel (utils)        33 // Base class:           G4VEmModel (utils)
 33 //                                                 34 // 
 34 // Author:               Anton Lechner (Anton.     35 // Author:               Anton Lechner (Anton.Lechner@cern.ch)
 35 //                                                 36 //
 36 // First implementation: 10. 11. 2008              37 // First implementation: 10. 11. 2008
 37 //                                                 38 //
 38 // Modifications: 03. 02. 2009 - Bug fix itera     39 // Modifications: 03. 02. 2009 - Bug fix iterators (AL)
 39 //                11. 03. 2009 - Introduced ne     40 //                11. 03. 2009 - Introduced new table handler (G4IonDEDXHandler)
 40 //                               and modified      41 //                               and modified method to add/remove tables
 41 //                               (tables are n     42 //                               (tables are now built in initialisation phase),
 42 //                               Minor bug fix     43 //                               Minor bug fix in ComputeDEDXPerVolume (AL)
 43 //                20. 11. 2009 - Added set-met     44 //                20. 11. 2009 - Added set-method for energy loss limit (AL)
 44 //                04. 11. 2010 - Moved virtual     45 //                04. 11. 2010 - Moved virtual methods to the source (VI)
 45 //                                                 46 //
 46 // Class description:                              47 // Class description:
 47 //    Model for computing the energy loss of i     48 //    Model for computing the energy loss of ions by employing a 
 48 //    parameterisation of dE/dx tables (defaul     49 //    parameterisation of dE/dx tables (default ICRU 73 tables). For 
 49 //    ion-material combinations and/or project     50 //    ion-material combinations and/or projectile energies not covered 
 50 //    by this model, the G4BraggIonModel and G     51 //    by this model, the G4BraggIonModel and G4BetheBloch models are
 51 //    employed.                                    52 //    employed.
 52 //                                                 53 //
 53 // Comments:                                       54 // Comments:
 54 //                                                 55 //
 55 // ===========================================     56 // =========================================================================== 
 56                                                    57 
 57 inline G4double G4IonParametrisedLossModel::De     58 inline G4double G4IonParametrisedLossModel::DeltaRayMeanEnergyTransferRate(
 58                                       const G4     59                                       const G4Material* material,
 59                     const G4ParticleDefinition     60                     const G4ParticleDefinition* particle,
 60               G4double kineticEnergy,              61               G4double kineticEnergy,
 61               G4double cutEnergy) {                62               G4double cutEnergy) {
 62                                                    63 
 63   // ############## Mean energy transferred to     64   // ############## Mean energy transferred to delta-rays ###################
 64   // Computes the mean energy transfered to de     65   // Computes the mean energy transfered to delta-rays per unit length,
 65   // considering only delta-rays with energies     66   // considering only delta-rays with energies above the energy threshold 
 66   // (energy cut)                                  67   // (energy cut)
 67   //                                               68   //
 68   // The mean energy transfer rate is derived      69   // The mean energy transfer rate is derived by using the differential
 69   // cross section given in the references bel     70   // cross section given in the references below.
 70   //                                               71   //
 71   // See Geant4 physics reference manual (vers     72   // See Geant4 physics reference manual (version 9.1), section 9.1.3
 72   //                                               73   // 
 73   // Ref.: W.M. Yao et al, Jour. of Phys. G 33     74   // Ref.: W.M. Yao et al, Jour. of Phys. G 33 (2006) 1.
 74   //       B. Rossi, High energy particles, Ne     75   //       B. Rossi, High energy particles, New York, NY: Prentice-Hall (1952).
 75   //                                               76   //
 76   // (Implementation adapted from G4BraggIonMo     77   // (Implementation adapted from G4BraggIonModel)
 77                                                    78 
 78                                                    79 
 79   //   *** Variables:                              80   //   *** Variables:
 80   //   kineticEnergy = kinetic energy of proje     81   //   kineticEnergy = kinetic energy of projectile
 81   //   totEnergy     = total energy of project     82   //   totEnergy     = total energy of projectile, i.e. kinetic energy
 82   //                   plus rest energy (Mc^2)     83   //                   plus rest energy (Mc^2)
 83   //   betaSquared   = beta of projectile squa     84   //   betaSquared   = beta of projectile squared, calculated as
 84   //                      beta^2 = 1 - 1 / (E/     85   //                      beta^2 = 1 - 1 / (E/Mc^2)^2
 85   //                             = T * ( E + M     86   //                             = T * ( E + Mc^2 ) / E^2
 86   //                   where T = kineticEnergy     87   //                   where T = kineticEnergy, E = totEnergy
 87   //   cutEnergy     = energy threshold for se     88   //   cutEnergy     = energy threshold for secondary particle production
 88   //                   i.e. energy cut, below      89   //                   i.e. energy cut, below which energy transfered to 
 89   //                   electrons is treated as     90   //                   electrons is treated as continuous loss of projectile
 90   //   maxKinEnergy  = maximum energy transfer     91   //   maxKinEnergy  = maximum energy transferable to secondary electrons
 91   //   meanRate      = mean kinetic energy of      92   //   meanRate      = mean kinetic energy of delta ray (per unit length) 
 92   //                   (above cutEnergy)           93   //                   (above cutEnergy)  
 93                                                    94 
 94   G4double meanRate = 0.0;                         95   G4double meanRate = 0.0;
 95                                                    96 
 96   G4double maxKinEnergy = MaxSecondaryEnergy(p     97   G4double maxKinEnergy = MaxSecondaryEnergy(particle, kineticEnergy);
 97                                                    98 
 98   if (cutEnergy < maxKinEnergy) {                  99   if (cutEnergy < maxKinEnergy) {
 99                                                   100 
100     G4double totalEnergy  = kineticEnergy + ca    101     G4double totalEnergy  = kineticEnergy + cacheMass;
101     G4double betaSquared  = kineticEnergy *       102     G4double betaSquared  = kineticEnergy * 
102                   (totalEnergy + cacheMass) /     103                   (totalEnergy + cacheMass) / (totalEnergy * totalEnergy);
103                                                   104 
104     G4double cutMaxEnergyRatio = cutEnergy / m    105     G4double cutMaxEnergyRatio = cutEnergy / maxKinEnergy;
105                                                   106 
106     meanRate =                                    107     meanRate = 
107         (- std::log(cutMaxEnergyRatio) - (1.0     108         (- std::log(cutMaxEnergyRatio) - (1.0 - cutMaxEnergyRatio) * betaSquared) * 
108         CLHEP::twopi_mc2_rcl2 *                   109         CLHEP::twopi_mc2_rcl2 * 
109         (material->GetTotNbOfElectPerVolume())    110         (material->GetTotNbOfElectPerVolume()) / betaSquared;
110                                                   111 
111     meanRate *= GetChargeSquareRatio(particle,    112     meanRate *= GetChargeSquareRatio(particle, material, kineticEnergy);
112   }                                               113   }
113                                                   114   
114   return meanRate;                                115   return meanRate;
115 }                                                 116 }
116                                                   117 
117 inline                                            118 inline
118 void G4IonParametrisedLossModel::UpdateCache(     119 void G4IonParametrisedLossModel::UpdateCache(
119                              const G4ParticleD    120                              const G4ParticleDefinition* particle) {
120                                                   121 
121   cacheParticle = particle;                       122   cacheParticle = particle;
122   cacheMass = particle -> GetPDGMass();           123   cacheMass = particle -> GetPDGMass();
123   cacheElecMassRatio = CLHEP::electron_mass_c2    124   cacheElecMassRatio = CLHEP::electron_mass_c2 / cacheMass;
124   G4double q = particle -> GetPDGCharge() / CL    125   G4double q = particle -> GetPDGCharge() / CLHEP::eplus;
125   cacheChargeSquare = q * q;                      126   cacheChargeSquare = q * q;
126 }                                                 127 }
127                                                   128 
128 inline                                            129 inline
129 LossTableList::iterator G4IonParametrisedLossM    130 LossTableList::iterator G4IonParametrisedLossModel::IsApplicable(
130                     const G4ParticleDefinition    131                     const G4ParticleDefinition* particle,  // Projectile (ion) 
131                     const G4Material* material    132                     const G4Material* material) {          // Target material
132                                                   133 
133   LossTableList::iterator iter = lossTableList    134   LossTableList::iterator iter = lossTableList.end();
134   LossTableList::iterator iterTables = lossTab    135   LossTableList::iterator iterTables = lossTableList.begin();
135   LossTableList::iterator iterTables_end = los    136   LossTableList::iterator iterTables_end = lossTableList.end();
136                                                   137 
137   for(;iterTables != iterTables_end; iterTable    138   for(;iterTables != iterTables_end; iterTables++) {
138       G4bool isApplicable = (*iterTables) ->      139       G4bool isApplicable = (*iterTables) -> 
139                        IsApplicable(particle,     140                        IsApplicable(particle, material);
140       if(isApplicable) {                          141       if(isApplicable) {
141          iter = iterTables;                       142          iter = iterTables;
142          break;                                   143          break;
143       }                                           144       }
144   }                                               145   }
145                                                   146 
146   return iter;                                    147   return iter;
147 }                                                 148 }
148                                                   149 
149                                                   150 
150 inline                                            151 inline
151 void G4IonParametrisedLossModel::SetEnergyLoss    152 void G4IonParametrisedLossModel::SetEnergyLossLimit(
152                                             G4    153                                             G4double ionEnergyLossLimit) {
153                                                   154 
154   if(ionEnergyLossLimit > 0 && ionEnergyLossLi    155   if(ionEnergyLossLimit > 0 && ionEnergyLossLimit <=1) {
155                                                   156 
156      energyLossLimit = ionEnergyLossLimit;        157      energyLossLimit = ionEnergyLossLimit;
157   }                                               158   }
158 }                                                 159 }
159                                                   160