#include <G4StatMFMacroTemperature.hh>

Collaboration diagram for G4StatMFMacroTemperature:

Public Member Functions
	G4StatMFMacroTemperature (const G4double anA, const G4double aZ, const G4double ExEnergy, const G4double FreeE0, const G4double kappa, std::vector< G4VStatMFMacroCluster > ClusterVector)

	~G4StatMFMacroTemperature ()

G4double	operator() (const G4double T)

G4double	GetMeanMultiplicity (void) const

G4double	GetChemicalPotentialMu (void) const

G4double	GetChemicalPotentialNu (void) const

G4double	GetTemperature (void) const

G4double	GetEntropy (void) const

G4double	CalcTemperature (void)

Private Member Functions
	G4StatMFMacroTemperature ()

	G4StatMFMacroTemperature (const G4StatMFMacroTemperature &)

G4StatMFMacroTemperature &	operator= (const G4StatMFMacroTemperature &right)

G4bool	operator== (const G4StatMFMacroTemperature &right) const

G4bool	operator!= (const G4StatMFMacroTemperature &right) const

G4double	FragsExcitEnergy (const G4double T)

void	CalcChemicalPotentialNu (const G4double T)

Private Attributes
G4double	theA

G4double	theZ

G4double	_ExEnergy

G4double	_FreeInternalE0

G4double	_Kappa

G4double	_MeanMultiplicity

G4double	_MeanTemperature

G4double	_ChemPotentialMu

G4double	_ChemPotentialNu

G4double	_MeanEntropy

std::vector< G4VStatMFMacroCluster * > *	_theClusters

Detailed Description

Definition at line 42 of file G4StatMFMacroTemperature.hh.

Constructor & Destructor Documentation

◆ G4StatMFMacroTemperature() [1/3]

G4StatMFMacroTemperature::G4StatMFMacroTemperature	(	const G4double	anA,
		const G4double	aZ,
		const G4double	ExEnergy,
		const G4double	FreeE0,
		const G4double	kappa,
		std::vector< G4VStatMFMacroCluster >	ClusterVector
	)

Definition at line 47 of file G4StatMFMacroTemperature.cc.

                                                      :
   theA(anA),
   theZ(aZ),
   _ExEnergy(ExEnergy),
   _FreeInternalE0(FreeE0),
   _Kappa(kappa),
   _MeanMultiplicity(0.0),
   _MeanTemperature(0.0),
   _ChemPotentialMu(0.0),
   _ChemPotentialNu(0.0),
   _MeanEntropy(0.0),
   _theClusters(ClusterVector) 
 {}

◆ ~G4StatMFMacroTemperature()

G4StatMFMacroTemperature::~G4StatMFMacroTemperature ( )

Definition at line 63 of file G4StatMFMacroTemperature.cc.

64 {}

◆ G4StatMFMacroTemperature() [2/3]

G4StatMFMacroTemperature::G4StatMFMacroTemperature ( )

private

Here is the caller graph for this function:

◆ G4StatMFMacroTemperature() [3/3]

G4StatMFMacroTemperature::G4StatMFMacroTemperature ( const G4StatMFMacroTemperature & )

inlineprivate

Definition at line 62 of file G4StatMFMacroTemperature.hh.

62 {};

Here is the call graph for this function:

Member Function Documentation

◆ CalcChemicalPotentialNu()

void G4StatMFMacroTemperature::CalcChemicalPotentialNu ( const G4double T )

private

