Geant4-11
Public Member Functions | Protected Member Functions | Protected Attributes | Private Member Functions | Private Attributes
G4EquilibriumEvaporator Class Reference

#include <G4EquilibriumEvaporator.hh>

Inheritance diagram for G4EquilibriumEvaporator:
G4CascadeDeexciteBase G4VCascadeDeexcitation G4VCascadeCollider

Public Member Functions

virtual void collide (G4InuclParticle *bullet, G4InuclParticle *target, G4CollisionOutput &globalOutput)
 
virtual void deExcite (const G4Fragment &target, G4CollisionOutput &output)
 
 G4EquilibriumEvaporator ()
 
virtual void setVerboseLevel (G4int verbose)
 
virtual ~G4EquilibriumEvaporator ()
 

Protected Member Functions

void getTargetData (const G4Fragment &target)
 
const G4Fragment & makeFragment (G4int A, G4int Z, G4double EX=0.)
 
const G4Fragment & makeFragment (G4LorentzVector mom, G4int A, G4int Z, G4double EX=0.)
 
virtual void setName (const G4String &name)
 
virtual G4bool validateOutput (const G4Fragment &target, const std::vector< G4InuclElementaryParticle > &particles)
 
virtual G4bool validateOutput (const G4Fragment &target, const std::vector< G4InuclNuclei > &fragments)
 
virtual G4bool validateOutput (const G4Fragment &target, G4CollisionOutput &output)
 

Protected Attributes

G4int A
 
G4Fragment aFragment
 
G4CascadeCheckBalance * balance
 
G4double EEXS
 
G4LorentzVector PEX
 
G4String theName
 
G4int verboseLevel
 
G4int Z
 

Private Member Functions

virtual G4bool explosion (const G4Fragment &target) const
 
virtual G4bool explosion (G4int a, G4int z, G4double e) const
 
 G4EquilibriumEvaporator (const G4EquilibriumEvaporator &)
 
G4double getAF (G4double x, G4int a, G4int z, G4double e) const
 
G4double getE0 (G4int A) const
 
G4double getPARLEVDEN (G4int A, G4int Z) const
 
G4double getQF (G4double x, G4double x2, G4int a, G4int z, G4double e) const
 
G4bool goodRemnant (G4int a, G4int z) const
 
G4EquilibriumEvaporator & operator= (const G4EquilibriumEvaporator &)
 

Private Attributes

G4CollisionOutput fission_output
 
std::pair< std::vector< G4double >, std::vector< G4double > > parms
 
G4CascadeInterpolator< 72 > QFinterp
 
G4BigBanger theBigBanger
 
G4Fissioner theFissioner
 
G4InuclSpecialFunctions::paraMaker theParaMaker
 

Detailed Description

Definition at line 57 of file G4EquilibriumEvaporator.hh.

Constructor & Destructor Documentation

◆ G4EquilibriumEvaporator() [1/2]

G4EquilibriumEvaporator::G4EquilibriumEvaporator ( )

Definition at line 152 of file G4EquilibriumEvaporator.cc.

153 : G4CascadeDeexciteBase("G4EquilibriumEvaporator"),
154 theParaMaker(verboseLevel), QFinterp(XREP) {
155 parms.first.resize(6,0.);
156 parms.second.resize(6,0.);
157}
G4CascadeDeexciteBase::G4CascadeDeexciteBase
G4CascadeDeexciteBase(const char *name)
Definition: G4CascadeDeexciteBase.cc:48
G4EquilibriumEvaporator::parms
std::pair< std::vector< G4double >, std::vector< G4double > > parms
Definition: G4EquilibriumEvaporator.hh:84
G4EquilibriumEvaporator::QFinterp
G4CascadeInterpolator< 72 > QFinterp
Definition: G4EquilibriumEvaporator.hh:88
G4EquilibriumEvaporator::theParaMaker
G4InuclSpecialFunctions::paraMaker theParaMaker
Definition: G4EquilibriumEvaporator.hh:77
anonymous_namespace{G4EquilibriumEvaporator.cc}::XREP
static const G4double XREP[72]
Definition: G4EquilibriumEvaporator.cc:126

References parms.

◆ ~G4EquilibriumEvaporator()

G4EquilibriumEvaporator::~G4EquilibriumEvaporator ( )
virtual

Definition at line 159 of file G4EquilibriumEvaporator.cc.

159{}

◆ G4EquilibriumEvaporator() [2/2]

G4EquilibriumEvaporator::G4EquilibriumEvaporator ( const G4EquilibriumEvaporator &  )
private

Member Function Documentation

◆ collide()

void G4VCascadeDeexcitation::collide ( G4InuclParticle *  bullet,
G4InuclParticle *  target,
G4CollisionOutput &  globalOutput 
)
virtualinherited

Implements G4VCascadeCollider.

Definition at line 37 of file G4VCascadeDeexcitation.cc.

39 {
40 if (verboseLevel) {
41 G4cout << " >>> G4VCascadeDeexcitation[" << theName << "]::collide "
42 << " *** SHOULD NOT BE CALLED ***" << G4endl;
43 }
44
45 throw G4HadronicException(__FILE__, __LINE__,
46 "G4VCascadeDeexcitation::collide() invalid, must use ::deExcite(G4Fagment*)");
47}
G4endl
#define G4endl
Definition: G4ios.hh:57
G4cout
G4GLOB_DLL std::ostream G4cout

References G4cout, G4endl, G4VCascadeCollider::theName, and G4VCascadeCollider::verboseLevel.

Referenced by G4InuclEvaporation::BreakItUp().

◆ deExcite()

void G4EquilibriumEvaporator::deExcite ( const G4Fragment &  target,
G4CollisionOutput &  output 
)
virtual

Implements G4VCascadeDeexcitation.

Definition at line 170 of file G4EquilibriumEvaporator.cc.

