G4FermiFragmentsPool Class Reference

#include <G4FermiFragmentsPool.hh>

Public Member Functions
	~G4FermiFragmentsPool ()
G4bool	IsApplicable (G4int Z, G4int A, G4double mass) const
const std::vector< const G4FermiConfiguration * > *	GetConfigurationList (G4int Z, G4int A, G4double mass) const
const G4VFermiFragment *	GetFragment (G4int Z, G4int A) const
const G4FermiPhaseSpaceDecay *	GetFermiPhaseSpaceDecay () const
G4int	GetMaxZ () const
G4int	GetMaxA () const
void	DumpFragment (const G4VFermiFragment *f) const
void	Dump () const

Static Public Member Functions
static G4FermiFragmentsPool *	Instance ()

Detailed Description

Definition at line 44 of file G4FermiFragmentsPool.hh.

Constructor & Destructor Documentation

G4FermiFragmentsPool::~G4FermiFragmentsPool

(

)

Definition at line 73 of file G4FermiFragmentsPool.cc.

{
  size_t nn;
  for(size_t i=0; i<17; ++i) {
    nn = list1[i].size();
    if(0 < nn) { for(size_t j=0; j<nn; ++j) { delete (list1[i])[j]; }}
    nn = list2[i].size();
    if(0 < nn) { for(size_t j=0; j<nn; ++j) { delete (list2[i])[j]; }}
    nn = list3[i].size();
    if(0 < nn) { for(size_t j=0; j<nn; ++j) { delete (list3[i])[j]; }}
    nn = list4[i].size();
    if(0 < nn) { for(size_t j=0; j<nn; ++j) { delete (list4[i])[j]; }}
  }
  nn = fragment_pool.size();
  if(0 < nn) { for(size_t j=0; j<nn; ++j) { delete fragment_pool[j]; }}
}

Member Function Documentation

void G4FermiFragmentsPool::Dump

(

)

const

Definition at line 674 of file G4FermiFragmentsPool.cc.

{
  G4cout << "##### List of Fragments in the Fermi Fragment Pool #####" 
     << G4endl;
  G4int nfrag = fragment_pool.size();
  for(G4int i=0; i<nfrag; ++i) {
    DumpFragment(fragment_pool[i]);
  }
  G4cout << G4endl;
}

Here is the call graph for this function:

void G4FermiFragmentsPool::DumpFragment

(

const G4VFermiFragment *

f

)

const

Definition at line 665 of file G4FermiFragmentsPool.cc.

