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

Last change on this file since 1036 was 962, checked in by garnier, 17 years ago

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