G4StatMF Class Reference

#include <G4StatMF.hh>

Inheritance diagram for G4StatMF:

Public Member Functions
	G4StatMF ()
	~G4StatMF () override
G4FragmentVector *	BreakItUp (const G4Fragment &theNucleus) override
	G4StatMF (const G4StatMF &right)=delete
G4StatMF &	operator= (const G4StatMF &right)=delete
G4bool	operator== (const G4StatMF &right)=delete
G4bool	operator!= (const G4StatMF &right)=delete
Public Member Functions inherited from G4VMultiFragmentation
	G4VMultiFragmentation ()
virtual	~G4VMultiFragmentation ()

Detailed Description

Definition at line 40 of file G4StatMF.hh.

Constructor & Destructor Documentation

G4StatMF() [1/2]

G4StatMF::G4StatMF

(

)

Definition at line 38 of file G4StatMF.cc.

{
  theMicrocanonicalEnsemble = new G4StatMFMicroCanonical();
  theMacrocanonicalEnsemble = new G4StatMFMacroCanonical();
  //fSecID = G4PhysicsModelCatalog::GetModelID("model_G4StatMF");
}

Referenced by G4StatMF(), operator!=(), operator=(), and operator==().

~G4StatMF()

G4StatMF::~G4StatMF ( )

override

Definition at line 45 of file G4StatMF.cc.

{
  delete theMicrocanonicalEnsemble;
  delete theMacrocanonicalEnsemble;
}

G4StatMF() [2/2]

G4StatMF::G4StatMF ( const G4StatMF & right )

delete

Member Function Documentation

BreakItUp()

G4FragmentVector * G4StatMF::BreakItUp ( const G4Fragment & theNucleus )

overridevirtual

Implements G4VMultiFragmentation.

Definition at line 51 of file G4StatMF.cc.

{
  // Maximun average multiplicity: M_0 = 2.6 for A ~ 200 
  // and M_0 = 3.3 for A <= 110
  G4int A = theFragment.GetA_asInt();
  G4double MaxAverageMultiplicity = G4StatMFParameters::GetMaxAverageMultiplicity(A);
  
  // Microcanonical ensemble - direct simulation
  theMicrocanonicalEnsemble->Initialise(theFragment);
  
  const G4int iLimit = 20;
  G4double Temperature = 0.0;
  
   G4StatMFChannel* theChannel = nullptr;
 
  for (G4int i=0; i<iLimit; ++i) {
    for (G4int j=0; j<iLimit; ++j) {
      
      G4double theMeanMult = theMicrocanonicalEnsemble->GetMeanMultiplicity();
      if (theMeanMult <= MaxAverageMultiplicity) {
    //G4cout << "MICROCANONICAL Nmean=" << theMeanMult
    //       << " i=" << i << " j=" << j << G4endl;
    // Choose fragments atomic numbers and charges from direct simulation
    theChannel = theMicrocanonicalEnsemble->ChooseAandZ(theFragment);
    fEnsemble = theMicrocanonicalEnsemble;
      } else {
    //-----------------------------------------------------
    // Non direct simulation part (Macrocanonical Ensemble)
    //-----------------------------------------------------
    // Macrocanonical ensemble initialization 
    theMacrocanonicalEnsemble->Initialise(theFragment);
    fEnsemble = theMacrocanonicalEnsemble;
    //G4cout << "MACROCANONICAL Nmean=" << theMeanMult
    //       << " i=" << i << " j=" << j << G4endl;
    // Select calculated fragment total multiplicity, 
    // fragment atomic numbers and fragment charges.
    theChannel = theMacrocanonicalEnsemble->ChooseAandZ(theFragment);
      }
      
      if (theChannel->CheckFragments()) { break; }
      delete theChannel; 
      theChannel = nullptr;
    }
        
    if (nullptr == theChannel || theChannel->GetMultiplicity() <= 1) {
      delete theChannel;
      theChannel = nullptr;
      break;
    }
 
    // G4cout << "   multiplicity=" << theChannel->GetMultiplicity() << G4endl;
    //--------------------------------------
    // Second part of simulation procedure.
    //--------------------------------------
    
    // Find temperature of breaking channel.
    Temperature = fEnsemble->GetMeanTemperature(); // Initial guess for Temperature 
 
    if (FindTemperatureOfBreakingChannel(theFragment, theChannel, Temperature)) {
      break;
    }
 
    // Do not forget to delete this unusable channel, for which we failed to find the temperature,
    // otherwise for very proton-reach nuclei it would lead to memory leak due to large 
    // number of iterations. N.B. "theChannel" is created in G4StatMFMacroCanonical::ChooseZ()
 
    // G4cout << " Iteration # " << Iterations << " Mean Temperature = " << Temperature << G4endl;
    delete theChannel;
    theChannel = nullptr;
  }
 
  // primary
  G4FragmentVector* theResult = nullptr;
  
  // no multi-fragmentation
  if (nullptr == theChannel || theChannel->GetMultiplicity() <= 1) {
    theResult = new G4FragmentVector();
    theResult->push_back(new G4Fragment(theFragment));
    delete theChannel;
    return theResult;
  }
  
  G4int Z = theFragment.GetZ_asInt();
  G4double m0 = theFragment.GetGroundStateMass() + theFragment.GetExcitationEnergy();
  auto bs = theFragment.GetMomentum().boostVector();
    
  G4double etot = 0.0;
  G4double ekin = 0.0;
  for (G4int i=0; i<iLimit; ++i) {
    theResult = theChannel->GetFragments(A, Z, Temperature);
    if (nullptr == theResult) { continue; }
    etot = 0.0;
    ekin = 0.0;
    for (auto const & ptr : *theResult) {
      G4double e = ptr->GetMomentum().e();
      G4double m1 = ptr->GetGroundStateMass() + ptr->GetExcitationEnergy();
      etot += e;
      ekin += std::max(e - m1, 0.0);
    }
    // correction possible
    if (etot - m0 + ekin > 0.0 && ekin > 0.0) { break; }
 
    // new attemt required
    for (auto const & ptr : *theResult) {
      delete ptr;
    }
    delete theResult;
    theResult = nullptr;
  }
  delete theChannel;
  
  // no multi-fragmentation
  if (nullptr == theResult || ekin <= 0.0) {
    theResult = new G4FragmentVector();
    theResult->push_back(new G4Fragment(theFragment));
    return theResult;
  }
 
  G4double x = 1.0 + (etot - m0)/ekin;
  G4LorentzVector lv1;
 
  // scale and boost
  for (auto const & ptr : *theResult) {
    G4double m1 = ptr->GetGroundStateMass() + ptr->GetExcitationEnergy();
    G4double ek = std::max((ptr->GetMomentum().e() - m1)*x, 0.0);
    auto mom = ptr->GetMomentum().vect().unit();
    mom *= std::sqrt(ek * (ek + 2.0*m1));
    lv1.set(mom.x(), mom.y(), mom.z(), ek + m1);
    lv1.boost(bs);
    ptr->SetMomentum(lv1);
  }
  return theResult;
}

operator!=()

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

delete

operator=()

G4StatMF & G4StatMF::operator= ( const G4StatMF & right )

delete

operator==()

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

delete

---

The documentation for this class was generated from the following files:

• G4StatMF.hh
• G4StatMF.cc