G4StatMFMicroPartition Class Reference

#include <G4StatMFMicroPartition.hh>


Public Member Functions

 G4StatMFMicroPartition (const G4int A, const G4double Z)
 ~G4StatMFMicroPartition ()
G4bool operator== (const G4StatMFMicroPartition &right) const
G4bool operator!= (const G4StatMFMicroPartition &right) const
G4StatMFChannel * ChooseZ (const G4double A0, const G4double Z0, const G4double MeanT)
G4double GetProbability (void)
void SetPartitionFragment (const G4int anA)
void Normalize (const G4double Normalization)
G4double CalcPartitionProbability (const G4double U, const G4double FreeInternalE0, const G4double SCompound)
G4double GetTemperature (void)
G4double GetEntropy (void)

Detailed Description

Definition at line 41 of file G4StatMFMicroPartition.hh.

Constructor & Destructor Documentation

G4StatMFMicroPartition::G4StatMFMicroPartition ( const G4int  A,
const G4double  Z 
) [inline]

Definition at line 45 of file G4StatMFMicroPartition.hh.

00045                                                             :
00046         theA(A), theZ(Z), _Probability(0.0), _Temperature(0.0), 
00047         _Entropy(0.0) {};

G4StatMFMicroPartition::~G4StatMFMicroPartition (  )  [inline]

Definition at line 51 of file G4StatMFMicroPartition.hh.

00051 {};

Member Function Documentation

G4double G4StatMFMicroPartition::CalcPartitionProbability ( const G4double  U,
const G4double  FreeInternalE0,
const G4double  SCompound 
)

Definition at line 230 of file G4StatMFMicroPartition.cc.

References G4StatMFParameters::DBetaDT(), G4StatMFParameters::Getr0(), and G4INCL::Math::pi.

00233 {       
00234   G4double T = CalcPartitionTemperature(U,FreeInternalE0);
00235   if ( T <= 0.0) return _Probability = 0.0;
00236   _Temperature = T;
00237   
00238   
00239   // Factorial of fragment multiplicity
00240   G4double Fact = 1.0;
00241   unsigned int i;
00242   for (i = 0; i < _thePartition.size() - 1; i++) 
00243     {
00244       G4double f = 1.0;
00245       for (unsigned int ii = i+1; i< _thePartition.size(); i++) 
00246         {
00247           if (_thePartition[i] == _thePartition[ii]) f++;
00248         }
00249       Fact *= f;
00250   }
00251         
00252   G4double ProbDegeneracy = 1.0;
00253   G4double ProbA32 = 1.0;       
00254         
00255   for (i = 0; i < _thePartition.size(); i++) 
00256     {
00257       ProbDegeneracy *= GetDegeneracyFactor(static_cast<G4int>(_thePartition[i]));
00258       ProbA32 *= static_cast<G4double>(_thePartition[i])*
00259         std::sqrt(static_cast<G4double>(_thePartition[i]));
00260     }
00261         
00262   // Compute entropy
00263   G4double PartitionEntropy = 0.0;
00264   for (i = 0; i < _thePartition.size(); i++) 
00265     {
00266       // interaction entropy for alpha
00267       if (_thePartition[i] == 4) 
00268         {
00269           PartitionEntropy += 
00270             2.0*T*_thePartition[i]/InvLevelDensity(_thePartition[i]);
00271         }
00272       // interaction entropy for Af > 4
00273       else if (_thePartition[i] > 4) 
00274         {
00275           PartitionEntropy += 
00276             2.0*T*_thePartition[i]/InvLevelDensity(_thePartition[i])
00277             - G4StatMFParameters::DBetaDT(T)
00278             * std::pow(static_cast<G4double>(_thePartition[i]),2.0/3.0);
00279         } 
00280     }
00281         
00282   // Thermal Wave Lenght = std::sqrt(2 pi hbar^2 / nucleon_mass T)
00283   G4double ThermalWaveLenght3 = 16.15*fermi/std::sqrt(T);
00284   ThermalWaveLenght3 = ThermalWaveLenght3*ThermalWaveLenght3*ThermalWaveLenght3;
00285   
00286   // Translational Entropy
00287   G4double kappa = (1. + elm_coupling*(std::pow(static_cast<G4double>(_thePartition.size()),1./3.)-1.0)
00288                     /(G4StatMFParameters::Getr0()*std::pow(static_cast<G4double>(theA),1./3.)));
00289   kappa = kappa*kappa*kappa;
00290   kappa -= 1.;
00291   G4double V0 = (4./3.)*pi*theA*G4StatMFParameters::Getr0()*G4StatMFParameters::Getr0()*
00292     G4StatMFParameters::Getr0();
00293   G4double FreeVolume = kappa*V0;
00294   G4double TranslationalS = std::max(0.0, std::log(ProbA32/Fact) +
00295                                      (_thePartition.size()-1.0)*std::log(FreeVolume/ThermalWaveLenght3) +
00296                                      1.5*(_thePartition.size()-1.0) - (3./2.)*std::log(theA));
00297   
00298   PartitionEntropy += std::log(ProbDegeneracy) + TranslationalS;
00299   _Entropy = PartitionEntropy;
00300         
00301   // And finally compute probability of fragment configuration
00302   G4double exponent = PartitionEntropy-SCompound;
00303   if (exponent > 700.0) exponent = 700.0;
00304   return _Probability = std::exp(exponent);
00305 }

