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	IsApplicable (G4int ZZ, G4int AA, G4double etot) const
const G4FermiDecayProbability *	FermiDecayProbability () const
G4int	GetMaxZ () const
G4int	GetMaxA () const
G4double	GetEnergyLimit () const
G4double	GetTolerance () const

Detailed Description

Definition at line 43 of file G4FermiFragmentsPoolVI.hh.

Constructor & Destructor Documentation

G4FermiFragmentsPoolVI::G4FermiFragmentsPoolVI ( )

explicit

Definition at line 40 of file G4FermiFragmentsPoolVI.cc.

{
  maxZ = 9;
  maxA = 17;
  tolerance = 0.1*CLHEP::keV;
  elim = 10*CLHEP::MeV;
  elim_unstable = 10*CLHEP::MeV;
  Initialise();
}

G4FermiFragmentsPoolVI::~G4FermiFragmentsPoolVI

(

)

Definition at line 50 of file G4FermiFragmentsPoolVI.cc.

{
  size_t nn;
  for(G4int i=0; i<maxA; ++i) {
    nn = list_p[i].size();
    for(size_t j=0; j<nn; ++j) { delete (list_p[i])[j]; }
    nn = list_c[i].size();
    for(size_t j=0; j<nn; ++j) { delete (list_c[i])[j]; }
    nn = list_d[i].size();
    for(size_t j=0; j<nn; ++j) { delete (list_d[i])[j]; }
    nn = list_u[i].size();
    for(size_t j=0; j<nn; ++j) { delete (list_u[i])[j]; }
  }
  nn = fragment_pool.size();
  for(size_t j=0; j<nn; ++j) { delete fragment_pool[j]; }
  nn = funstable.size();
  for(size_t j=0; j<nn; ++j) { delete funstable[j]; }
}

Member Function Documentation

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

Definition at line 90 of file G4FermiFragmentsPoolVI.cc.

{
  const G4FermiChannels* res = nullptr; 
  G4double demax = e;

  // 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();
    if(std::abs(de) <= tolerance) { 
      res = (list_c[A])[j];
      break;
    } else if(de > 0.0 && de < demax) {
      res = (list_c[A])[j];
      demax = de;
    } else if(de > 0.0 && de >= demax) {
      break;
    }
  }
  // stable + unstable channels
  if(!res) {
    for(size_t j=0; j<list_d[A].size(); ++j) {
      const G4FermiFragment* frag = (list_g[A])[j];
      if(frag->GetZ() != Z) { continue; }
      G4double de = e - frag->GetTotalEnergy();
      if(std::abs(de) <= tolerance || de > 0.0) { 
    res = (list_d[A])[j];
    break;
      }
    }  
  }
  return res;
}

Here is the call graph for this function:

void G4FermiFragmentsPoolVI::Dump

(

)

const

Definition at line 415 of file G4FermiFragmentsPoolVI.cc.