171 {
172 if (verboseLevel) {
173 G4cout << " >>> G4EquilibriumEvaporator::deExcite" << G4endl;
174 }
175
176 if (verboseLevel>1) G4cout << " evaporating target: \n" << target << G4endl;
177
178 // Implementation of the equilibium evaporation according to Dostrovsky
179 // (Phys. Rev. 116 (1959) 683.
180 // Note that pairing energy which is of order 1 MeV for odd-even and even-odd
181 // nuclei is not included
182
183 // Element in array: 0 : neutron
184 // 1 : proton
185 // 2 : deuteron
186 // 3 : triton
187 // 4 : 3He
188 // 5 : alpha
189
190 const G4double huge_num = 50.0;
191 const G4double small = -50.0;
192 const G4double prob_cut_off = 1.0e-15;
193 const G4double Q1[6] = { 0.0, 0.0, 2.23, 8.49, 7.72, 28.3 }; // binding energy
194 const G4int AN[6] = { 1, 1, 2, 3, 3, 4 }; // mass number
195 const G4int Q[6] = { 0, 1, 1, 1, 2, 2 }; // charge
196 const G4double G[6] = { 2.0, 2.0, 6.0, 6.0, 6.0, 4.0 };
197 const G4double BE = 0.0063;
198 const G4double fisssion_cut = 1000.0;
199 const G4double cut_off_energy = 0.1;
200
201 const G4double BF = 0.0242;
202 const G4int itry_max = 1000;
203 const G4int itry_global_max = 1000;
204 const G4double small_ekin = 1.0e-6;
205 const G4int itry_gam_max = 100;
206
207 G4double W[8];
208 G4double u[6]; // Level density for each particle type: (Atarg - Aemitted)*parlev
209 G4double V[6]; // Coulomb energy
210 G4double TM[6]; // Maximum possible kinetic energy of emitted particle
211 G4int A1[6]; // A of remnant nucleus
212 G4int Z1[6]; // Z of remnant nucleus
213
214 getTargetData(target);
215 if (verboseLevel > 3) G4cout << " after noeq: eexs " << EEXS << G4endl;
216
217 G4InuclElementaryParticle dummy(small_ekin, proton);
218 G4LorentzConvertor toTheNucleiSystemRestFrame;
219 //*** toTheNucleiSystemRestFrame.setVerbose(verboseLevel);
220 toTheNucleiSystemRestFrame.setBullet(dummy);
221
222 G4LorentzVector ppout;
223
224 // See if fragment should just be dispersed
225 if (explosion(A, Z, EEXS)) {
226 if (verboseLevel > 1) G4cout << " big bang in eql start " << G4endl;
227 theBigBanger.deExcite(target, output);
228
229 validateOutput(target, output); // Check energy conservation
230 return;
231 }
232
233 // If nucleus is in ground state, no evaporation
234 if (EEXS < cut_off_energy) {
235 if (verboseLevel > 1) G4cout << " no energy for evaporation" << G4endl;
236 output.addRecoilFragment(target);
237
238 validateOutput(target, output); // Check energy conservation
239 return;
240 }
241
242 // Initialize evaporation attempts
243 G4double coul_coeff = (A >= 100.0) ? 1.4 : 1.2;
244
245 G4LorentzVector pin = PEX; // Save original target for testing
246
247 G4bool try_again = true;
248 G4bool fission_open = true;
249 G4int itry_global = 0;
250
251 /* Loop checking 08.06.2015 MHK */
252 while (try_again && itry_global < itry_global_max) {
253 itry_global++;
254
255 // Set rest frame of current (recoiling) nucleus
256 toTheNucleiSystemRestFrame.setTarget(PEX);
257 toTheNucleiSystemRestFrame.toTheTargetRestFrame();
258
259 if (verboseLevel > 2) {
260 G4double nuc_mass = G4InuclNuclei::getNucleiMass(A, Z, EEXS);
261 G4cout << " A " << A << " Z " << Z << " mass " << nuc_mass
262 << " EEXS " << EEXS << G4endl;
263 }
264
265 if (explosion(A, Z, EEXS)) { // big bang
266 if (verboseLevel > 2)
267 G4cout << " big bang in eql step " << itry_global << G4endl;
268
269 theBigBanger.deExcite(makeFragment(PEX,A,Z,EEXS), output);
270
271 validateOutput(target, output); // Check energy conservation
272 return;
273 }
274
275 if (EEXS < cut_off_energy) { // Evaporation not possible
276 if (verboseLevel > 2)
277 G4cout << " no energy for evaporation in eql step " << itry_global
278 << G4endl;
279
280 try_again = false;
281 break;
282 }
283
284 // Normal evaporation chain
285 G4double E0 = getE0(A);
286 G4double parlev = getPARLEVDEN(A, Z);
287 G4double u1 = parlev * A;
288
289 theParaMaker.getParams(Z, parms);
290 const std::vector<G4double>& AK = parms.first;
291 const std::vector<G4double>& CPA = parms.second;
292
293 G4double DM0 = bindingEnergy(A,Z);
294 G4int i(0);
295
296 for (i = 0; i < 6; i++) {
297 A1[i] = A - AN[i];
298 Z1[i] = Z - Q[i];
299 u[i] = parlev * A1[i];
300 V[i] = 0.0;
301 TM[i] = -0.1;
302
303 if (goodRemnant(A1[i], Z1[i])) {
304 G4double QB = DM0 - bindingEnergy(A1[i],Z1[i]) - Q1[i];
305 V[i] = coul_coeff * Z * Q[i] * AK[i] / (1.0 + EEXS / E0) /
306 (G4cbrt(A1[i]) + G4cbrt(AN[i]));
307 TM[i] = EEXS - QB - V[i] * A / A1[i];
308 if (verboseLevel > 3) {
309 G4cout << " i=" << i << " : QB " << QB << " u " << u[i]
310 << " V " << V[i] << " TM " << TM[i] << G4endl;
311 }
312 }
313 }
314
315 G4double ue = 2.0 * std::sqrt(u1 * EEXS);
316 G4double prob_sum = 0.0;
317
318 W[0] = 0.0;
319 if (TM[0] > cut_off_energy) {
320 G4double AL = getAL(A);
321 G4double A13 = G4cbrt(A1[0]);
322 W[0] = BE * A13*A13 * G[0] * AL;
323 G4double TM1 = 2.0 * std::sqrt(u[0] * TM[0]) - ue;
324
325 if (TM1 > huge_num) TM1 = huge_num;
326 else if (TM1 < small) TM1 = small;
327
328 W[0] *= G4Exp(TM1);
329 prob_sum += W[0];
330 }
331
332 for (i = 1; i < 6; i++) {
333 W[i] = 0.0;
334 if (TM[i] > cut_off_energy) {
335 G4double A13 = G4cbrt(A1[i]);
336 W[i] = BE * A13*A13 * G[i] * (1.0 + CPA[i]);
337 G4double TM1 = 2.0 * std::sqrt(u[i] * TM[i]) - ue;
338
339 if (TM1 > huge_num) TM1 = huge_num;
340 else if (TM1 < small) TM1 = small;
341
342 W[i] *= G4Exp(TM1);
343 prob_sum += W[i];
344 }
345 }
346
347 // fisson part
348 W[6] = 0.0;
349 if (A >= 100.0 && fission_open) {
350 G4double X2 = Z * Z / A;
351 G4double X1 = 1.0 - 2.0 * Z / A;
352 G4double X = 0.019316 * X2 / (1.0 - 1.79 * X1 * X1);
353 G4double EF = EEXS - getQF(X, X2, A, Z, EEXS);
354
355 if (EF > 0.0) {
356 G4double AF = u1 * getAF(X, A, Z, EEXS);
357 G4double TM1 = 2.0 * std::sqrt(AF * EF) - ue;
358
359 if (TM1 > huge_num) TM1 = huge_num;
360 else if (TM1 < small) TM1 = small;
361
362 W[6] = BF * G4Exp(TM1);
363 if (W[6] > fisssion_cut*W[0]) W[6] = fisssion_cut*W[0];
364
365 prob_sum += W[6];
366 }
367 }
368
369 // again time to decide what next
370 if (verboseLevel > 2) {
371 G4cout << " Evaporation probabilities: sum = " << prob_sum
372 << "\n\t n " << W[0] << " p " << W[1] << " d " << W[2]
373 << " He3 " << W[3] << "\n\t t " << W[4] << " alpha " << W[5]
374 << " fission " << W[6] << G4endl;
375 }
376
377 G4int icase = -1;
378
379 if (prob_sum < prob_cut_off) { // photon emission chain
380 G4double UCR0 = 2.5 + 150.0 / A;
381 G4double T00 = 1.0 / (std::sqrt(u1 / UCR0) - 1.25 / UCR0);
382
383 if (verboseLevel > 3)
384 G4cout << " UCR0 " << UCR0 << " T00 " << T00 << G4endl;
385
386 G4int itry_gam = 0;
387 while (EEXS > cut_off_energy && try_again) {
388 itry_gam++;
389 G4int itry = 0;
390 G4double T04 = 4.0 * T00;
391 G4double FMAX;
392
393 if (T04 < EEXS) {
394 FMAX = (T04*T04*T04*T04) * G4Exp((EEXS - T04) / T00);
395 } else {
396 FMAX = EEXS*EEXS*EEXS*EEXS;
397 };
398
399 if (verboseLevel > 3)
400 G4cout << " T04 " << T04 << " FMAX (EEXS^4) " << FMAX << G4endl;
401
402 G4double S(0), X1(0);
403 while (itry < itry_max) {
404 itry++;
405 S = EEXS * inuclRndm();
406 X1 = (S*S*S*S) * G4Exp((EEXS - S) / T00);
407
408 if (X1 > FMAX * inuclRndm()) break;
409 };
410
411 if (itry == itry_max) { // Maximum attempts exceeded
412 try_again = false;
413 break;
414 }
415
416 if (verboseLevel > 2) G4cout << " photon escape ?" << G4endl;
417
418 if (S < EEXS) { // Valid evaporate
419 S /= GeV; // Convert to Bertini units
420
421 G4double pmod = S;
422 G4LorentzVector mom = generateWithRandomAngles(pmod, 0.);
423
424 // Push evaporated particle into current rest frame
425 mom = toTheNucleiSystemRestFrame.backToTheLab(mom);
426
427 if (verboseLevel > 3) {
428 G4cout << " nucleus px " << PEX.px() << " py " << PEX.py()
429 << " pz " << PEX.pz() << " E " << PEX.e() << G4endl
430 << " evaporate px " << mom.px() << " py " << mom.py()
431 << " pz " << mom.pz() << " E " << mom.e() << G4endl;
432 }
433
434 PEX -= mom; // Remaining four-momentum
435 EEXS -= S*GeV; // New excitation energy (in MeV)
436
437 // NOTE: In-situ construction will be optimized away (no copying)
438 output.addOutgoingParticle(G4InuclElementaryParticle(mom, photon,
439 G4InuclParticle::Equilib));
440
441 if (verboseLevel > 3)
442 G4cout << output.getOutgoingParticles().back() << G4endl;
443
444 ppout += mom;
445 } else {
446 if (itry_gam == itry_gam_max) try_again = false;
447 }
448 } // while (EEXS > cut_off
449 try_again = false;
450 } else { // if (prob_sum < prob_cut_off)
451 G4double SL = prob_sum * inuclRndm();
452 if (verboseLevel > 3) G4cout << " random SL " << SL << G4endl;
453
454 G4double S1 = 0.0;
455 for (i = 0; i < 7; i++) { // Select evaporation scenario
456 S1 += W[i];
457 if (SL <= S1) {
458 icase = i;
459 break;
460 };
461 };
462
463 if (icase < 0) continue; // Failed to choose scenario, try again
464
465 if (icase < 6) { // particle or light nuclei escape
466 if (verboseLevel > 2) {
467 G4cout << " particle/light-ion escape ("
468 << (icase==0 ? "neutron" : icase==1 ? "proton" :
469 icase==2 ? "deuteron" : icase==3 ? "He3" :
470 icase==4 ? "triton" : icase==5 ? "alpha" : "ERROR!")
471 << ")?" << G4endl;
472 }
473
474 G4double Xmax = (std::sqrt(u[icase]*TM[icase] + 0.25) - 0.5)/u[icase];
475 G4int itry1 = 0;
476 G4bool bad = true;
477
478 while (itry1 < itry_max && bad) {
479 itry1++;
480 G4int itry = 0;
481 G4double S = 0.0;
482 G4double X = 0.0;
483 G4double Ptest = 0.0;
484
485 while (itry < itry_max) {
486 itry++;
487
488 // Sampling from eq. 17 of Dostrovsky
489 X = G4UniformRand()*TM[icase];
490 Ptest = (X/Xmax)*G4Exp(-2.*u[icase]*Xmax + 2.*std::sqrt(u[icase]*(TM[icase] - X)));
491 if (G4UniformRand() < Ptest) {
492 S = X + V[icase];
493 break;
494 }
495 }
496
497 if (S > V[icase] && S < EEXS) { // real escape
498
499 if (verboseLevel > 2)
500 G4cout << " escape itry1 " << itry1 << " icase "
501 << icase << " S (MeV) " << S << G4endl;
502
503 S /= GeV; // Convert to Bertini units
504
505 if (icase < 2) { // particle escape
506 G4int ptype = 2 - icase;
507 if (verboseLevel > 2)
508 G4cout << " particle " << ptype << " escape" << G4endl;
509
510 // generate particle momentum
511 G4double mass =
512 G4InuclElementaryParticle::getParticleMass(ptype);
513
514 G4double pmod = std::sqrt((2.0 * mass + S) * S);
515 G4LorentzVector mom = generateWithRandomAngles(pmod, mass);
516
517 // Push evaporated particle into current rest frame
518 mom = toTheNucleiSystemRestFrame.backToTheLab(mom);
519
520 if (verboseLevel > 2) {
521 G4cout << " nucleus px " << PEX.px() << " py " << PEX.py()
522 << " pz " << PEX.pz() << " E " << PEX.e() << G4endl
523 << " evaporate px " << mom.px() << " py " << mom.py()
524 << " pz " << mom.pz() << " E " << mom.e() << G4endl;
525 }
526
527 // New excitation energy depends on residual nuclear state
528 G4double mass_new =
529 G4InuclNuclei::getNucleiMass(A1[icase],Z1[icase]);
530
531 G4double EEXS_new = ((PEX-mom).m() - mass_new)*GeV;
532 if (EEXS_new < 0.0) continue; // Sanity check for new nucleus
533
534 PEX -= mom; // Remaining four-momentum
535 EEXS = EEXS_new;
536
537 A = A1[icase];
538 Z = Z1[icase];
539
540 // NOTE: In-situ construction optimizes away (no copying)
541 output.addOutgoingParticle(G4InuclElementaryParticle(mom,
542 ptype, G4InuclParticle::Equilib));
543
544 if (verboseLevel > 3)
545 G4cout << output.getOutgoingParticles().back() << G4endl;
546
547 ppout += mom;
548 bad = false;
549 } else { // if (icase < 2)
550 if (verboseLevel > 2) {
551 G4cout << " nucleus A " << AN[icase] << " Z " << Q[icase]
552 << " escape icase " << icase << G4endl;
553 }
554
555 G4double mass =
556 G4InuclNuclei::getNucleiMass(AN[icase],Q[icase]);
557
558 // generate particle momentum
559 G4double pmod = std::sqrt((2.0 * mass + S) * S);
560 G4LorentzVector mom = generateWithRandomAngles(pmod,mass);
561
562 // Push evaporated particle into current rest frame
563 mom = toTheNucleiSystemRestFrame.backToTheLab(mom);
564
565 if (verboseLevel > 2) {
566 G4cout << " nucleus px " << PEX.px() << " py " << PEX.py()
567 << " pz " << PEX.pz() << " E " << PEX.e() << G4endl
568 << " evaporate px " << mom.px() << " py " << mom.py()
569 << " pz " << mom.pz() << " E " << mom.e() << G4endl;
570 }
571
572 // New excitation energy depends on residual nuclear state
573 G4double mass_new =
574 G4InuclNuclei::getNucleiMass(A1[icase],Z1[icase]);
575
576 G4double EEXS_new = ((PEX-mom).m() - mass_new)*GeV;
577 if (EEXS_new < 0.0) continue; // Sanity check for new nucleus
578
579 PEX -= mom; // Remaining four-momentum
580 EEXS = EEXS_new;
581
582 A = A1[icase];
583 Z = Z1[icase];
584
585 // NOTE: In-situ constructor optimizes away (no copying)
586 output.addOutgoingNucleus(G4InuclNuclei(mom,
587 AN[icase], Q[icase], 0.*GeV,
588 G4InuclParticle::Equilib));
589
590 if (verboseLevel > 3)
591 G4cout << output.getOutgoingNuclei().back() << G4endl;
592
593 ppout += mom;
594 bad = false;
595 } // if (icase < 2)
596 } // if (EPR > 0.0 ...
597 } // while (itry1 ...
598
599 if (itry1 == itry_max || bad) try_again = false;
600 } else { // if (icase < 6)
601 if (verboseLevel > 2) {
602 G4cout << " fission: A " << A << " Z " << Z << " eexs " << EEXS
603 << " Wn " << W[0] << " Wf " << W[6] << G4endl;
604 }
605
606 // Catch fission output separately for verification
607 fission_output.reset();
608 theFissioner.deExcite(makeFragment(A,Z,EEXS), fission_output);
609
610 if (fission_output.numberOfFragments() == 2) { // fission ok
611 if (verboseLevel > 2) G4cout << " fission done in eql" << G4endl;
612
613 // Move fission fragments to lab frame for processing
614 fission_output.boostToLabFrame(toTheNucleiSystemRestFrame);
615
616 // Now evaporate the fission fragments individually
617 this->deExcite(fission_output.getRecoilFragment(0), output);
618 this->deExcite(fission_output.getRecoilFragment(1), output);
619
620 validateOutput(target, output); // Check energy conservation
621 return;
622 } else { // fission forbidden now
623 fission_open = false;
624 }
625 } // End of fission case
626 } // if (prob_sum < prob_cut_off)
627 } // while (try_again
628
629 // this time it's final nuclei
630
631 if (itry_global == itry_global_max) {
632 if (verboseLevel > 3) {
633 G4cout << " ! itry_global " << itry_global_max << G4endl;
634 }
635 }
636
637 G4LorentzVector pnuc = pin - ppout;
638
639 // NOTE: In-situ constructor will be optimized away (no copying)
640 output.addOutgoingNucleus(G4InuclNuclei(pnuc, A, Z, 0.,
641 G4InuclParticle::Equilib));
642
643 if (verboseLevel > 3) {
644 G4cout << " remaining nucleus \n" << output.getOutgoingNuclei().back()
645 << G4endl;
646 }
647
648
649 validateOutput(target, output); // Check energy conservation
650 return;
651}
S
G4double S(G4double temp)
Definition: G4DNAElectronHoleRecombination.cc:76
A13
#define A13
Definition: G4ErrorMatrix.cc:877
G4Exp
G4double G4Exp(G4double initial_x)
Exponential Function double precision.
Definition: G4Exp.hh:179
SL
static const G4double * SL[nLA]
Definition: G4PhotoNuclearCrossSection.cc:1475
m
static constexpr double m
Definition: G4SIunits.hh:109
GeV
static constexpr double GeV
Definition: G4SIunits.hh:203
G4double
double G4double
Definition: G4Types.hh:83
G4bool
bool G4bool
Definition: G4Types.hh:86
G4int
int G4int
Definition: G4Types.hh:85
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:52
G4BigBanger::deExcite
virtual void deExcite(const G4Fragment &target, G4CollisionOutput &output)
Definition: G4BigBanger.cc:68
G4CascadeDeexciteBase::getTargetData
void getTargetData(const G4Fragment &target)
Definition: G4CascadeDeexciteBase.cc:66
G4CascadeDeexciteBase::makeFragment
const G4Fragment & makeFragment(G4LorentzVector mom, G4int A, G4int Z, G4double EX=0.)
Definition: G4CascadeDeexciteBase.cc:86
G4CascadeDeexciteBase::validateOutput
virtual G4bool validateOutput(const G4Fragment &target, G4CollisionOutput &output)
Definition: G4CascadeDeexciteBase.cc:130
G4CollisionOutput::addRecoilFragment
void addRecoilFragment(const G4Fragment *aFragment)
Definition: G4CollisionOutput.hh:98
G4CollisionOutput::getOutgoingNuclei
const std::vector< G4InuclNuclei > & getOutgoingNuclei() const
Definition: G4CollisionOutput.hh:136
G4CollisionOutput::boostToLabFrame
void boostToLabFrame(const G4LorentzConvertor &convertor)
Definition: G4CollisionOutput.cc:322
G4CollisionOutput::addOutgoingParticle
void addOutgoingParticle(const G4InuclElementaryParticle &particle)
Definition: G4CollisionOutput.hh:79
G4CollisionOutput::getOutgoingParticles
const std::vector< G4InuclElementaryParticle > & getOutgoingParticles() const
Definition: G4CollisionOutput.hh:126
G4CollisionOutput::getRecoilFragment
const G4Fragment & getRecoilFragment(G4int index=0) const
Definition: G4CollisionOutput.cc:115
G4CollisionOutput::addOutgoingNucleus
void addOutgoingNucleus(const G4InuclNuclei &nuclei)
Definition: G4CollisionOutput.hh:85
G4CollisionOutput::numberOfFragments
G4int numberOfFragments() const
Definition: G4CollisionOutput.hh:142
G4EquilibriumEvaporator::getPARLEVDEN
G4double getPARLEVDEN(G4int A, G4int Z) const
Definition: G4EquilibriumEvaporator.cc:731
G4EquilibriumEvaporator::getQF
G4double getQF(G4double x, G4double x2, G4int a, G4int z, G4double e) const
Definition: G4EquilibriumEvaporator.cc:682
G4EquilibriumEvaporator::deExcite
virtual void deExcite(const G4Fragment &target, G4CollisionOutput &output)
Definition: G4EquilibriumEvaporator.cc:170
G4EquilibriumEvaporator::getAF
G4double getAF(G4double x, G4int a, G4int z, G4double e) const
Definition: G4EquilibriumEvaporator.cc:713
G4EquilibriumEvaporator::explosion
virtual G4bool explosion(G4int a, G4int z, G4double e) const
Definition: G4EquilibriumEvaporator.cc:653
G4EquilibriumEvaporator::goodRemnant
G4bool goodRemnant(G4int a, G4int z) const
Definition: G4EquilibriumEvaporator.cc:672
G4EquilibriumEvaporator::getE0
G4double getE0(G4int A) const
Definition: G4EquilibriumEvaporator.cc:743
G4Fissioner::deExcite
virtual void deExcite(const G4Fragment &target, G4CollisionOutput &output)
Definition: G4Fissioner.cc:65
G4InuclElementaryParticle::getParticleMass
static G4double getParticleMass(G4int type)
Definition: G4InuclElementaryParticle.cc:215
G4InuclNuclei::getNucleiMass
G4double getNucleiMass() const
Definition: G4InuclNuclei.hh:139
G4InuclSpecialFunctions::paraMaker::getParams
void getParams(G4double Z, std::pair< std::vector< G4double >, std::vector< G4double > > &parms)
Definition: paraMaker.cc:62
G4LorentzConvertor::setBullet
void setBullet(const G4InuclParticle *bullet)
Definition: G4LorentzConvertor.cc:66
G4LorentzConvertor::backToTheLab
G4LorentzVector backToTheLab(const G4LorentzVector &mom) const
Definition: G4LorentzConvertor.cc:134
G4LorentzConvertor::setTarget
void setTarget(const G4InuclParticle *target)
Definition: G4LorentzConvertor.cc:70
G4InuclSpecialFunctions::bindingEnergy
G4double bindingEnergy(G4int A, G4int Z)
Definition: bindingEnergy.cc:36
G4InuclSpecialFunctions::generateWithRandomAngles
G4LorentzVector generateWithRandomAngles(G4double p, G4double mass=0.)
Definition: G4InuclSpecialFunctions.cc:177
anonymous_namespace{paraMaker.cc}::Z1
static const G4double Z1[5]
Definition: paraMaker.cc:41
Q
static double Q[]
Definition: nf_gammaFunctions.cc:91

