G4FermiFragmentsPoolVI Class Reference

#include <G4FermiFragmentsPoolVI.hh>

Public Member Functions
	G4FermiFragmentsPoolVI ()
	~G4FermiFragmentsPoolVI ()
void	Initialise ()
const G4FermiChannels *	ClosestChannels (const G4int Z, const G4int A, const G4double mass) const
void	DumpFragment (const G4FermiFragment *) const
void	Dump () const
G4bool	HasDecay (const G4int Z, const G4int A, const G4double eexc) const
G4bool	IsInitialized () const
	G4FermiFragmentsPoolVI (const G4FermiFragmentsPoolVI &right)=delete
const G4FermiFragmentsPoolVI &	operator= (const G4FermiFragmentsPoolVI &right)=delete
G4bool	operator== (const G4FermiFragmentsPoolVI &right) const =delete
G4bool	operator!= (const G4FermiFragmentsPoolVI &right) const =delete

Detailed Description

Definition at line 41 of file G4FermiFragmentsPoolVI.hh.

Constructor & Destructor Documentation

G4FermiFragmentsPoolVI() [1/2]

G4FermiFragmentsPoolVI::G4FermiFragmentsPoolVI

(

)

Definition at line 41 of file G4FermiFragmentsPoolVI.cc.

{}

~G4FermiFragmentsPoolVI()

G4FermiFragmentsPoolVI::~G4FermiFragmentsPoolVI

(

)

Definition at line 44 of file G4FermiFragmentsPoolVI.cc.

{
  for (G4int i=0; i<maxA; ++i) {
    for (G4int j=0; j<maxZ; ++j) {
      auto ptr = list_c[j][i];
      if (nullptr != ptr) {
    for ( auto const & p : *ptr) { delete p; }
        delete ptr;
      }
    }
  }
  for (auto const & ptr : fragment_pool) { delete ptr; }
}

G4FermiFragmentsPoolVI() [2/2]

G4FermiFragmentsPoolVI::G4FermiFragmentsPoolVI ( const G4FermiFragmentsPoolVI & right )

delete

Member Function Documentation

ClosestChannels()

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

Definition at line 72 of file G4FermiFragmentsPoolVI.cc.

{
  const G4FermiChannels* res = nullptr;
  if (Z >= maxZ || A >= maxA) { return res; } 
 
  auto chan = list_c[Z][A];
  if (nullptr == chan) { return res; }
 
  G4double demax = 1.e+9;
  for (auto const & ch : *chan) {
    if (ch->NumberPairs() == 0) { continue; }
    G4double de = etot - ch->GetFragment()->GetTotalEnergy();
    // an excitation coincide with a level
    if (std::abs(de) <= fTolerance) {
      return ch;
    }
    if (de >= 0 && de < demax) {
      demax = de;
      res = ch;
    } 
  }
  return res;
}

Dump()

void G4FermiFragmentsPoolVI::Dump

(

)

const

Definition at line 263 of file G4FermiFragmentsPoolVI.cc.

{
  G4cout <<"----------------------------------------------------------------"
         <<G4endl;
  G4cout << "##### List of Fragments in the Fermi Fragment Pool #####" 
         << G4endl;
  std::size_t nfrag = fragment_pool.size();
  G4cout << "      Nfragnents=" << nfrag << " Elim(MeV)=" << fElim/CLHEP::MeV << G4endl; 
  for(std::size_t i=0; i<nfrag; ++i) {
    DumpFragment(fragment_pool[i]);
  }
  G4cout << G4endl;
 
 
  G4cout << "----------------------------------------------------------------"
         << G4endl;
  G4cout << "### G4FermiFragmentPoolVI: fragments sorted by A" << G4endl; 
 
  G4int ama{0};
  G4long prec = G4cout.precision(6);
  for (G4int A=1; A<maxA; ++A) {
    for (G4int Z=0; Z<maxZ; ++Z) {
      auto chan = list_c[Z][A];
      if (nullptr == chan) { continue; }
      std::size_t jmax = chan->size();
      G4cout << " # A=" << A << "  Z=" << Z << "  Nfagments=" << jmax << G4endl;
      for(std::size_t j=0; j<jmax; ++j) {
    auto ch = (*chan)[j];
    if(nullptr == ch) { continue; }
    auto f = ch->GetFragment();
    G4int a1 = f->GetA();
    G4int z1 = f->GetZ();
    std::size_t nch = ch->NumberPairs();
    ama += nch;
    G4cout << "   ("<<a1<<","<<z1<<");  Eex(MeV)= "
           << f->GetExcitationEnergy() 
           << " 2S=" << f->TwoSpinParity()
           << "; Nchannels=" << nch
           << G4endl; 
    for (std::size_t k=0; k<nch; ++k) {
          auto fpair = ch->GetPair(k);
      if(nullptr == fpair) { continue; }
      G4cout << "         (" << fpair->GetFragment1()->GetZ()
         << ", "  << fpair->GetFragment1()->GetA() 
         << ", " << fpair->GetFragment1()->GetExcitationEnergy()
         << ")  ("<< fpair->GetFragment2()->GetZ()
         << ", "  << fpair->GetFragment2()->GetA() << ", "
         << fpair->GetFragment2()->GetExcitationEnergy()
         << ")  prob= " << fpair->Probability()
         << G4endl;
    }
      }
    }
  }
  G4cout.precision(prec);
  G4cout << " ======== Total number of channels " << ama << "  ======" << G4endl;
}