{
  if(f) {
    G4cout << "Z= " << f->GetZ() << " A= " << f->GetA() 
       << " Mass(GeV)= " << f->GetFragmentMass()/GeV
       << " Eexc(MeV)= " << f->GetExcitationEnergy() << G4endl;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

const std::vector< const G4FermiConfiguration * > * G4FermiFragmentsPool::GetConfigurationList	(	G4int	Z,
		G4int	A,
		G4double	mass
	)		const

Definition at line 494 of file G4FermiFragmentsPool.cc.

{
  std::vector<const G4FermiConfiguration*>* v = 
    new std::vector<const G4FermiConfiguration*>;
  if(Z >= maxZ || A >= maxA) { return v; }

  //G4cout << "G4FermiFragmentsPool::GetConfigurationList:"
  // << " Z= " << Z << " A= " << A << " Mass(GeV)= " << mass/GeV<< G4endl;

  // look into pair list
  size_t nz = list2[A].size();
  if(0 < nz) {
    for(size_t j=0; j<nz; ++j) {
      const G4FermiConfiguration* conf = (list2[A])[j];
      if(Z == conf->GetZ() && mass >= conf->GetMass()) { 
    v->push_back(conf); 
      }
      //G4cout << "Pair dM(MeV)= " << mass - conf->GetMass() << G4endl; }
    }
  }
  // look into triple list
  nz = list3[A].size();
  if(0 < nz) {
    for(size_t j=0; j<nz; ++j) {
      const G4FermiConfiguration* conf = (list3[A])[j];
      if(Z == conf->GetZ() && mass >= conf->GetMass()) { 
    v->push_back(conf); 
      }
      //G4cout << "Triple dM(MeV)= " << mass - conf->GetMass() << G4endl; }
    }
  }
  // look into quartet list
  nz = list4[A].size();
  if(0 < nz) {
    for(size_t j=0; j<nz; ++j) {
      const G4FermiConfiguration* conf = (list4[A])[j];
      if(Z == conf->GetZ() && mass >= conf->GetMass()) { 
    v->push_back(conf);
      }
      //  G4cout << "Quartet dM(MeV)= " << mass - conf->GetMass() << G4endl; }
    }
  }
  // return if vector not empty
  if(0 < v->size()) { 
    if(verbose > 0) { 
      G4double ExEn= mass - G4NucleiProperties::GetNuclearMass(A,Z);
      G4cout<<"Total number of configurations = "<<v->size()<<" for A= "
        <<A<<"   Z= "<<Z<<"   E*= "<< ExEn<<" MeV"<<G4endl;
      size_t size_vector_conf = v->size();
      for(size_t jc=0; jc<size_vector_conf; ++jc) {     
    const std::vector<const G4VFermiFragment*>* v_frag = 
      (*v)[jc]->GetFragmentList();
    size_t size_vector_fragments = v_frag->size();
    G4cout<<size_vector_fragments<<"-body configuration "<<jc+1<<": ";
    for(size_t jf=0;jf<size_vector_fragments;++jf){
      G4int af= (*v_frag)[jf]->GetA();
      G4int zf= (*v_frag)[jf]->GetZ();
      G4double ex=(*v_frag)[jf]->GetExcitationEnergy();
      G4cout<<"(a="<<af<<", z="<<zf<<", ex="<<ex<<")  ";
    }
    G4cout<<G4endl;
    G4cout<<"-----------------------------------------------------"<<G4endl;
      }
    }
    return v; 
  }

  // search in the pool and if found then return vector with one element
  nz = list1[A].size();
  if(0 < nz) {
    for(size_t j=0; j<nz; ++j) {
      const G4FermiConfiguration* conf = (list1[A])[j];

      //  G4cout << "Single dM(MeV)= " << mass - conf->GetMass() << G4endl; }
      if(Z == conf->GetZ() && mass >= conf->GetMass()) {
    if(!(*(conf->GetFragmentList()))[0]->IsStable()) {
      v->push_back(conf);

      if(verbose > 0) { 
        G4double ExEn= mass -G4NucleiProperties::GetNuclearMass(A,Z);
        G4cout<<"Only 1 configurations for A= "
          <<A<<"   Z= "<<Z<<"   E*= "<< ExEn<<" MeV"<<G4endl;
        const std::vector<const G4VFermiFragment*>* v_frag 
          = (*v)[0]->GetFragmentList();
        size_t size_vector_fragments=v_frag->size();
        G4cout<<"1 Fragment configuration: ";
        for(size_t jf=0;jf<size_vector_fragments;++jf){
          G4int af= (*v_frag)[jf]->GetA();
          G4int zf= (*v_frag)[jf]->GetZ();
          G4double ex=(*v_frag)[jf]->GetExcitationEnergy();
          G4cout<<"(a="<<af<<", z="<<zf<<", ex="<<ex<<")  ";
        }
        G4cout<<G4endl;
        G4cout<<"-----------------------------------------------------"<<G4endl;    
      }
      return v;
    }
      }
    }
  }
  //failer
  if(verbose > 0) { 
    G4cout << "G4FermiFragmentsPool::GetConfigurationList: WARNING: not "
       << "able decay fragment Z= " << Z << " A= " << A
       << " Mass(GeV)= " << mass/GeV<< G4endl;
  }
  return v;
}

Here is the call graph for this function:

const G4FermiPhaseSpaceDecay * G4FermiFragmentsPool::GetFermiPhaseSpaceDecay

(

)

const

Definition at line 111 of file G4FermiFragmentsPool.cc.

{
  return &thePhaseSpace;
}

Here is the caller graph for this function:

const G4VFermiFragment * G4FermiFragmentsPool::GetFragment	(	G4int	Z,
		G4int	A
	)		const

Definition at line 649 of file G4FermiFragmentsPool.cc.

{
  const G4VFermiFragment* f = 0;
  if(Z < maxZ && A < maxA) { 
    size_t nz = list1[A].size();
    for(size_t j=0; j<nz; ++j) {
      const G4FermiConfiguration* conf = (list1[A])[j];
      if(Z == conf->GetZ()) { 
    f = (*(conf->GetFragmentList()))[0]; 
    break; 
      }
    }
  }
  return f;
}

Here is the call graph for this function:

G4int G4FermiFragmentsPool::GetMaxA

(

)

const

Definition at line 105 of file G4FermiFragmentsPool.cc.

{
  return maxA;
}

G4int G4FermiFragmentsPool::GetMaxZ

(

)

const

Definition at line 100 of file G4FermiFragmentsPool.cc.

{
  return maxZ;
}

G4FermiFragmentsPool * G4FermiFragmentsPool::Instance ( void  )

static

Definition at line 56 of file G4FermiFragmentsPool.cc.

{
  if(0 == theInstance) {
    static G4FermiFragmentsPool instance;
    theInstance = &instance;
  }
  return theInstance;
}

Here is the caller graph for this function:

G4bool G4FermiFragmentsPool::IsApplicable	(	G4int	Z,
		G4int	A,
		G4double	mass
	)		const

Definition at line 452 of file G4FermiFragmentsPool.cc.

{
  if(Z >= maxZ || A >= maxA || A <= 0) { return false; }
  // look into pair list
  size_t nz = list2[A].size();
  if(0 < nz) {
    for(size_t j=0; j<nz; ++j) {
      const G4FermiConfiguration* conf = (list2[A])[j];
      if(Z == conf->GetZ() && mass >= conf->GetMass()) { return true; }
    }
  }
  // look into triple list
  nz = list3[A].size();
  if(0 < nz) {
    for(size_t j=0; j<nz; ++j) {
      const G4FermiConfiguration* conf = (list3[A])[j];
      if(Z == conf->GetZ() && mass >= conf->GetMass()) { return true; }
    }
  }
  // look into quartet list
  nz = list4[A].size();
  if(0 < nz) {
    for(size_t j=0; j<nz; ++j) {
      const G4FermiConfiguration* conf = (list4[A])[j];
      if(Z == conf->GetZ() && mass >= conf->GetMass()) { return true; }
    }
  }

  // search in the pool and if found then return vector with one element
  nz = list1[A].size();
  if(0 < nz) {
    for(size_t j=0; j<nz; ++j) {
      const G4FermiConfiguration* conf = (list1[A])[j];
      if(Z == conf->GetZ() && mass >= conf->GetMass()) {
    if(!(*(conf->GetFragmentList()))[0]->IsStable()) { return true; }
      }
    }
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• geant4.10.03.p01/source/processes/hadronic/models/de_excitation/fermi_breakup/include/G4FermiFragmentsPool.hh
• geant4.10.03.p01/source/processes/hadronic/models/de_excitation/fermi_breakup/src/G4FermiFragmentsPool.cc