References G4CascadeDeexciteBase::A, A13, G4CollisionOutput::addOutgoingNucleus(), G4CollisionOutput::addOutgoingParticle(), G4CollisionOutput::addRecoilFragment(), G4LorentzConvertor::backToTheLab(), G4InuclSpecialFunctions::bindingEnergy(), G4CollisionOutput::boostToLabFrame(), G4BigBanger::deExcite(), deExcite(), G4Fissioner::deExcite(), CLHEP::HepLorentzVector::e(), G4CascadeDeexciteBase::EEXS, G4InuclParticle::Equilib, explosion(), fission_output, G4InuclSpecialFunctions::G4cbrt(), G4cout, G4endl, G4Exp(), G4UniformRand, G4InuclSpecialFunctions::generateWithRandomAngles(), getAF(), G4InuclSpecialFunctions::getAL(), getE0(), G4InuclNuclei::getNucleiMass(), G4CollisionOutput::getOutgoingNuclei(), G4CollisionOutput::getOutgoingParticles(), G4InuclSpecialFunctions::paraMaker::getParams(), getPARLEVDEN(), G4InuclElementaryParticle::getParticleMass(), getQF(), G4CollisionOutput::getRecoilFragment(), G4CascadeDeexciteBase::getTargetData(), GeV, goodRemnant(), G4InuclSpecialFunctions::inuclRndm(), m, G4CascadeDeexciteBase::makeFragment(), G4CollisionOutput::numberOfFragments(), parms, G4CascadeDeexciteBase::PEX, G4InuclParticleNames::photon, G4InuclParticleNames::proton, CLHEP::HepLorentzVector::px(), CLHEP::HepLorentzVector::py(), CLHEP::HepLorentzVector::pz(), Q, G4CollisionOutput::reset(), S(), G4LorentzConvertor::setBullet(), G4LorentzConvertor::setTarget(), SL, theBigBanger, theFissioner, theParaMaker, G4LorentzConvertor::toTheTargetRestFrame(), G4CascadeDeexciteBase::validateOutput(), G4VCascadeCollider::verboseLevel, G4CascadeDeexciteBase::Z, and anonymous_namespace{paraMaker.cc}::Z1.