DumpFragment()

void G4FermiFragmentsPoolVI::DumpFragment

(

const G4FermiFragment *

f

)

const

Definition at line 251 of file G4FermiFragmentsPoolVI.cc.

{
  if (nullptr != f) {
    G4long 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->TwoSpinParity() << G4endl;
    G4cout.precision(prec);
  }
}

Referenced by Dump().

HasDecay()

G4bool G4FermiFragmentsPoolVI::HasDecay	(	const G4int	Z,
		const G4int	A,
		const G4double	eexc ) const

Definition at line 58 of file G4FermiFragmentsPoolVI.cc.

{
  if (Z < maxZ && A < maxA && nullptr != list_c[Z][A]) {
    for (auto const & ch : *(list_c[Z][A])) {
      if (ch->GetExcitation() <= eexc + fTolerance && ch->NumberPairs() > 0) {
    return true;
      } 
    }
  }
  return false;
}

Initialise()

void G4FermiFragmentsPoolVI::Initialise

(

)

Definition at line 107 of file G4FermiFragmentsPoolVI.cc.

{
  if (isInitialized) { return; }
  isInitialized = true;
  G4DeexPrecoParameters* param = 
    G4NuclearLevelData::GetInstance()->GetParameters();
  fTolerance = 2*CLHEP::eV;
  fElim = param->GetFBUEnergyLimit();
 
  fragment_pool.reserve(991);
 
  // stable particles
  fragment_pool.push_back(new G4FermiFragment(1, 0, 1, 0.0, DBL_MAX));
  fragment_pool.push_back(new G4FermiFragment(1, 1, 1, 0.0, DBL_MAX));
  fragment_pool.push_back(new G4FermiFragment(2, 1, 2, 0.0, DBL_MAX));
  fragment_pool.push_back(new G4FermiFragment(3, 1, 1, 0.0, 3.8879e+08));
  fragment_pool.push_back(new G4FermiFragment(3, 2, 1, 0.0, DBL_MAX));
  fragment_pool.push_back(new G4FermiFragment(4, 2, 0, 0.0, DBL_MAX));
  fragment_pool.push_back(new G4FermiFragment(5, 2, 3, 0.0, 7.0325e-22));
  fragment_pool.push_back(new G4FermiFragment(5, 3, 3, 0.0, 3.70493e-22));
 
  // use level data and construct the pool
  G4NuclearLevelData* ndata = G4NuclearLevelData::GetInstance();
  for (G4int Z=1; Z<maxZ; ++Z) {
    G4int Amin = ndata->GetMinA(Z);
    G4int Amax = std::min(maxA, ndata->GetMaxA(Z)+1);
    for (G4int A=Amin; A<Amax; ++A) {
      const G4LevelManager* man = ndata->GetLevelManager(Z, A);
      if (nullptr != man) {
        std::size_t nn = man->NumberOfTransitions();
        for(std::size_t i=0; i<=nn; ++i) {
          G4double exc = man->LevelEnergy(i);
      /*          
          G4cout << "++ Z=" << Z << " A=" << A << " Eex=" << exc 
                 << " time(ns)=" << man->LifeTime(i)/ns << " i=" << i
                 << " InPool=" << IsInThePool(Z, A, exc) << G4endl;
      */
          // only levels below limit are consided 
          if (exc >= fElim) { continue; }
          // only new are considered
          if (IsInThePool(Z, A, exc)) { continue; }
          fragment_pool.push_back(new G4FermiFragment(A, Z, man->TwoSpinParity(i),
                                                      exc, man->LifeTime(i)));
        }
      }
    }
  }
  G4int nfrag = (G4int)fragment_pool.size();
  for (auto const& f : fragment_pool) {
    G4int Z = f->GetZ();
    G4int A = f->GetA();
    if (list_c[Z][A] == nullptr) {
      list_c[Z][A] = new std::vector<G4FermiChannels*>;
    }
    (list_c[Z][A])->push_back(new G4FermiChannels(f));
  }
 
  // list of fragment pairs ordered by A
  for (G4int i=0; i<nfrag; ++i) {
    const G4FermiFragment* f1 = fragment_pool[i];
    G4int Z1 = f1->GetZ();
    G4int A1 = f1->GetA();
    G4double e1 = f1->GetTotalEnergy();
    for (G4int j=0; j<nfrag; ++j) {
      const G4FermiFragment* f2 = fragment_pool[j];
      G4int Z2 = f2->GetZ();
      G4int A2 = f2->GetA();
      if(A2 < A1 || (A2 == A1 && Z2 < Z1)) { continue; }
      G4int Z = Z1 + Z2;
      G4int A = A1 + A2;
 
      if(Z >= maxZ || A >= maxA) { continue; } 
 
      G4double e2 = f2->GetTotalEnergy();
      G4double minE = e1 + e2;
      G4double exc = minE - G4NucleiProperties::GetNuclearMass(A, Z);
      /*
      if(1 == Z) {
        G4cout << "+!+ Z=" << Z << " A=" << A 
             << " Z1=" << Z1 << " A1=" << A1
             << " Z2=" << Z2 << " A2=" << A2 << " Eex=" << exc 
             << "  Qb=" << G4FermiBreakUpUtil::CoulombBarrier(Z1, A1, Z2, A2, exc)
             << " e1=" << e1 << " e2=" << e2
             << " M=" << G4NucleiProperties::GetNuclearMass(A, Z)
             << G4endl; 
      }
      */
      // ignore very excited case
      if (exc > fElim) { continue; }
      auto chan = list_c[Z][A];
      if (nullptr == chan) { continue; }
      std::size_t kmax = chan->size();
      for (std::size_t k=0; k<kmax; ++k) {
    auto ch = (*chan)[k];
        const G4double e0 = ch->GetMass();
        auto f0 = ch->GetFragment();
        if (e0 > minE && G4FermiBreakUpUtil::CheckSpinParity(f1, f2, f0)) { 
          const G4double cb =
            G4FermiBreakUpUtil::CoulombBarrier(Z1, A1, Z2, A2, ch->GetExcitation());
          if (e0 >= minE + cb) {
        ch->AddChannel(new G4FermiPair(f1, f2));
      }
        }
      }
    }
  }
  // compute cumulative probabilities
  for (G4int A=1; A<maxA; ++A) {
    for (G4int Z=0; Z<maxZ; ++Z) {
      auto chan = list_c[Z][A];
      if(nullptr == chan) { continue; }
      std::size_t kmax = chan->size();
      for (std::size_t k=0; k<kmax; ++k) {
    auto ch = (*chan)[k];
    auto frag = ch->GetFragment();
    std::size_t nch = ch->NumberPairs();
    if (1 < nch) {
      const std::vector<G4FermiPair*>& pairs = ch->GetChannels();
      G4double ptot = 0.0;
      for (std::size_t i=0; i<nch; ++i) {
        ptot += G4FermiBreakUpUtil::Probability(frag->GetA(),
                                                    pairs[i]->GetFragment1(),
                                                    pairs[i]->GetFragment2(),
                                                    frag->GetTotalEnergy(),
                            frag->GetExcitationEnergy());
            pairs[i]->SetProbability(ptot);
      }
      // normalisation
      if (0.0 == ptot) {
        pairs[0]->SetProbability(1.0);
      } else {
        ptot = 1./ptot;
        for (std::size_t i=0; i<nch-1; ++i) {
          G4double x = ptot*pairs[i]->Probability();
          pairs[i]->SetProbability(x);
        }
        pairs[nch - 1]->SetProbability(1.0);
          }
        }
      }
    }
  }
}

Referenced by G4FermiBreakUpVI::BreakFragment(), and G4FermiBreakUpVI::G4FermiBreakUpVI().

IsInitialized()

G4bool G4FermiFragmentsPoolVI::IsInitialized ( ) const

inline

Definition at line 60 of file G4FermiFragmentsPoolVI.hh.

{ return isInitialized; };

Referenced by G4FermiBreakUpVI::BreakFragment(), and G4FermiBreakUpVI::Initialise().

operator!=()

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

delete

operator=()

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

delete

operator==()

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

delete

---

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

• G4FermiFragmentsPoolVI.hh
• G4FermiFragmentsPoolVI.cc