G4FermiFragmentsPoolVI Class Reference

#include <G4FermiFragmentsPoolVI.hh>

Public Member Functions
	G4FermiFragmentsPoolVI ()
	~G4FermiFragmentsPoolVI ()
const G4FermiChannels *	ClosestChannels (G4int Z, G4int A, G4double mass) const
void	DumpFragment (const G4FermiFragment *) const
void	Dump () const
G4bool	IsPhysical (G4int Z, G4int A) const
G4bool	HasChannels (G4int Z, G4int A, G4double exc) const
const G4FermiDecayProbability *	FermiDecayProbability () const
G4int	GetMaxZ () const
G4int	GetMaxA () const
G4double	GetEnergyLimit () const
G4double	GetTolerance () const

Detailed Description

Definition at line 45 of file G4FermiFragmentsPoolVI.hh.

Constructor & Destructor Documentation

G4FermiFragmentsPoolVI()

G4FermiFragmentsPoolVI::G4FermiFragmentsPoolVI ( )

explicit

Definition at line 39 of file G4FermiFragmentsPoolVI.cc.

{
  //  G4cout << "### G4FermiFragmentsPoolVI is constructed" << G4endl;
  G4DeexPrecoParameters* param = 
    G4NuclearLevelData::GetInstance()->GetParameters();
  tolerance = param->GetMinExcitation();
  timelim   = (G4float)param->GetMaxLifeTime();
 
  elim = param->GetFBUEnergyLimit();
  elimf= (G4float)elim;
  /*
  G4cout << "G4FermiFragmentsPoolVI: tolerance= " << tolerance
         << " timelim= " << timelim << " elim= " << elim << G4endl;
  */
  fragment_pool.reserve(991);
  Initialise();
}

~G4FermiFragmentsPoolVI()

G4FermiFragmentsPoolVI::~G4FermiFragmentsPoolVI

(

)

Definition at line 57 of file G4FermiFragmentsPoolVI.cc.

{
  for(G4int i=0; i<maxA; ++i) {
    for(auto & ptr : list_p[i]) { delete ptr; ptr = nullptr; }
    for(auto & ptr : list_c[i]) { delete ptr; ptr = nullptr; }
  }
  for(auto & ptr : fragment_pool) { delete ptr; ptr = nullptr; }
}

Member Function Documentation

ClosestChannels()

const G4FermiChannels * G4FermiFragmentsPoolVI::ClosestChannels	(	G4int	Z,
		G4int	A,
		G4double	mass
	)		const

Definition at line 67 of file G4FermiFragmentsPoolVI.cc.

{
  const G4FermiChannels* res = nullptr;
  G4double demax = 1.e+9;
 
  // stable channels
  for(size_t j=0; j<(list_c[A]).size(); ++j) {
    const G4FermiFragment* frag = (list_f[A])[j];
    if(frag->GetZ() != Z) { continue; }
    G4double de = e - frag->GetTotalEnergy();
    //G4cout << "  Stab check " << j << " channel de= " << de 
    // << " tol= " << tolerance << G4endl;
    // an excitation coincide with a level
    if(std::abs(de) <= tolerance) { 
      res = (list_c[A])[j];
      break; 
    } else {
      // closest level selected
      de += tolerance;
      if(de >= 0.0 && de <= demax) {
        res = (list_c[A])[j];
        demax = de;
      }
      //G4cout << "  Stab chan: " << j << " N= " 
      //<< res->GetNumberOfChannels() << G4endl;
    }
  }
  return res;
}

Dump()

void G4FermiFragmentsPoolVI::Dump

(

)

const

Definition at line 302 of file G4FermiFragmentsPoolVI.cc.