Referenced by G4CascadeDeexcitation::deExcite(), deExcite(), and G4EvaporationInuclCollider::deExcite().

◆ explosion() [1/2]

virtual G4bool G4EquilibriumEvaporator::explosion ( const G4Fragment &  target) const
inlineprivatevirtual

Reimplemented from G4CascadeDeexciteBase.

Definition at line 71 of file G4EquilibriumEvaporator.hh.

71 {
72 return G4CascadeDeexciteBase::explosion(target);
73 }
G4CascadeDeexciteBase::explosion
virtual G4bool explosion(const G4Fragment &target) const
Definition: G4CascadeDeexciteBase.cc:109

References G4CascadeDeexciteBase::explosion().

◆ explosion() [2/2]

G4bool G4EquilibriumEvaporator::explosion ( G4int  a,
G4int  z,
G4double  e 
) const
privatevirtual

Reimplemented from G4CascadeDeexciteBase.

Definition at line 653 of file G4EquilibriumEvaporator.cc.

655 {
656 if (verboseLevel > 3) {
657 G4cout << " >>> G4EquilibriumEvaporator::explosion? ";
658 }
659
660 const G4double be_cut = 3.0;
661
662 // Different criteria from base class, since nucleus more "agitated"
663 G4bool bigb = (!(a >= 12 && z >= 0 && z < 3*(a-z)) &&
664 (e >= be_cut * bindingEnergy(a,z))
665 );
666
667 if (verboseLevel > 3) G4cout << bigb << G4endl;
668
669 return bigb;
670}

