source: trunk/source/processes/hadronic/models/incl/include/G4Incl.hh@ 1344

Last change on this file since 1344 was 1340, checked in by garnier, 15 years ago

update ti head
File size: 24.0 KB
RevLine 
[819]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//
[1340]26// $Id: G4Incl.hh,v 1.18 2010/10/26 02:47:59 kaitanie Exp $
[819]27// Translation of INCL4.2/ABLA V3
28// Pekka Kaitaniemi, HIP (translation)
29// Christelle Schmidt, IPNL (fission code)
30// Alain Boudard, CEA (contact person INCL/ABLA)
31// Aatos Heikkinen, HIP (project coordination)
32
33#ifndef G4Incl_hh
34#define G4Incl_hh 1
35
36#include "globals.hh"
[962]37#include "G4InclRandomNumbers.hh"
[819]38#include "G4InclDataDefs.hh"
39#include "G4Abla.hh"
40#include <fstream>
[1340]41#include "G4VInclLogger.hh"
42#include "G4InclInput.hh"
[819]43
44using namespace std;
45/**
46 * Class containing INCL4 hadronic cascade algorithm.
47 */
48
49class G4Incl {
50
51public:
52 /**
53 *
54 * Support for Doxygen JavaDoc style.
55 *
56 * \author{pekka.kaitaniemi@helsinki.fi}
57 */
58
59 /**
60 * Constructor to be used with Geant4.
61 * @param hazard a pointer to G4Hazard structure.
62 * @param calincl a pointer to G4Calincl structure.
63 * @param ws a pointer to G4Ws structure.
64 * @param mat a pointer to G4Mat structure.
65 * @param varntp a pointer to G4VarNtp structure.
66 */
[1340]67 G4Incl(G4Hazard *hazard, G4InclInput *calincl, G4Ws *ws, G4Mat *mat, G4VarNtp *varntp);
[819]68
69 /**
70 * Constructor for private unit testing purposes.
71 * @param hazard a pointer to G4Hazard structure.
72 * @param dton a pointer to G4Dton structure.
73 * @param saxw a pointer to G4Saxw structure.
74 * @param ws a pointer to G4Ws structure.
75 */
76 G4Incl(G4Hazard *hazard, G4Dton *dton, G4Saxw *saxw, G4Ws *ws);
77
78 G4Incl();
79
80 ~G4Incl(); // Destructor
81
[1196]82 void dumpParticles();
[819]83 G4double energyTest(G4int i); // Test for NaN energy of particle i.
84 void dumpBl5(std::ofstream& dumpOut); // Dump the contents of G4Bl5.
85 void dumpSaxw(std::ofstream& dumpOut); // Dump the contents of G4Saxw.
86 void dumpBl1(std::ofstream& dumpOut); // Dump the contents of G4Bl1.
87 void dumpBl2(std::ofstream& dumpOut); // Dump the contents of G4Bl2.
88 void dumpBl3(std::ofstream& dumpOut); // Dump the contents of G4Bl3.
89
90 /**
[1340]91 * Set Fermi break-up use flag.
92 */
93 void setUseFermiBreakUp(G4bool useIt);
94
95 /**
96 * Set projectile spectator use flag.
97 *
98 * Select whether or not to produce so-called spectator nucleus from
99 * the projectile nucleons that do not hit the target.
100 */
101 void setUseProjectileSpectators(G4bool useIt);
102
103 /**
[819]104 * Set verbosity level.
105 */
106 void setVerboseLevel(G4int level);
107 /**
108 * Get verbosity level.
109 */
110 G4int getVerboseLevel();
111
112 void setDtonData(G4Dton *newDton); // Set internal data.
113 void setWsData(G4Ws *newWs);
114 void setHazardData(G4Hazard *newHazard);
115 void setSaxwData(G4Saxw *newSaxw);
116 void setSpl2Data(G4Spl2 *newSpl2);
117 void setMatData(G4Mat *newMat);
[1340]118 void setInput(G4InclInput *newCalincl);
[819]119 void setLightNucData(G4LightNuc *newLightNuc);
120 void setLightGausNucData(G4LightGausNuc *newLightGausNuc);
121 void setBl1Data(G4Bl1 *newBl1);
122 void setBl2Data(G4Bl2 *newBl2);
123 void setBl3Data(G4Bl3 *newBl3);
124 void setBl4Data(G4Bl4 *newBl4);
125 void setBl5Data(G4Bl5 *newBl5);
126 void setBl6Data(G4Bl6 *newBl6);
127 void setBl8Data(G4Bl8 *newBl8);
128 void setBl9Data(G4Bl9 *newBl9);
129 void setBl10Data(G4Bl10 *newBl10);
130 void setKindData(G4Kind *newKind);
131
[1340]132 /**
133 * Register the logger.
134 */
135 void registerLogger(G4VInclLogger *aLogger) {
136 if(aLogger != 0) {
137 theLogger = aLogger;
138 abla->registerLogger(aLogger);
139 }
140 }
141
[819]142public:
143 /**
144 * Process one event with INCL4 only.
145 */
[1340]146 void processEventIncl(G4InclInput *input);
[819]147
148 /**
149 * Process one event with INCL4 and built-in ABLA evaporation and fission.
150 */
[1340]151 void processEventInclAbla(G4InclInput *input, G4int eventnumber);
[819]152
153public: // Methods used to initialize INCL
154 /**
155 * Initialize INCL.
156 *
157 * @param initRandomSeed choose whether INCL should initialize random seeds.
158 */
159 void initIncl(G4bool initRandomSeed);
160
161 /**
162 * Initialize target materials.
163 *
164 * @param izmat charge number
165 * @param iamat mass number
166 * @param imat material number (array index)
167 */
168 void initMaterial(G4int izmat, G4int iamat, G4int imat);
169
170 /**
171 * A normal member taking two arguments and returning an integer value.
172 *
173 * @param l an integer argument.
174 * @param q a constant character pointer.
175 * @return The test results
176 */
177 G4double deutv(G4int l, G4double q);
178
179 /**
180 * Returns the values of the function:
181 * \f[
182 * (0.23162461 + (j - 1))^2
183 * \f]
184 *
185 * @param j an integer parameter
186 * @return a double value
187 */
188 G4double fm2(G4int j);
189
190 /**
191 * Interpolates function described by class G4Saxw around a point.
192 *
193 * @param xv interpolation point
194 * @return a double value
195 */
196 G4double interpolateFunction(G4double xv);
197
198 /**
199 * Calculates the first derivative of the function stored in class G4Saxw.
200 *
201 * @param xv an integer parameter
202 */
203 void firstDerivative(G4int k);
204
205 /**
206 * Returns the values of the function:
207 * \f[
208 * \frac{r^2}{1 + e^{\frac{r - r_{0}}{A_{dif}}}}
209 * \f]
210 *
211 * @param r a G4double argument
212 * @return a double value
213 */
214 G4double wsax(G4double r);
215
216 /**
217 * Returns the values of the function:
218 * \f[
219 * \frac{1}{A_{dif}^{2}} \frac{r^3 e^{r - r_0}}{1 + e^{\frac{r - r_{0}}{A_{dif}}}}
220 * \f]
221 *
222 * @param r a G4double argument
223 * @return a double value
224 */
225 G4double derivWsax(G4double r);
226
227 /**
228 * Returns the values of the function:
229 * \f[
230 * r^2 (1.0 + r_0 \frac{r^2}{A_{dif}}) e^{-\frac{r^2}{A_{dif}^2}}
231 * \f]
232 * @param r a G4double argument
233 * @return a double value
234 */
235 G4double dmho(G4double r);
236
237 /**
238 * Returns the values of the function:
239 * \f[
240 * -\frac{2r^4}{A_{dif}^2} (r_0(1.0 - \frac{r^2}{A_{dif}^2}) - 1.0) e^{-\frac{r^2}{A_{dif}^2}}
241 * \f]
242 *
243 * @param r a G4double argument
244 * @return a double value
245 */
246 G4double derivMho(G4double r);
247
248 /**
249 * Returns the values of the function:
250 * \f[
251 * \frac{r^4}{A_{dif}^2} e^{-\frac{1}{2} \frac{r^2}{A_{dif}^2}}
252 * \f]
253 *
254 * @param r a G4double argument
255 * @return a double value
256 */
257 G4double derivGaus(G4double r);
258
259 /**
260 * Ce subroutine appele sur le premier tir va calculer la densite du deuton
261 * dans l'espace des impulsions et preparer l'interpolation permettant ensuite
262 * le tir au hasard d'un module de l'impulsion (q).
263 * Ce subroutine remplit le G4Spl2:
264 * xsp, ysp integrale normalisee de la densite de 0 a q.
265 * a(),b(),c() coefs des nsp points pour une interpolation du second degre.
266 * q est en fm-1.
267 */
268 void densDeut();
269
270 /**
271 * Integrate using Alkazhov's method.
272 *
273 * @param ami a double parameter
274 * @param ama a double parameter
275 * @param dr a double parameter
276 * @param functionChoice an integer parameter
277 * @return a double value
278 */
279 G4double integrate(G4double ami, G4double ama, G4double step, G4int functionChoice);
280
281 /**
282 * Deuteron density
283 *
284 * @param q a double parameter
285 * @return a double value
286 */
287 G4double dens(G4double q);
288
289 /**
290 *
291 */
292 void spl2ab();
293
294 /**
295 *
296 * @param xv a double parameter
297 * @return a double value
298 */
299 G4double splineab(G4double xv);
300
301public: // Main INCL routines
302 /**
303 * INCL model as a function.
304 */
305 void pnu(G4int *ibert_p, G4int *nopart_p, G4int *izrem_p, G4int *iarem_p, G4double *esrem_p,
306 G4double *erecrem_p, G4double *alrem_p, G4double *berem_p, G4double *garem_p,
[1340]307 G4double *bimpact_p, G4int *l_p, G4double *xjrem, G4double *yjrem, G4double *zjrem);
308
309 //C projection de JREM sur Z:
310 // MREM=ANINT(ZJREM/197.328)
311 // IF (MREM.GT.JREM) MREM=JREM
312 // IF (MREM.LT.-JREM) MREM=-JREM
[819]313
314 /**
315 * Single nucleon-nucleon collision.
316 */
317 void collis(G4double *p1_p, G4double *p2_p, G4double *p3_p, G4double *e1_p, G4double *pout11_p, G4double *pout12_p,
318 G4double *pout13_p, G4double *eout1_p, G4double *q1_p, G4double *q2_p, G4double *q3_p,
319 G4double *q4_p, G4int *np_p, G4int *ip_p, G4int *k2_p, G4int *k3_p, G4int *k4_p,
320 G4int *k5_p, G4int *m1_p, G4int *m2_p, G4int *is1_p, G4int *is2_p);
321
322 /**
323 * This routine describes the anisotropic decay of a particle of
324 * mass xi into 2 particles of masses x1,x2.
325 * The anisotropy is supposed to follow a 1+3*hel*(std::cos(theta))**2 law
326 * with respect to the direction of the incoming particle.
327 *
328 * In the input, p1,p2,p3 is the momentum of particle xi.
329 *
330 * In the output, p1,p2,p3 is the momentum of particle x1,
331 * while q1,q2,q3 is the momentum of particle x2.
332 *
333 * @param p1_p pointer to momentum component 1
334 * @param p2_p pointer to momentum component 2
335 * @param p3_p pointer to momentum component 3
336 * @param wp_p pointer to a double parameter
337 * @param q1_p pointer to momentum component 1
338 * @param q2_p pointer to momentum component 2
339 * @param q3_p pointer to momentum component 3
340 * @param wq_p pointer to a double parameter
341 * @param xi_p pointer to a double parameter
342 * @param x1_p pointer to momentum component 1
343 * @param x2_p pointer to momentum component 2
344 * @param x3_p pointer to momentum compone n3
345 * @param hel_p pointer to a double parameter
346 */
347 void decay2(G4double *p1_p, G4double *p2_p, G4double *p3_p, G4double *wp_p, G4double *q1_p,
348 G4double *q2_p, G4double *q3_p, G4double *wq_p, G4double *xi_p, G4double *x1_p,
349 G4double *x2_p, G4double *hel_p);
350
351 /**
352 * Time calculation.
353 *
354 * @param i an index of particle 1
355 * @param j an index of particle 2
356 */
357 void time(G4int i, G4int j);
358
359 /**
360 * New time.
361 *
362 * @param l1 an integer parameter
363 * @param l2 an integer parameter
364 */
365 void newt(G4int l1, G4int l2);
366
367 /**
368 *
369 *
370 * @param l1 an integer parameter
371 */
372 void new1(G4int l1);
373
374 /**
375 *
376 *
377 * @param y1 a double parameter
378 * @param y2 a double parameter
379 * @param y3 a double parameter
380 * @param q1 a double parameter
381 * @param q2 a double parameter
382 * @param q3 a double parameter
383 * @param q4 a double parameter
384 * @param npion number of pions
385 * @param l1 an integer parameter
386 */
387 void new2(G4double y1, G4double y2, G4double y3, G4double q1, G4double q2, G4double q3,
388 G4double q4, G4int npion, G4int l1);
389
390 /**
391 *
392 *
393 * @param y1 a double parameter
394 * @param y2 a double parameter
395 * @param y3 a double parameter
396 * @param q1 a double parameter
397 * @param q2 a double parameter
398 * @param q3 a double parameter
399 * @param q4 a double parameter
400 * @param npion number of pions
401 * @param l1 an integer parameter
402 */
403 void new3(G4double y1, G4double y2, G4double y3, G4double q1, G4double q2, G4double q3,
404 G4double q4, G4int npion, G4int l1);
405
406 /**
407 * Lorentz transformation.
408 *
409 * @param q1 a double parameter
410 * @param q2 a double parameter
411 * @param q3 a double parameter
412 * @param b1 a double parameter
413 * @param b2 a double parameter
414 * @param b3 a double parameter
415 * @param E energy
416 */
417 void loren(G4double *q1, G4double *q2, G4double *q3, G4double *b1, G4double *b2, G4double *b3, G4double *E);
418
419 /**
420 * Pauli blocking.
421 *
422 * @param l an integer parameter
423 * @param xr a double parameter
424 * @param pr a double parameter
425 * @return a double value
426 */
427 G4double pauliBlocking(G4int l, G4double xr, G4double pr);
428
429 /**
430 * Fit by J. Vandermeulen.
431 * Low energy fit from reference J.Cugnon, D. L'hote and J. Vandermeulen, NIM B111 (1996) 215.
432 *
433 * @param E energy
434 * @param m a double parameter m = 0, 1, 2 for nucleon-nucleon, nucleon-delta, delta-delta
435 * @param i a double parameter i = 2, 0, -2 for pp, pn, nn
436 * @return a double value
437 */
438 G4double lowEnergy(G4double E, G4double m, G4double i);
439
440 /**
441 * Total cross-sections.
442 *
443 * @param E energy
444 * @param m an integer parameter m=0,1,2 for nucleon-nucleon, nucleon-delta, delta-delta
445 * @param i an integer parameter i = 2, 0, -2 for pp, pn, nn
446 * @return a double value
447 */
448 G4double totalCrossSection(G4double E, G4int m, G4int i);
449
450 /**
451 *
452 *
453 * @param Ein energy
454 * @param d a double parameter
455 * @param i an integer parameter
456 * @param isa an integer parameter
457 * @return a double value
458 */
459 G4double srec(G4double Ein, G4double d, G4int i, G4int isa);
460
461 /**
462 * Delta production cross section.
463 *
464 * @param E energy
465 * @param i an integer parameter
466 * @return a double value
467 */
468 G4double deltaProductionCrossSection(G4double E, G4int i);
469
470 /**
471 * Sigma(pi+ + p) in the (3,3) region.
472 * New fit by J. Vandermeulen and constant value above the (3,3) resonance.
473 *
474 * @param x a double parameter
475 * @return a double value
476 */
477 G4double pionNucleonCrossSection(G4double x);
478
479 /**
480 * Transmission probability for a nucleon of kinetic energy
481 * E on the edge of the well of depth v0 (nr approximation).
482 * ,
483 * of the nucleus and r is the target radius
484 *
485 * @param E kinetic energy
486 * @param iz the isospin of the nucleon
487 * @param izn the instanteneous charge
488 * @param r
489 * @param v0
490 * @return a double value
491 */
[1340]492 // G4double transmissionProb(G4double E, G4double iz, G4double izn, G4double r, G4double v0);
493 // G4double transmissionProb(G4double E, G4int iz, G4int izn, G4double r, G4double v0)
494 G4double transmissionProb(G4double E, G4int iz, G4int ia, G4int izn, G4double r, G4double v0);
495 // G4double transmissionProb(G4double E, G4int iz, G4int ia, G4int izn,G4double R, G4double v0);
496 // G4double transmissionProb(G4double E, G4double iz, G4double izn, G4double r, G4double v0);
[819]497
[1340]498 void projo_spec(G4int ia1, G4int ips,
499 G4double fmpinc, G4double pinc, G4double tlab);
500
501 void ordered(G4double t, G4int nb);
502
[819]503 /**
504 *
505 *
506 * @param x1 a double parameter
507 * @param x2 a double parameter
508 * @param x3 a double parameter
509 * @param p1 a double parameter
510 * @param p2 a double parameter
511 * @param p3 a double parameter
512 * @param E a double parameter
513 * @param r2 a double parameter
514 * @return a double value
515 */
[1196]516 G4double ref(G4double &x1, G4double &x2, G4double &x3, G4double p1,
[819]517 G4double p2, G4double p3, G4double E, G4double r2);
518
519 /**
520 * ForceAbsor
521 */
522 void forceAbsor(G4int *nopart, G4int *iarem, G4int *izrem, G4double *esrem, G4double *erecrem,
523 G4double *alrem, G4double *berem, G4double *garem, G4int *jrem);
524
525 /**
526 * ForceAbs
527 * @param iprojo projectile
528 * @param at target mass number
529 * @param zt target charge number
530 * @param ep projectile energy
531 * @param bmax a double parameter
532 * @param pt a double parameter
533 * @return absorption probability
534 */
535 G4double forceAbs(G4double iprojo, G4double at, G4double zt, G4double ep, G4double bmax, G4double pt);
536
537 /**
538 * absoprption xsec revised version rkt-97/5
539 * neutron data from barashenkov
540 * this gives absorption xsec for given zp,ap,zt,at,e (mev/nucleon)
541 * arguement changed to mev; then e=ep/ap mev/nucleon
542 * can be used for neutrons also.
543 * this has coulomb as ours
544 * @param zp projectile charge number
545 * @param zp projectile mass number
546 * @param zt a double parameter
547 * @param zt target charge number
548 * @param at target mass number
549 * @param ep projectile energy
550 */
551 G4double xabs2(G4double zp, G4double ap, G4double zt, G4double at, G4double ep);
552
553 /**
554 * Standard random number generator.
555 * @param *rndm pointer to the variable reserved for random number
556 * @param *seed pointer to the random seed
557 */
558 void standardRandom(G4double *rndm, G4long *seed);
559
560 /**
561 * First derivative of a gaussian potential.
562 * @param *rndm pointer to the variable reserved for random number
563 */
564 void gaussianRandom(G4double *rndm);
565
566 /**
567 * Safe exponential function which eliminates the CPU under and overflows.
568 * @param x a double parameter
569 * @return a double value
570 */
571 G4double safeExp(G4double x);
572
573 /**
574 * Nuclear radius
575 * @param A mass number (double parameter)
576 */
[1340]577 G4double radius(G4int A);
[819]578
579 /** Parametrisation de la section efficace de réaction calculée par incl4.1
580 * iprojo=1 proton incident, iprojo=2, neutron incident).
581 * entre al et u, entre 10 et 100 mev protons, 20 et 100 mev neutrons.
582 * bon ordre de grandeur pour les noyaux légers (c, o ...), trés faux
583 * a energie sup a 100 mev.
584 * (Comment needs to be translated)
585 * @param projectile an integer parameter (1 = proton, 2 = neutron)
586 * @param E energy of the projectile (double parameter)
587 * @param A target mass number (double parameter)
588 * @return cross section (double value)
589 */
590 G4double crossSection(G4int projectile, G4double E, G4double A);
591
592 /**
593 * coulombTransm
594 * subroutine coulomb_transm(e,fm1,z1,fm2,z2,proba)
595 * calcul du coulombien dans lahet (proba de transmission ou
596 * d'entree dans le potentiel nucleaire).
597 * @param E energy (a double parameter)
598 * @param fm1 a double parameter
599 * @param z1 a double parameter
600 * @param fm2 a double parameter
601 * @param z2 a double parameter
602 * @return a double value
603 */
604 G4double coulombTransm(G4double E, G4double fm1, G4double z1, G4double fm2, G4double z2);
605
606 /**
607 * Clmb1
608 * @param eta a double parameter \f$\eta = c_2*z_1*z_2*\sqrt{m/E}\f$
609 * @param rho a double parameter \f$\rho = c_3*(r_1+r_2)*\sqrt{mE}\f$
610 * @return a double value
611 */
612 G4double clmb1(G4double rho, G4double eta, G4double *ml);
613
614 /**
615 * First derivative of a gaussian potential.
616 * @param eta a double parameter \f$\eta = c_2*z_1*z_2*\sqrt{m/E}\f$
617 * @param rho a double parameter \f$\rho = c_3*(r_1+r_2)*\sqrt{mE}\f$
618 * @return a double value
619 */
620 G4double clmb2(G4double rho, G4double eta, G4double *t1);
621
622public: // Utilities
623 /**
624 * Returns the smaller of two numbers.
625 * @param a a double value
626 * @param b a double value
627 * @return a double value
628 */
629 G4double min(G4double a, G4double b);
630
631 /**
632 * Returns the smaller of two numbers.
633 * @param a an integer value
634 * @param b an integer value
635 * @return an integer value
636 */
637 G4int min(G4int a, G4int b);
638
639 /**
640 * Returns the greater of two numbers.
641 * @param a a double value
642 * @param b a double value
643 * @return a double value
644 */
645 G4double max(G4double a, G4double b);
646
647 /**
648 * Returns the greater of two numbers.
649 * @param a an integer value
650 * @param b an integer value
651 * @return an integer value
652 */
653 G4int max(G4int a, G4int b);
654
655 /**
656 * Rounds a double to the nearest int
657 * @param a double parameter
658 * @return an integer value
659 */
660 G4int nint(G4double number);
661
662 /**
663 * Calls a function
664 * @param functionChoice an integer value representing the choice of
665 * function (0 = wsax, 1 = derivWsax, 2 = dmho, 3 = derivMho, 4 = derivGaus)
666 * @param r a double parameter
667 * @return a double value
668 */
669 G4double callFunction(G4int functionChoice, G4double r);
670
671 G4double am(G4double a, G4double b, G4double c, G4double d);
672 G4double pcm(G4double e, G4double a, G4double c);
673 G4double sign(G4double a, G4double b);
674 G4double utilabs(G4double a);
675 G4double amax1(G4double a, G4double b);
676 G4double w(G4double a, G4double b, G4double c, G4double d);
677 G4int idnint(G4double a);
[1315]678
679 void print_log_start_step();
680 void print_log_end_step();
681 void print_log_entry(G4int iavatars, G4int iselected, G4int iparticles, G4int imin);
682 void print_avatars();
683 void print_one_avatar(G4int index);
684 void print_one_particle(G4int index);
685 void print_three_vector(G4double x, G4double y, G4double z);
686 void print_map();
687
[819]688 private:
689
690 /**
691 * Random seeds for INCL4 internal random number generators.
692 */
693 G4Hazard *hazard;
694
695 /**
696 * Data structure for INCL4.
697 */
698 G4Dton *dton;
699
700 /**
701 * Data structure for INCL4. Contains the Woods-Saxon potential
702 * functions for target nuclei.
703 */
704 G4Saxw *saxw;
705
706 /**
707 * Data structure for INCL4.
708 */
709 G4Ws *ws;
710
711 /**
712 * G4Spl2
713 */
714 G4Spl2 *spl2;
715
716 /**
717 * G4LightGausNuc
718 */
719 G4LightGausNuc *light_gaus_nuc;
720
721 /**
722 * G4LightNuc
723 */
724 G4LightNuc *light_nuc;
725
726 /**
[1340]727 * INCL input data structure
[819]728 */
[1340]729 G4InclInput *calincl;
[819]730
731 /**
732 * G4Mat
733 */
734 G4Mat *mat;
735
736 /**
737 *
738 */
739 G4Bl1 *bl1;
740
741 /**
742 *
743 */
744 G4Bl2 *bl2;
745
746 /**
747 *
748 */
749 G4Bl3 *bl3;
750
751 /**
752 *
753 */
754 G4Bl4 *bl4;
755
756 /**
757 *
758 */
759 G4Bl5 *bl5;
760
761 /**
762 *
763 */
764 G4Bl6 *bl6;
765
766 /**
767 *
768 */
769 G4Bl8 *bl8;
770
771 /**
772 *
773 */
774 G4Bl9 *bl9;
775
776 /**
777 *
778 */
779 G4Bl10 *bl10;
780
781 /**
782 *
783 */
784 G4Kind *kindstruct;
785
786 /**
[1340]787 * Projectile properties.
788 */
789 G4Bev *bev;
790
791 /**
[819]792 *
793 */
794 G4Paul *paul;
795
796 /**
797 * Detailed information of the cascade
798 */
799 G4VarAvat *varavat;
800
801 /**
802 * Cascade output.
803 */
804 G4VarNtp *varntp;
805
806 /**
807 * For storing the results of the evaporation.
808 */
809 G4VarNtp *evaporationResult;
810
811 /**
812 * Defines the verbosity of console output. Values can be between 0
813 * and 4 where 0 means silent and 4 the most verbose possible
814 * output.
815 */
816 G4int verboseLevel;
817
818 /**
819 * Function ID for wsax.
820 * @see wsax
821 * @see integrate
822 * @see callFunction
823 */
824 G4int wsaxFunction;
825
826 /**
827 * Function ID for derivWsax.
828 * @see derivWsax
829 * @see integrate
830 * @see callFunction
831 */
832 G4int derivWsaxFunction;
833
834 /**
835 * Function ID for dmho.
836 * @see derivWsax
837 * @see integrate
838 * @see callFunction
839 */
840 G4int dmhoFunction;
841
842 /**
843 * Function ID for derivMho.
844 * @see derivMho
845 * @see integrate
846 * @see callFunction
847 */
848 G4int derivMhoFunction;
849
850 /**
851 * Function ID for derivGaus.
852 * @see derivGaus
853 * @see integrate
854 * @see callFunction
855 */
856 G4int derivGausFunction;
857
858 /**
859 * Function ID for dens.
860 * @see dens
861 * @see integrate
862 * @see callFunction
863 */
864 G4int densFunction;
865
[1340]866 /**
867 * Use fermi break-up?
868 */
869 G4bool useFermiBreakup;
870
871 /**
872 * Projectile spectator nucleus support?
873 */
874 G4bool useProjSpect;
875
876 /**
877 * Type of the particle at index i.
878 *
879 * The extension to large composite projectiles the value is
880 * negative for projectile spectators. Otherwise the particle types
881 * are given in exactly the same way as in G4Calincl::f[6].
882 * @see G4Calincl::f
883 */
[819]884 G4int kind[300]; //= (*kind_p);
885 G4double ep[300]; // = (*ep_p);
886 G4double alpha[300]; // = (*alpha_p);
887 G4double beta[300]; // = (*beta_p);
888 G4double gam[300]; // = (*gam_p);
889
[1340]890 G4VBe *be;
891 G4InclProjSpect *ps;
892 G4InclFermi *fermi;
893 G4QuadvectProjo *qvp;
[819]894 G4Volant *volant;
895 G4Abla *abla;
[962]896 G4InclRandomInterface *randomGenerator;
[1315]897
[1340]898 G4VInclLogger *theLogger;
[1315]899 G4int inside_step; // Flag to determine whether we are inside or outside a simulation step
[819]900};
901
902#endif
Note: See TracBrowser for help on using the repository browser.