Geant4  10.03.p03
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4FermiFragmentsPoolVI Class Reference

#include <G4FermiFragmentsPoolVI.hh>

Public Member Functions

 G4FermiFragmentsPoolVI ()
 
 ~G4FermiFragmentsPoolVI ()
 
const G4FermiChannelsClosestChannels (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 G4FermiDecayProbabilityFermiDecayProbability () 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.

41 {
42  maxZ = 9;
43  maxA = 17;
44  tolerance = 0.1*CLHEP::keV;
45  elim = 10*CLHEP::MeV;
46  elim_unstable = 10*CLHEP::MeV;
47  Initialise();
48 }
static constexpr double keV
static constexpr double MeV
G4FermiFragmentsPoolVI::~G4FermiFragmentsPoolVI ( )

Definition at line 50 of file G4FermiFragmentsPoolVI.cc.

51 {
52  size_t nn;
53  for(G4int i=0; i<maxA; ++i) {
54  nn = list_p[i].size();
55  for(size_t j=0; j<nn; ++j) { delete (list_p[i])[j]; }
56  nn = list_c[i].size();
57  for(size_t j=0; j<nn; ++j) { delete (list_c[i])[j]; }
58  nn = list_d[i].size();
59  for(size_t j=0; j<nn; ++j) { delete (list_d[i])[j]; }
60  nn = list_u[i].size();
61  for(size_t j=0; j<nn; ++j) { delete (list_u[i])[j]; }
62  }
63  nn = fragment_pool.size();
64  for(size_t j=0; j<nn; ++j) { delete fragment_pool[j]; }
65  nn = funstable.size();
66  for(size_t j=0; j<nn; ++j) { delete funstable[j]; }
67 }
int G4int
Definition: G4Types.hh:78

Member Function Documentation

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

Definition at line 90 of file G4FermiFragmentsPoolVI.cc.

91 {
92  const G4FermiChannels* res = nullptr;
93  G4double demax = e;
94 
95  // stable channels;
96  for(size_t j=0; j<list_c[A].size(); ++j) {
97  const G4FermiFragment* frag = (list_f[A])[j];
98  if(frag->GetZ() != Z) { continue; }
99  G4double de = e - frag->GetTotalEnergy();
100  if(std::abs(de) <= tolerance) {
101  res = (list_c[A])[j];
102  break;
103  } else if(de > 0.0 && de < demax) {
104  res = (list_c[A])[j];
105  demax = de;
106  } else if(de > 0.0 && de >= demax) {
107  break;
108  }
109  }
110  // stable + unstable channels
111  if(!res) {
112  for(size_t j=0; j<list_d[A].size(); ++j) {
113  const G4FermiFragment* frag = (list_g[A])[j];
114  if(frag->GetZ() != Z) { continue; }
115  G4double de = e - frag->GetTotalEnergy();
116  if(std::abs(de) <= tolerance || de > 0.0) {
117  res = (list_d[A])[j];
118  break;
119  }
120  }
121  }
122  return res;
123 }
G4int GetZ(void) const
double A(double temperature)
double G4double
Definition: G4Types.hh:76
G4double GetTotalEnergy(void) const

Here is the call graph for this function:

void G4FermiFragmentsPoolVI::Dump ( ) const

Definition at line 415 of file G4FermiFragmentsPoolVI.cc.

416 {
417  G4cout <<"----------------------------------------------------------------"
418  <<G4endl;
419  G4cout << "##### List of Fragments in the Fermi Fragment Pool #####"
420  << G4endl;
421  G4cout << " For stable Elim(MeV) = " << elim/CLHEP::MeV
422  << " for unstable Elim(MeV) = " << elim_unstable/CLHEP::MeV << G4endl;
423  G4int nfrag = fragment_pool.size();
424  for(G4int i=0; i<nfrag; ++i) {
425  DumpFragment(fragment_pool[i]);
426  }
427  G4cout << G4endl;
428 
429  G4int prec = G4cout.precision(6);
430 
431  G4cout << "----------------------------------------------------------------"
432  << G4endl;
433  G4cout << "### G4FermiFragmentPoolVI: fragments sorted by A" << G4endl;
434  for(G4int A=1; A<maxA; ++A) {
435  G4cout << " # A= " << A << G4endl;
436  for(size_t j=0; j<list_f[A].size(); ++j) {
437  const G4FermiFragment* f = (list_f[A])[j];
438  G4int a1 = f->GetA();
439  G4int z1 = f->GetZ();
440  size_t nch = (list_c[A])[j]->GetNumberOfChannels();
441  G4cout << " ("<<a1<<","<<z1<<"); Eex(MeV)= "
442  << f->GetExcitationEnergy()
443  << " 2S= " << f->GetSpin()
444  << "; Nchannels= " << nch
445  << " MassExcess= " << f->GetTotalEnergy() -
446  (z1*proton_mass_c2 + (a1 - z1)*neutron_mass_c2)
447  << G4endl;
448  for(size_t k=0; k<nch; ++k) {
449  const G4FermiPair* fpair = ((list_c[A])[j]->GetChannels())[k];
450  G4cout << " (" << fpair->GetFragment1()->GetZ()
451  << ", " << fpair->GetFragment1()->GetA()
452  << ", " << fpair->GetFragment1()->GetExcitationEnergy()
453  << ") ("<< fpair->GetFragment2()->GetZ()
454  << ", " << std::setw(3)<< fpair->GetFragment2()->GetA()
455  << ", " << std::setw(8)<< fpair->GetFragment2()->GetExcitationEnergy()
456  << ") prob= " << ((list_c[A])[j]->GetProbabilities())[k]
457  << G4endl;
458  }
459  }
460  }
461  G4cout << G4endl;
462  G4cout << "----------------------------------------------------------------"
463  << G4endl;
464 
465  G4cout << "### G4FermiFragmentPoolVI: " << funstable.size()
466  << " unphysical fragments" << G4endl;
467  for(G4int A=1; A<maxA; ++A) {
468  G4cout << " # A= " << A << G4endl;
469  for(size_t j=0; j<list_g[A].size(); ++j) {
470  const G4FermiFragment* f = (list_g[A])[j];
471  G4int a1 = f->GetA();
472  G4int z1 = f->GetZ();
473  size_t nch = (list_d[A])[j]->GetNumberOfChannels();
474  G4cout << "("<<a1<<","<<z1<<"); Eex(MeV)= "
475  << std::setw(8) << f->GetExcitationEnergy()
476  << "; Nchannels= " << nch
477  << " MassExcess= " << f->GetTotalEnergy() -
478  (z1*proton_mass_c2 + (a1 - z1)*neutron_mass_c2)
479  << G4endl;
480  for(size_t k=0; k<nch; ++k) {
481  const G4FermiPair* fpair = ((list_d[A])[j]->GetChannels())[k];
482  G4cout << " (" << fpair->GetFragment1()->GetZ()
483  << ", " << fpair->GetFragment1()->GetA()
484  << ", " << std::setw(8)<< fpair->GetFragment1()->GetExcitationEnergy()
485  << ") ("<< fpair->GetFragment2()->GetZ()
486  << ", " << std::setw(3)<< fpair->GetFragment2()->GetA()
487  << ", " << std::setw(8)<< fpair->GetFragment2()->GetExcitationEnergy()
488  << ") prob= " << ((list_d[A])[j]->GetProbabilities())[k]
489  << G4endl;
490  }
491  }
492  G4cout << G4endl;
493  }
494  G4cout << G4endl;
495  G4cout << "----------------------------------------------------------------"
496  << G4endl;
497  G4cout << G4endl;
498  G4cout << "### Pairs of stable fragments: " << G4endl;
499  for(G4int A=2; A<maxA; ++A) {
500  G4cout << " A= " << A<<G4endl;
501  for(size_t j=0; j<list_p[A].size(); ++j) {
502  const G4FermiFragment* f1 = (list_p[A])[j]->GetFragment1();
503  const G4FermiFragment* f2 = (list_p[A])[j]->GetFragment2();
504  G4int a1 = f1->GetA();
505  G4int z1 = f1->GetZ();
506  G4int a2 = f2->GetA();
507  G4int z2 = f2->GetZ();
508  G4cout << "("<<a1<<","<<z1<<")("<<a2<<","<<z2<<") % Eex(MeV)= "
509  << std::setw(8)<< (list_p[A])[j]->GetExcitationEnergy()
510  << " Eex1= " << std::setw(8)<< f1->GetExcitationEnergy()
511  << " Eex2= " << std::setw(8)<< f2->GetExcitationEnergy()
512  << G4endl;
513  }
514  G4cout << G4endl;
515  G4cout <<"----------------------------------------------------------------"
516  << G4endl;
517  }
518  G4cout << "### Pairs of stable+unstable fragments: " << G4endl;
519  for(G4int A=2; A<maxA; ++A) {
520  G4cout << " A= " << A << G4endl;
521  for(size_t j=0; j<list_u[A].size(); ++j) {
522  const G4FermiFragment* f1 = (list_u[A])[j]->GetFragment1();
523  const G4FermiFragment* f2 = (list_u[A])[j]->GetFragment2();
524  G4int a1 = f1->GetA();
525  G4int z1 = f1->GetZ();
526  G4int a2 = f2->GetA();
527  G4int z2 = f2->GetZ();
528  G4cout << "("<<a1<<","<<z1<<")("<<a2<<","<<z2<<") % Eex(MeV)= "
529  << std::setw(8)<< (list_u[A])[j]->GetExcitationEnergy()
530  << " Eex1= " << std::setw(8)<< f1->GetExcitationEnergy()
531  << " Eex2= " << std::setw(8)<< f2->GetExcitationEnergy()
532  << G4endl;
533  }
534  G4cout << G4endl;
535  G4cout << "----------------------------------------------------------------"
536  << G4endl;
537  }
538  G4cout.precision(prec);
539 }
G4int GetSpin(void) const
const G4FermiFragment * GetFragment2() const
Definition: G4FermiPair.hh:103
void DumpFragment(const G4FermiFragment *) const
G4int GetZ(void) const
int G4int
Definition: G4Types.hh:78
const G4FermiFragment * GetFragment1() const
Definition: G4FermiPair.hh:98
static const double prec
Definition: RanecuEngine.cc:58
G4GLOB_DLL std::ostream G4cout
double A(double temperature)
static constexpr double MeV
float proton_mass_c2
Definition: hepunit.py:275
float neutron_mass_c2
Definition: hepunit.py:276
G4int GetA(void) const
#define G4endl
Definition: G4ios.hh:61
G4double GetTotalEnergy(void) const
G4double GetExcitationEnergy(void) const

Here is the call graph for this function:

void G4FermiFragmentsPoolVI::DumpFragment ( const G4FermiFragment f) const

Definition at line 402 of file G4FermiFragmentsPoolVI.cc.

403 {
404  if(f) {
405  G4int prec = G4cout.precision(6);
406  G4cout << " Z= " << f->GetZ() << " A= " << std::setw(2) << f->GetA()
407  << " Mass(GeV)= " << std::setw(8) << f->GetFragmentMass()/GeV
408  << " Eexc(MeV)= " << std::setw(7) << f->GetExcitationEnergy()
409  << " 2s= " << f->GetSpin()
410  << G4endl;
411  G4cout.precision(prec);
412  }
413 }
G4int GetSpin(void) const
G4int GetZ(void) const
int G4int
Definition: G4Types.hh:78
static const double prec
Definition: RanecuEngine.cc:58
G4GLOB_DLL std::ostream G4cout
G4double GetFragmentMass(void) const
G4int GetA(void) const
static constexpr double GeV
Definition: G4SIunits.hh:217
#define G4endl
Definition: G4ios.hh:61
G4double GetExcitationEnergy(void) const

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.

123 {
124  return &theDecay;
125 }

Here is the caller graph for this function:

G4double G4FermiFragmentsPoolVI::GetEnergyLimit ( ) const
inline

Definition at line 127 of file G4FermiFragmentsPoolVI.hh.

128 {
129  return elim;
130 }

Here is the caller graph for this function:

G4int G4FermiFragmentsPoolVI::GetMaxA ( ) const
inline

Definition at line 116 of file G4FermiFragmentsPoolVI.hh.

117 {
118  return maxA;
119 }
G4int G4FermiFragmentsPoolVI::GetMaxZ ( ) const
inline

Definition at line 111 of file G4FermiFragmentsPoolVI.hh.

112 {
113  return maxZ;
114 }
G4double G4FermiFragmentsPoolVI::GetTolerance ( ) const
inline

Definition at line 132 of file G4FermiFragmentsPoolVI.hh.

133 {
134  return tolerance;
135 }

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.

71 {
72  G4bool isInList = false;
73  size_t nn = list_f[A].size();
74  for(size_t i=0; i<nn; ++i) {
75  if(Z == (list_f[A])[i]->GetZ()) {
76  isInList = true;
77  if(etot <= (list_f[A])[i]->GetFragmentMass() + elim) { return true; }
78  }
79  }
80  if(isInList) { return false; }
81  nn = list_g[A].size();
82  for(size_t i=0; i<nn; ++i) {
83  if(Z == (list_g[A])[i]->GetZ() &&
84  etot <= (list_g[A])[i]->GetFragmentMass() + elim) { return true; }
85  }
86  return false;
87 }
double A(double temperature)
bool G4bool
Definition: G4Types.hh:79

Here is the call graph for this function:


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