References G4InuclSpecialFunctions::bindingEnergy(), G4cout, G4endl, and G4VCascadeCollider::verboseLevel.

Referenced by deExcite().

◆ getAF()

G4double G4EquilibriumEvaporator::getAF ( G4double  x,
G4int  a,
G4int  z,
G4double  e 
) const
private

Definition at line 713 of file G4EquilibriumEvaporator.cc.

716 {
717
718 if (verboseLevel > 3) {
719 G4cout << " >>> G4EquilibriumEvaporator::getAF" << G4endl;
720 }
721
722 // ugly parameterisation to fit the experimental fission cs for Hg - Bi nuclei
723 G4double AF = 1.285 * (1.0 - e / 1100.0);
724
725 if(AF < 1.06) AF = 1.06;
726 // if(AF < 1.08) AF = 1.08;
727
728 return AF;
729}

References G4cout, G4endl, and G4VCascadeCollider::verboseLevel.

Referenced by deExcite().

◆ getE0()

G4double G4EquilibriumEvaporator::getE0 ( G4int  A) const
private

Definition at line 743 of file G4EquilibriumEvaporator.cc.

743 {
744
745 if (verboseLevel > 3) {
746 G4cout << " >>> G4EquilibriumEvaporator::getE0" << G4endl;
747 }
748
749 const G4double e0 = 200.0;
750
751 return e0;
752}

