Geant4  10.03.p03
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4FermiFragmentsPoolVI.cc
Go to the documentation of this file.
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 // $Id: G4FermiFragmentsPoolVI.cc,v 1.5 2006-06-29 20:13:13 gunter Exp $
27 //
28 // FermiBreakUp de-excitation model
29 // by V. Ivanchenko (July 2016)
30 //
31 
33 #include "G4PhysicalConstants.hh"
34 #include "G4SystemOfUnits.hh"
35 #include "G4StableFermiFragment.hh"
36 #include "G4NuclearLevelData.hh"
37 #include "G4LevelManager.hh"
38 #include <iomanip>
39 
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 }
49 
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 }
68 
69 G4bool
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 }
88 
89 const G4FermiChannels*
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 }
124 
125 G4bool G4FermiFragmentsPoolVI::IsInThePool(G4int Z, G4int A,
126  G4double exc) const
127 {
128  G4bool res = false;
129  G4int nfrag = fragment_pool.size();
130  for(G4int i=0; i<nfrag; ++i) {
131  const G4FermiFragment* fr = fragment_pool[i];
132  if(fr->GetZ() == Z && fr->GetA() == A &&
133  std::abs(exc - fr->GetExcitationEnergy()) < tolerance) {
134  res = true;
135  break;
136  }
137  }
138  return res;
139 }
140 
141 G4bool G4FermiFragmentsPoolVI::IsInPhysPairs(const G4FermiFragment* f1,
142  const G4FermiFragment* f2,
143  G4double exc) const
144 {
145  G4bool res = false;
146  G4int A1 = f1->GetA();
147  G4int A2 = f2->GetA();
148  G4int A = A1 + A2;
149  G4int nn = list_p[A].size();
150  for(G4int i=0; i<nn; ++i) {
151  if(f1 == (list_p[A])[i]->GetFragment1() && f2 == (list_p[A])[i]->GetFragment2()
152  && std::abs((list_p[A])[i]->GetExcitationEnergy() - exc) < tolerance) {
153  res = true;
154  break;
155  }
156  }
157  return res;
158 }
159 
160 G4bool G4FermiFragmentsPoolVI::IsInUnphysPairs(const G4FermiFragment* f1,
161  const G4FermiFragment* f2,
162  G4double exc) const
163 {
164  G4bool res = false;
165  G4int A1 = f1->GetA();
166  G4int A2 = f2->GetA();
167  G4int A = A1 + A2;
168  G4int nn = list_u[A].size();
169  for(G4int i=0; i<nn; ++i) {
170  if(f1 == (list_u[A])[i]->GetFragment1() && f2 == (list_u[A])[i]->GetFragment2()
171  && std::abs((list_u[A])[i]->GetExcitationEnergy() - exc) < tolerance) {
172  res = true;
173  break;
174  }
175  }
176  return res;
177 }
178 
179 void G4FermiFragmentsPoolVI::Initialise()
180 {
181  static const G4int nmin = 8;
182 
183  // stable particles
184  fragment_pool.push_back(new G4FermiFragment(1, 0, 1, 0.0));
185  fragment_pool.push_back(new G4FermiFragment(1, 1, 1, 0.0));
186  fragment_pool.push_back(new G4FermiFragment(2, 1, 2, 0.0));
187  fragment_pool.push_back(new G4FermiFragment(3, 1, 1, 0.0));
188  fragment_pool.push_back(new G4FermiFragment(3, 2, 1, 0.0));
189  fragment_pool.push_back(new G4FermiFragment(4, 2, 0, 0.0));
190  fragment_pool.push_back(new G4FermiFragment(5, 2, 3, 0.0));
191  fragment_pool.push_back(new G4FermiFragment(5, 3, 3, 0.0));
192 
193  // use level data and construct the pool
195  for(G4int Z=3; Z<maxZ; ++Z) {
196  G4int Amin = ndata->GetMinA(Z);
197  G4int Amax = std::min(maxA, ndata->GetMaxA(Z)+1);
198  for(G4int A=Amin; A<Amax; ++A) {
199  const G4LevelManager* man = ndata->GetLevelManager(Z, A);
200  if(man) {
201  size_t nn = man->NumberOfTransitions();
202  for(size_t i=0; i<=nn; ++i) {
203  G4double exc = (G4double)man->LevelEnergy(i);
204  // only levels below limit are consided
205  if(exc < elim) {
206  fragment_pool.push_back(new G4FermiFragment(A, Z,
207  std::abs(man->SpinParity(i)), exc));
208  }
209  }
210  }
211  }
212  }
213  // prepare structures per A
214  G4int nfrag = fragment_pool.size();
215  for(G4int i=0; i<nfrag; ++i) {
216  const G4FermiFragment* f = fragment_pool[i];
217  G4int A = f->GetA();
218  G4double exc = f->GetExcitationEnergy();
219  list_f[A].push_back(f);
220  list_c[A].push_back(new G4FermiChannels(6, exc, f->GetTotalEnergy()));
221  }
222  // list of unphysical fragments
223  for(G4int Z=0; Z<maxZ; ++Z) {
224  G4int A0 = std::max(Z, 1);
225  for(G4int A=A0; A<maxA; ++A) {
226  if(IsInThePool(Z, A, 0.0)) { continue; }
227  const G4FermiFragment* f = new G4FermiFragment(A, Z, -1, 0.0, false);
228  funstable.push_back(f);
229  list_g[A].push_back(f);
230  list_d[A].push_back(new G4FermiChannels(nmin+1,0.0,f->GetTotalEnergy()));
231  }
232  }
233  // G4cout << "@@@@@@ main loop @@@@@@" << G4endl;
234  // list of fragment pairs ordered by A
235  for(G4int i=0; i<nfrag; ++i) {
236  const G4FermiFragment* f1 = fragment_pool[i];
237  G4int Z1 = f1->GetZ();
238  G4int A1 = f1->GetA();
239  G4double e1 = f1->GetTotalEnergy();
240  for(G4int j=0; j<nfrag; ++j) {
241  const G4FermiFragment* f2 = fragment_pool[j];
242  G4int Z2 = f2->GetZ();
243  G4int A2 = f2->GetA();
244  if(A2 < A1 || (A2 == A1 && Z2 < Z1)) { continue; }
245  G4int Z = Z1 + Z2;
246  G4int A = A1 + A2;
247  if(Z >= maxZ || A >= maxA) { continue; }
248  G4double e2 = f2->GetTotalEnergy();
249  G4double minE = e1 + e2 + f1->GetCoulombBarrier(A2, Z2, 0.0);
250  G4double exc = minE - G4NucleiProperties::GetNuclearMass(A, Z);
251  /*
252  G4cout << "Z= " << Z << " A= " << A
253  << " Z1= " << Z1 << " A1= " << A1
254  << " Z2= " << Z2 << " A2= " << A2 << " Eex= " << exc
255  << " Qb= " << f1->GetCoulombBarrier(A2, Z2, 0.0)
256  << " " << e1
257  << " " << e2
258  << " " << G4NucleiProperties::GetNuclearMass(A, Z)
259  << G4endl;
260  */
261  // ignore very excited case
262  if(exc >= elim) { continue; }
263 
264  G4bool isFound = false;
265  G4int kmax = list_f[A].size();
266  for(G4int k=0; k<kmax; ++k) {
267  if(Z != (list_f[A])[k]->GetZ()) { continue; }
268  G4double exc1 = (list_f[A])[k]->GetExcitationEnergy();
269  //G4cout << "## Z= " << Z << " A= " << A
270  // << " Exc1= " << exc1 << " Exc= " << exc << G4endl;
271  if(exc1 + tolerance < exc || IsInPhysPairs(f1, f2, exc1)) { continue; }
272  G4FermiPair* fpair = new G4FermiPair(f1, f2, exc1);
273  list_p[A].push_back(fpair);
274  (list_c[A])[k]->AddChannel(fpair);
275  isFound = true;
276  }
277  if(isFound) { continue; }
278  kmax = list_g[A].size();
279  for(G4int k=0; k<kmax; ++k) {
280  if(Z != (list_g[A])[k]->GetZ()) { continue; }
281  G4double exc1 = (list_g[A])[k]->GetExcitationEnergy();
282  if(exc1 + tolerance < exc || IsInUnphysPairs(f1, f2, exc)
283  || (list_d[A])[k]->GetNumberOfChannels() > nmin) { continue; }
284  G4FermiPair* fpair = new G4FermiPair(f1, f2, exc);
285  list_u[A].push_back(fpair);
286  (list_d[A])[k]->AddChannel(fpair);
287  }
288  }
289  }
290 
291  // G4cout << "@@@@@@ sec loop @@@@@@" << G4endl;
292  // list of fragment pairs (stable+unstable) ordered by A
293  G4int unphys = funstable.size();
294  for(G4int i=0; i<nfrag; ++i) {
295  const G4FermiFragment* f1 = fragment_pool[i];
296  G4int Z1 = f1->GetZ();
297  G4int A1 = f1->GetA();
298  G4double e1 = f1->GetTotalEnergy();
299  for(G4int j=0; j<unphys; ++j) {
300  const G4FermiFragment* f2 = funstable[j];
301  G4int Z2 = f2->GetZ();
302  G4int A2 = f2->GetA();
303  G4int Z = Z1 + Z2;
304  G4int A = A1 + A2;
305  if(Z >= maxZ || A >= maxA) { continue; }
306  G4double e2 = f2->GetTotalEnergy();
307  G4double minE = e1 + e2;
308  /*
309  G4cout << "Z= " << Z << " A= " << A << " Z1= " << Z1 << " A1= " << A1
310  << " Z2= " << Z2 << " A2= " << A2 << G4endl;
311  */
312 
313  // check if this is the list of stable pairs
314  G4bool isFound = false;
315  G4int kmax = list_f[A].size();
316  for(G4int k=0; k<kmax; ++k) {
317  if(Z != (list_f[A])[k]->GetZ() ||
318  (list_c[A])[k]->GetNumberOfChannels() > 0) { continue; }
319  G4double etot = (list_f[A])[k]->GetTotalEnergy();
320  if(etot + tolerance >= minE) {
321  G4FermiPair* fpair =
322  new G4FermiPair(f1,f2,(list_f[A])[k]->GetExcitationEnergy());
323  list_p[A].push_back(fpair);
324  (list_c[A])[k]->AddChannel(fpair);
325  isFound = true;
326  break;
327  }
328  }
329  if(isFound) { continue; }
330  kmax = list_g[A].size();
331  for(G4int k=0; k<kmax; ++k) {
332  if(Z != (list_g[A])[k]->GetZ()) { continue; }
333  G4double etot = (list_g[A])[k]->GetTotalEnergy();
334  G4double exc = etot - minE;
335  //G4cout << "@@ Exc= " << exc << G4endl;
336  if(exc + tolerance < 0.0 || IsInUnphysPairs(f1, f2, exc)
337  || (list_d[A])[k]->GetNumberOfChannels() > nmin) { continue; }
338  G4FermiPair* fpair = new G4FermiPair(f1, f2, std::max(exc, 0.0));
339  list_u[A].push_back(fpair);
340  (list_d[A])[k]->AddChannel(fpair);
341  }
342  }
343  }
344 
345  // compute static probabilities
346  for(G4int A=1; A<maxA; ++A) {
347  for(size_t j=0; j<list_c[A].size(); ++j) {
348  G4FermiChannels* ch = (list_c[A])[j];
349  const G4FermiFragment* frag = (list_f[A])[j];
350  size_t nch = ch->GetNumberOfChannels();
351  if(1 < nch) {
352  std::vector<G4double>& prob = ch->GetProbabilities();
353  const std::vector<const G4FermiPair*>& pairs = ch->GetChannels();
354  G4double ptot = 0.0;
355  for(size_t i=0; i<nch; ++i) {
356  ptot += theDecay.ComputeProbability(frag->GetZ(), frag->GetA(),
357  frag->GetSpin(),
358  frag->GetTotalEnergy(),
359  pairs[i]->GetFragment1(),
360  pairs[i]->GetFragment2());
361  prob[i] = ptot;
362  }
363  if(0.0 == ptot) {
364  prob[0] = 1.0;
365  } else {
366  ptot = 1./ptot;
367  for(size_t i=0; i<nch-1; ++i) { prob[i] *= ptot; }
368  prob[nch-1] = 1.0;
369  }
370  }
371  }
372  }
373  for(G4int A=1; A<maxA; ++A) {
374  for(size_t j=0; j<list_d[A].size(); ++j) {
375  G4FermiChannels* ch = (list_d[A])[j];
376  const G4FermiFragment* frag = (list_g[A])[j];
377  size_t nch = ch->GetNumberOfChannels();
378  if(1 < nch) {
379  std::vector<G4double>& prob = ch->GetProbabilities();
380  const std::vector<const G4FermiPair*>& pairs = ch->GetChannels();
381  G4double ptot = 0.0;
382  for(size_t i=0; i<nch; ++i) {
383  ptot += theDecay.ComputeProbability(frag->GetZ(), frag->GetA(),
384  frag->GetSpin(),
385  frag->GetTotalEnergy(),
386  pairs[i]->GetFragment1(),
387  pairs[i]->GetFragment2());
388  prob[i] = ptot;
389  }
390  if(0.0 == ptot) {
391  prob[0] = 1.0;
392  } else {
393  ptot = 1./ptot;
394  for(size_t i=0; i<nch-1; ++i) { prob[i] *= ptot; }
395  prob[nch-1] = 1.0;
396  }
397  }
398  }
399  }
400 }
401 
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 }
414 
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 }
540 
G4int GetMinA(G4int Z) const
G4double ComputeProbability(G4int Z, G4int A, G4int spin, G4double TotalE, const G4FermiFragment *f1, const G4FermiFragment *f2) const
static G4double GetNuclearMass(const G4double A, const G4double Z)
G4double GetCoulombBarrier(G4int Ares, G4int Zres, G4double Eex) const
G4int GetSpin(void) const
G4int SpinParity(size_t i) const
const G4FermiFragment * GetFragment2() const
Definition: G4FermiPair.hh:103
static constexpr double keV
const G4LevelManager * GetLevelManager(G4int Z, G4int A)
void DumpFragment(const G4FermiFragment *) const
G4int GetZ(void) const
int G4int
Definition: G4Types.hh:78
const G4FermiChannels * ClosestChannels(G4int Z, G4int A, G4double mass) const
G4bool IsApplicable(G4int ZZ, G4int AA, G4double etot) const
const G4FermiFragment * GetFragment1() const
Definition: G4FermiPair.hh:98
const std::vector< const G4FermiPair * > & GetChannels() const
static const double prec
Definition: RanecuEngine.cc:58
G4float LevelEnergy(size_t i) const
G4GLOB_DLL std::ostream G4cout
double A(double temperature)
bool G4bool
Definition: G4Types.hh:79
static constexpr double MeV
size_t NumberOfTransitions() const
float proton_mass_c2
Definition: hepunit.py:275
G4int GetMaxA(G4int Z) const
G4double GetFragmentMass(void) const
float neutron_mass_c2
Definition: hepunit.py:276
G4int GetA(void) const
T max(const T t1, const T t2)
brief Return the largest of the two arguments
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
static constexpr double GeV
Definition: G4SIunits.hh:217
#define G4endl
Definition: G4ios.hh:61
double G4double
Definition: G4Types.hh:76
G4double GetTotalEnergy(void) const
size_t GetNumberOfChannels() const
std::vector< G4double > & GetProbabilities()
static G4NuclearLevelData * GetInstance()
G4double GetExcitationEnergy(void) const