Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/hadronic/models/de_excitation/multifragmentation/src/G4StatMFFragment.cc

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/hadronic/models/de_excitation/multifragmentation/src/G4StatMFFragment.cc (Version 11.3.0) and /processes/hadronic/models/de_excitation/multifragmentation/src/G4StatMFFragment.cc (Version 6.0)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                    <<   3 // * DISCLAIMER                                                       *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th <<   5 // * The following disclaimer summarizes all the specific disclaimers *
  6 // * the Geant4 Collaboration.  It is provided <<   6 // * of contributors to this software. The specific disclaimers,which *
  7 // * conditions of the Geant4 Software License <<   7 // * govern, are listed with their locations in:                      *
  8 // * LICENSE and available at  http://cern.ch/ <<   8 // *   http://cern.ch/geant4/license                                  *
  9 // * include a list of copyright holders.      << 
 10 // *                                                9 // *                                                                  *
 11 // * Neither the authors of this software syst     10 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     11 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     12 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     13 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  <<  14 // * use.                                                             *
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                               15 // *                                                                  *
 18 // * This  code  implementation is the result  <<  16 // * This  code  implementation is the  intellectual property  of the *
 19 // * technical work of the GEANT4 collaboratio <<  17 // * GEANT4 collaboration.                                            *
 20 // * By using,  copying,  modifying or  distri <<  18 // * By copying,  distributing  or modifying the Program (or any work *
 21 // * any work based  on the software)  you  ag <<  19 // * based  on  the Program)  you indicate  your  acceptance of  this *
 22 // * use  in  resulting  scientific  publicati <<  20 // * statement, and all its terms.                                    *
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // *******************************************     21 // ********************************************************************
 25 //                                                 22 //
 26 //                                                 23 //
                                                   >>  24 // $Id: G4StatMFFragment.cc,v 1.3 2003/11/04 11:30:35 lara Exp $
                                                   >>  25 // GEANT4 tag $Name: geant4-06-00 $
 27 //                                                 26 //
 28 // Hadronic Process: Nuclear De-excitations        27 // Hadronic Process: Nuclear De-excitations
 29 // by V. Lara                                      28 // by V. Lara
 30                                                    29 
 31 #include "G4StatMFFragment.hh"                     30 #include "G4StatMFFragment.hh"
 32 #include "G4PhysicalConstants.hh"              << 
 33 #include "G4HadronicException.hh"                  31 #include "G4HadronicException.hh"
 34 #include "G4Pow.hh"                            <<  32 
 35                                                    33 
 36 // Copy constructor                                34 // Copy constructor
 37 G4StatMFFragment::G4StatMFFragment(const G4Sta     35 G4StatMFFragment::G4StatMFFragment(const G4StatMFFragment & )
 38 {                                                  36 {
 39     throw G4HadronicException(__FILE__, __LINE <<  37     throw G4HadronicException(__FILE__, __LINE__, "G4StatMFFragment::copy_constructor meant to not be accessable");
 40 }                                                  38 }
 41                                                    39 
 42 // Operators                                       40 // Operators
 43                                                    41 
 44 G4StatMFFragment & G4StatMFFragment::              42 G4StatMFFragment & G4StatMFFragment::
 45 operator=(const G4StatMFFragment & )               43 operator=(const G4StatMFFragment & )
 46 {                                                  44 {
 47     throw G4HadronicException(__FILE__, __LINE <<  45     throw G4HadronicException(__FILE__, __LINE__, "G4StatMFFragment::operator= meant to not be accessable");
 48     return *this;                                  46     return *this;
 49 }                                                  47 }
 50                                                    48 
                                                   >>  49 
 51 G4bool G4StatMFFragment::operator==(const G4St     50 G4bool G4StatMFFragment::operator==(const G4StatMFFragment & ) const
 52 {                                                  51 {
 53 //  throw G4HadronicException(__FILE__, __LINE <<  52 //  throw G4HadronicException(__FILE__, __LINE__, "G4StatMFFragment::operator== meant to not be accessable");
 54     return false;                                  53     return false;
 55 }                                                  54 }
 56                                                    55  
                                                   >>  56 
 57 G4bool G4StatMFFragment::operator!=(const G4St     57 G4bool G4StatMFFragment::operator!=(const G4StatMFFragment & ) const
 58 {                                                  58 {
 59 //  throw G4HadronicException(__FILE__, __LINE <<  59 //  throw G4HadronicException(__FILE__, __LINE__, "G4StatMFFragment::operator!= meant to not be accessable");
 60     return true;                                   60     return true;
 61 }                                                  61 }
 62                                                    62 
                                                   >>  63 
                                                   >>  64 
 63 G4double G4StatMFFragment::GetCoulombEnergy(vo     65 G4double G4StatMFFragment::GetCoulombEnergy(void) const
 64 {                                                  66 {
 65   G4double res = 0.0;                          <<  67     if (theZ <= 0.1) return 0.0;
 66   if (theZ >= 1) {                             <<  68     G4double Coulomb = (3./5.)*(elm_coupling*theZ*theZ)*
 67     res = G4StatMFParameters::GetCoulomb();    <<  69   pow(1.0+G4StatMFParameters::GetKappaCoulomb(),1./3.)/
 68   }                                            <<  70   (G4StatMFParameters::Getr0()*pow(theA,1./3.));
 69   return res;                                  <<  71             
                                                   >>  72     return Coulomb;
 70 }                                                  73 }
 71                                                    74 
                                                   >>  75 
 72 G4double G4StatMFFragment::GetEnergy(const G4d     76 G4double G4StatMFFragment::GetEnergy(const G4double T) const
 73 {                                                  77 {
 74   if (theA < 1 || theZ < 0 || theZ > theA) {   <<  78     if (theA < 1 || theZ < 0 || theZ > theA) {
 75     G4cout << "G4StatMFFragment::GetEnergy: A  <<  79   G4cerr << "G4StatMFFragment::GetEnergy: A = " << theA 
 76      << ", Z = " << theZ << G4endl;            <<  80          << ", Z = " << theZ << G4endl;
 77     throw G4HadronicException(__FILE__, __LINE <<  81   throw G4HadronicException(__FILE__, __LINE__, 
 78             "G4StatMFFragment::GetEnergy: Wron <<  82       "G4StatMFFragment::GetEnergy: Wrong values for A and Z!");
 79   }                                            <<  83     }
 80   G4double BulkEnergy = G4NucleiProperties::Ge <<  84     G4double BulkEnergy = G4NucleiProperties::GetMassExcess(static_cast<G4int>(theA),
 81                                                <<  85                   static_cast<G4int>(theZ));
 82   if (theA < 4) return BulkEnergy - GetCoulomb <<  86   
 83                                                <<  87     if (theA < 4) return BulkEnergy - GetCoulombEnergy();
 84   G4double SurfaceEnergy;                      <<  88   
 85   if (G4StatMFParameters::DBetaDT(T) == 0.0) S <<  89     G4double SurfaceEnergy;
 86   else SurfaceEnergy = 2.5*G4Pow::GetInstance( <<  90     if (G4StatMFParameters::DBetaDT(T) == 0.0) SurfaceEnergy = 0.0;
 87    G4StatMFParameters::GetBeta0()/             <<  91     else SurfaceEnergy = (5./2.)*pow(theA,2.0/3.0)*T*T*
 88    (G4StatMFParameters::GetCriticalTemp()*     <<  92        G4StatMFParameters::GetBeta0()/
 89     G4StatMFParameters::GetCriticalTemp());    <<  93        (G4StatMFParameters::GetCriticalTemp()*
 90                                                <<  94         G4StatMFParameters::GetCriticalTemp());
 91   G4double ExchangeEnergy = theA*T*T/GetInvLev <<  95            
 92   if (theA != 4) ExchangeEnergy += SurfaceEner <<  96            
 93   return BulkEnergy + ExchangeEnergy - GetCoul <<  97     G4double ExchangeEnergy = theA*T*T/GetInvLevelDensity();
                                                   >>  98     if (theA != 4) ExchangeEnergy += SurfaceEnergy;     
                                                   >>  99   
                                                   >> 100     return  BulkEnergy + ExchangeEnergy - GetCoulombEnergy();   
                                                   >> 101   
 94 }                                                 102 }
 95                                                   103 
                                                   >> 104 
 96 G4double G4StatMFFragment::GetInvLevelDensity(    105 G4double G4StatMFFragment::GetInvLevelDensity(void) const
 97 {                                                 106 {
 98   G4double res = 0.0;                          << 107     // Calculate Inverse Density Level
 99   if (theA > 1) {                              << 108     // Epsilon0*(1 + 3 /(Af - 1))
100     res =  G4StatMFParameters::GetEpsilon0()*( << 109     if (theA == 1) return 0.0;
101   }                                            << 110     else return
102   return res;                                  << 111      G4StatMFParameters::GetEpsilon0()*(1.0+3.0/(theA - 1.0));
103 }                                                 112 }
104                                                   113 
                                                   >> 114 
                                                   >> 115 
105 G4Fragment * G4StatMFFragment::GetFragment(con    116 G4Fragment * G4StatMFFragment::GetFragment(const G4double T)
106 {                                                 117 {
107   G4double U = CalcExcitationEnergy(T);        << 118     G4double U = CalcExcitationEnergy(T);
108   G4double M = GetNuclearMass();               << 119   
109   G4LorentzVector FourMomentum(_momentum,std:: << 120     G4double M = GetNuclearMass();
110   G4Fragment * theFragment = new G4Fragment(th << 121 
111   return theFragment;                          << 122     G4LorentzVector FourMomentum(_momentum,sqrt(_momentum.mag2()+(M+U)*(M+U)));
                                                   >> 123 
                                                   >> 124     G4Fragment * theFragment = new G4Fragment(static_cast<G4int>(theA),static_cast<G4int>(theZ),FourMomentum);
                                                   >> 125 
                                                   >> 126     return theFragment;
112 }                                                 127 }
113                                                   128 
                                                   >> 129 
114 G4double G4StatMFFragment::CalcExcitationEnerg    130 G4double G4StatMFFragment::CalcExcitationEnergy(const G4double T)
115 {                                                 131 {
116   if (theA <= 3) return 0.0;                   << 132     if (theA <= 3) return 0.0;
                                                   >> 133   
                                                   >> 134     G4double BulkEnergy = theA*T*T/GetInvLevelDensity();
117                                                   135   
118   G4double BulkEnergy = theA*T*T/GetInvLevelDe << 136     // if it is an alpha particle: done
                                                   >> 137     if (theA == 4) return BulkEnergy;
119                                                   138   
120   // if it is an alpha particle: done          << 139     // Term connected with surface energy
121   if (theA == 4) return BulkEnergy;            << 140     G4double SurfaceEnergy = 0.0;
122                                                << 141     if (abs(G4StatMFParameters::DBetaDT(T)) > 1.0e-20) 
123   // Term connected with surface energy        << 142 //    SurfaceEnergy = (5./2.)*pow(theA,2.0/3.0)*T*T*G4StatMFParameters::GetBeta0()/
124   G4double SurfaceEnergy = 0.0;                << 143 //      (G4StatMFParameters::GetCriticalTemp()*G4StatMFParameters::GetCriticalTemp());
125   G4double q = G4StatMFParameters::DBetaDT(T); << 144   SurfaceEnergy = (5./2.)*pow(theA,2.0/3.0)*(G4StatMFParameters::Beta(T) - 
126   if (std::abs(q) > 1.0e-20) {                 << 145                T*G4StatMFParameters::DBetaDT(T) - G4StatMFParameters::GetBeta0());
127     SurfaceEnergy = 2.5*G4Pow::GetInstance()-> << 146     
128       *(G4StatMFParameters::Beta(T) - T*q - G4 << 147     return BulkEnergy + SurfaceEnergy;
129   }                                            << 
130   return BulkEnergy + SurfaceEnergy;           << 
131 }                                                 148 }
                                                   >> 149 
                                                   >> 150 
132                                                   151