References G4cout, G4endl, and G4VCascadeCollider::verboseLevel.

Referenced by deExcite().

◆ getPARLEVDEN()

G4double G4EquilibriumEvaporator::getPARLEVDEN ( G4int  A,
G4int  Z 
) const
private

Definition at line 731 of file G4EquilibriumEvaporator.cc.

732 {
733
734 if (verboseLevel > 3) {
735 G4cout << " >>> G4EquilibriumEvaporator::getPARLEVDEN" << G4endl;
736 }
737
738 const G4double par = 0.125;
739
740 return par;
741}

References G4cout, G4endl, and G4VCascadeCollider::verboseLevel.

Referenced by deExcite().

◆ getQF()

G4double G4EquilibriumEvaporator::getQF ( G4double  x,
G4double  x2,
G4int  a,
G4int  z,
G4double  e 
) const
private

Definition at line 682 of file G4EquilibriumEvaporator.cc.

686 {
687 if (verboseLevel > 3) {
688 G4cout << " >>> G4EquilibriumEvaporator::getQF ";
689 }
690
691 const G4double G0 = 20.4;
692 const G4double XMIN = 0.6761;
693 const G4double XMAX = 0.8274;
694
695 G4double QFF = 0.0;
696
697 if (x < XMIN || x > XMAX) {
698 G4double X1 = 1.0 - 0.02 * x2;
699 G4double FX = (0.73 + (3.33 * X1 - 0.66) * X1) * (X1*X1*X1);
700 G4double A13 = G4cbrt(a);
701 QFF = G0 * FX * A13*A13;
702 } else {
703 QFF = QFinterp.interpolate(x, QFREP);
704 }
705
706 if (QFF < 0.0) QFF = 0.0;
707
708 if (verboseLevel>3) G4cout << " returns " << QFF << G4endl;
709
710 return QFF;
711}
G4CascadeInterpolator::interpolate
G4double interpolate(const G4double x, const G4double(&yb)[nBins]) const
anonymous_namespace{G4EquilibriumEvaporator.cc}::QFREP
const G4double QFREP[72]
Definition: G4EquilibriumEvaporator.cc:97

References A13, G4InuclSpecialFunctions::G4cbrt(), G4cout, G4endl, G4CascadeInterpolator< NBINS >::interpolate(), QFinterp, anonymous_namespace{G4EquilibriumEvaporator.cc}::QFREP, and G4VCascadeCollider::verboseLevel.

Referenced by deExcite().

◆ getTargetData()

void G4CascadeDeexciteBase::getTargetData ( const G4Fragment &  target)
protectedinherited

Definition at line 66 of file G4CascadeDeexciteBase.cc.

66 {
67 A = target.GetA_asInt();
68 Z = target.GetZ_asInt();
69 PEX = target.GetMomentum()/GeV; // Convert from G4 to Bertini units
70 EEXS = target.GetExcitationEnergy();
71}
G4Fragment::GetExcitationEnergy
G4double GetExcitationEnergy() const
Definition: G4Fragment.hh:299
G4Fragment::GetMomentum
const G4LorentzVector & GetMomentum() const
Definition: G4Fragment.hh:323
G4Fragment::GetZ_asInt
G4int GetZ_asInt() const
Definition: G4Fragment.hh:276
G4Fragment::GetA_asInt
G4int GetA_asInt() const
Definition: G4Fragment.hh:271

References G4CascadeDeexciteBase::A, G4CascadeDeexciteBase::EEXS, G4Fragment::GetA_asInt(), G4Fragment::GetExcitationEnergy(), G4Fragment::GetMomentum(), G4Fragment::GetZ_asInt(), GeV, G4CascadeDeexciteBase::PEX, and G4CascadeDeexciteBase::Z.

Referenced by G4BigBanger::deExcite(), deExcite(), G4Fissioner::deExcite(), and G4NonEquilibriumEvaporator::deExcite().

◆ goodRemnant()

G4bool G4EquilibriumEvaporator::goodRemnant ( G4int  a,
G4int  z 
) const
private

Definition at line 672 of file G4EquilibriumEvaporator.cc.

673 {
674 if (verboseLevel > 3) {
675 G4cout << " >>> G4EquilibriumEvaporator::goodRemnant(" << a << "," << z
676 << ")? " << (a>1 && z>0 && a>z) << G4endl;
677 }
678
679 return a > 1 && z > 0 && a > z;
680}

References G4cout, G4endl, and G4VCascadeCollider::verboseLevel.

Referenced by deExcite().

◆ makeFragment() [1/2]

const G4Fragment & G4CascadeDeexciteBase::makeFragment ( G4int  A,
G4int  Z,
G4double  EX = 0. 
)
protectedinherited

Definition at line 81 of file G4CascadeDeexciteBase.cc.

81 {
82 return makeFragment(zero, fragA, fragZ, EX);
83}
anonymous_namespace{G4CascadeDeexciteBase.cc}::zero
static const G4LorentzVector zero(0., 0., 0., 0.)

References G4CascadeDeexciteBase::makeFragment(), and anonymous_namespace{G4CascadeDeexciteBase.cc}::zero.

◆ makeFragment() [2/2]

const G4Fragment & G4CascadeDeexciteBase::makeFragment ( G4LorentzVector  mom,
G4int  A,
G4int  Z,
G4double  EX = 0. 
)
protectedinherited

Definition at line 86 of file G4CascadeDeexciteBase.cc.

87 {
88 if (verboseLevel>2) {
89 G4cout << " >>> " << theName << "::makeFragment " << mom << " " << fragA
90 << " " << fragZ << " " << EX << G4endl;
91 }
92
93 // Adjust four-momentum so that mass is nucleus + excitation
94 G4double mass =
95 G4InuclNuclei::getNucleiMass(fragA,fragZ) + EX/GeV;
96 mom.setVectM(mom.vect(), mass);
97
98 // Overwrite previous fragment contents, zeroing out excitons
99 aFragment.SetZandA_asInt(fragZ, fragA);
100 aFragment.SetMomentum(mom*GeV); // Bertini uses GeV!
101 aFragment.SetNumberOfHoles(0,0);
102 aFragment.SetNumberOfExcitedParticle(0,0);
103
104 return aFragment;
105}
CLHEP::HepLorentzVector::setVectM
void setVectM(const Hep3Vector &spatial, double mass)
CLHEP::HepLorentzVector::vect
Hep3Vector vect() const
G4Fragment::SetNumberOfHoles
void SetNumberOfHoles(G4int valueTot, G4int valueP=0)
Definition: G4Fragment.hh:391
G4Fragment::SetMomentum
void SetMomentum(const G4LorentzVector &value)
Definition: G4Fragment.hh:328
G4Fragment::SetNumberOfExcitedParticle
void SetNumberOfExcitedParticle(G4int valueTot, G4int valueP)
Definition: G4Fragment.hh:372
G4Fragment::SetZandA_asInt
void SetZandA_asInt(G4int Znew, G4int Anew)
Definition: G4Fragment.hh:281

