Ignore:
Timestamp:
Nov 5, 2010, 3:45:55 PM (15 years ago)
Author:
garnier
Message:

update ti head

Location:
trunk/source/processes/electromagnetic/lowenergy
Files:
27 edited

Legend:

Unmodified
Added
Removed
  • trunk/source/processes/electromagnetic/lowenergy/History

    r1337 r1340  
    1 $Id: History,v 1.442 2010/06/15 08:04:11 gcosmo Exp $
     1$Id: History,v 1.462 2010/11/04 14:52:17 sincerti Exp $
    22-------------------------------------------------------------------
    33
     
    1717     * Reverse chronological order (last date on top), please *
    1818     ----------------------------------------------------------
     19
     2004.11.2010, S. Incerti, tag emlowen-V09-03-54
     21            - removed warnings in Rudd ionization classes (SI)
     22            - G4IonParametrisedLossModel - (VI) moved few virtual methods from
     23            inline to source, minor cleanup of initialisation 
     24
     2503.11.2010, S. Incerti, tag emlowen-V09-03-53
     26            restricted momentum conservation to electrons
     27            in G4DNA ionisation
     28
     2903.11.2010, S. Incerti, tag emlowen-V09-03-52
     30            new preliminary Geant4-DNA ionisation class for ions by Z. Francis
     31            to be used with G4LEDATA 6.18
     32
     3317.10.2010, S. Incerti, tag emlowen-V09-03-51
     34            extended low energy coverage of G4DNA electron models
     35            to be used with G4LEDATA 6.17
     36
     3714.10.2010, V. Ivanchenko, tag emlowen-V09-03-50
     38            G4GeneratorBS - optimise computations to speedup, fixed comments
     39            G4GeneratorBN - fixed comments
     40            G4VBremAngularDistribution - moved to utils
     41            G4ModifiedTsai - moved to standard
     42
     4313.10.2010, L. Pandola, tag emlowen-V09-03-49
     44            Update G4LivermoreIonisationModel to produce fluorescence AlongStep
     45            only if above the production cuts. Stricter check for energy
     46            conservation
     47
     4808.10.2010, S. Incerti, tag emlowen-V09-03-48
     49            Added new excitation model for H
     50
     5115.09.2010, S. Incerti, tag emlowen-V09-03-47
     52            Added protection in xs file opening for G4DNA Sanche excitation
     53
     5415.09.2010, S. Incerti, tag emlowen-V09-03-46
     55            Corrected data file names in G4DNA Melton and Sanche       
     56
     5708.09.2010, S. Incerti, tag emlowen-V09-03-45
     58            Updated high energy limits of G4DNAExcitation and G4DNAIonisation
     59
     6008.09.2010, S. Incerti, tag emlowen-V09-03-44
     61            Set high energy limit of G4DNAScreenedRutherfordModel to 1 MeV
     62
     6308.09.2010, S. Incerti, tag emlowen-V09-03-43
     64            Added new G4DNA processes and models for vib. exc & attachment
     65            Provided by Z. Francis et al. - Appl. Rad. Isot. (2010)
     66            http://dx.doi.org/10.1016/j.apradiso.2010.08.011
     67            to be used with G4LEDATA 6.16
     68
     6908.09.2010, S. Incerti, tag emlowen-V09-03-42
     70            Decreased low energy limit of G4DNAScreenedRutherfordModel
     71
     7205.09.2010, S. Incerti, tag emlowen-V09-03-41
     73            Bugzilla 1120
     74            Modified G4PhotoElectricAngularGeneratorSauterGavrila.cc
     75            as proposed by J. Goldberg
     76
     7725.08.2010, S. Incerti, tag emlowen-V09-03-40
     78            - updated & extended Rudd and Miller & Green models
     79            - to be used with G4LEDATA 6.15
     80
     8125.08.2010, S. Incerti, tag emlowen-V09-03-39
     82            -Adapted all high energy limits of G4DNA electron models
     83
     8424.08.2010, S. Incerti, tag emlowen-V09-03-38
     85            -Changed low energy limit of G4DNA elastic scattering models for e-
     86            -Switched default excitation model for e- to Born
     87            -to be used with G4LEDATA 6.14
     88
     8928.07.2010, L. Pandola, tag emlowen-V09-03-37
     90            First full version of G4Penelope08IonisationModel, model for e+/e-
     91            ionisation according to Penelope v2008. Still beta version.
     92
     9326.07.2010, L. Pandola, tag emlowen-V09-03-36
     94            Added class G4PenelopeCrossSection to store/handle cross sections
     95            (and higher momenta, like stopping powers) for the updated
     96            Penelope08 e+/e- models (ionisation and bremsstrahlung).
    1997
    209815.06.2010, G. Cosmo, tag emlowen-V09-03-35
  • trunk/source/processes/electromagnetic/lowenergy/include/G4DNAScreenedRutherfordElasticModel.hh

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 // $Id: G4DNAScreenedRutherfordElasticModel.hh,v 1.2 2010/01/07 18:10:19 sincerti Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4DNAScreenedRutherfordElasticModel.hh,v 1.3 2010/09/08 13:39:11 sincerti Exp $
     27// GEANT4 tag $Name: emlowen-V09-03-54 $
    2828//
    2929
     
    6767  G4double killBelowEnergy; 
    6868  G4double lowEnergyLimit; 
    69   G4double lowEnergyLimitOfModel; 
    70   G4double intermediateEnergyLimit;
     69  G4double intermediateEnergyLimit;
    7170  G4double highEnergyLimit;
    7271  G4bool isInitialised;
  • trunk/source/processes/electromagnetic/lowenergy/include/G4Generator2BN.hh

    r819 r1340  
    2424// ********************************************************************
    2525//
     26// $Id: G4Generator2BN.hh,v 1.4 2010/10/14 14:00:29 vnivanch Exp $
     27// GEANT4 tag $Name: emlowen-V09-03-54 $
    2628//
    2729// -------------------------------------------------------------------
     
    6365public:
    6466
    65   G4Generator2BN(const G4String& name);
     67  G4Generator2BN(const G4String& name = "");
    6668
    67   ~G4Generator2BN();
     69  virtual ~G4Generator2BN();
    6870
    6971  G4double PolarAngle(const G4double initial_energy,
  • trunk/source/processes/electromagnetic/lowenergy/include/G4Generator2BS.hh

    r819 r1340  
    2424// ********************************************************************
    2525//
     26// $Id: G4Generator2BS.hh,v 1.5 2010/10/14 14:00:29 vnivanch Exp $
     27// GEANT4 tag $Name: emlowen-V09-03-54 $
    2628//
    2729// -------------------------------------------------------------------
     
    3941//
    4042// Modifications:
    41 // 02 Jun 2003                           First implementation acording with new design
     43// 02 Jun 2003  First implementation acording with new design
     44// 12 Oct 2010  V.Ivanchenko moved RejectionFunction inline
    4245//               
    4346//
    4447// Class Description:
    4548//
    46 // Concrete class for Bremsstrahlung Angular Distribution Generation - 2BS Distribution
    47 // Further documentation available from http://www.ge.infn.it/geant4/lowE
     49// Concrete class for Bremsstrahlung Angular Distribution Generation
     50// 2BS Distribution
     51//
    4852
    4953// -------------------------------------------------------------------
     
    5761#include "G4VBremAngularDistribution.hh"
    5862
     63class G4Pow;
     64
    5965class G4Generator2BS : public G4VBremAngularDistribution
    6066{
     
    6268public:
    6369
    64   G4Generator2BS(const G4String& name);
     70  G4Generator2BS(const G4String& name="");
    6571
    66   ~G4Generator2BS();
     72  virtual ~G4Generator2BS();
    6773
    6874  G4double PolarAngle(const G4double initial_energy,
     
    7480protected:
    7581
    76   G4double RejectionFunction(G4double value) const;
     82  inline G4double RejectionFunction(G4double value) const;
    7783
    7884private:
     85
    7986  G4double z;
    8087  G4double rejection_argument1, rejection_argument2, rejection_argument3;
    8188  G4double EnergyRatio;
    8289
     90  G4Pow* g4pow;
     91
    8392  // hide assignment operator
    84      G4Generator2BS & operator=(const  G4Generator2BS &right);
    85      G4Generator2BS(const  G4Generator2BS&);
     93  G4Generator2BS & operator=(const  G4Generator2BS &right);
     94  G4Generator2BS(const  G4Generator2BS&);
    8695
    8796};
    8897
     98inline G4double G4Generator2BS::RejectionFunction(G4double value) const
     99{
     100  G4double argument = (1+value)*(1+value);
     101  return (4+std::log(rejection_argument3+(z/argument)))*
     102    ((4*EnergyRatio*value/argument)-rejection_argument1)+rejection_argument2;
     103}
     104
    89105#endif
    90106
  • trunk/source/processes/electromagnetic/lowenergy/include/G4IonParametrisedLossModel.hh

    r1228 r1340  
    2424// ********************************************************************
    2525//
    26 //
     26// $Id: G4IonParametrisedLossModel.hh,v 1.8 2010/11/04 12:21:47 vnivanch Exp $
     27// GEANT4 tag $Name: emlowen-V09-03-54 $
    2728//
    2829// ===========================================================================
     
    136137
    137138   // Function, which computes the mean energy transfer rate to delta rays
    138    G4double DeltaRayMeanEnergyTransferRate(
     139   inline G4double DeltaRayMeanEnergyTransferRate(
    139140                                 const G4Material*, // Target Material
    140141                                 const G4ParticleDefinition*, // Projectile
     
    183184   // Function checking the applicability of physics tables to ion-material
    184185   // combinations (Note: the energy range of tables is not checked)
    185    LossTableList::iterator IsApplicable(
     186   inline LossTableList::iterator IsApplicable(
    186187                      const G4ParticleDefinition*,  // Projectile (ion)
    187188                      const G4Material*);           // Target material
     
    208209   
    209210   // Function for setting energy loss limit for stopping power integration
    210    void SetEnergyLossLimit(G4double ionEnergyLossLimit);
     211   inline void SetEnergyLossLimit(G4double ionEnergyLossLimit);
    211212
    212213 protected:
     214
     215   virtual
    213216   G4double MaxSecondaryEnergy(const G4ParticleDefinition*,
    214217                               G4double);   // Kinetic energy of projectile
     
    231234
    232235   // Function, which updates parameters concering particle properties
    233    void UpdateCache(
     236   inline void UpdateCache(
    234237                  const G4ParticleDefinition*);  // Projectile (ion)
    235238 
     
    287290
    288291   // Pointer to particle change object, which is used to set e.g. the
    289    // energy loss due to nuclear stopping
     292   // energy loss and secondary delta-electron
     293   // used indicating if model is initialized 
    290294   G4ParticleChangeForLoss* particleChangeLoss;
    291 
    292    // Flag indicating if model is initialized (i.e. if
    293    // G4ParticleChangeForLoss was created)
    294    G4bool modelIsInitialised;
    295295
    296296   // ######################################################################
  • trunk/source/processes/electromagnetic/lowenergy/include/G4IonParametrisedLossModel.icc

    r1196 r1340  
    2424// ********************************************************************
    2525//
    26 //
     26// $Id: G4IonParametrisedLossModel.icc,v 1.7 2010/11/04 12:21:47 vnivanch Exp $
     27// GEANT4 tag $Name: emlowen-V09-03-54 $
    2728//
    2829// ===========================================================================
     
    4344//                               Minor bug fix in ComputeDEDXPerVolume (AL)
    4445//                20. 11. 2009 - Added set-method for energy loss limit (AL)
     46//                04. 11. 2010 - Moved virtual methods to the source (VI)
    4547//
    4648// Class description:
     
    5456//
    5557// ===========================================================================
    56 
    5758
    5859inline G4double G4IonParametrisedLossModel::DeltaRayMeanEnergyTransferRate(
     
    116117}
    117118
    118 
    119 inline
    120 G4double G4IonParametrisedLossModel::MaxSecondaryEnergy(
    121                              const G4ParticleDefinition* particle,
    122                              G4double kineticEnergy) {
    123 
    124   // ############## Maximum energy of secondaries ##########################
    125   // Function computes maximum energy of secondary electrons which are
    126   // released by an ion
    127   //
    128   // See Geant4 physics reference manual (version 9.1), section 9.1.1
    129   //
    130   // Ref.: W.M. Yao et al, Jour. of Phys. G 33 (2006) 1.
    131   //       C.Caso et al. (Part. Data Group), Europ. Phys. Jour. C 3 1 (1998).
    132   //       B. Rossi, High energy particles, New York, NY: Prentice-Hall (1952).
    133   //
    134   // (Implementation adapted from G4BraggIonModel)
    135 
    136   if(particle != cacheParticle) UpdateCache(particle);
    137 
    138   G4double tau  = kineticEnergy/cacheMass;
    139   G4double tmax = 2.0 * electron_mass_c2 * tau * (tau + 2.) /
    140                   (1. + 2.0 * (tau + 1.) * cacheElecMassRatio +
    141                   cacheElecMassRatio * cacheElecMassRatio);
    142 
    143   return tmax;
    144 }
    145 
    146 
    147119inline
    148120void G4IonParametrisedLossModel::UpdateCache(
     
    155127  cacheChargeSquare = q * q;
    156128}
    157 
    158 
    159 inline
    160 G4double G4IonParametrisedLossModel::GetChargeSquareRatio(
    161                              const G4ParticleDefinition* particle,
    162                              const G4Material* material,
    163                              G4double kineticEnergy) {    // Kinetic energy
    164 
    165   G4double chargeSquareRatio = corrections ->
    166                                      EffectiveChargeSquareRatio(particle,
    167                                                                 material,
    168                                                                 kineticEnergy);
    169   corrFactor = chargeSquareRatio *
    170                        corrections -> EffectiveChargeCorrection(particle,
    171                                                                 material,
    172                                                                 kineticEnergy);
    173   return corrFactor;
    174 }
    175 
    176 
    177 inline
    178 G4double G4IonParametrisedLossModel::GetParticleCharge(
    179                              const G4ParticleDefinition* particle,
    180                              const G4Material* material,
    181                              G4double kineticEnergy) {   // Kinetic energy
    182 
    183   return corrections -> GetParticleCharge(particle, material, kineticEnergy);
    184 }
    185 
    186129
    187130inline
  • trunk/source/processes/electromagnetic/lowenergy/src/G4DNABornExcitationModel.cc

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 // $Id: G4DNABornExcitationModel.cc,v 1.9 2010/03/27 11:32:41 sincerti Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4DNABornExcitationModel.cc,v 1.10 2010/08/24 13:51:06 sincerti Exp $
     27// GEANT4 tag $Name: emlowen-V09-03-54 $
    2828//
    2929
     
    7878  if (verboseLevel > 3)
    7979    G4cout << "Calling G4DNABornExcitationModel::Initialise()" << G4endl;
    80 
    81   // Energy limits
    82   // Energy limits
    8380
    8481  G4String fileElectron("dna/sigma_excitation_e_born");
  • trunk/source/processes/electromagnetic/lowenergy/src/G4DNABornIonisationModel.cc

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 // $Id: G4DNABornIonisationModel.cc,v 1.16 2010/03/26 18:10:43 sincerti Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4DNABornIonisationModel.cc,v 1.18 2010/11/03 12:22:36 sincerti Exp $
     27// GEANT4 tag $Name: emlowen-V09-03-54 $
    2828//
    2929
     
    376376    deltaDirection.rotateUz(primaryDirection);
    377377
    378     G4double deltaTotalMomentum = std::sqrt(secondaryKinetic*(secondaryKinetic + 2.*electron_mass_c2 ));
    379 
    380     G4double finalPx = totalMomentum*primaryDirection.x() - deltaTotalMomentum*deltaDirection.x();
    381     G4double finalPy = totalMomentum*primaryDirection.y() - deltaTotalMomentum*deltaDirection.y();
    382     G4double finalPz = totalMomentum*primaryDirection.z() - deltaTotalMomentum*deltaDirection.z();
    383     G4double finalMomentum = std::sqrt(finalPx*finalPx + finalPy*finalPy + finalPz*finalPz);
    384     finalPx /= finalMomentum;
    385     finalPy /= finalMomentum;
    386     finalPz /= finalMomentum;
    387    
    388     G4ThreeVector direction;
    389     direction.set(finalPx,finalPy,finalPz);
    390    
    391     fParticleChangeForGamma->ProposeMomentumDirection(direction.unit()) ;
     378    if (particle->GetDefinition() == G4Electron::ElectronDefinition())
     379    {
     380      G4double deltaTotalMomentum = std::sqrt(secondaryKinetic*(secondaryKinetic + 2.*electron_mass_c2 ));
     381
     382      G4double finalPx = totalMomentum*primaryDirection.x() - deltaTotalMomentum*deltaDirection.x();
     383      G4double finalPy = totalMomentum*primaryDirection.y() - deltaTotalMomentum*deltaDirection.y();
     384      G4double finalPz = totalMomentum*primaryDirection.z() - deltaTotalMomentum*deltaDirection.z();
     385      G4double finalMomentum = std::sqrt(finalPx*finalPx + finalPy*finalPy + finalPz*finalPz);
     386      finalPx /= finalMomentum;
     387      finalPy /= finalMomentum;
     388      finalPz /= finalMomentum;
     389   
     390      G4ThreeVector direction;
     391      direction.set(finalPx,finalPy,finalPz);
     392   
     393      fParticleChangeForGamma->ProposeMomentumDirection(direction.unit()) ;
     394    }
     395   
     396    else fParticleChangeForGamma->ProposeMomentumDirection(primaryDirection) ;
     397   
    392398    fParticleChangeForGamma->SetProposedKineticEnergy(k-bindingEnergy-secondaryKinetic);
    393399    fParticleChangeForGamma->ProposeLocalEnergyDeposit(bindingEnergy);
     
    507513    G4double maxSecKinetic = 4.* (electron_mass_c2 / proton_mass_c2) * k;
    508514    phi = twopi * G4UniformRand();
    509     cosTheta = std::sqrt(secKinetic / maxSecKinetic);
     515   
     516    // cosTheta = std::sqrt(secKinetic / maxSecKinetic);
     517   
     518    // Restriction below 100 eV from Emfietzoglou (2000)
     519   
     520    if (secKinetic>100*eV) cosTheta = std::sqrt(secKinetic / maxSecKinetic);
     521    else cosTheta = (2.*G4UniformRand())-1.;
     522       
    510523  }                     
    511524}
  • trunk/source/processes/electromagnetic/lowenergy/src/G4DNAChampionElasticModel.cc

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 // $Id: G4DNAChampionElasticModel.cc,v 1.12 2010/04/08 17:29:08 sincerti Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4DNAChampionElasticModel.cc,v 1.15 2010/10/17 11:28:51 sincerti Exp $
     27// GEANT4 tag $Name: emlowen-V09-03-54 $
    2828//
    2929
     
    4141{
    4242
    43   killBelowEnergy = 8.23*eV; // Minimum e- energy for energy loss by excitation
     43  killBelowEnergy = 0.025*eV; // Minimum e- energy for energy loss by excitation
    4444  lowEnergyLimit = 0 * eV;
    45   lowEnergyLimitOfModel = 7.4 * eV; // The model lower energy is 7.4 eV
    46   highEnergyLimit = 10 * MeV;
     45  lowEnergyLimitOfModel = 0.025 * eV;
     46  highEnergyLimit = 1. * MeV;
    4747  SetLowEnergyLimit(lowEnergyLimit);
    4848  SetHighEnergyLimit(highEnergyLimit);
     
    139139
    140140    std::ostringstream eFullFileName;
    141     eFullFileName << path << "/dna/sigmadiff_cumulated_elastic_e_champion.dat";
     141    eFullFileName << path << "/dna/sigmadiff_cumulatedshort_elastic_e_champion.dat";
    142142    std::ifstream eDiffCrossSection(eFullFileName.str().c_str());
    143143     
  • trunk/source/processes/electromagnetic/lowenergy/src/G4DNAElastic.cc

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 // $Id: G4DNAElastic.cc,v 1.3 2009/03/04 13:28:49 sincerti Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4DNAElastic.cc,v 1.4 2010/09/08 14:07:16 sincerti Exp $
     27// GEANT4 tag $Name: emlowen-V09-03-54 $
    2828
    2929#include "G4DNAElastic.hh"
     
    6262    if(!Model()) SetModel(new G4DNAScreenedRutherfordElasticModel);
    6363    Model()->SetLowEnergyLimit(0*eV);
    64     Model()->SetHighEnergyLimit(10*MeV);
     64    Model()->SetHighEnergyLimit(1.*MeV);
    6565    AddEmModel(1, Model());
    6666  }
  • trunk/source/processes/electromagnetic/lowenergy/src/G4DNAExcitation.cc

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 // $Id: G4DNAExcitation.cc,v 1.4 2010/03/27 11:32:41 sincerti Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4DNAExcitation.cc,v 1.7 2010/10/08 08:53:17 sincerti Exp $
     27// GEANT4 tag $Name: emlowen-V09-03-54 $
    2828
    2929#include "G4DNAExcitation.hh"
     
    5757       &p == G4Electron::Electron()
    5858    || &p == G4Proton::ProtonDefinition()
     59    || &p == instance->GetIon("hydrogen")
    5960    || &p == instance->GetIon("alpha++")
    6061    || &p == instance->GetIon("alpha+")
     
    7778    {
    7879
    79       // First model
    80 
     80      // Emfietzoglou model
     81/*
    8182      if(!Model()) SetModel(new G4DNAEmfietzoglouExcitationModel);
    8283      Model()->SetLowEnergyLimit(8.23*eV);
    8384      Model()->SetHighEnergyLimit(10*MeV);
     85*/
     86      // Born model
    8487
    85       // Alternative model
    86 /*
    8788      if(!Model()) SetModel(new G4DNABornExcitationModel);
    8889      Model()->SetLowEnergyLimit(9*eV);
    8990      Model()->SetHighEnergyLimit(1*MeV);
    90 */
     91
    9192      AddEmModel(1, Model());   
    9293    }
     
    106107    }
    107108
     109    if(name == "hydrogen")
     110    {
     111      if(!Model()) SetModel(new G4DNAMillerGreenExcitationModel);
     112      Model()->SetLowEnergyLimit(10*eV);
     113      Model()->SetHighEnergyLimit(500*keV);
     114   
     115      AddEmModel(1, Model());   
     116    }
     117
     118
    108119    if( name == "alpha" || name == "alpha+" || name == "helium" )
    109120    {
    110121      if(!Model()) SetModel(new G4DNAMillerGreenExcitationModel);
    111122      Model()->SetLowEnergyLimit(1*keV);
    112       Model()->SetHighEnergyLimit(10*MeV);
     123      Model()->SetHighEnergyLimit(400*MeV);
    113124
    114125      AddEmModel(1, Model());   
  • trunk/source/processes/electromagnetic/lowenergy/src/G4DNAGenericIonsManager.cc

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 // $Id: G4DNAGenericIonsManager.cc,v 1.6 2009/06/10 13:32:36 mantero Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4DNAGenericIonsManager.cc,v 1.7 2010/11/03 10:44:26 sincerti Exp $
     27// GEANT4 tag $Name: emlowen-V09-03-54 $
    2828
    2929#include "G4DNAGenericIonsManager.hh"
     
    7171 G4Ions *positronium2s;
    7272 
     73 G4Ions *carbon;
     74 G4Ions *nitrogen;
     75 G4Ions *oxygen;
     76 G4Ions *iron;
     77
     78 iron=     new G4Ions(
     79                        "iron",    52.5672*GeV,       0.0*MeV,  +26.0*eplus,
     80                        0,              +1,             0,
     81                        0,               0,             0,
     82                        "nucleus",              +26,            +56,           0,
     83                        true,                -1.0,             0,       
     84                        false,                "",               0,             
     85                        0.0);
     86
     87 oxygen=   new G4Ions(
     88                        "oxygen",    15.0074*GeV,       0.0*MeV,  +8.0*eplus,
     89                        0,              +1,             0,
     90                        0,               0,             0,
     91                        "nucleus",              +8,            +16,           0,
     92                        true,                -1.0,             0,       
     93                        false,                "",               0,             
     94                        0.0);
     95
     96
     97 nitrogen= new G4Ions(
     98                        "nitrogen",    13.132*GeV,       0.0*MeV,  +7.0*eplus,
     99                        0,              +1,             0,
     100                        0,               0,             0,
     101                        "nucleus",              +7,            +14,           0,
     102                        true,                -1.0,             0,       
     103                        false,                "",               0,             
     104                        0.0);
     105
     106 carbon=   new G4Ions(
     107                        "carbon",    11.267025440*GeV,       0.0*MeV,  +6.0*eplus,
     108                        0,              +1,             0,
     109                        0,               0,             0,
     110                        "nucleus",              +6,            +12,           0,
     111                        true,                -1.0,             0,       
     112                        false,                "",               0,             
     113                        0.0);
    73114 
    74  helium=     new G4Ions(
     115 helium=   new G4Ions(
    75116                        "helium",    3.727417*GeV,       0.0*MeV,  +0.0*eplus,
    76117                        0,              +1,             0,
     
    81122                        0.0);
    82123
    83  alphaPlus=  new G4Ions("alpha+",    3.727417*GeV,       0.0*MeV,  +1.0*eplus,
     124 alphaPlus= new G4Ions("alpha+",    3.727417*GeV,       0.0*MeV,  +1.0*eplus,
    84125                               1,              +1,             0,
    85126                               0,               0,             0,
     
    110151
    111152
    112  /*
    113  // molechules construction
    114 
    115  G4Ions* oxonium; // H3O -- it will become H3O+
    116  G4Ions* hydroxyl; // OH -- it will produce OH- too
    117  G4Ions* molHydrogen; // H2
    118  //G4Ions* hydroxide; // OH-
    119  G4Ions* hydroPeroxide; // H2O2
    120  G4Ions* water; // H2O -- it will become also H2O+
    121 
    122 
    123  G4double mass = 19.02*g/Avogadro - 11*electron_mass_c2;
    124 
    125  oxonium = new G4Ions("H3O",        mass,             0,  +11.0*eplus,
    126                       0,               0,             0,
    127                       0,               0,             0,
    128                       "molecule",      0,             0,           0,
    129                       true,         -1.0,             0,
    130                       false,          "",             0,             
    131                       0.0);
    132  
    133  mass = 17.00734*g/Avogadro - 9*electron_mass_c2;
    134  
    135  hydroxyl = new G4Ions("OH",        mass,             0,  +9.0*eplus,
    136                       0,               0,             0,
    137                       0,               0,             0,
    138                       "molecule",      0,             0,           0,
    139                       true,         -1.0,             0,
    140                       false,          "",             0,             
    141                       0.0);
    142 
    143  mass = 2.01588*g/Avogadro - 2*electron_mass_c2;
    144 
    145  molHydrogen = new G4Ions("H2",         mass,             0,  +2.0*eplus,
    146                           0,               0,             0,
    147                           0,               0,             0,
    148                           "molecule",      0,             0,           0,
    149                           true,         -1.0,             0,
    150                           false,          "",             0,             
    151                           0.0);
    152 
    153  mass = 34.01468*g/Avogadro - 18*electron_mass_c2;
    154 
    155  hydroPeroxide = new G4Ions("H2O2",      mass,             0, +18.0*eplus,
    156                            0,               0,             0,
    157                            0,               0,             0,
    158                            "molecule",      0,             0,           0,
    159                            true,         -1.0,             0,
    160                            false,          "",             0,             
    161                            0.0);
    162  
    163  mass = 18.015*g/Avogadro - 10*electron_mass_c2;
    164 
    165  water = new G4Ions("H2O",        mass,             0,  +10.0*eplus,
    166                     0,               0,             0,
    167                     0,               0,             0,
    168                     "molecule",      0,             0,           0,
    169                     true,         -1.0,             0,
    170                     false,          "",             0,             
    171                     0.0);
    172 
    173  map["H3O" ]  =oxonium;
    174  map["OH"  ]  =hydroxyl;
    175  map["H2"  ]  =molHydrogen;
    176  map["H2O2"]  =hydroPeroxide;
    177  map["H2O" ]  =water;
    178  */
    179 
    180 
    181153 map["helium"  ]=helium;
    182154 map["hydrogen"]=hydrogen;
     
    185157 map["Ps-1s"   ]=positronium1s;
    186158 map["Ps-2s"   ]=positronium2s;
     159 map["carbon"  ]=carbon;
     160 map["nitrogen"]=nitrogen;
     161 map["oxygen"  ]=oxygen;
     162 map["iron"    ]=iron;
     163
    187164
    188165}
  • trunk/source/processes/electromagnetic/lowenergy/src/G4DNAIonisation.cc

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 // $Id: G4DNAIonisation.cc,v 1.4 2009/11/02 17:00:11 sincerti Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4DNAIonisation.cc,v 1.5 2010/09/08 14:30:45 sincerti Exp $
     27// GEANT4 tag $Name: emlowen-V09-03-54 $
    2828
    2929#include "G4DNAIonisation.hh"
     
    9191      if(!Model(2)) SetModel(new G4DNABornIonisationModel,2);
    9292      Model(2)->SetLowEnergyLimit(500*keV);
    93       Model(2)->SetHighEnergyLimit(10*MeV);
     93      Model(2)->SetHighEnergyLimit(100*MeV);
    9494   
    9595      AddEmModel(1, Model(1));   
     
    110110      if(!Model()) SetModel(new G4DNARuddIonisationModel);
    111111      Model()->SetLowEnergyLimit(0*keV);
    112       Model()->SetHighEnergyLimit(10*MeV);
     112      Model()->SetHighEnergyLimit(400*MeV);
    113113
    114114      AddEmModel(1, Model());   
  • trunk/source/processes/electromagnetic/lowenergy/src/G4DNAMillerGreenExcitationModel.cc

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 // $Id: G4DNAMillerGreenExcitationModel.cc,v 1.9 2010/06/08 21:50:00 sincerti Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4DNAMillerGreenExcitationModel.cc,v 1.11 2010/10/08 08:53:17 sincerti Exp $
     27// GEANT4 tag $Name: emlowen-V09-03-54 $
    2828//
    2929
     
    7474  instance = G4DNAGenericIonsManager::Instance();
    7575  G4ParticleDefinition* protonDef = G4Proton::ProtonDefinition();
     76  G4ParticleDefinition* hydrogenDef = instance->GetIon("hydrogen");
    7677  G4ParticleDefinition* alphaPlusPlusDef = instance->GetIon("alpha++");
    7778  G4ParticleDefinition* alphaPlusDef = instance->GetIon("alpha+");
     
    7980
    8081  G4String proton;
     82  G4String hydrogen;
    8183  G4String alphaPlusPlus;
    8284  G4String alphaPlus;
     
    102104  }
    103105
     106  if (hydrogenDef != 0)
     107  {
     108    hydrogen = hydrogenDef->GetParticleName();
     109    lowEnergyLimit[hydrogen] = 10. * eV;
     110    highEnergyLimit[hydrogen] = 500. * keV;
     111   
     112    kineticEnergyCorrection[0] = 1.;
     113    slaterEffectiveCharge[0][0] = 0.;
     114    slaterEffectiveCharge[1][0] = 0.;
     115    slaterEffectiveCharge[2][0] = 0.;
     116    sCoefficient[0][0] = 0.;
     117    sCoefficient[1][0] = 0.;
     118    sCoefficient[2][0] = 0.;
     119  }
     120  else
     121  {
     122    G4Exception("G4DNAMillerGreenExcitationModel::Initialise: hydrogen is not defined");
     123   
     124  }
    104125  if (alphaPlusPlusDef != 0)
    105126  {
    106127    alphaPlusPlus = alphaPlusPlusDef->GetParticleName();
    107128    lowEnergyLimit[alphaPlusPlus] = 1. * keV;
    108     highEnergyLimit[alphaPlusPlus] = 10. * MeV;
     129    highEnergyLimit[alphaPlusPlus] = 400. * MeV;
    109130
    110131    kineticEnergyCorrection[1] = 0.9382723/3.727417;
     
    125146    alphaPlus = alphaPlusDef->GetParticleName();
    126147    lowEnergyLimit[alphaPlus] = 1. * keV;
    127     highEnergyLimit[alphaPlus] = 10. * MeV;
     148    highEnergyLimit[alphaPlus] = 400. * MeV;
    128149
    129150    kineticEnergyCorrection[2] = 0.9382723/3.727417;
    130151    slaterEffectiveCharge[0][2]=2.0;
    131     slaterEffectiveCharge[1][2]=1.15;
    132     slaterEffectiveCharge[2][2]=1.15;
     152
     153// Following values provided by M. Dingfelder
     154    slaterEffectiveCharge[1][2]=2.00;
     155    slaterEffectiveCharge[2][2]=2.00;
     156//
    133157    sCoefficient[0][2]=0.7;
    134158    sCoefficient[1][2]=0.15;
     
    144168    helium = heliumDef->GetParticleName();
    145169    lowEnergyLimit[helium] = 1. * keV;
    146     highEnergyLimit[helium] = 10. * MeV;
     170    highEnergyLimit[helium] = 400. * MeV;
    147171   
    148172    kineticEnergyCorrection[3] = 0.9382723/3.727417;
     
    153177    sCoefficient[1][3]=0.25;
    154178    sCoefficient[2][3]=0.25;
     179
    155180  }
    156181  else
     
    163188    SetLowEnergyLimit(lowEnergyLimit[proton]);
    164189    SetHighEnergyLimit(highEnergyLimit[proton]);
     190  }
     191
     192  if (particle==hydrogenDef)
     193  {
     194    SetLowEnergyLimit(lowEnergyLimit[hydrogen]);
     195    SetHighEnergyLimit(highEnergyLimit[hydrogen]);
    165196  }
    166197
     
    231262      particleDefinition != G4Proton::ProtonDefinition()
    232263      &&
     264      particleDefinition != instance->GetIon("hydrogen")
     265      &&
    233266      particleDefinition != instance->GetIon("alpha++")
    234267      &&
     
    272305
    273306      // add ONE or TWO electron-water excitation for alpha+ and helium
    274  
     307/* 
    275308      if ( particleDefinition == instance->GetIon("alpha+")
    276309           ||
     
    278311         )
    279312      {
     313
    280314          G4DNAEmfietzoglouExcitationModel * excitationXS = new G4DNAEmfietzoglouExcitationModel();
     315          excitationXS->Initialise(G4Electron::ElectronDefinition());
    281316
    282317          G4double sigmaExcitation=0;
     
    294329         
    295330          delete excitationXS;
     331
     332          // Alternative excitation model
     333
     334          G4DNABornExcitationModel * excitationXS = new G4DNABornExcitationModel();
     335          excitationXS->Initialise(G4Electron::ElectronDefinition());
     336
     337          G4double sigmaExcitation=0;
     338          G4double tmp=0;
     339
     340          if (k*0.511/3728 > 9*eV && k*0.511/3728 < 1*MeV ) sigmaExcitation =
     341            excitationXS->CrossSectionPerVolume(material,G4Electron::ElectronDefinition(),k*0.511/3728,tmp,tmp)
     342            /material->GetAtomicNumDensityVector()[1];
     343       
     344          if ( particleDefinition == instance->GetIon("alpha+") )
     345            crossSection = crossSection +  sigmaExcitation ;
     346         
     347          if ( particleDefinition == instance->GetIon("helium") )
     348            crossSection = crossSection + 2*sigmaExcitation ;
     349         
     350          delete excitationXS;
     351         
    296352      }     
     353*/     
    297354
    298355    }
     
    327384  G4int level = RandomSelect(particleEnergy0,aDynamicParticle->GetDefinition());
    328385
    329   G4double excitationEnergy = waterExcitation.ExcitationEnergy(level);
     386  //  G4double excitationEnergy = waterExcitation.ExcitationEnergy(level);
     387
     388  // Dingfelder's excitation levels
     389  const G4double excitation[]={ 8.17*eV, 10.13*eV, 11.31*eV, 12.91*eV, 14.50*eV};
     390  G4double excitationEnergy = excitation[level];
     391
    330392  G4double newEnergy = particleEnergy0 - excitationEnergy;
    331393 
     
    364426  const G4double omegaj[]={0.85, 0.88, 0.88, 0.78, 0.78};
    365427 
     428  // Dingfelder's excitation levels
     429  const G4double Eliq[5]={ 8.17*eV, 10.13*eV, 11.31*eV, 12.91*eV, 14.50*eV};
     430
    366431  G4int particleTypeIndex = 0;
    367432  G4DNAGenericIonsManager* instance;
     
    369434
    370435  if (particleDefinition == G4Proton::ProtonDefinition()) particleTypeIndex=0;
     436  if (particleDefinition == instance->GetIon("hydrogen")) particleTypeIndex=0;
    371437  if (particleDefinition == instance->GetIon("alpha++")) particleTypeIndex=1;
    372438  if (particleDefinition == instance->GetIon("alpha+")) particleTypeIndex=2;
     
    377443
    378444  // SI - added protection
    379   if (tCorrected < waterExcitation.ExcitationEnergy(excitationLevel)) return 0;
     445  if (tCorrected < Eliq[excitationLevel]) return 0;
    380446  //
    381447 
     
    384450  G4double numerator;
    385451  numerator = std::pow(z * aj[excitationLevel], omegaj[excitationLevel]) *
    386     std::pow(tCorrected - waterExcitation.ExcitationEnergy(excitationLevel), nu);
     452    std::pow(tCorrected - Eliq[excitationLevel], nu);
     453
     454  // H case : see S. Uehara et al. IJRB 77, 2, 139-154 (2001) - section 3.3
     455 
     456  if (particleDefinition == instance->GetIon("hydrogen"))
     457     numerator = std::pow(z * 0.75*aj[excitationLevel], omegaj[excitationLevel]) *
     458     std::pow(tCorrected - Eliq[excitationLevel], nu);
     459
    387460
    388461  G4double power;
     
    394467  G4double zEff = particleDefinition->GetPDGCharge() / eplus + particleDefinition->GetLeptonNumber();
    395468
    396   zEff -= ( sCoefficient[0][particleTypeIndex] * S_1s(k, waterExcitation.ExcitationEnergy(excitationLevel), slaterEffectiveCharge[0][particleTypeIndex], 1.) +
    397             sCoefficient[1][particleTypeIndex] * S_2s(k, waterExcitation.ExcitationEnergy(excitationLevel), slaterEffectiveCharge[1][particleTypeIndex], 2.) +
    398             sCoefficient[2][particleTypeIndex] * S_2p(k, waterExcitation.ExcitationEnergy(excitationLevel), slaterEffectiveCharge[2][particleTypeIndex], 2.) );
     469  zEff -= ( sCoefficient[0][particleTypeIndex] * S_1s(k, Eliq[excitationLevel], slaterEffectiveCharge[0][particleTypeIndex], 1.) +
     470            sCoefficient[1][particleTypeIndex] * S_2s(k, Eliq[excitationLevel], slaterEffectiveCharge[1][particleTypeIndex], 2.) +
     471            sCoefficient[2][particleTypeIndex] * S_2p(k, Eliq[excitationLevel], slaterEffectiveCharge[2][particleTypeIndex], 2.) );
     472
     473  if (particleDefinition == instance->GetIon("hydrogen")) zEff = 1.;
    399474
    400475  G4double cross = sigma0 * zEff * zEff * numerator / denominator;
     476
    401477
    402478  return cross;
     
    415491
    416492  if ( particle == instance->GetIon("alpha++") ||
    417        particle == G4Proton::ProtonDefinition()  )
     493       particle == G4Proton::ProtonDefinition()|| 
     494       particle == instance->GetIon("hydrogen")  ||
     495       particle == instance->GetIon("alpha+")  ||
     496       particle == instance->GetIon("helium")
     497     )
    418498  { 
    419499     while (i > 0)
     
    437517  }
    438518
     519/*
    439520  // add ONE or TWO electron-water excitation for alpha+ and helium
    440521   
     
    449530         
    450531          G4DNAEmfietzoglouExcitationModel * excitationXS = new G4DNAEmfietzoglouExcitationModel();
     532          excitationXS->Initialise(G4Electron::ElectronDefinition());
    451533         
    452534          G4double sigmaExcitation=0;
     
    455537 
    456538          G4double partial = PartialCrossSection(k,i,particle);
     539
    457540          if (particle == instance->GetIon("alpha+")) partial = PartialCrossSection(k,i,particle) + sigmaExcitation;
    458541          if (particle == instance->GetIon("helium")) partial = PartialCrossSection(k,i,particle) + 2*sigmaExcitation;
     542
    459543          values.push_front(partial);
    460544          value += partial;
     
    474558    }
    475559  }     
     560*/
    476561
    477562  return 0;
     
    552637
    553638  G4double tElectron = 0.511/3728. * t;
    554   G4double value = 2. * tElectron * slaterEffectiveCharge / (energyTransferred * shellNumber);
    555  
     639 
     640  // The following is provided by M. Dingfelder
     641  G4double H = 2.*13.60569172 * eV;
     642  G4double value = std::sqrt ( 2. * tElectron / H ) / ( energyTransferred / H ) *  (slaterEffectiveCharge/shellNumber);
     643
    556644  return value;
    557645}
  • trunk/source/processes/electromagnetic/lowenergy/src/G4DNARuddIonisationModel.cc

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 // $Id: G4DNARuddIonisationModel.cc,v 1.17 2010/04/07 20:08:31 sincerti Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4DNARuddIonisationModel.cc,v 1.21 2010/11/04 14:52:17 sincerti Exp $
     27// GEANT4 tag $Name: emlowen-V09-03-54 $
    2828//
    2929
     
    159159
    160160    lowEnergyLimit[alphaPlusPlus] = lowEnergyLimitForZ2;
    161     highEnergyLimit[alphaPlusPlus] = 10. * MeV;
     161    highEnergyLimit[alphaPlusPlus] = 400. * MeV;
    162162
    163163    // Cross section
     
    181181
    182182    lowEnergyLimit[alphaPlus] = lowEnergyLimitForZ2;
    183     highEnergyLimit[alphaPlus] = 10. * MeV;
     183    highEnergyLimit[alphaPlus] = 400. * MeV;
    184184
    185185    // Cross section
     
    202202
    203203    lowEnergyLimit[helium] = lowEnergyLimitForZ2;
    204     highEnergyLimit[helium] = 10. * MeV;
     204    highEnergyLimit[helium] = 400. * MeV;
    205205
    206206    // Cross section
     
    363363              sigma = table->FindValue(k);
    364364
    365               // BEGIN ELECTRON CORRECTION
    366               // add ONE or TWO electron-water excitation for alpha+ and helium
    367    
    368               if ( particleDefinition == instance->GetIon("alpha+")
    369                    ||
    370                    particleDefinition == instance->GetIon("helium")
    371                    )
    372               {
    373      
    374                   G4DNACrossSectionDataSet* electronDataset = new G4DNACrossSectionDataSet
    375                     (new G4LogLogInterpolation, eV, (1./3.343e22)*m*m);
    376        
    377                   electronDataset->LoadData("dna/sigma_ionisation_e_born");
    378 
    379                   G4double kElectron = k * 0.511/3728;
    380 
    381                   if ( particleDefinition == instance->GetIon("alpha+") )
    382                   {
    383                       G4double tmp1 = table->FindValue(k) + electronDataset->FindValue(kElectron);
    384                       delete electronDataset;
    385                       if (verboseLevel > 3)
    386                       {
    387                         G4cout << "---> Kinetic energy(eV)=" << k/eV << G4endl;
    388                         G4cout << " - Cross section per water molecule (cm^2)=" << tmp1/cm/cm << G4endl;
    389                         G4cout << " - Cross section per water molecule (cm^-1)=" <<
    390                         tmp1*material->GetAtomicNumDensityVector()[1]/(1./cm) << G4endl;
    391                       }
    392                       return tmp1*material->GetAtomicNumDensityVector()[1];
    393                   }
    394 
    395                   if ( particleDefinition == instance->GetIon("helium") )
    396                   {
    397                       G4double tmp2 = table->FindValue(k) +  2. * electronDataset->FindValue(kElectron);
    398                       delete electronDataset;
    399                       if (verboseLevel > 3)
    400                       {
    401                         G4cout << "---> Kinetic energy(eV)=" << k/eV << G4endl;
    402                         G4cout << " - Cross section per water molecule (cm^2)=" << tmp2/cm/cm << G4endl;
    403                         G4cout << " - Cross section per water molecule (cm^-1)=" << tmp2*
    404                         material->GetAtomicNumDensityVector()[1]/(1./cm) << G4endl;
    405                       }
    406                       return tmp2*material->GetAtomicNumDensityVector()[1];
    407                   }
    408               }     
    409 
    410               // END ELECTRON CORRECTION
    411365         }
    412366      }
     
    489443      G4ParticleDefinition* definition = particle->GetDefinition();
    490444      G4ParticleMomentum primaryDirection = particle->GetMomentumDirection();
     445      /*
    491446      G4double particleMass = definition->GetPDGMass();
    492447      G4double totalEnergy = k + particleMass;
    493448      G4double pSquare = k*(totalEnergy+particleMass);
    494449      G4double totalMomentum = std::sqrt(pSquare);
     450      */
    495451
    496452      G4int ionizationShell = RandomSelect(k,particleName);
     
    511467      deltaDirection.rotateUz(primaryDirection);
    512468
     469      // Ignored for ions on electrons
     470      /*
    513471      G4double deltaTotalMomentum = std::sqrt(secondaryKinetic*(secondaryKinetic + 2.*electron_mass_c2 ));
    514472
     
    525483
    526484      fParticleChangeForGamma->ProposeMomentumDirection(direction.unit()) ;
     485      */
     486      fParticleChangeForGamma->ProposeMomentumDirection(primaryDirection);
     487
    527488      fParticleChangeForGamma->SetProposedKineticEnergy(k-bindingEnergy-secondaryKinetic);
    528489      fParticleChangeForGamma->ProposeLocalEnergyDeposit(bindingEnergy);
     
    575536  }
    576537 
     538 
    577539  G4double secElecKinetic = 0.;
    578540 
     
    616578 
    617579  phi = twopi * G4UniformRand();
    618   cosTheta = std::sqrt(secKinetic / maxSecKinetic);
     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 
    619588}
    620589
     
    656625  G4double alphaConst ;
    657626
    658   const G4double Bj[5] = {12.61*eV, 14.73*eV, 18.55*eV, 32.20*eV, 539.7*eV};
     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};
    659630
    660631  if (j == 4)
     
    681652      E1 = 0.38;
    682653      A2 = 1.07;
    683       B2 = 14.6;
     654      // Value provided by M. Dingfelder (priv. comm)
     655      B2 = 11.6;
     656      //
    684657      C2 = 0.60;
    685658      D2 = 0.04;
     
    697670
    698671  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
    699675  G4double Ry = 13.6*eV;
    700676
     
    713689      tau = (0.511/3728.) * k ;
    714690  }
    715  
     691
    716692  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
    717695  G4double v2 = tau / Bj[ionizationLevelIndex];
     696  if (j==4) v2 = tau / waterStructure.IonisationEnergy(ionizationLevelIndex);
     697
    718698  G4double v = std::sqrt(v2);
    719699  G4double wc = 4.*v2 - 2.*v - (Ry/(4.*Bj[ionizationLevelIndex]));
     700  if (j==4) wc = 4.*v2 - 2.*v - (Ry/(4.*waterStructure.IonisationEnergy(ionizationLevelIndex)));
    720701
    721702  G4double L1 = (C1* std::pow(v,(D1))) / (1.+ E1*std::pow(v, (D1+4.)));
     
    731712    * ( (F1+w*F2) / ( std::pow((1.+w),3) * ( 1.+std::exp(alphaConst*(w-wc)/v))) );
    732713
     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
    733718  if ( (particleDefinition == instance->GetIon("hydrogen")) && (ionizationLevelIndex==4))
    734719
    735     sigma = Gj[j] * (S/Bj[ionizationLevelIndex])
     720//    sigma = Gj[j] * (S/Bj[ionizationLevelIndex])
     721    sigma = Gj[j] * (S/waterStructure.IonisationEnergy(ionizationLevelIndex))
    736722    * ( (F1+w*F2) / ( std::pow((1.+w),3) * ( 1.+std::exp(alphaConst*(w-wc)/v))) );
    737723
     
    756742  {
    757743      slaterEffectiveCharge[0]=2.0;
    758       slaterEffectiveCharge[1]=1.15;
    759       slaterEffectiveCharge[2]=1.15;
     744      // The following values are provided by M. Dingfelder (priv. comm)   
     745      slaterEffectiveCharge[1]=2.0;
     746      slaterEffectiveCharge[2]=2.0;
     747      //
    760748      sCoefficient[0]=0.7;
    761749      sCoefficient[1]=0.15;
     
    780768      sigma = Gj[j] * (S/Bj[ionizationLevelIndex]) * ( (F1+w*F2) / ( std::pow((1.+w),3) * ( 1.+std::exp(alphaConst*(w-wc)/v))) );
    781769   
     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
    782773      G4double zEff = particleDefinition->GetPDGCharge() / eplus + particleDefinition->GetLeptonNumber();
    783774 
     
    852843
    853844  G4double tElectron = 0.511/3728. * t;
    854   G4double value = 2. * tElectron * slaterEffectiveChg / (energyTransferred * shellNumber);
     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);
    855848 
    856849  return value;
     
    872865    {
    873866        G4double value = (std::log10(k/eV)-4.2)/0.5;
    874         return((0.8/(1+std::exp(value))) + 0.9);
     867        // The following values are provided by M. Dingfelder (priv. comm)   
     868        return((0.6/(1+std::exp(value))) + 0.9);
    875869    }
    876870    else
     
    891885  G4DNAGenericIonsManager *instance;
    892886  instance = G4DNAGenericIonsManager::Instance();
    893   G4double kElectron(0);
    894 
    895   G4DNACrossSectionDataSet * electronDataset = new G4DNACrossSectionDataSet (new G4LogLogInterpolation, eV, (1./3.343e22)*m*m);
    896887 
    897   if ( particle == instance->GetIon("alpha+")->GetParticleName()
    898        ||
    899        particle == instance->GetIon("helium")->GetParticleName()
    900        )
    901   {     
    902       electronDataset->LoadData("dna/sigma_ionisation_e_born");
    903 
    904       kElectron = k * 0.511/3728;
    905        
    906   }     
    907  
    908   // END PART 1/2 OF ELECTRON CORRECTION
    909  
    910888  G4int level = 0;
    911889
     
    931909              i--;
    932910              valuesBuffer[i] = table->GetComponent(i)->FindValue(k);
    933 
    934               // BEGIN PART 2/2 OF ELECTRON CORRECTION
    935               // Use only electron partial cross sections
    936              
    937               if (particle == instance->GetIon("alpha+")->GetParticleName())
    938                 {valuesBuffer[i]=table->GetComponent(i)->FindValue(k) + electronDataset->GetComponent(i)->FindValue(kElectron); }
    939 
    940               if (particle == instance->GetIon("helium")->GetParticleName())
    941                 {valuesBuffer[i]=table->GetComponent(i)->FindValue(k) + 2*electronDataset->GetComponent(i)->FindValue(kElectron); }
    942 
    943               // BEGIN PART 2/2 OF ELECTRON CORRECTION
    944 
    945911              value += valuesBuffer[i];
    946912          }
     
    958924              {
    959925                  delete[] valuesBuffer;
    960                  
    961                   if (electronDataset) delete electronDataset;
    962                  
    963926                  return i;
    964927              }
     
    975938  }
    976939
    977   delete electronDataset;
    978      
    979940  return level;
    980941}
  • trunk/source/processes/electromagnetic/lowenergy/src/G4DNAScreenedRutherfordElasticModel.cc

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 // $Id: G4DNAScreenedRutherfordElasticModel.cc,v 1.10 2010/01/07 18:10:50 sincerti Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4DNAScreenedRutherfordElasticModel.cc,v 1.14 2010/09/08 14:07:16 sincerti Exp $
     27// GEANT4 tag $Name: emlowen-V09-03-54 $
    2828//
    2929
     
    4141{
    4242
    43   killBelowEnergy = 8.23*eV; // Minimum e- energy for energy loss by excitation
     43  killBelowEnergy = 0.025*eV; // Minimum e- energy for energy loss by excitation
    4444  lowEnergyLimit = 0 * eV;
    45   lowEnergyLimitOfModel = 7 * eV; // The model lower energy is 7 eV
    4645  intermediateEnergyLimit = 200 * eV; // Switch between two final state models
    47   highEnergyLimit = 10 * MeV;
     46  highEnergyLimit = 1. * MeV;
    4847  SetLowEnergyLimit(lowEnergyLimit);
    4948  SetHighEnergyLimit(highEnergyLimit);
     
    174173  if (ekin < highEnergyLimit)
    175174  {
    176      
    177       //SI : XS must not be zero otherwise sampling of secondaries method ignored
    178       if (ekin < lowEnergyLimitOfModel) ekin = lowEnergyLimitOfModel;
    179       //
    180175     
    181176      G4double z = 10.;
  • trunk/source/processes/electromagnetic/lowenergy/src/G4Generator2BN.cc

    r819 r1340  
    2424// ********************************************************************
    2525//
     26// $Id: G4Generator2BN.cc,v 1.9 2010/10/14 14:01:02 vnivanch Exp $
     27// GEANT4 tag $Name: emlowen-V09-03-54 $
    2628//
    2729// -------------------------------------------------------------------
     
    4547// Class Description:
    4648//
    47 // Concrete base class for Bremsstrahlung Angular Distribution Generation - 2BN Distribution
     49// Concrete base class for Bremsstrahlung Angular Distribution Generation
     50// 2BN Distribution
    4851//
    4952// Class Description: End
    5053//
    5154// -------------------------------------------------------------------
    52 //
    53 //   
     55//   
    5456
    5557#include "G4Generator2BN.hh"
     
    150152
    151153
    152 G4Generator2BN::G4Generator2BN(const G4String& name):G4VBremAngularDistribution(name)
     154G4Generator2BN::G4Generator2BN(const G4String&)
     155 : G4VBremAngularDistribution("AngularGen2BN")
    153156{
    154157  b = 1.2;
     
    172175
    173176G4Generator2BN::~G4Generator2BN()
    174 {;}
     177{}
    175178
    176179//
  • trunk/source/processes/electromagnetic/lowenergy/src/G4Generator2BS.cc

    r819 r1340  
    2424// ********************************************************************
    2525//
     26// $Id: G4Generator2BS.cc,v 1.10 2010/10/14 14:01:02 vnivanch Exp $
     27// GEANT4 tag $Name: emlowen-V09-03-54 $
    2628//
    2729// -------------------------------------------------------------------
     
    3941//
    4042// Modifications:
    41 // 02 Jun 2003                    First implementation acording with new design
    42 // 05 Nov 2003  MGP               Fixed std namespace
    43 // 17 Nov 2003  MGP               Fixed compilation problem on Windows                 
     43// 02 Jun 2003               First implementation acording with new design
     44// 05 Nov 2003  MGP          Fixed std namespace
     45// 17 Nov 2003  MGP          Fixed compilation problem on Windows                 
     46// 12 Oct 2010  V.Ivanchenko Moved RejectionFunction inline, use G4Pow to speadup
    4447//
    4548// Class Description:
    4649//
    47 // Concrete base class for Bremsstrahlung Angular Distribution Generation - 2BS Distribution
     50// Concrete base class for Bremsstrahlung Angular Distribution Generation
     51// 2BS Distribution
    4852//
    4953// Class Description: End
     
    5155// -------------------------------------------------------------------
    5256//
    53 //   
    5457
    5558#include "G4Generator2BS.hh"
    56 #include "Randomize.hh"
    57 //    
     59#include "Randomize.hh"   
     60#include "G4Pow.hh"   
    5861
    59 G4Generator2BS::G4Generator2BS(const G4String& name):G4VBremAngularDistribution(name)
    60 {;}
     62//
     63
     64G4Generator2BS::G4Generator2BS(const G4String&)
     65  : G4VBremAngularDistribution("AngularGen2BS")
     66{
     67  g4pow = G4Pow::GetInstance();
     68}
    6169
    6270//   
    6371
    6472G4Generator2BS::~G4Generator2BS()
    65 {;}
     73{}
    6674
    6775//
     
    7987  // Departement of Medical Physics, Memorial Sloan-Kettering Cancer Center, New York
    8088
    81 
    8289  G4double theta = 0;
    8390
     
    8794  G4double gMaxEnergy = (pi*initialTotalEnergy)*(pi*initialTotalEnergy);
    8895
    89   G4double Zeff = std::sqrt(static_cast<G4double>(Z) * (static_cast<G4double>(Z) + 1.0));
    90   z = (0.00008116224*(std::pow(Zeff,0.3333333)));
     96  //G4double Zeff = std::sqrt(static_cast<G4double>(Z) * (static_cast<G4double>(Z) + 1.0));
     97  //z = (0.00008116224*(std::pow(Zeff,0.3333333)));
     98
     99  // VI speadup
     100  z = 0.00008116224*(g4pow->Z13(Z) + g4pow->Z13(Z+1));
    91101
    92102  // Rejection arguments
     
    97107
    98108  // Calculate rejection function at 0, 1 and Emax
    99   G4double gfunction0 = RejectionFunction(0);
    100   G4double gfunction1 = RejectionFunction(1);
     109  G4double gfunction0 = RejectionFunction(0.0);
     110  G4double gfunction1 = RejectionFunction(1.0);
    101111  G4double gfunctionEmax = RejectionFunction(gMaxEnergy);
    102 
    103112
    104113  // Calculate Maximum value
     
    110119  do{
    111120    rand = G4UniformRand();
    112     rand = rand/(1-rand+1.0/gMaxEnergy);
     121    rand /= (1 - rand + 1.0/gMaxEnergy);
    113122    gfunctionTest = RejectionFunction(rand);
    114123    randTest = G4UniformRand();
    115124
    116   }while(randTest > (gfunctionTest/gMaximum));
     125  } while(randTest*gMaximum > gfunctionTest);
    117126
    118127  theta = std::sqrt(rand)/initialTotalEnergy;
    119128
    120 
    121129  return theta;
    122130}
     131
    123132//
    124 
    125 G4double G4Generator2BS::RejectionFunction(G4double value) const
    126 {
    127 
    128   G4double argument = (1+value)*(1+value);
    129 
    130   G4double gfunction = (4+std::log(rejection_argument3+(z/argument)))*
    131     ((4*EnergyRatio*value/argument)-rejection_argument1)+rejection_argument2;
    132 
    133   return gfunction;
    134 
    135 }
    136133
    137134void G4Generator2BS::PrintGeneratorInformation() const
    138135{
    139136  G4cout << "\n" << G4endl;
    140   G4cout << "Bremsstrahlung Angular Generator is 2BS Generator from 2BS Koch & Motz distribution (Rev Mod Phys 31(4), 920 (1959))" << G4endl;
     137  G4cout << "Bremsstrahlung Angular Generator is 2BS Generator "
     138         << "from 2BS Koch & Motz distribution (Rev Mod Phys 31(4), 920 (1959))" << G4endl;
    141139  G4cout << "Sampling algorithm adapted from PIRS-0203" << G4endl;
    142140  G4cout << "\n" << G4endl;
  • trunk/source/processes/electromagnetic/lowenergy/src/G4IonParametrisedLossModel.cc

    r1228 r1340  
    2424// ********************************************************************
    2525//
    26 //
     26// $Id: G4IonParametrisedLossModel.cc,v 1.10 2010/11/04 12:21:48 vnivanch Exp $
     27// GEANT4 tag $Name: emlowen-V09-03-54 $
    2728//
    2829// ===========================================================================
     
    6465//                               functions accordingly, added new cache param.)
    6566//                             - Removed GetRange function (AL) 
     67//                04. 11. 2010 - Moved virtual methods to the source (VI)
    6668//
    6769//
     
    107109    nmbSubBins(100),
    108110    particleChangeLoss(0),
    109     modelIsInitialised(false),
    110     corrections(0),
    111111    corrFactor(1.0),
    112112    energyLossLimit(0.01),
    113     cutEnergies(0) {
    114 
     113    cutEnergies(0)
     114{
    115115  genericIon = G4GenericIon::Definition();
    116116  genericIonPDGMass = genericIon -> GetPDGMass();
     117  corrections = G4LossTableManager::Instance() -> EmCorrections();
    117118 
    118119  // The upper limit of the current model is set to 100 TeV
     
    192193  return couple -> GetMaterial() -> GetIonisation() ->
    193194                                                  GetMeanExcitationEnergy();
     195}
     196
     197// #########################################################################
     198
     199G4double G4IonParametrisedLossModel::MaxSecondaryEnergy(
     200                             const G4ParticleDefinition* particle,
     201                             G4double kineticEnergy) {
     202
     203  // ############## Maximum energy of secondaries ##########################
     204  // Function computes maximum energy of secondary electrons which are
     205  // released by an ion
     206  //
     207  // See Geant4 physics reference manual (version 9.1), section 9.1.1
     208  //
     209  // Ref.: W.M. Yao et al, Jour. of Phys. G 33 (2006) 1.
     210  //       C.Caso et al. (Part. Data Group), Europ. Phys. Jour. C 3 1 (1998).
     211  //       B. Rossi, High energy particles, New York, NY: Prentice-Hall (1952).
     212  //
     213  // (Implementation adapted from G4BraggIonModel)
     214
     215  if(particle != cacheParticle) UpdateCache(particle);
     216
     217  G4double tau  = kineticEnergy/cacheMass;
     218  G4double tmax = 2.0 * electron_mass_c2 * tau * (tau + 2.) /
     219                  (1. + 2.0 * (tau + 1.) * cacheElecMassRatio +
     220                  cacheElecMassRatio * cacheElecMassRatio);
     221
     222  return tmax;
     223}
     224
     225// #########################################################################
     226
     227G4double G4IonParametrisedLossModel::GetChargeSquareRatio(
     228                             const G4ParticleDefinition* particle,
     229                             const G4Material* material,
     230                             G4double kineticEnergy) {    // Kinetic energy
     231
     232  G4double chargeSquareRatio = corrections ->
     233                                     EffectiveChargeSquareRatio(particle,
     234                                                                material,
     235                                                                kineticEnergy);
     236  corrFactor = chargeSquareRatio *
     237                       corrections -> EffectiveChargeCorrection(particle,
     238                                                                material,
     239                                                                kineticEnergy);
     240  return corrFactor;
     241}
     242
     243// #########################################################################
     244
     245G4double G4IonParametrisedLossModel::GetParticleCharge(
     246                             const G4ParticleDefinition* particle,
     247                             const G4Material* material,
     248                             G4double kineticEnergy) {   // Kinetic energy
     249
     250  return corrections -> GetParticleCharge(particle, material, kineticEnergy);
    194251}
    195252
     
    295352  }
    296353
    297   // The particle change object is cast to G4ParticleChangeForLoss
    298   if(! modelIsInitialised) {
    299 
    300      modelIsInitialised = true;
    301      corrections = G4LossTableManager::Instance() -> EmCorrections();
    302 
    303      if(!particleChangeLoss) {
    304         if(pParticleChange) {
    305 
    306            particleChangeLoss = reinterpret_cast<G4ParticleChangeForLoss*>
    307                (pParticleChange);
    308         }
    309         else {
    310           particleChangeLoss = new G4ParticleChangeForLoss();
    311         }
    312      }
     354  // The particle change object
     355  if(! particleChangeLoss) {
     356    particleChangeLoss = GetParticleChangeForLoss();
    313357  }
    314358 
  • trunk/source/processes/electromagnetic/lowenergy/src/G4LivermoreIonisationModel.cc

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 // $Id: G4LivermoreIonisationModel.cc,v 1.8 2010/03/26 09:32:50 pandola Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4LivermoreIonisationModel.cc,v 1.9 2010/10/13 07:28:47 pandola Exp $
     27// GEANT4 tag $Name: emlowen-V09-03-54 $
    2828//
    2929// Author: Luciano Pandola
     
    4444//                  - atomic deexcitation managed via G4VEmModel::DeexcitationFlag() is
    4545//                    set as "true" (default would be false)
     46// 12 Oct 2010   L Pandola
     47//                  - add debugging information about energy in
     48//                    SampleDeexcitationAlongStep()
     49//                  - generate fluorescence SampleDeexcitationAlongStep() only above
     50//                    the cuts.
     51//
    4652//
    4753
     
    125131    }
    126132  energySpectrum = new G4eIonisationSpectrum();
    127   if (verboseLevel > 0)
     133  if (verboseLevel > 3)
    128134    G4cout << "G4VEnergySpectrum is initialized" << G4endl;
    129135
     
    159165    }
    160166
    161   if (verboseLevel > 1)
     167  if (verboseLevel > 3)
    162168    {
    163169      G4cout << "Cross section data: " << G4endl;
     
    440446  //secondaries. The eloss value is updated.
    441447  G4double energyLossBefore = eloss;
     448
    442449  if (verboseLevel > 2)
    443     G4cout << "Energy loss along step before deexcitation : " << energyLossBefore/keV <<
    444       " keV" << G4endl;
    445 
     450    {
     451      G4cout << "-----------------------------------------------------------" << G4endl;
     452      G4cout << " SampleDeexcitationAlongStep() from G4LivermoreIonisation" << G4endl;
     453      G4cout << "Energy loss along step before deexcitation : " << energyLossBefore/keV <<
     454        " keV" << G4endl;
     455    }
    446456  G4double incidentEnergy = theTrack.GetDynamicParticle()->GetKineticEnergy();
    447457
     
    453463  G4double cute = (*(theCoupleTable->GetEnergyCutsVector(1)))[index];
    454464 
    455   //Notice: in LowEnergyIonisation, fluorescence is always generated above 250 eV
    456   //not above the tracking cut.
    457   //G4double cutForLowEnergySecondaryParticles = 250.0*eV;
    458465
    459466  std::vector<G4DynamicParticle*>* deexcitationProducts =
     
    505512                              {
    506513                                e = aSecondary->GetKineticEnergy();
    507                                 if ( eTot + e <= eloss )
     514                                G4double itsCut = cutg;
     515                                if (aSecondary->GetParticleDefinition() == G4Electron::Electron())
     516                                  itsCut = cute;
     517                                if ( eTot + e <= eloss && e > itsCut )
    508518                                  {
    509519                                    eTot += e;
     
    524534    }
    525535
     536  G4double energyLossInFluorescence = 0.0;
    526537  size_t nSecondaries = deexcitationProducts->size();
    527538  if (nSecondaries > 0)
    528539    {
    529       fParticleChange->SetNumberOfSecondaries(nSecondaries);
     540      //You may have already secondaries produced by SampleSubCutSecondaries()
     541      //at the process G4VEnergyLossProcess
     542      G4int secondariesBefore = fParticleChange->GetNumberOfSecondaries();
     543      fParticleChange->SetNumberOfSecondaries(nSecondaries+secondariesBefore);
    530544      const G4StepPoint* preStep = theTrack.GetStep()->GetPreStepPoint();
    531545      const G4StepPoint* postStep = theTrack.GetStep()->GetPostStepPoint();
     
    538552      G4double time, q;
    539553      G4ThreeVector position;
    540      
     554
    541555      for (size_t i=0; i<nSecondaries; i++)
    542556        {
     
    553567                  position += r;
    554568                  G4Track* newTrack = new G4Track(part, time, position);
     569                  energyLossInFluorescence += eSecondary;
    555570                  pParticleChange->AddSecondary(newTrack);
    556571                }
     
    566581  delete deexcitationProducts;
    567582 
     583  //Check and verbosities. Ensure energy conservation
    568584  if (verboseLevel > 2)
    569     G4cout << "Energy loss along step after deexcitation : " << eloss/keV << 
    570       " keV" << G4endl;
     585    {
     586      G4cout << "Energy loss along step after deexcitation : " << eloss/keV << 
     587        " keV" << G4endl;
     588    }
     589  if (verboseLevel > 1)
     590    {
     591      G4cout << "------------------------------------------------------------------" << G4endl;
     592      G4cout << "Energy in fluorescence: " << energyLossInFluorescence/keV << " keV" << G4endl;
     593      G4cout << "Residual energy loss: " << eloss/keV << " keV " << G4endl;
     594      G4cout << "Total final: " << (energyLossInFluorescence+eloss)/keV << " keV" << G4endl;
     595      G4cout << "Total initial: " << energyLossBefore/keV << " keV" << G4endl; 
     596      G4cout << "------------------------------------------------------------------" << G4endl;
     597    }
     598  if (verboseLevel > 0)
     599    {
     600      if (std::fabs(energyLossBefore-energyLossInFluorescence-eloss)>10*eV)
     601        {
     602          G4cout << "Found energy non-conservation at SampleDeexcitationAlongStep() " << G4endl;
     603          G4cout << "Energy in fluorescence: " << energyLossInFluorescence/keV << " keV" << G4endl;
     604          G4cout << "Residual energy loss: " << eloss/keV << " keV " << G4endl;
     605          G4cout << "Total final: " << (energyLossInFluorescence+eloss)/keV << " keV" << G4endl;
     606          G4cout << "Total initial: " << energyLossBefore/keV << " keV" << G4endl;     
     607        }
     608    }
    571609}
    572610
     
    655693           xsis->AddComponent(p);
    656694         }
    657        if(verboseLevel>0) xsis->PrintData();
     695       if(verboseLevel>3) xsis->PrintData();
    658696       shellVacancy->AddXsiTable(xsis);
    659697    }
  • trunk/source/processes/electromagnetic/lowenergy/src/G4LivermorePhotoElectricModel.cc

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 // $Id: G4LivermorePhotoElectricModel.cc,v 1.11 2010/03/26 09:32:50 pandola Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4LivermorePhotoElectricModel.cc,v 1.12 2010/10/13 07:15:42 pandola Exp $
     27// GEANT4 tag $Name: emlowen-V09-03-54 $
    2828//
    2929//
     
    304304  if (!DeexcitationFlag() && augerbool)
    305305    {
    306       G4cout << "WARNING - G4PenelopePhotoElectricModel" << G4endl;
     306      G4cout << "WARNING - G4LivermorePhotoElectricModel" << G4endl;
    307307      G4cout << "The use of the Atomic Deexcitation Manager is set to false " << G4endl;
    308308      G4cout << "Therefore, Auger electrons will be not generated anyway" << G4endl;
  • trunk/source/processes/electromagnetic/lowenergy/src/G4Penelope08ComptonModel.cc

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 // $Id: G4Penelope08ComptonModel.cc,v 1.6 2010/04/12 13:53:29 pandola Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4Penelope08ComptonModel.cc,v 1.7 2010/07/28 07:09:16 pandola Exp $
     27// GEANT4 tag $Name: emlowen-V09-03-54 $
    2828//
    2929// Author: Luciano Pandola
     
    4242#include "G4VEMDataSet.hh"
    4343#include "G4PhysicsTable.hh"
    44 #include "G4ElementTable.hh"
    45 #include "G4Element.hh"
    4644#include "G4PhysicsLogVector.hh"
    4745#include "G4AtomicTransitionManager.hh"
  • trunk/source/processes/electromagnetic/lowenergy/src/G4Penelope08GammaConversionModel.cc

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 // $Id: G4Penelope08GammaConversionModel.cc,v 1.3 2010/06/25 09:41:17 gunter Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4Penelope08GammaConversionModel.cc,v 1.4 2010/07/28 07:09:16 pandola Exp $
     27// GEANT4 tag $Name: emlowen-V09-03-54 $
    2828//
    2929// Author: Luciano Pandola
     
    8787  if (fScreeningFunction)
    8888    delete fScreeningFunction;
    89 
    9089}
    9190
  • trunk/source/processes/electromagnetic/lowenergy/src/G4Penelope08PhotoElectricModel.cc

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 // $Id: G4Penelope08PhotoElectricModel.cc,v 1.4 2010/06/25 09:41:19 gunter Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4Penelope08PhotoElectricModel.cc,v 1.5 2010/07/28 07:09:16 pandola Exp $
     27// GEANT4 tag $Name: emlowen-V09-03-54 $
    2828//
    2929// Author: Luciano Pandola
     
    4242#include "G4ElementTable.hh"
    4343#include "G4Element.hh"
    44 #include "G4CrossSectionHandler.hh"
    4544#include "G4AtomicTransitionManager.hh"
    4645#include "G4AtomicShell.hh"
     
    487486  //(theTable)[ishell] --> cross section for shell (ishell-1)
    488487
    489 
    490 
    491488  //reserve space for the vectors
    492489  //everything is log-log
  • trunk/source/processes/electromagnetic/lowenergy/src/G4Penelope08RayleighModel.cc

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 // $Id: G4Penelope08RayleighModel.cc,v 1.2 2010/06/25 09:41:28 gunter Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4Penelope08RayleighModel.cc,v 1.3 2010/07/28 07:09:16 pandola Exp $
     27// GEANT4 tag $Name: emlowen-V09-03-54 $
    2828//
    2929// Author: Luciano Pandola
     
    4343#include "G4ElementTable.hh"
    4444#include "G4Element.hh"
    45 #include "G4PenelopeIntegrator.hh"
    4645#include "G4PhysicsFreeVector.hh"
    4746
     
    224223
    225224   if (verboseLevel > 2)
    226     G4cout << "Compton cross Section at " << energy/keV << " keV for Z=" << Z <<
     225    G4cout << "Rayleigh cross section at " << energy/keV << " keV for Z=" << Z <<
    227226      " = " << cross/barn << " barn" << G4endl;
    228227    return cross;
     
    414413  fParticleChange->SetProposedKineticEnergy(photonEnergy0) ;
    415414 
    416 
    417415  return;
    418416}
  • trunk/source/processes/electromagnetic/lowenergy/src/G4PenelopeOscillatorManager.cc

    r1337 r1340  
    6666{
    6767  Clear();
     68  delete instance;
    6869}
    6970 
  • trunk/source/processes/electromagnetic/lowenergy/src/G4PhotoElectricAngularGeneratorSauterGavrila.cc

    r1337 r1340  
    7979
    8080  if (gamma > 5.) {
    81     return G4ThreeVector(sinteta*cosphi, sinteta*sinphi, costeta);
     81    G4ThreeVector direction (sinteta*cosphi, sinteta*sinphi, costeta);
     82    return direction;
     83    // Bugzilla 1120
     84    // SI on 05/09/2010 as suggested by JG 04/09/10
    8285  }
    8386
Note: See TracChangeset for help on using the changeset viewer.