Geant4  10.02.p02
G4WilsonAblationModel.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 // * *
21 // * Parts of this code which have been developed by QinetiQ Ltd *
22 // * under contract to the European Space Agency (ESA) are the *
23 // * intellectual property of ESA. Rights to use, copy, modify and *
24 // * redistribute this software for general public use are granted *
25 // * in compliance with any licensing, distribution and development *
26 // * policy adopted by the Geant4 Collaboration. This code has been *
27 // * written by QinetiQ Ltd for the European Space Agency, under ESA *
28 // * contract 17191/03/NL/LvH (Aurora Programme). *
29 // * *
30 // * By using, copying, modifying or distributing the software (or *
31 // * any work based on the software) you agree to acknowledge its *
32 // * use in resulting scientific publications, and indicate your *
33 // * acceptance of all terms of the Geant4 Software license. *
34 // ********************************************************************
35 //
36 // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
37 //
38 // MODULE: G4WilsonAblationModel.cc
39 //
40 // Version: 1.0
41 // Date: 08/12/2009
42 // Author: P R Truscott
43 // Organisation: QinetiQ Ltd, UK
44 // Customer: ESA/ESTEC, NOORDWIJK
45 // Contract: 17191/03/NL/LvH
46 //
47 // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
48 //
49 // CHANGE HISTORY
50 // --------------
51 //
52 // 6 October 2003, P R Truscott, QinetiQ Ltd, UK
53 // Created.
54 //
55 // 15 March 2004, P R Truscott, QinetiQ Ltd, UK
56 // Beta release
57 //
58 // 08 December 2009, P R Truscott, QinetiQ Ltd, UK
59 // Ver 1.0
60 // Updated as a result of changes in the G4Evaporation classes. These changes
61 // affect mostly SelectSecondariesByEvaporation, and now you have variables
62 // associated with the evaporation model which can be changed:
63 // OPTxs to select the inverse cross-section
64 // OPTxs = 0 => Dostrovski's parameterization
65 // OPTxs = 1 or 2 => Chatterjee's paramaterization
66 // OPTxs = 3 or 4 => Kalbach's parameterization
67 // useSICB => use superimposed Coulomb Barrier for inverse cross
68 // sections
69 // Other problem found with G4Fragment definition using Lorentz vector and
70 // **G4ParticleDefinition**. This does not allow A and Z to be defined for the
71 // fragment for some reason. Now the fragment is defined more explicitly:
72 // G4Fragment *fragment = new G4Fragment(A, Z, lorentzVector);
73 // to avoid this quirk. Bug found in SelectSecondariesByDefault: *type is now
74 // equated to evapType[i] whereas previously it was equated to fragType[i].
75 //
76 // 06 August 2015, A. Ribon, CERN
77 // Migrated std::exp and std::pow to the faster G4Exp and G4Pow.
78 //
79 // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
81 //
82 #include <iomanip>
83 #include <numeric>
84 
85 #include "G4WilsonAblationModel.hh"
86 #include "G4PhysicalConstants.hh"
87 #include "G4SystemOfUnits.hh"
88 #include "Randomize.hh"
89 #include "G4ParticleTable.hh"
90 #include "G4IonTable.hh"
91 #include "G4Alpha.hh"
92 #include "G4He3.hh"
93 #include "G4Triton.hh"
94 #include "G4Deuteron.hh"
95 #include "G4Proton.hh"
96 #include "G4Neutron.hh"
103 #include "G4PhotonEvaporation.hh"
104 #include "G4LorentzVector.hh"
105 #include "G4VEvaporationChannel.hh"
106 
107 #include "G4Exp.hh"
108 #include "G4Pow.hh"
109 
110 
112 //
114 {
115 //
116 //
117 // Send message to stdout to advise that the G4Abrasion model is being used.
118 //
120 //
121 //
122 // Set the default verbose level to 0 - no output.
123 //
124  verboseLevel = 0;
125 //
126 //
127 // Set the binding energy per nucleon .... did I mention that this is a crude
128 // model for nuclear de-excitation?
129 //
130  B = 10.0 * MeV;
131 //
132 //
133 // It is possuble to switch off secondary particle production (other than the
134 // final nuclear fragment). The default is on.
135 //
136  produceSecondaries = true;
137 //
138 //
139 // Now we need to define the decay modes. We're using the G4Evaporation model
140 // to help determine the kinematics of the decay.
141 //
142  nFragTypes = 6;
143  fragType[0] = G4Alpha::Alpha();
144  fragType[1] = G4He3::He3();
145  fragType[2] = G4Triton::Triton();
147  fragType[4] = G4Proton::Proton();
149  for(G4int i=0; i<200; ++i) { fSig[i] = 0.0; }
150 //
151 //
152 // Set verboseLevel default to no output.
153 //
154  verboseLevel = 0;
157 //
158 //
159 // Set defaults for evaporation classes. These can be overridden by user
160 // "set" methods.
161 //
162  OPTxs = 3;
163  useSICB = false;
164  fragmentVector = 0;
165 }
167 //
169 {}
170 
172 //
174  (const G4Fragment &theNucleus)
175 {
176 //
177 //
178 // Initilise the pointer to the G4FragmentVector used to return the information
179 // about the breakup.
180 //
181  fragmentVector = new G4FragmentVector;
182  fragmentVector->clear();
183 //
184 //
185 // Get the A, Z and excitation of the nucleus.
186 //
187  G4int A = theNucleus.GetA_asInt();
188  G4int Z = theNucleus.GetZ_asInt();
189  G4double ex = theNucleus.GetExcitationEnergy();
190  if (verboseLevel >= 2)
191  {
192  G4cout <<"oooooooooooooooooooooooooooooooooooooooo"
193  <<"oooooooooooooooooooooooooooooooooooooooo"
194  <<G4endl;
195  G4cout.precision(6);
196  G4cout <<"IN G4WilsonAblationModel" <<G4endl;
197  G4cout <<"Initial prefragment A=" <<A
198  <<", Z=" <<Z
199  <<", excitation energy = " <<ex/MeV <<" MeV"
200  <<G4endl;
201  }
202 //
203 //
204 // Check that there is a nucleus to speak of. It's possible there isn't one
205 // or its just a proton or neutron. In either case, the excitation energy
206 // (from the Lorentz vector) is not used.
207 //
208  if (A == 0)
209  {
210  if (verboseLevel >= 2)
211  {
212  G4cout <<"No nucleus to decay" <<G4endl;
213  G4cout <<"oooooooooooooooooooooooooooooooooooooooo"
214  <<"oooooooooooooooooooooooooooooooooooooooo"
215  <<G4endl;
216  }
217  return fragmentVector;
218  }
219  else if (A == 1)
220  {
221  G4LorentzVector lorentzVector = theNucleus.GetMomentum();
222  lorentzVector.setE(lorentzVector.e()-ex+10.0*eV);
223  if (Z == 0)
224  {
225  G4Fragment *fragment = new G4Fragment(lorentzVector,G4Neutron::Neutron());
226  fragmentVector->push_back(fragment);
227  }
228  else
229  {
230  G4Fragment *fragment = new G4Fragment(lorentzVector,G4Proton::Proton());
231  fragmentVector->push_back(fragment);
232  }
233  if (verboseLevel >= 2)
234  {
235  G4cout <<"Final fragment is in fact only a nucleon) :" <<G4endl;
236  G4cout <<(*fragmentVector)[0] <<G4endl;
237  G4cout <<"oooooooooooooooooooooooooooooooooooooooo"
238  <<"oooooooooooooooooooooooooooooooooooooooo"
239  <<G4endl;
240  }
241  return fragmentVector;
242  }
243 //
244 //
245 // Then the number of nucleons ablated (either as nucleons or light nuclear
246 // fragments) is based on a simple argument for the binding energy per nucleon.
247 //
248  G4int DAabl = (G4int) (ex / B);
249  if (DAabl > A) DAabl = A;
250 // The following lines are no longer accurate given we now treat the final fragment
251 // if (verboseLevel >= 2)
252 // G4cout <<"Number of nucleons ejected = " <<DAabl <<G4endl;
253 
254 //
255 //
256 // Determine the nuclear fragment from the ablation process by sampling the
257 // Rudstam equation.
258 //
259  G4int AF = A - DAabl;
260  G4int ZF = 0;
261 
262  if (AF > 0)
263  {
264  G4Pow* g4pow = G4Pow::GetInstance();
265  G4double AFd = (G4double) AF;
266  G4double R = 11.8 / g4pow->powZ(AF, 0.45);
267  G4int minZ = std::max(1, Z - DAabl);
268 //
269 //
270 // Here we define an integral probability distribution based on the Rudstam
271 // equation assuming a constant AF.
272 //
273  G4int zmax = std::min(199, Z);
274  G4double sum = 0.0;
275  for (ZF=minZ; ZF<=zmax; ++ZF)
276  {
277  sum += G4Exp(-R*g4pow->powA(std::abs(ZF - 0.486*AFd + 3.8E-04*AFd*AFd),1.5));
278  fSig[ZF] = sum;
279  }
280 //
281 //
282 // Now sample that distribution to determine a value for ZF.
283 //
284  sum *= G4UniformRand();
285  for (ZF=minZ; ZF<=zmax; ++ZF) {
286  if(sum <= fSig[ZF]) { break; }
287  }
288  }
289  G4int DZabl = Z - ZF;
290 //
291 //
292 // Now determine the nucleons or nuclei which have bee ablated. The preference
293 // is for the production of alphas, then other nuclei in order of decreasing
294 // binding energy. The energies assigned to the products of the decay are
295 // provisional for the moment (the 10eV is just to avoid errors with negative
296 // excitation energies due to rounding).
297 //
298  G4double totalEpost = 0.0;
299  evapType.clear();
300  for (G4int ift=0; ift<nFragTypes; ift++)
301  {
302  G4ParticleDefinition *type = fragType[ift];
303  G4double n = std::floor((G4double) DAabl / type->GetBaryonNumber() + 1.0E-10);
304  G4double n1 = 1.0E+10;
305  if (fragType[ift]->GetPDGCharge() > 0.0)
306  n1 = std::floor((G4double) DZabl / type->GetPDGCharge() + 1.0E-10);
307  if (n > n1) n = n1;
308  if (n > 0.0)
309  {
310  G4double mass = type->GetPDGMass();
311  for (G4int j=0; j<(G4int) n; j++)
312  {
313  totalEpost += mass;
314  evapType.push_back(type);
315  }
316  DAabl -= (G4int) (n * type->GetBaryonNumber() + 1.0E-10);
317  DZabl -= (G4int) (n * type->GetPDGCharge() + 1.0E-10);
318  }
319  }
320 //
321 //
322 // Determine the properties of the final nuclear fragment. Note that if
323 // the final fragment is predicted to have a nucleon number of zero, then
324 // really it's the particle last in the vector evapType which becomes the
325 // final fragment. Therefore delete this from the vector if this is the
326 // case.
327 //
328  G4double massFinalFrag = 0.0;
329  if (AF > 0)
330  massFinalFrag = G4ParticleTable::GetParticleTable()->GetIonTable()->
331  GetIonMass(ZF,AF);
332  else
333  {
334  G4ParticleDefinition *type = evapType[evapType.size()-1];
335  AF = type->GetBaryonNumber();
336  ZF = (G4int) (type->GetPDGCharge() + 1.0E-10);
337  evapType.erase(evapType.end()-1);
338  }
339  totalEpost += massFinalFrag;
340 //
341 //
342 // Provide verbose output on the nuclear fragment if requested.
343 //
344  if (verboseLevel >= 2)
345  {
346  G4cout <<"Final fragment A=" <<AF
347  <<", Z=" <<ZF
348  <<G4endl;
349  for (G4int ift=0; ift<nFragTypes; ift++)
350  {
351  G4ParticleDefinition *type = fragType[ift];
352  G4int n = std::count(evapType.begin(),evapType.end(),type);
353  if (n > 0)
354  G4cout <<"Particle type: " <<std::setw(10) <<type->GetParticleName()
355  <<", number of particles emitted = " <<n <<G4endl;
356  }
357  }
358 //
359 // Add the total energy from the fragment. Note that the fragment is assumed
360 // to be de-excited and does not undergo photo-evaporation .... I did mention
361 // this is a bit of a crude model?
362 //
363  G4double massPreFrag = theNucleus.GetGroundStateMass();
364  G4double totalEpre = massPreFrag + ex;
365  G4double excess = totalEpre - totalEpost;
366 // G4Fragment *resultNucleus(theNucleus);
367  G4Fragment *resultNucleus = new G4Fragment(A, Z, theNucleus.GetMomentum());
368  G4ThreeVector boost(0.0,0.0,0.0);
369  G4int nEvap = 0;
370  if (produceSecondaries && evapType.size()>0)
371  {
372  if (excess > 0.0)
373  {
374  SelectSecondariesByEvaporation (resultNucleus);
375  nEvap = fragmentVector->size();
376  boost = resultNucleus->GetMomentum().findBoostToCM();
377  if (evapType.size() > 0)
378  SelectSecondariesByDefault (boost);
379  }
380  else
381  SelectSecondariesByDefault(G4ThreeVector(0.0,0.0,0.0));
382  }
383 
384  if (AF > 0)
385  {
387  GetIonMass(ZF,AF);
388  G4double e = mass + 10.0*eV;
389  G4double p = std::sqrt(e*e-mass*mass);
390  G4ThreeVector direction(0.0,0.0,1.0);
391  G4LorentzVector lorentzVector = G4LorentzVector(direction*p, e);
392  lorentzVector.boost(-boost);
393  G4Fragment* frag = new G4Fragment(AF, ZF, lorentzVector);
394  fragmentVector->push_back(frag);
395  }
396  delete resultNucleus;
397 //
398 //
399 // Provide verbose output on the ablation products if requested.
400 //
401  if (verboseLevel >= 2)
402  {
403  if (nEvap > 0)
404  {
405  G4cout <<"----------------------" <<G4endl;
406  G4cout <<"Evaporated particles :" <<G4endl;
407  G4cout <<"----------------------" <<G4endl;
408  }
409  G4int ie = 0;
410  G4FragmentVector::iterator iter;
411  for (iter = fragmentVector->begin(); iter != fragmentVector->end(); iter++)
412  {
413  if (ie == nEvap)
414  {
415 // G4cout <<*iter <<G4endl;
416  G4cout <<"---------------------------------" <<G4endl;
417  G4cout <<"Particles from default emission :" <<G4endl;
418  G4cout <<"---------------------------------" <<G4endl;
419  }
420  G4cout <<*iter <<G4endl;
421  }
422  G4cout <<"oooooooooooooooooooooooooooooooooooooooo"
423  <<"oooooooooooooooooooooooooooooooooooooooo"
424  <<G4endl;
425  }
426 
427  return fragmentVector;
428 }
430 //
432  (G4Fragment *intermediateNucleus)
433 {
434  G4Fragment theResidualNucleus = *intermediateNucleus;
435  G4bool evaporate = true;
436  // Loop checking, 05-Aug-2015, Vladimir Ivanchenko
437  while (evaporate && evapType.size() != 0)
438  {
439 //
440 //
441 // Here's the cheaky bit. We're hijacking the G4Evaporation model, in order to
442 // more accurately sample to kinematics, but the species of the nuclear
443 // fragments will be the ones of our choosing as above.
444 //
445  std::vector <G4VEvaporationChannel*> theChannels1;
446  theChannels1.clear();
447  std::vector <G4VEvaporationChannel*>::iterator i;
448  VectorOfFragmentTypes::iterator iter;
449  std::vector <VectorOfFragmentTypes::iterator> iters;
450  iters.clear();
451  iter = std::find(evapType.begin(), evapType.end(), G4Alpha::Alpha());
452  if (iter != evapType.end())
453  {
454  theChannels1.push_back(new G4AlphaEvaporationChannel);
455  i = theChannels1.end() - 1;
456  (*i)->SetOPTxs(OPTxs);
457  (*i)->UseSICB(useSICB);
458 // (*i)->Initialize(theResidualNucleus);
459  iters.push_back(iter);
460  }
461  iter = std::find(evapType.begin(), evapType.end(), G4He3::He3());
462  if (iter != evapType.end())
463  {
464  theChannels1.push_back(new G4He3EvaporationChannel);
465  i = theChannels1.end() - 1;
466  (*i)->SetOPTxs(OPTxs);
467  (*i)->UseSICB(useSICB);
468 // (*i)->Initialize(theResidualNucleus);
469  iters.push_back(iter);
470  }
471  iter = std::find(evapType.begin(), evapType.end(), G4Triton::Triton());
472  if (iter != evapType.end())
473  {
474  theChannels1.push_back(new G4TritonEvaporationChannel);
475  i = theChannels1.end() - 1;
476  (*i)->SetOPTxs(OPTxs);
477  (*i)->UseSICB(useSICB);
478 // (*i)->Initialize(theResidualNucleus);
479  iters.push_back(iter);
480  }
481  iter = std::find(evapType.begin(), evapType.end(), G4Deuteron::Deuteron());
482  if (iter != evapType.end())
483  {
484  theChannels1.push_back(new G4DeuteronEvaporationChannel);
485  i = theChannels1.end() - 1;
486  (*i)->SetOPTxs(OPTxs);
487  (*i)->UseSICB(useSICB);
488 // (*i)->Initialize(theResidualNucleus);
489  iters.push_back(iter);
490  }
491  iter = std::find(evapType.begin(), evapType.end(), G4Proton::Proton());
492  if (iter != evapType.end())
493  {
494  theChannels1.push_back(new G4ProtonEvaporationChannel);
495  i = theChannels1.end() - 1;
496  (*i)->SetOPTxs(OPTxs);
497  (*i)->UseSICB(useSICB);
498 // (*i)->Initialize(theResidualNucleus);
499  iters.push_back(iter);
500  }
501  iter = std::find(evapType.begin(), evapType.end(), G4Neutron::Neutron());
502  if (iter != evapType.end())
503  {
504  theChannels1.push_back(new G4NeutronEvaporationChannel);
505  i = theChannels1.end() - 1;
506  (*i)->SetOPTxs(OPTxs);
507  (*i)->UseSICB(useSICB);
508 // (*i)->Initialize(theResidualNucleus);
509  iters.push_back(iter);
510  }
511  G4int nChannels = theChannels1.size();
512 
513  G4double totalProb = 0.0;
514  G4int ich = 0;
515  G4double probEvapType[6] = {0.0};
516  std::vector<G4VEvaporationChannel*>::iterator iterEv;
517  for (iterEv=theChannels1.begin(); iterEv!=theChannels1.end(); iterEv++) {
518  totalProb += (*iterEv)->GetEmissionProbability(intermediateNucleus);
519  probEvapType[ich] = totalProb;
520  ++ich;
521  }
522  if (totalProb > 0.0) {
523 //
524 //
525 // The emission probability for at least one of the evaporation channels is
526 // positive, therefore work out which one should be selected and decay
527 // the nucleus.
528 //
529  G4double xi = totalProb*G4UniformRand();
530  G4int ii = 0;
531  for (ii=0; ii<nChannels; ii++) {
532  if (xi < probEvapType[ii]) { break; }
533  }
534  if (ii >= nChannels) { ii = nChannels - 1; }
535  G4FragmentVector *evaporationResult = theChannels1[ii]->
536  BreakUp(*intermediateNucleus);
537  fragmentVector->push_back((*evaporationResult)[0]);
538  *intermediateNucleus = *(*evaporationResult)[1];
539  //delete evaporationResult->back();
540  delete evaporationResult;
541  //evapType.erase(iters[ii]);
542  }
543  else
544  {
545 //
546 //
547 // Probability for further evaporation is nil so have to escape from this
548 // routine and set the energies of the secondaries to 10eV.
549 //
550  evaporate = false;
551  }
552  }
553 
554  return;
555 }
557 //
559 {
560  for (unsigned i=0; i<evapType.size(); i++)
561  {
562  G4ParticleDefinition *type = evapType[i];
563  G4double mass = type->GetPDGMass();
564  G4double e = mass + 10.0*eV;
565  G4double p = std::sqrt(e*e-mass*mass);
566  G4double costheta = 2.0*G4UniformRand() - 1.0;
567  G4double sintheta = std::sqrt((1.0 - costheta)*(1.0 + costheta));
568  G4double phi = twopi * G4UniformRand() * rad;
569  G4ThreeVector direction(sintheta*std::cos(phi),sintheta*std::sin(phi),costheta);
570  G4LorentzVector lorentzVector = G4LorentzVector(direction*p, e);
571  lorentzVector.boost(-boost);
572 // Possibility that the following line is not correctly carrying over A and Z
573 // from particle definition. Force values. PRT 03/12/2009.
574 // G4Fragment *fragment =
575 // new G4Fragment(lorentzVector, type);
576  G4int A = type->GetBaryonNumber();
577  G4int Z = (G4int) (type->GetPDGCharge() + 1.0E-10);
578  G4Fragment *fragment =
579  new G4Fragment(A, Z, lorentzVector);
580 
581  fragmentVector->push_back(fragment);
582  }
583 }
585 //
587 {
588  G4cout <<G4endl;
589  G4cout <<" *****************************************************************"
590  <<G4endl;
591  G4cout <<" Nuclear ablation model for nuclear-nuclear interactions activated"
592  <<G4endl;
593  G4cout <<" (Written by QinetiQ Ltd for the European Space Agency)"
594  <<G4endl;
595  G4cout <<" !!! WARNING: This model is not well validation and should not be used for accurate simulation !!!"
596  <<G4endl;
597  G4cout <<" *****************************************************************"
598  <<G4endl;
599  G4cout << G4endl;
600 
601  return;
602 }
604 //
static G4Pow * GetInstance()
Definition: G4Pow.cc:55
G4double powA(G4double A, G4double y) const
Definition: G4Pow.hh:259
virtual std::vector< G4VEvaporationChannel * > * GetChannel()=0
static const double MeV
Definition: G4SIunits.hh:211
void SelectSecondariesByDefault(G4ThreeVector)
VectorOfFragmentTypes evapType
CLHEP::Hep3Vector G4ThreeVector
Definition: G4Pow.hh:56
G4ParticleDefinition * fragType[6]
double B(double temperature)
void SelectSecondariesByEvaporation(G4Fragment *)
int G4int
Definition: G4Types.hh:78
const G4String & GetParticleName() const
std::vector< G4VEvaporationChannel * > * theChannels
G4IonTable * GetIonTable() const
#define G4UniformRand()
Definition: Randomize.hh:97
G4GLOB_DLL std::ostream G4cout
double A(double temperature)
G4int GetA_asInt() const
Definition: G4Fragment.hh:256
bool G4bool
Definition: G4Types.hh:79
const G4LorentzVector & GetMomentum() const
Definition: G4Fragment.hh:289
static const double twopi
Definition: G4SIunits.hh:75
std::vector< G4Fragment * > G4FragmentVector
Definition: G4Fragment.hh:63
static G4Triton * Triton()
Definition: G4Triton.cc:95
static G4Proton * Proton()
Definition: G4Proton.cc:93
G4double GetGroundStateMass() const
Definition: G4Fragment.hh:278
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104
const G4int n
static G4Deuteron * Deuteron()
Definition: G4Deuteron.cc:94
static const double rad
Definition: G4SIunits.hh:148
G4double G4Exp(G4double initial_x)
Exponential Function double precision.
Definition: G4Exp.hh:183
static const double eV
Definition: G4SIunits.hh:212
G4double GetPDGMass() const
static G4ParticleTable * GetParticleTable()
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
G4int GetZ_asInt() const
Definition: G4Fragment.hh:261
#define G4endl
Definition: G4ios.hh:61
static G4Alpha * Alpha()
Definition: G4Alpha.cc:89
G4double powZ(G4int Z, G4double y) const
Definition: G4Pow.hh:254
double G4double
Definition: G4Types.hh:76
G4double GetPDGCharge() const
G4VEvaporationFactory * theChannelFactory
static G4He3 * He3()
Definition: G4He3.cc:94
G4FragmentVector * fragmentVector
G4double GetExcitationEnergy() const
Definition: G4Fragment.hh:273
CLHEP::HepLorentzVector G4LorentzVector
G4FragmentVector * BreakItUp(const G4Fragment &theNucleus)