{
  G4cout <<"----------------------------------------------------------------"
         <<G4endl;
  G4cout << "##### List of Fragments in the Fermi Fragment Pool #####" 
         << G4endl;
  G4int nfrag = fragment_pool.size();
  G4cout << "      For stable " << nfrag << " Elim(MeV) = " 
         << elim/CLHEP::MeV << G4endl; 
  for(G4int i=0; i<nfrag; ++i) {
    DumpFragment(fragment_pool[i]);
  }
  G4cout << G4endl;
 
 
  G4cout << "----------------------------------------------------------------"
         << G4endl;
  G4cout << "### G4FermiFragmentPoolVI: fragments sorted by A" << G4endl; 
 
  G4int prec = G4cout.precision(6);
  G4int ama[maxA];
  ama[0] =  0;
  for(G4int A=1; A<maxA; ++A) {
    G4cout << " # A= " << A << G4endl;
    size_t am(0); 
    for(size_t j=0; j<list_f[A].size(); ++j) {
      const G4FermiFragment* f = (list_f[A])[j];
      G4int a1 = f->GetA();
      G4int z1 = f->GetZ();
      size_t nch = (list_c[A])[j]->GetNumberOfChannels();
      am = std::max(am, nch);
      G4cout << "   ("<<a1<<","<<z1<<");  Eex(MeV)= "
             << f->GetExcitationEnergy() 
             << " 2S= " << f->GetSpin()
             << "; Nchannels= " << nch
             << " MassExcess= " << f->GetTotalEnergy() - 
        (z1*proton_mass_c2 + (a1 - z1)*neutron_mass_c2)
             << G4endl; 
      for(size_t k=0; k<nch; ++k) {
        const G4FermiPair* fpair = ((list_c[A])[j]->GetChannels())[k];
        G4cout << "         (" << fpair->GetFragment1()->GetZ()
               << ", "  << fpair->GetFragment1()->GetA() 
               << ",  " << fpair->GetFragment1()->GetExcitationEnergy()
               << ")  ("<< fpair->GetFragment2()->GetZ()
               << ", "  << std::setw(3)<< fpair->GetFragment2()->GetA()  
               << ",  " << std::setw(8)<< fpair->GetFragment2()->GetExcitationEnergy()
               << ")  prob= " << ((list_c[A])[j]->GetProbabilities())[k]
               << G4endl; 
      }
    }
    ama[A] = am; 
  }
  G4cout.precision(prec);
  G4cout << G4endl;
 
  G4cout << "    Number of fragments per A:" << G4endl;
  for(G4int j=0; j<maxA; ++j) { G4cout << list_f[j].size() << ", "; }
  G4cout << G4endl;
 
  G4cout << "    Max number of channels per A:" << G4endl; 
  for (size_t j=0; j<maxA; ++j) { G4cout << ama[j] << ", "; }
  G4cout << G4endl;
 
  G4cout << "    Number of fragment pairs per A:" << G4endl;
  for(G4int j=0; j<maxA; ++j) { G4cout << list_p[j].size() << ", "; }
  G4cout << G4endl;
 
  G4cout << "----------------------------------------------------------------"
         << G4endl;
  G4cout << "### Pairs of stable fragments: " << G4endl;
 
  prec = G4cout.precision(6);
  for(G4int A=2; A<maxA; ++A) {
    G4cout << "  A= " << A<<G4endl; 
    for(size_t j=0; j<list_p[A].size(); ++j) {
      const G4FermiFragment* f1 = (list_p[A])[j]->GetFragment1();
      const G4FermiFragment* f2 = (list_p[A])[j]->GetFragment2();
      G4int a1 = f1->GetA();
      G4int z1 = f1->GetZ();
      G4int a2 = f2->GetA();
      G4int z2 = f2->GetZ();
      G4cout << "("<<a1<<","<<z1<<")("<<a2<<","<<z2<<") % Eex(MeV)= "
             << std::setw(8)<< (list_p[A])[j]->GetExcitationEnergy() 
             << " Eex1= " << std::setw(8)<< f1->GetExcitationEnergy()
             << " Eex2= " << std::setw(8)<< f2->GetExcitationEnergy()
             << G4endl; 
    }
    G4cout << G4endl;
    G4cout <<"----------------------------------------------------------------"
           << G4endl;
  }
  G4cout.precision(prec);
}

DumpFragment()

void G4FermiFragmentsPoolVI::DumpFragment

(

const G4FermiFragment *

f

)

const

Definition at line 288 of file G4FermiFragmentsPoolVI.cc.

{
  if(f) {
    G4int prec = G4cout.precision(6);
    G4cout << "   Z= " << f->GetZ() << " A= " << std::setw(2) << f->GetA() 
           << " Mass(GeV)= " << std::setw(8) << f->GetFragmentMass()/GeV
           << " Eexc(MeV)= " << std::setw(7) << f->GetExcitationEnergy()
           << " 2s= " << f->GetSpin() << " IsStable: " 
           << HasChannels(f->GetZ(), f->GetA(), f->GetExcitationEnergy())
           << G4endl;
    G4cout.precision(prec);
  }
}

Referenced by Dump().

FermiDecayProbability()

const G4FermiDecayProbability * G4FermiFragmentsPoolVI::FermiDecayProbability ( ) const

inline

Definition at line 115 of file G4FermiFragmentsPoolVI.hh.

{
  return &theDecay;
}

Referenced by G4FermiBreakUpVI::Initialise().

GetEnergyLimit()

G4double G4FermiFragmentsPoolVI::GetEnergyLimit ( ) const

inline

Definition at line 120 of file G4FermiFragmentsPoolVI.hh.

{
  return elim;
}

Referenced by G4FermiBreakUpVI::Initialise().

GetMaxA()

G4int G4FermiFragmentsPoolVI::GetMaxA ( ) const

inline

Definition at line 109 of file G4FermiFragmentsPoolVI.hh.

{
  return maxA;
}

GetMaxZ()

G4int G4FermiFragmentsPoolVI::GetMaxZ ( ) const

inline

Definition at line 104 of file G4FermiFragmentsPoolVI.hh.

{
  return maxZ;
}

GetTolerance()

G4double G4FermiFragmentsPoolVI::GetTolerance ( ) const

inline

Definition at line 125 of file G4FermiFragmentsPoolVI.hh.

{
  return tolerance;
}

HasChannels()

G4bool G4FermiFragmentsPoolVI::HasChannels	(	G4int	Z,
		G4int	A,
		G4double	exc
	)		const

Definition at line 117 of file G4FermiFragmentsPoolVI.cc.

{
  // stable fragment
  for(size_t j=0; j<(list_f[A]).size(); ++j) {
    const G4FermiFragment* frag = (list_f[A])[j];
    if(frag->GetZ() == Z) {
      if(exc > frag->GetExcitationEnergy() && 
         (list_c[A])[j]->GetNumberOfChannels() > 0) { return true; } 
    }
  }
  return false;
}

Referenced by DumpFragment(), and G4FermiBreakUpVI::IsApplicable().

IsPhysical()

G4bool G4FermiFragmentsPoolVI::IsPhysical	(	G4int	Z,
		G4int	A
	)		const

Definition at line 97 of file G4FermiFragmentsPoolVI.cc.

{
  for(auto const& ptr : list_f[A]) {
    if(ptr->GetZ() == Z) { return true; }
  }
  return false;
}

---

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

• G4FermiFragmentsPoolVI.hh
• G4FermiFragmentsPoolVI.cc