References G4CascadeDeexciteBase::aFragment, G4cout, G4endl, G4InuclNuclei::getNucleiMass(), GeV, G4Fragment::SetMomentum(), G4Fragment::SetNumberOfExcitedParticle(), G4Fragment::SetNumberOfHoles(), CLHEP::HepLorentzVector::setVectM(), G4Fragment::SetZandA_asInt(), G4VCascadeCollider::theName, CLHEP::HepLorentzVector::vect(), and G4VCascadeCollider::verboseLevel.

Referenced by deExcite(), G4Fissioner::deExcite(), G4NonEquilibriumEvaporator::deExcite(), and G4CascadeDeexciteBase::makeFragment().

◆ operator=()

G4EquilibriumEvaporator & G4EquilibriumEvaporator::operator= ( const G4EquilibriumEvaporator &  )
private

◆ setName()

virtual void G4VCascadeCollider::setName ( const G4String &  name)
inlineprotectedvirtualinherited

Definition at line 55 of file G4VCascadeCollider.hh.

55{ theName = name; }
G4InuclParticleNames::name
const char * name(G4int ptype)
Definition: G4InuclParticleNames.hh:76

References G4InuclParticleNames::name(), and G4VCascadeCollider::theName.

Referenced by G4CascadeCheckBalance::setOwner().

◆ setVerboseLevel()

void G4EquilibriumEvaporator::setVerboseLevel ( G4int  verbose)
virtual

Reimplemented from G4CascadeDeexciteBase.

Definition at line 161 of file G4EquilibriumEvaporator.cc.

161 {
162 G4CascadeDeexciteBase::setVerboseLevel(verbose);
163 theFissioner.setVerboseLevel(verbose);
164 theBigBanger.setVerboseLevel(verbose);
165}
G4CascadeDeexciteBase::setVerboseLevel
virtual void setVerboseLevel(G4int verbose=0)
Definition: G4CascadeDeexciteBase.cc:58

References G4CascadeDeexciteBase::setVerboseLevel(), theBigBanger, and theFissioner.

Referenced by G4CascadeDeexcitation::setVerboseLevel().

◆ validateOutput() [1/3]

G4bool G4CascadeDeexciteBase::validateOutput ( const G4Fragment &  target,
const std::vector< G4InuclElementaryParticle > &  particles 
)
protectedvirtualinherited

Definition at line 142 of file G4CascadeDeexciteBase.cc.

143 {
144 if (!balance) return true; // Skip checks unless requested
145
146 if (verboseLevel > 1)
147 G4cout << " >>> " << theName << "::validateOutput" << G4endl;
148
149 balance->setVerboseLevel(verboseLevel);
150 balance->collide(target, particles);
151 return balance->okay(); // Returns false if violations
152}
G4CascadeCheckBalance::collide
void collide(G4InuclParticle *bullet, G4InuclParticle *target, G4CollisionOutput &output)
Definition: G4CascadeCheckBalance.cc:88
G4CascadeDeexciteBase::balance
G4CascadeCheckBalance * balance
Definition: G4CascadeDeexciteBase.hh:57
G4VCascadeCollider::setVerboseLevel
virtual void setVerboseLevel(G4int verbose=0)
Definition: G4VCascadeCollider.hh:49

References G4CascadeDeexciteBase::balance, G4CascadeCheckBalance::collide(), G4cout, G4endl, G4CascadeCheckBalance::okay(), G4VCascadeCollider::setVerboseLevel(), G4VCascadeCollider::theName, and G4VCascadeCollider::verboseLevel.

◆ validateOutput() [2/3]

G4bool G4CascadeDeexciteBase::validateOutput ( const G4Fragment &  target,
const std::vector< G4InuclNuclei > &  fragments 
)
protectedvirtualinherited

Definition at line 154 of file G4CascadeDeexciteBase.cc.

155 {
156 if (!balance) return true; // Skip checks unless requested
157
158 if (verboseLevel > 1)
159 G4cout << " >>> " << theName << "::validateOutput" << G4endl;
160
161 balance->setVerboseLevel(verboseLevel);
162 balance->collide(target, fragments);
163 return balance->okay(); // Returns false if violations
164}

References G4CascadeDeexciteBase::balance, G4CascadeCheckBalance::collide(), G4cout, G4endl, G4CascadeCheckBalance::okay(), G4VCascadeCollider::setVerboseLevel(), G4VCascadeCollider::theName, and G4VCascadeCollider::verboseLevel.

◆ validateOutput() [3/3]

G4bool G4CascadeDeexciteBase::validateOutput ( const G4Fragment &  target,
G4CollisionOutput &  output 
)
protectedvirtualinherited

Definition at line 130 of file G4CascadeDeexciteBase.cc.

131 {
132 if (!balance) return true; // Skip checks unless requested
133
134 if (verboseLevel > 1)
135 G4cout << " >>> " << theName << "::validateOutput" << G4endl;
136
137 balance->setVerboseLevel(verboseLevel);
138 balance->collide(target, output);
139 return balance->okay(); // Returns false if violations
140}

References G4CascadeDeexciteBase::balance, G4CascadeCheckBalance::collide(), G4cout, G4endl, G4CascadeCheckBalance::okay(), G4VCascadeCollider::setVerboseLevel(), G4VCascadeCollider::theName, and G4VCascadeCollider::verboseLevel.

Referenced by G4BigBanger::deExcite(), deExcite(), and G4NonEquilibriumEvaporator::deExcite().

Field Documentation

◆ A

G4int G4CascadeDeexciteBase::A
protectedinherited

Definition at line 73 of file G4CascadeDeexciteBase.hh.

Referenced by G4BigBanger::deExcite(), deExcite(), G4Fissioner::deExcite(), G4NonEquilibriumEvaporator::deExcite(), G4CascadeDeexciteBase::getTargetData(), and mcscore.MCParticle::printout().

◆ aFragment

G4Fragment G4CascadeDeexciteBase::aFragment
protectedinherited

Definition at line 82 of file G4CascadeDeexciteBase.hh.

Referenced by G4CascadeDeexciteBase::makeFragment().

◆ balance

G4CascadeCheckBalance* G4CascadeDeexciteBase::balance
protectedinherited

Definition at line 57 of file G4CascadeDeexciteBase.hh.

Referenced by G4CascadeDeexciteBase::G4CascadeDeexciteBase(), G4CascadeDeexciteBase::setVerboseLevel(), G4CascadeDeexciteBase::validateOutput(), and G4CascadeDeexciteBase::~G4CascadeDeexciteBase().

◆ EEXS

G4double G4CascadeDeexciteBase::EEXS
protectedinherited

Definition at line 76 of file G4CascadeDeexciteBase.hh.

Referenced by G4BigBanger::deExcite(), deExcite(), G4Fissioner::deExcite(), G4NonEquilibriumEvaporator::deExcite(), and G4CascadeDeexciteBase::getTargetData().

