cloudy trunk
Loading...
Searching...
No Matches
parse_atom_iso.cpp
Go to the documentation of this file.
1/* This file is part of Cloudy and is copyright (C)1978-2013 by Gary J. Ferland and
2 * others. For conditions of distribution and use see copyright notice in license.txt */
3/*ParseAtomISO parse information from the atom XX-like command line */
4#include "cddefines.h"
5#include "elementnames.h"
6#include "optimize.h"
7#include "hydrogenic.h"
8#include "input.h"
9#include "iso.h"
10#include "parser.h"
11#include "phycon.h"
12#include "rfield.h"
13#include "taulines.h"
14#include "thirdparty.h"
15
16/*ParseAtomISO parse parameters off the XX-like command */
17void ParseAtomISO(long ipISO, Parser &p )
18{
19 long int numLevels;
20
21 DEBUG_ENTRY( "ParseAtomISO()" );
22
23 /* look for the name of an element - if we don't find one do the entire
24 * iso sequence - returns negative number if element not found */
25 long int nelem = p.GetElem( );
26
27 /* H-like Helium is not possible */
28 if( ipISO==ipHE_LIKE && nelem==ipHYDROGEN )
29 {
30 fprintf(ioQQQ," Sorry, H-like He does not exist.\n");
32 }
33
34 /* collisions - don't pick up the levels collapsed command */
35 if( p.nMatch("COLL") && !p.nMatch("LEVE" ) )
36 {
37 /* option to turn collisions off, all are
38 * set to 1 in zero. command can accept only one option at a time */
39 if( p.nMatch("EXCI") )
40 {
41 /* turn off collisional excitation */
42 iso_ctrl.lgColl_excite[ipISO] = false;
43 phycon.lgPhysOK = false;
44 }
45 else if( p.nMatch("IONI") )
46 {
47 /* turn off collisional ionization */
48 iso_ctrl.lgColl_ionize[ipISO] = false;
49 phycon.lgPhysOK = false;
50 }
51
52 else if( p.nMatch("2S2P") || ( p.nMatch("2P2S") && ipISO == ipH_LIKE ) )
53 {
54 /* >>chng 02 feb 07, change from 2s2p to l-mixing */
55 /* this is the atom h-like collision l-mixing command */
56 fprintf(ioQQQ,"This command changed to ATOM H-LIKE COLLISIONS L-MIXING\n");
57 fprintf(ioQQQ,"I will parse it for now, but may not in the future.\n");
58 /* turn off 2s - 2p collisions */
59 iso_ctrl.lgColl_l_mixing[ipISO] = false;
60 phycon.lgPhysOK = false;
61 }
62
63 else if( p.nMatch("L-MI") )
64 {
65 if( ipISO == ipH_LIKE )
66 {
67 /* >>chng 02 feb 07, change from 2s2p to l-mixing */
68 /* this is the atom h-like collision l-mixing command */
69 iso_ctrl.lgColl_l_mixing[ipISO] = false;
70 phycon.lgPhysOK = false;
71 }
72 else if( p.nMatch("THER") )
73 {
74 /* use l-mix from
75 *>>refer l-mix all Vrinceanu, D. & Flannery, M. R. 2001, PhysRevA 63, 032701 */
76 if( p.nMatch("NO T") )
77 {
78 /* This is the "NO Thermal average" command. It
79 * causes collisions strengths to be evaluated at kT rather than
80 * integrated over a Maxwellian peaked at kT. */
81 iso_ctrl.lgCS_therm_ave[ipISO] = false;
82 }
83 else
84 {
85 iso_ctrl.lgCS_therm_ave[ipISO] = true;
86 }
87 }
88 else if( p.nMatch("PENG") )
89 {
90 iso_ctrl.lgCS_Vrinceanu[ipISO] = false;
91 }
92 else if( p.nMatch(" OFF" ) )
93 {
94 /* this is the atom xx-like collision l-mixing command */
95 /* turn off same-n collisions */
96 iso_ctrl.lgColl_l_mixing[ipISO] = false;
97 phycon.lgPhysOK = false;
98 iso_ctrl.lgCS_Vrinceanu[ipISO] = false;
99 iso_ctrl.lgCS_therm_ave[ipISO] = false;
100 }
101 else
102 {
103 fprintf( ioQQQ, " needs parameter\n" );
105 }
106 }
107 else if( p.nMatch(" OFF" ) )
108 {
109 /* turn everything off, since no keyword given */
110 iso_ctrl.lgColl_excite[ipISO] = false;
111 iso_ctrl.lgColl_ionize[ipISO] = false;
112 iso_ctrl.lgColl_l_mixing[ipISO] = false;
113 phycon.lgPhysOK = false;
114 }
115 else
116 {
117 fprintf( ioQQQ, " needs parameter\n" );
119 }
120 }
121
122 else if( p.nMatch("CONT") && p.nMatch("LOWE") )
123 {
124 /* disable continuum lowering for this isoelectronic sequence */
125 if( p.nMatch("OFF") )
126 iso_ctrl.lgContinuumLoweringEnabled[ipISO] = false;
127 else
128 iso_ctrl.lgContinuumLoweringEnabled[ipISO] = true;
129 }
130
131 else if( p.nMatch("DAMP") )
132 {
133 if( ipISO == ipHE_LIKE )
134 {
135 fprintf(ioQQQ," Sorry, the DAMPING option is not implemented for the he-like sequence.\n");
137 }
138
139 /* turn off absorption due to Ly alpha damping wings */
140 hydro.DampOnFac = 0.;
141 }
142
143 else if( p.nMatch("DIEL") )
144 {
145 if( ipISO == ipH_LIKE )
146 {
147 fprintf(ioQQQ," Sorry, but dielectronic recombination onto the h-like sequence is not possible.\n");
149 }
150
151 /* This sets which set of data to use for dielectronic recombination. */
152 if( p.nMatch(" OFF") )
153 {
154 iso_ctrl.lgDielRecom[ipISO] = false;
155 }
156 else
157 iso_ctrl.lgDielRecom[ipISO] = true;
158 }
159
160 else if( p.nMatch("LEVE") )
161 {
162 /* the number of levels read in is n, the principal quantum number
163 * only lines with upper levels less than n will be printed */
164
165 /* number of levels for iso-sequence */
166 /* there are two options here,
167 * when keyword ELEMENT appears, scan off element name and change levels only for
168 * that one.
169 * when there is no ELEMENT then set all in iso to same number */
170
171 /* lgHydroMalloc is false at start of calculation, set true when space
172 * allocated for the hydrogen and helium lines. Once done we must ignore all
173 * future changes in the number of levels */
174 if( p.nMatch("LTE") )
175 {
176 /* force level ratios to LTE */
177 iso_ctrl.lgLTE_levels[ipISO] = true;
178 }
179 else if( p.nMatch("PRIN") )
180 {
181 /* only print - do not change levels */
182 iso_ctrl.lgPrintNumberOfLevels = true;
183 }
184 else if( !lgHydroMalloc )
185 {
186 numLevels = (long int)p.FFmtRead();
187
188 if( !p.lgEOL() )
189 {
190 if( ipISO == ipH_LIKE && numLevels > NHYDRO_MAX_LEVEL-2 )
191 {
192 fprintf( ioQQQ, " Not possible to set nhlvl to >NHYDRO_MAX_LEVEL-2= %i\n",
194 fprintf( ioQQQ, " change NHYDRO_MAX_LEVEL\n");
196 }
197
198 /* check that alpha transition of highest level is within energy bounds of continuum */
199 if( !p.nMatch("COLL") && ipISO == ipH_LIKE &&
200 ( 2. / POW3((double)numLevels) < rfield.emm ) )
201 {
202 fprintf( ioQQQ, " Not possible to set iso_sp[ipH_LIKE][ipHYDROGEN].numLevels_max to such a high value, since "
203 "alpha transition not within energy bounds of code\n");
204
205 fprintf( ioQQQ, " lowest energy is %e and corresponding highest level is %li\n" ,
206 rfield.emm, (long)pow(2./rfield.emm, 0.3333) );
208 }
209 }
210
211 if( p.lgEOL() )
212 {
213 int LevelsResolved=-1 , LevelsCollapsed=10;
214 /* no number, so check for either large or small */
215 if( p.nMatch("LARG") )
216 {
217 /* includes all levels with tabulated rec coefficient */
218 LevelsResolved = RREC_MAXN;
219 }
220
221 /* this is small or compact keyword */
222 else if( p.nMatch("SMAL") || p.nMatch("COMP") )
223 {
224 if( ipISO == ipH_LIKE )
225 LevelsResolved = 5;
226 else if( ipISO == ipHE_LIKE )
227 LevelsResolved = 3;
228 else
230 }
231 else
232 /* punch out if no number */
233 p.NoNumb("levels");
234
235 if( nelem<0 )
236 {
237 // element not specified, do entire sequence
238 for( nelem=ipISO; nelem<LIMELM; ++nelem )
239 {
240 iso_sp[ipISO][nelem].nCollapsed_max =
241 MIN2( iso_sp[ipISO][nelem].nCollapsed_max , LevelsCollapsed );
242 iso_sp[ipISO][nelem].n_HighestResolved_max =
243 MIN2( iso_sp[ipISO][nelem].n_HighestResolved_max , LevelsResolved );
244 iso_update_num_levels( ipISO, nelem );
245 }
246 }
247 else
248 {
249 iso_sp[ipISO][nelem].nCollapsed_max = LevelsCollapsed;
250 iso_sp[ipISO][nelem].n_HighestResolved_max = LevelsResolved;
251 iso_update_num_levels( ipISO, nelem );
252 }
253 }
254
255 else if( p.nMatch("COLLAP") )
256 {
257 // set number of collapsed levels
258 if( numLevels < 1 )
259 {
260 fprintf( ioQQQ, "There must be at least one collapsed level.\n");
262 }
263
264 if( nelem<0 )
265 {
266 // element not specified, do entire sequence
267 for( nelem=ipISO; nelem<LIMELM; ++nelem )
268 {
269 iso_sp[ipISO][nelem].nCollapsed_max = numLevels;
270 iso_update_num_levels( ipISO, nelem );
271 }
272 }
273 else
274 {
275 iso_sp[ipISO][nelem].nCollapsed_max = numLevels;
276 iso_update_num_levels( ipISO, nelem );
277 }
278 }
279 else if( p.nMatch("RESOLV") )
280 {
281 // number of resolved levels
282 if( ( numLevels < 3 ) && !p.nMatch("COLL") )
283 {
284 fprintf( ioQQQ, " cannot have fewer than 3 resolved levels, the requested number was %li\n" ,
285 numLevels );
286 fprintf( ioQQQ, " Sorry.\n" );
288 }
289
290 if( nelem<0 )
291 {
292 // element not specified, do entire sequence
293 for( nelem=ipISO; nelem<LIMELM; ++nelem )
294 {
295 iso_sp[ipISO][nelem].n_HighestResolved_max = numLevels;
296 iso_update_num_levels( ipISO, nelem );
297 }
298 }
299 else
300 {
301 iso_sp[ipISO][nelem].n_HighestResolved_max = numLevels;
302 iso_update_num_levels( ipISO, nelem );
303 }
304 }
305 else
306 {
307 fprintf(ioQQQ, "I did not recognize a keyword on this atom xx-like levels command."
308 " Should be COLLAPSED or RESOLVED.\n Sorry.\n\n");
310 }
311 }
312 }
313
314 else if( p.nMatch("ERRO") && p.nMatch("GENE" ) )
315 {
316 /* Rates will be modified by a randomly generated error that falls within
317 * the range specifically set for each rate (or set of rates). */
318 iso_ctrl.lgRandErrGen[ipISO] = true;
319 iso_ctrl.modelRank[ipISO] = (int)p.FFmtRead();
320
321 iso_ctrl.modelRank[ipISO] = MAX2( 0, iso_ctrl.modelRank[ipISO] );
322 if( p.lgEOL() )
323 /* Changed to avoid lint complaint */
324 /* iso_ctrl.modelRank[ipISO] = (unsigned)time(NULL); */
325 iso_ctrl.modelRank[ipISO] = abs((int)time(NULL));
326
327 /* this allows a seed that is dependent upon the processor rank
328 * in a parallel run. */
329 /* We add 2 so that the seed is always greater than 1, which would reset the generator. */
330 init_genrand( (unsigned)iso_ctrl.modelRank[ipISO] + 2);
331
332 if( p.nMatch("PESS") )
333 iso_ctrl.lgPessimisticErrors = true;
334 else
335 iso_ctrl.lgPessimisticErrors = false;
336 }
337
338 else if( p.nMatch(" FSM") )
339 {
340 if( ipISO == ipH_LIKE )
341 {
342 fprintf(ioQQQ," Sorry, but fine-structure mixing can only be implemented for the He-like sequence.\n");
344 }
345
346 if( !p.nMatch("CRASH"))
347 {
348 fprintf(ioQQQ," Sorry, but fine-structure mixing for the He-like sequence does not now work.\n");
349 fprintf(ioQQQ," Add the keyword CRASH to skip this message and proceed on to the problem.\n");
351 }
352 /* turn on fine structure mixing of spontaneous decays.
353 * >>refer Helike FSM Bauman, R., MacAdams, K., and Ferland, G. (2003). */
354 if( p.nMatch(" OFF") )
355 iso_ctrl.lgFSM[ipISO] = false;
356 else
357 iso_ctrl.lgFSM[ipISO] = true;
358 }
359
360 else if( p.nMatch("GBAR") )
361 {
362 if( ipISO == ipH_LIKE )
363 {
364 fprintf(ioQQQ," Sorry, the GBAR option is only implemented for the He-like sequence.\n");
366 }
367
368 /* the HEGBAR command - to change cs of higher levels */
369 /* first turn all off, one will be turned back on */
370 iso_ctrl.lgCS_Vriens[ipISO] = false;
371 iso_ctrl.lgCS_None[ipISO] = false;
372 iso_ctrl.nCS_new[ipISO] = false;
373
374 /* now turn one on */
375 if( p.nMatch("VRIE") )
376 {
377 /* option to change how collisions for unknown levels affect things */
378 iso_ctrl.lgCS_Vriens[ipISO] = true;
379 }
380 else if( p.nMatch(" NEW") )
381 {
382 /* option to change how collisions for unknown levels affect things */
383 iso_ctrl.nCS_new[ipISO] = (int)p.FFmtRead();
384
385 /* there are two options, 1 and 2, for which fit - default (no number)
386 * will be 1, the broken power law fit */
387 if( p.lgEOL() )
388 iso_ctrl.nCS_new[ipISO] = 1;
389
390 ASSERT( iso_ctrl.nCS_new[ipISO] );
391 }
392 else if( p.nMatch(" OFF") )
393 {
394 /* option to change how collisions for unknown levels affect things */
395 iso_ctrl.lgCS_None[ipISO] = true;
396 }
397 else
398 {
399 fprintf( ioQQQ, " needs parameter\n" );
401 }
402 }
403
404
405 else if( p.nMatch("LYMA") )
406 {
407 if( ipISO == ipH_LIKE && p.nMatch("PUMP") )
408 {
409 /* >>chng 05 jul 08, separate out Lyman pump commands */
410 if( p.nMatch(" OFF") )
411 {
412 /* option to turn off all continuum pumping of Lyman lines */
413 hydro.lgLymanPumping = false;
414 }
415 else if( p.nMatch("SCALE") )
416 {
417 /* multiplicative factor for all continuum pumping of H I Lyman lines,
418 * account for possible emission in the line - only affects H I
419 * not entire H-like iso sequence */
420 hydro.xLymanPumpingScaleFactor =
421 (realnum)p.FFmtRead();
422 /* scale factor is log if <=0,
423 * represents line in emission if >1
424 * LOG keyword forces interpretation as a log */
425 if( hydro.xLymanPumpingScaleFactor <= 0. ||
426 p.nMatch(" LOG") )
427 {
428 hydro.xLymanPumpingScaleFactor =
429 (realnum)pow((realnum)10.f , hydro.xLymanPumpingScaleFactor );
430 }
431
432 /* vary option */
433 if( optimize.lgVarOn )
434 {
435 optimize.nvarxt[optimize.nparm] = 1;
436 strcpy( optimize.chVarFmt[optimize.nparm], "ATOM H-LIKE LYMAN PUMPING SCALE %f LOG" );
437
438 /* pointer to where to write */
439 optimize.nvfpnt[optimize.nparm] = input.nRead;
440
441 /* current parameters - always log so steps are log */
442 optimize.vincr[optimize.nparm] = 0.1f;
443 optimize.vparm[0][optimize.nparm] = (realnum)log10(hydro.xLymanPumpingScaleFactor);
444 ++optimize.nparm;
445 }
446 }
447 else
448 {
449 fprintf(ioQQQ," Sorry, I didn\'t recognize an option on this ATOM H-LIKE LYMAN PUMP command.\n");
450 fprintf(ioQQQ," The options are \" OFF\", and \"SCALE\".\n");
452 }
453 }
454 else if( p.nMatch("EXTRA") )
455 {
456 /* option to set number of "extra" Lyman lines, used for optical depths only */
457 iso_ctrl.nLyman[ipISO] = (long int)p.FFmtRead();
458 if( p.lgEOL() )
459 p.NoNumb("'extra' Lyman lines");
460 if( iso_ctrl.nLyman[ipISO] < 2 )
461 {
462 // Code does not elsewhere protect against values less than 2.
463 fprintf(ioQQQ," Sorry, the value on this ATOM xx-LIKE LYMAN command must be at least 2.\n");
465 }
466 }
467 else
468 {
469 fprintf(ioQQQ," Sorry, I didn\'t recognize an option on this ATOM xx-LIKE LYMAN command.\n");
470 fprintf(ioQQQ," The options are \"PUMP\", and \"EXTRA\".\n");
472 }
473 }
474
475 /* don't interpolate on look-up tables but compute recombination on the fly instead */
476 else if( p.nMatch("RECO") &&
477 p.nMatch(" NO ") && p.nMatch("INTE") )
478 {
479 /* flag set by atom xx-like no recombination interp command,
480 * says to generate recombination coefficients
481 * on the fly */
482 iso_ctrl.lgNoRecombInterp[ipISO] = true;
483 }
484
485 else if( p.nMatch("REDI") )
486 {
487 int ipRedis=0;
488 /* there are three functions, PRD_, CRD_, and CRDW,
489 * representing partial redistribution,
490 * complete redistribution (doppler core only, no wings)
491 * and complete with wings */
492 /* partial redistribution */
493 if( p.nMatch(" PRD") )
494 {
495 ipRedis = ipPRD;
496 }
497 /* complete redistribution no wings */
498 else if( p.nMatch(" CRD") )
499 {
500 ipRedis = ipCRD;
501 }
502 /* complete redistribution with wings */
503 else if( p.nMatch("CRDW") )
504 {
505 ipRedis = ipCRDW;
506 }
507
508 /* if not SHOW option (handled below) then we have a problem */
509 else if( !p.nMatch("SHOW") )
510 {
511 fprintf(ioQQQ," There should have been a second keyword on this command.\n");
512 fprintf(ioQQQ," Options are _PRD, _CRD, CRDW (_ is space). Sorry.\n");
514 }
515
516 /* resonance lines - not Lya*/
517 if( p.nMatch("ALPH") )
518 {
519 iso_ctrl.ipLyaRedist[ipISO] = ipRedis;
520 }
521 /* Lya itself */
522 else if( p.nMatch("RESO") )
523 {
524 iso_ctrl.ipResoRedist[ipISO] = ipRedis;
525 }
526 /* subordinate lines */
527 else if( p.nMatch("SUBO") )
528 {
529 iso_ctrl.ipSubRedist[ipISO] = ipRedis;
530 }
531 /* the show option, say what we are assuming */
532 else if( p.nMatch("SHOW") )
533 {
534 fprintf(ioQQQ," Ly a is ");
535 if( iso_ctrl.ipLyaRedist[ipISO] ==ipCRDW )
536 {
537 fprintf(ioQQQ,"complete redistribution with wings\n");
538 }
539 else if( iso_ctrl.ipLyaRedist[ipISO] ==ipCRD )
540 {
541 fprintf(ioQQQ,"complete redistribution with core only.\n");
542 }
543 else if( iso_ctrl.ipLyaRedist[ipISO] ==ipPRD )
544 {
545 fprintf(ioQQQ,"partial redistribution.\n");
546 }
547 else if( iso_ctrl.ipLyaRedist[ipISO] ==ipLY_A )
548 {
549 fprintf(ioQQQ,"special Lya.\n");
550 }
551 else
552 {
553 fprintf(ioQQQ," PROBLEM Impossible value for iso_ctrl.ipLyaRedist.\n");
555 }
556
557 fprintf(ioQQQ," Other %s resonance lines are ",
558 elementnames.chElementSym[ipISO] );
559
560 if( iso_ctrl.ipResoRedist[ipISO] ==ipCRDW )
561 {
562 fprintf(ioQQQ,"complete redistribution with wings\n");
563 }
564 else if( iso_ctrl.ipResoRedist[ipISO] ==ipCRD )
565 {
566 fprintf(ioQQQ,"complete redistribution with core only.\n");
567 }
568 else if( iso_ctrl.ipResoRedist[ipISO] ==ipPRD )
569 {
570 fprintf(ioQQQ,"partial redistribution.\n");
571 }
572 else
573 {
574 fprintf(ioQQQ," PROBLEM Impossible value for iso_ctrl.ipResoRedist.\n");
576 }
577
578 fprintf(ioQQQ," %s subordinate lines are ",
579 elementnames.chElementSym[ipISO] );
580
581 if( iso_ctrl.ipSubRedist[ipISO] ==ipCRDW )
582 {
583 fprintf(ioQQQ,"complete redistribution with wings\n");
584 }
585 else if( iso_ctrl.ipSubRedist[ipISO] ==ipCRD )
586 {
587 fprintf(ioQQQ,"complete redistribution with core only.\n");
588 }
589 else if( iso_ctrl.ipSubRedist[ipISO] ==ipPRD )
590 {
591 fprintf(ioQQQ,"partial redistribution.\n");
592 }
593 else
594 {
595 fprintf(ioQQQ," PROBLEM Impossible value for iso_ctrl.ipSubRedist.\n");
597 }
598 }
599 else
600 {
601 fprintf(ioQQQ," here should have been another keyword on this command.\n");
602 fprintf(ioQQQ," Options are ALPHA, RESONANCE, SUBORDINATE. Sorry.\n");
604 }
605 }
606
607 else if( p.nMatch("TOPO") )
608 {
609 if( p.nMatch(" OFF") )
610 {
611 iso_ctrl.lgTopoff[ipISO] = false;
612 fprintf( ioQQQ, "ISO %li TOPOFF is OFF\n", ipISO );
613 }
614 else
615 iso_ctrl.lgTopoff[ipISO] = true;
616 }
617
618
619 else
620 {
621 fprintf( ioQQQ, " There should have been a keyword on this ATOM H-LIKE or HE-LIKE command.\n Sorry.\n" );
623 }
624 return;
625}
FILE * ioQQQ
Definition cddefines.cpp:7
#define ASSERT(exp)
Definition cddefines.h:578
#define POW3
Definition cddefines.h:936
#define MIN2
Definition cddefines.h:761
const int NHYDRO_MAX_LEVEL
Definition cddefines.h:266
const int LIMELM
Definition cddefines.h:258
#define EXIT_FAILURE
Definition cddefines.h:140
#define cdEXIT(FAIL)
Definition cddefines.h:434
float realnum
Definition cddefines.h:103
#define MAX2
Definition cddefines.h:782
const int ipCRDW
Definition cddefines.h:294
NORETURN void TotalInsanity(void)
Definition service.cpp:886
const int ipHYDROGEN
Definition cddefines.h:305
#define DEBUG_ENTRY(funcname)
Definition cddefines.h:684
const int ipCRD
Definition cddefines.h:292
const int ipLY_A
Definition cddefines.h:296
const int ipPRD
Definition cddefines.h:290
bool lgHydroMalloc
Definition cdinit.cpp:61
long int GetElem(void) const
Definition parser.cpp:209
double FFmtRead(void)
Definition parser.cpp:353
bool nMatch(const char *chKey) const
Definition parser.h:135
bool lgEOL(void) const
Definition parser.h:98
NORETURN void NoNumb(const char *chDesc) const
Definition parser.cpp:233
t_elementnames elementnames
t_hydro hydro
Definition hydrogenic.cpp:5
t_input input
Definition input.cpp:12
t_iso_sp iso_sp[NISO][LIMELM]
Definition iso.cpp:8
t_isoCTRL iso_ctrl
Definition iso.cpp:6
void iso_update_num_levels(long ipISO, long nelem)
const int ipHE_LIKE
Definition iso.h:63
#define RREC_MAXN
Definition iso.h:95
const int ipH_LIKE
Definition iso.h:62
t_optimize optimize
Definition optimize.cpp:5
void ParseAtomISO(long ipISO, Parser &p)
t_phycon phycon
Definition phycon.cpp:6
t_rfield rfield
Definition rfield.cpp:8
void init_genrand(unsigned long s)