G4FermiFragmentsPool Class Reference

#include <G4FermiFragmentsPool.hh>

Public Member Functions
	~G4FermiFragmentsPool ()
const std::vector < G4FermiConfiguration * > *	GetConfigurationList (G4int Z, G4int A, G4double mass)
const G4VFermiFragment *	GetFragment (G4int Z, G4int A)
G4int	GetMaxZ () const
G4int	GetMaxA () const

Static Public Member Functions
static G4FermiFragmentsPool *	Instance ()

Detailed Description

Definition at line 43 of file G4FermiFragmentsPool.hh.

Constructor & Destructor Documentation

G4FermiFragmentsPool::~G4FermiFragmentsPool

(

)

Definition at line 73 of file G4FermiFragmentsPool.cc.

References G4InuclParticleNames::nn.

{
  for(size_t i=0; i<17; ++i) {
    size_t 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]; }}
  }
  size_t nn = listextra.size();
  if(0 < nn) { for(size_t j=0; j<nn; ++j) { delete listextra[j]; }}
  nn = fragment_pool.size();
  if(0 < nn) { for(size_t j=0; j<nn; ++j) { delete fragment_pool[j]; }}
}

Member Function Documentation

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

Definition at line 449 of file G4FermiFragmentsPool.cc.

References G4cout, G4endl, G4FermiConfiguration::GetA(), G4FermiConfiguration::GetFragmentList(), G4FermiConfiguration::GetMass(), G4NucleiProperties::GetNuclearMass(), G4FermiConfiguration::GetZ(), python.hepunit::GeV, python.hepunit::neutron_mass_c2, python.hepunit::proton_mass_c2, and test::v.

{
  //JMQ 040511 for printing the total number of configurations for a given A
  G4int nconf=0;

  std::vector<G4FermiConfiguration*>* v = new std::vector<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) {
      G4FermiConfiguration* conf = (list2[A])[j];
      if(Z == conf->GetZ() && mass >= conf->GetMass()) { 
    v->push_back(conf); 
     ++nconf;
      }
      //if(Z == conf->GetZ()) { 
      //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) {
      G4FermiConfiguration* conf = (list3[A])[j];
      if(Z == conf->GetZ() && mass >= conf->GetMass()) { 
    v->push_back(conf); 
    ++nconf;
      }
      //if(Z == conf->GetZ()) { 
      //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) {
      G4FermiConfiguration* conf = (list4[A])[j];
      if(Z == conf->GetZ() && mass >= conf->GetMass()) { 
    v->push_back(conf);
    ++nconf; 
      }
      //if(Z == conf->GetZ()) { 
      //  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 = "<<nconf<<" 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) {     
    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();
  G4FermiConfiguration* conf1 = 0; 
  if(0 < nz) {
    for(size_t j=0; j<nz; ++j) {
      G4FermiConfiguration* conf = (list1[A])[j];
      //if(Z == conf->GetZ()) { 
      //  G4cout << "Single dM(MeV)= " << mass - conf->GetMass() << G4endl; }

      if(Z == conf->GetZ() && mass >= conf->GetMass()) {
    if(!(conf->GetFragmentList())[0]->IsStable()) {
      ++nconf;
      v->push_back(conf);
      if(verbose > 0) { 
        G4double ExEn= mass -G4NucleiProperties::GetNuclearMass(A,Z);
        G4cout<<"Total number of configurations = "<<nconf<<" 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) {     
          std::vector<const G4VFermiFragment*> v_frag = (*v)[jc]->GetFragmentList();
          size_t size_vector_fragments=v_frag.size();
          G4cout<<"1 Fragment 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;
    } else {
      conf1 = conf;
      break;
    }
      }
    }
  }
    
  // search in the list of exotic configurations
  nz = listextra.size();
  if(0 < nz) {
    for(size_t j=0; j<nz; ++j) {
      G4FermiConfiguration* conf = listextra[j];
      if(Z == conf->GetZ() && A == conf->GetA() && 
     mass >= conf->GetMass()) { 
    ++nconf;
    v->push_back(conf); 
    if(verbose > 0) { 
      G4double ExEn= mass -G4NucleiProperties::GetNuclearMass(A,Z);
      G4cout<<"Total number of configurations = "<<nconf<<" 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) {     
        std::vector<const G4VFermiFragment*> v_frag = (*v)[jc]->GetFragmentList();
        size_t size_vector_fragments=v_frag.size();
        G4cout<<"Found exotic configuration -> 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;
      }
    }
  }
  //G4cout << "Explore dM(MeV)= " 
  //     << mass - Z*proton_mass_c2 - (A-Z)*neutron_mass_c2 << G4endl; 

  // add new exotic configuration
  if(mass > Z*proton_mass_c2 + (A-Z)*neutron_mass_c2) {
    std::vector<const G4VFermiFragment*>  newvec;
    G4int idx = 1;
    for(G4int i=0; i<A; ++i) {
      if(i == Z) { idx = 0; }
      newvec.push_back(fragment_pool[idx]);
    }
    G4FermiConfiguration* conf = new G4FermiConfiguration(newvec);
    listextra.push_back(conf);
    v->push_back(conf);
    ++nconf;
    if(verbose > 0) { 
      G4cout<<"Total number of configurations = "<<nconf<<G4endl;
      G4double ExEn= mass -G4NucleiProperties::GetNuclearMass(A,Z);
      G4cout<<"Total number of configurations = "<<nconf<<" 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) {     
    std::vector<const G4VFermiFragment*> v_frag = (*v)[jc]->GetFragmentList();
    size_t size_vector_fragments=v_frag.size();
    G4cout<<"New exotic configuration -> 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;
  }

  // only photon evaporation is possible
  if(conf1) {
    v->push_back(conf1); 
    ++nconf;
    if(verbose > 0) { 
      G4cout<<"Total number of configurations = "<<nconf<<G4endl;
      G4double ExEn= mass -G4NucleiProperties::GetNuclearMass(A,Z);
      G4cout<<"Total number of configurations = "<<nconf<<" 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) {     
    std::vector<const G4VFermiFragment*> v_frag = (*v)[jc]->GetFragmentList();
    size_t size_vector_fragments=v_frag.size();
    G4cout<<"Only evaporation is possible -> 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;   
  }

  //failer
  if(verbose > 0) { 
    G4cout << "G4FermiFragmentsPool::GetConfigurationList: WARNING: not "
       << "able decay fragment Z= " << Z << " A= " << A
       << " Mass(GeV)= " << mass/GeV<< G4endl;
  }
  return v;
}

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

Definition at line 717 of file G4FermiFragmentsPool.cc.

References G4FermiConfiguration::GetFragmentList(), and G4FermiConfiguration::GetZ().

Referenced by G4ExcitationHandler::BreakItUp().

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

G4int G4FermiFragmentsPool::GetMaxA ( ) const

inline

Definition at line 102 of file G4FermiFragmentsPool.hh.

{
  return maxA;
}

G4int G4FermiFragmentsPool::GetMaxZ ( ) const

inline

Definition at line 97 of file G4FermiFragmentsPool.hh.

{
  return maxZ;
}

G4FermiFragmentsPool * G4FermiFragmentsPool::Instance ( void  )

static

Definition at line 56 of file G4FermiFragmentsPool.cc.

Referenced by G4ExcitationHandler::G4ExcitationHandler(), and G4FermiConfigurationList::G4FermiConfigurationList().

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

---

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

• G4FermiFragmentsPool.hh
• G4FermiFragmentsPool.cc