G4StatMFChannel * G4StatMFMicroPartition::ChooseZ ( const G4double  A0,
const G4double  Z0,
const G4double  MeanT 
)

Definition at line 323 of file G4StatMFMicroPartition.cc.

References G4StatMFChannel::CreateFragment(), and G4StatMFParameters::GetGamma0().

00325 {
00326   std::vector<G4int> FragmentsZ;
00327   
00328   G4int ZBalance = 0;
00329   do 
00330     {
00331       G4double CC = G4StatMFParameters::GetGamma0()*8.0;
00332       G4int SumZ = 0;
00333       for (unsigned int i = 0; i < _thePartition.size(); i++) 
00334         {
00335           G4double ZMean;
00336           G4double Af = _thePartition[i];
00337           if (Af > 1.5 && Af < 4.5) ZMean = 0.5*Af;
00338           else ZMean = Af*Z0/A0;
00339           G4double ZDispersion = std::sqrt(Af * MeanT/CC);
00340           G4int Zf;
00341           do 
00342             {
00343               Zf = static_cast<G4int>(G4RandGauss::shoot(ZMean,ZDispersion));
00344             } 
00345           while (Zf < 0 || Zf > Af);
00346           FragmentsZ.push_back(Zf);
00347           SumZ += Zf;
00348         }
00349       ZBalance = static_cast<G4int>(Z0) - SumZ;
00350     } 
00351   while (std::abs(ZBalance) > 1.1);
00352   FragmentsZ[0] += ZBalance;
00353         
00354   G4StatMFChannel * theChannel = new G4StatMFChannel;
00355   for (unsigned int i = 0; i < _thePartition.size(); i++)
00356     {
00357       theChannel->CreateFragment(_thePartition[i],FragmentsZ[i]);
00358     }
00359 
00360   return theChannel;
00361 }

G4double G4StatMFMicroPartition::GetEntropy ( void   )  [inline]

Definition at line 96 of file G4StatMFMicroPartition.hh.

00097         {
00098             return _Entropy;
00099         }

G4double G4StatMFMicroPartition::GetProbability ( void   )  [inline]

Definition at line 72 of file G4StatMFMicroPartition.hh.

00073         { return _Probability; }

G4double G4StatMFMicroPartition::GetTemperature ( void   )  [inline]

Definition at line 91 of file G4StatMFMicroPartition.hh.

00092         {
00093             return _Temperature;
00094         }

void G4StatMFMicroPartition::Normalize ( const G4double  Normalization  )  [inline]

Definition at line 83 of file G4StatMFMicroPartition.hh.

00084         { _Probability /= Normalization; }

G4bool G4StatMFMicroPartition::operator!= ( const G4StatMFMicroPartition &  right  )  const

Definition at line 60 of file G4StatMFMicroPartition.cc.

00061 {
00062   //throw G4HadronicException(__FILE__, __LINE__, "G4StatMFMicroPartition::operator!= meant to not be accessable");
00063   return true;
00064 }

G4bool G4StatMFMicroPartition::operator== ( const G4StatMFMicroPartition &  right  )  const

Definition at line 53 of file G4StatMFMicroPartition.cc.

00054 {
00055   //throw G4HadronicException(__FILE__, __LINE__, "G4StatMFMicroPartition::operator== meant to not be accessable");
00056   return false;
00057 }

void G4StatMFMicroPartition::SetPartitionFragment ( const G4int  anA  )  [inline]

Definition at line 77 of file G4StatMFMicroPartition.hh.

00078         { 
00079             _thePartition.push_back(anA);
00080             CoulombFreeEnergy(anA);
00081         }

The documentation for this class was generated from the following files:
Generated on Mon May 27 17:53:26 2013 for Geant4 by  doxygen 1.4.7