{
  G4cout <<"----------------------------------------------------------------"
     <<G4endl;
  G4cout << "##### List of Fragments in the Fermi Fragment Pool #####" 
     << G4endl;
  G4cout << "      For stable Elim(MeV) = " << elim/CLHEP::MeV 
     << "   for unstable Elim(MeV) = " << elim_unstable/CLHEP::MeV << G4endl; 
  G4int nfrag = fragment_pool.size();
  for(G4int i=0; i<nfrag; ++i) {
    DumpFragment(fragment_pool[i]);
  }
  G4cout << G4endl;

  G4int prec = G4cout.precision(6);

  G4cout << "----------------------------------------------------------------"
     << G4endl;
  G4cout << "### G4FermiFragmentPoolVI: fragments sorted by A" << G4endl; 
  for(G4int A=1; A<maxA; ++A) {
    G4cout << " # A= " << A << G4endl; 
    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();
      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; 
      }
    }
  }
  G4cout << G4endl;
  G4cout << "----------------------------------------------------------------"
     << G4endl;
 
  G4cout << "### G4FermiFragmentPoolVI: " << funstable.size() 
     << " unphysical fragments" << G4endl;
  for(G4int A=1; A<maxA; ++A) {
    G4cout << " # A= " << A << G4endl; 
    for(size_t j=0; j<list_g[A].size(); ++j) {
      const G4FermiFragment* f = (list_g[A])[j];
      G4int a1 = f->GetA();
      G4int z1 = f->GetZ();
      size_t nch = (list_d[A])[j]->GetNumberOfChannels();
      G4cout << "("<<a1<<","<<z1<<");  Eex(MeV)= "
         << std::setw(8) << f->GetExcitationEnergy()
         << "; 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_d[A])[j]->GetChannels())[k];
        G4cout << "         (" << fpair->GetFragment1()->GetZ()
           << ", "  << fpair->GetFragment1()->GetA() 
           << ",  " << std::setw(8)<< fpair->GetFragment1()->GetExcitationEnergy()
           << ")  ("<< fpair->GetFragment2()->GetZ()
           << ", "  << std::setw(3)<< fpair->GetFragment2()->GetA()  
           << ",  " << std::setw(8)<< fpair->GetFragment2()->GetExcitationEnergy()
           << ")  prob= " << ((list_d[A])[j]->GetProbabilities())[k]
           << G4endl; 
      }
    }
    G4cout << G4endl; 
  }
  G4cout << G4endl;
  G4cout << "----------------------------------------------------------------"
     << G4endl;
  G4cout << G4endl;
  G4cout << "### Pairs of stable fragments: " << G4endl;
  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 << "### Pairs of stable+unstable fragments: " << G4endl;
  for(G4int A=2; A<maxA; ++A) {
    G4cout << "  A= " << A << G4endl; 
    for(size_t j=0; j<list_u[A].size(); ++j) {
      const G4FermiFragment* f1 = (list_u[A])[j]->GetFragment1();
      const G4FermiFragment* f2 = (list_u[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_u[A])[j]->GetExcitationEnergy() 
             << " Eex1= " << std::setw(8)<< f1->GetExcitationEnergy()
             << " Eex2= " << std::setw(8)<< f2->GetExcitationEnergy()
         << G4endl; 
    }
    G4cout << G4endl;
    G4cout << "----------------------------------------------------------------"
       << G4endl;
  }
  G4cout.precision(prec);
}

Here is the call graph for this function:

void G4FermiFragmentsPoolVI::DumpFragment

(

const G4FermiFragment *

f

)

const

Definition at line 402 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() 
       << G4endl;
    G4cout.precision(prec);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

const G4FermiDecayProbability * G4FermiFragmentsPoolVI::FermiDecayProbability ( ) const

inline

Definition at line 122 of file G4FermiFragmentsPoolVI.hh.

{
  return &theDecay;
}

Here is the caller graph for this function:

G4double G4FermiFragmentsPoolVI::GetEnergyLimit ( ) const

inline

Definition at line 127 of file G4FermiFragmentsPoolVI.hh.

{
  return elim;
}

Here is the caller graph for this function:

G4int G4FermiFragmentsPoolVI::GetMaxA ( ) const

inline

Definition at line 116 of file G4FermiFragmentsPoolVI.hh.

{
  return maxA;
}

G4int G4FermiFragmentsPoolVI::GetMaxZ ( ) const

inline

Definition at line 111 of file G4FermiFragmentsPoolVI.hh.

{
  return maxZ;
}

G4double G4FermiFragmentsPoolVI::GetTolerance ( ) const

inline

Definition at line 132 of file G4FermiFragmentsPoolVI.hh.

{
  return tolerance;
}

Here is the caller graph for this function:

G4bool G4FermiFragmentsPoolVI::IsApplicable	(	G4int	ZZ,
		G4int	AA,
		G4double	etot
	)		const

Definition at line 70 of file G4FermiFragmentsPoolVI.cc.

{
  G4bool isInList = false;
  size_t nn = list_f[A].size();
  for(size_t i=0; i<nn; ++i) {
    if(Z == (list_f[A])[i]->GetZ()) { 
      isInList = true;
      if(etot <= (list_f[A])[i]->GetFragmentMass() + elim) { return true; }
    }
  }
  if(isInList) { return false; }
  nn = list_g[A].size();
  for(size_t i=0; i<nn; ++i) {
    if(Z == (list_g[A])[i]->GetZ() &&
       etot <= (list_g[A])[i]->GetFragmentMass() + elim) { return true; }
  }
  return false;
}

Here is the call graph for this function:

---

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

• source/geant4.10.03.p03/source/processes/hadronic/models/de_excitation/fermi_breakup/include/G4FermiFragmentsPoolVI.hh
• source/geant4.10.03.p03/source/processes/hadronic/models/de_excitation/fermi_breakup/src/G4FermiFragmentsPoolVI.cc