◆ fission_output

G4CollisionOutput G4EquilibriumEvaporator::fission_output
private

Definition at line 85 of file G4EquilibriumEvaporator.hh.

Referenced by deExcite().

◆ parms

std::pair<std::vector<G4double>, std::vector<G4double> > G4EquilibriumEvaporator::parms
private

Definition at line 84 of file G4EquilibriumEvaporator.hh.

Referenced by deExcite(), and G4EquilibriumEvaporator().

◆ PEX

G4LorentzVector G4CascadeDeexciteBase::PEX
protectedinherited

Definition at line 75 of file G4CascadeDeexciteBase.hh.

Referenced by G4BigBanger::deExcite(), deExcite(), G4Fissioner::deExcite(), G4NonEquilibriumEvaporator::deExcite(), and G4CascadeDeexciteBase::getTargetData().

◆ QFinterp

G4CascadeInterpolator<72> G4EquilibriumEvaporator::QFinterp
private

Definition at line 88 of file G4EquilibriumEvaporator.hh.

Referenced by getQF().

◆ theBigBanger

G4BigBanger G4EquilibriumEvaporator::theBigBanger
private

Definition at line 91 of file G4EquilibriumEvaporator.hh.

Referenced by deExcite(), and setVerboseLevel().

◆ theFissioner

G4Fissioner G4EquilibriumEvaporator::theFissioner
private

Definition at line 90 of file G4EquilibriumEvaporator.hh.

Referenced by deExcite(), and setVerboseLevel().

◆ theName

G4String G4VCascadeCollider::theName
protectedinherited

Definition at line 52 of file G4VCascadeCollider.hh.

Referenced by G4CascadeCheckBalance::baryonOkay(), G4CascadeCheckBalance::chargeOkay(), G4VCascadeDeexcitation::collide(), G4CascadeCheckBalance::collide(), G4CascadeCheckBalance::ekinOkay(), G4CascadeCheckBalance::energyOkay(), G4CascadeDeexciteBase::explosion(), G4CascadeRecoilMaker::G4CascadeRecoilMaker(), G4VCascadeCollider::G4VCascadeCollider(), G4CascadeColliderBase::inelasticInteractionPossible(), G4CascadeDeexciteBase::makeFragment(), G4CascadeRecoilMaker::makeRecoilFragment(), G4CascadeRecoilMaker::makeRecoilNuclei(), G4CascadeCheckBalance::momentumOkay(), G4VCascadeCollider::setName(), G4CascadeCheckBalance::strangeOkay(), G4CascadeDeexciteBase::validateOutput(), and G4CascadeColliderBase::validateOutput().

◆ theParaMaker

G4InuclSpecialFunctions::paraMaker G4EquilibriumEvaporator::theParaMaker
private

Definition at line 77 of file G4EquilibriumEvaporator.hh.

Referenced by deExcite().

◆ verboseLevel

G4int G4VCascadeCollider::verboseLevel
protectedinherited

Definition at line 53 of file G4VCascadeCollider.hh.

Referenced by G4CascadeCheckBalance::baryonOkay(), G4CascadeCheckBalance::chargeOkay(), G4IntraNucleiCascader::collide(), G4InuclCollider::collide(), G4LightTargetCollider::collide(), G4VCascadeDeexcitation::collide(), G4CascadeCheckBalance::collide(), G4CascadeRecoilMaker::collide(), G4ElementaryParticleCollider::collide(), G4IntraNucleiCascader::copySecondaries(), G4IntraNucleiCascader::copyWoundedNucleus(), G4IntraNucleiCascader::decayTrappedParticle(), G4CascadeDeexcitation::deExcite(), G4InuclCollider::deexcite(), G4PreCompoundDeexcitation::deExcite(), G4BigBanger::deExcite(), deExcite(), G4EvaporationInuclCollider::deExcite(), G4Fissioner::deExcite(), G4NonEquilibriumEvaporator::deExcite(), G4CascadeCheckBalance::ekinOkay(), G4CascadeCheckBalance::energyOkay(), explosion(), G4CascadeDeexciteBase::explosion(), G4CascadeRecoilMaker::fillRecoil(), G4IntraNucleiCascader::finalize(), G4IntraNucleiCascader::finishCascade(), G4VCascadeCollider::G4VCascadeCollider(), G4BigBanger::generateBangInSCM(), G4IntraNucleiCascader::generateCascade(), G4BigBanger::generateMomentumModules(), G4ElementaryParticleCollider::generateMultiplicity(), G4ElementaryParticleCollider::generateSCMfinalState(), G4ElementaryParticleCollider::generateSCMmuonAbsorption(), G4ElementaryParticleCollider::generateSCMpionAbsorption(), G4ElementaryParticleCollider::generateSCMpionNAbsorption(), G4BigBanger::generateX(), getAF(), G4Fissioner::getC2(), getE0(), G4NonEquilibriumEvaporator::getE0(), G4NonEquilibriumEvaporator::getMatrixElement(), G4NonEquilibriumEvaporator::getParLev(), getPARLEVDEN(), getQF(), G4Fissioner::getZopt(), G4CascadeRecoilMaker::goodNucleus(), goodRemnant(), G4CascadeColliderBase::inelasticInteractionPossible(), G4IntraNucleiCascader::initialize(), G4CascadeDeexciteBase::makeFragment(), G4CascadeRecoilMaker::makeRecoilFragment(), G4CascadeRecoilMaker::makeRecoilNuclei(), G4BigBanger::maxProbability(), G4CascadeCheckBalance::momentumOkay(), G4IntraNucleiCascader::newCascade(), G4InuclCollider::photonuclearOkay(), G4ElementaryParticleCollider::pionNucleonAbsorption(), G4Fissioner::potentialMinimization(), G4IntraNucleiCascader::preloadCascade(), G4IntraNucleiCascader::processSecondary(), G4IntraNucleiCascader::processTrappedParticle(), G4IntraNucleiCascader::releaseSecondary(), G4IntraNucleiCascader::rescatter(), G4InuclCollider::rescatter(), G4IntraNucleiCascader::setupCascade(), G4InuclCollider::setVerboseLevel(), G4LightTargetCollider::setVerboseLevel(), G4VCascadeCollider::setVerboseLevel(), G4CascadeCheckBalance::strangeOkay(), G4InuclCollider::useCascadeDeexcitation(), G4InuclCollider::usePreCompoundDeexcitation(), G4CascadeDeexciteBase::validateOutput(), G4CascadeColliderBase::validateOutput(), G4CascadeRecoilMaker::wholeEvent(), and G4BigBanger::xProbability().

◆ Z

G4int G4CascadeDeexciteBase::Z
protectedinherited

Definition at line 74 of file G4CascadeDeexciteBase.hh.

Referenced by G4BigBanger::deExcite(), deExcite(), G4Fissioner::deExcite(), G4NonEquilibriumEvaporator::deExcite(), G4CascadeDeexciteBase::getTargetData(), and mcscore.MCParticle::printout().

The documentation for this class was generated from the following files:
Generated by doxygen 1.9.3