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

Last change on this file since 1199 was 1196, checked in by garnier, 16 years ago

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