Definition at line 186 of file G4StatMFMacroTemperature.cc.

 {
   G4StatMFMacroChemicalPotential * theChemPot = new
     G4StatMFMacroChemicalPotential(theA,theZ,_Kappa,T,_theClusters);
 
   _ChemPotentialNu = theChemPot->CalcChemicalPotentialNu();
   _ChemPotentialMu = theChemPot->GetChemicalPotentialMu();
   _MeanMultiplicity = theChemPot->GetMeanMultiplicity();        
   delete theChemPot;
             
   return;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CalcTemperature()

G4double G4StatMFMacroTemperature::CalcTemperature ( void )

Definition at line 66 of file G4StatMFMacroTemperature.cc.

 {
   // Inital guess for the interval of the ensemble temperature values
   G4double Ta = 0.5; 
   G4double Tb = std::max(std::sqrt(_ExEnergy/(theA*0.12)),0.01*MeV);
     
   G4double fTa = this->operator()(Ta); 
   G4double fTb = this->operator()(Tb); 
 
   // Bracketing the solution
   // T should be greater than 0.
   // The interval is [Ta,Tb]
   // We start with a value for Ta = 0.5 MeV
   // it should be enough to have fTa > 0 If it isn't 
   // the case, we decrease Ta. But carefully, because 
   // fTa growes very fast when Ta is near 0 and we could have
   // an overflow.
 
   G4int iterations = 0;  
   // Loop checking, 05-Aug-2015, Vladimir Ivanchenko
   while (fTa < 0.0 && ++iterations < 10) {
     Ta -= 0.5*Ta;
     fTa = this->operator()(Ta);
   }
   // Usually, fTb will be less than 0, but if it is not the case: 
   iterations = 0;  
   // Loop checking, 05-Aug-2015, Vladimir Ivanchenko
   while (fTa*fTb > 0.0 && iterations++ < 10) {
     Tb += 2.*std::fabs(Tb-Ta);
     fTb = this->operator()(Tb);
   }
     
   if (fTa*fTb > 0.0) {
     G4cerr <<"G4StatMFMacroTemperature:"<<" Ta="<<Ta<<" Tb="<<Tb<< G4endl;
     G4cerr <<"G4StatMFMacroTemperature:"<<" fTa="<<fTa<<" fTb="<<fTb<< G4endl;
     throw G4HadronicException(__FILE__, __LINE__, "G4StatMFMacroTemperature::CalcTemperature: I couldn't bracket the solution.");
   }
 
   G4Solver<G4StatMFMacroTemperature> * theSolver = 
     new G4Solver<G4StatMFMacroTemperature>(100,1.e-4);
   theSolver->SetIntervalLimits(Ta,Tb);
   if (!theSolver->Crenshaw(*this)){ 
     G4cout <<"G4StatMFMacroTemperature, Crenshaw method failed:"<<" Ta="
        <<Ta<<" Tb="<<Tb<< G4endl;
     G4cout <<"G4StatMFMacroTemperature, Crenshaw method failed:"<<" fTa="
        <<fTa<<" fTb="<<fTb<< G4endl;
   }
   _MeanTemperature = theSolver->GetRoot();
   G4double FunctionValureAtRoot =  this->operator()(_MeanTemperature);
   delete  theSolver;
 
   // Verify if the root is found and it is indeed within the physical domain, 
   // say, between 1 and 50 MeV, otherwise try Brent method:
   if (std::fabs(FunctionValureAtRoot) > 5.e-2) {
     if (_MeanTemperature < 1. || _MeanTemperature > 50.) {
       G4cout << "Crenshaw method failed; function = " << FunctionValureAtRoot 
          << " solution? = " << _MeanTemperature << " MeV " << G4endl;
       G4Solver<G4StatMFMacroTemperature> * theSolverBrent = 
     new G4Solver<G4StatMFMacroTemperature>(200,1.e-3);
       theSolverBrent->SetIntervalLimits(Ta,Tb);
       if (!theSolverBrent->Brent(*this)){
     G4cout <<"G4StatMFMacroTemperature, Brent method failed:"
            <<" Ta="<<Ta<<" Tb="<<Tb<< G4endl;
     G4cout <<"G4StatMFMacroTemperature, Brent method failed:"
            <<" fTa="<<fTa<<" fTb="<<fTb<< G4endl; 
     throw G4HadronicException(__FILE__, __LINE__, "G4StatMFMacroTemperature::CalcTemperature: I couldn't find the root with any method.");
       }
 
       _MeanTemperature = theSolverBrent->GetRoot();
       FunctionValureAtRoot =  this->operator()(_MeanTemperature);
       delete theSolverBrent;
     }
     if (std::abs(FunctionValureAtRoot) > 5.e-2) {
       G4cout << "Brent method failed; function = " << FunctionValureAtRoot 
          << " solution? = " << _MeanTemperature << " MeV " << G4endl;
       throw G4HadronicException(__FILE__, __LINE__, "G4StatMFMacroTemperature::CalcTemperature: I couldn't find the root with any method.");
     }
   }
   //G4cout << "G4StatMFMacroTemperature::CalcTemperature: function = " 
   //<< FunctionValureAtRoot 
   //       << " T(MeV)= " << _MeanTemperature << G4endl;
   return _MeanTemperature;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FragsExcitEnergy()

G4double G4StatMFMacroTemperature::FragsExcitEnergy ( const G4double T )

private

Definition at line 150 of file G4StatMFMacroTemperature.cc.

 {
   // Model Parameters
   G4Pow* g4pow = G4Pow::GetInstance();
   G4double R0 = G4StatMFParameters::Getr0()*g4pow->Z13(theA);
   G4double R = R0*g4pow->A13(1.0+G4StatMFParameters::GetKappaCoulomb());
   G4double FreeVol = _Kappa*(4.*pi/3.)*R0*R0*R0; 
  
   // Calculate Chemical potentials
   CalcChemicalPotentialNu(T);
 
 
   // Average total fragment energy
   G4double AverageEnergy = 0.0;
   std::vector<G4VStatMFMacroCluster*>::iterator i;
   for (i =  _theClusters->begin(); i != _theClusters->end(); ++i) 
     {
       AverageEnergy += (*i)->GetMeanMultiplicity() * (*i)->CalcEnergy(T);
     }
     
   // Add Coulomb energy         
   AverageEnergy += 0.6*elm_coupling*theZ*theZ/R;        
     
   // Calculate mean entropy
   _MeanEntropy = 0.0;
   for (i = _theClusters->begin(); i != _theClusters->end(); ++i) 
     {
       _MeanEntropy += (*i)->CalcEntropy(T,FreeVol); 
     }
 
   // Excitation energy per nucleon
   return AverageEnergy - _FreeInternalE0;
 }