cloudy  trunk
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 */
17 void 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");
31  cdEXIT(EXIT_FAILURE);
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" );
104  cdEXIT(EXIT_FAILURE);
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" );
118  cdEXIT(EXIT_FAILURE);
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");
136  cdEXIT(EXIT_FAILURE);
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");
148  cdEXIT(EXIT_FAILURE);
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",
193  NHYDRO_MAX_LEVEL-2 );
194  fprintf( ioQQQ, " change NHYDRO_MAX_LEVEL\n");
195  cdEXIT(EXIT_FAILURE);
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) );
207  cdEXIT(EXIT_FAILURE);
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
229  TotalInsanity();
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");
261  cdEXIT(EXIT_FAILURE);
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" );
287  cdEXIT(EXIT_FAILURE);
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");
309  cdEXIT(EXIT_FAILURE);
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");
343  cdEXIT(EXIT_FAILURE);
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");
350  cdEXIT(EXIT_FAILURE);
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");
365  cdEXIT(EXIT_FAILURE);
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" );
400  cdEXIT(EXIT_FAILURE);
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");
451  cdEXIT(EXIT_FAILURE);
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");
464  cdEXIT(EXIT_FAILURE);
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");
471  cdEXIT(EXIT_FAILURE);
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");
513  cdEXIT(EXIT_FAILURE);
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");
554  TotalInsanity();
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");
575  TotalInsanity();
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");
596  TotalInsanity();
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");
603  cdEXIT(EXIT_FAILURE);
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" );
622  cdEXIT(EXIT_FAILURE);
623  }
624  return;
625 }
Parser::nMatch
bool nMatch(const char *chKey) const
Definition: parser.h:135
t_optimize::vincr
realnum vincr[LIMPAR]
Definition: optimize.h:191
Parser::FFmtRead
double FFmtRead(void)
Definition: parser.cpp:353
ipHE_LIKE
const int ipHE_LIKE
Definition: iso.h:63
NHYDRO_MAX_LEVEL
const int NHYDRO_MAX_LEVEL
Definition: cddefines.h:266
t_optimize::nparm
long int nparm
Definition: optimize.h:201
elementnames.h
t_iso_sp::n_HighestResolved_max
long int n_HighestResolved_max
Definition: iso.h:505
t_input::nRead
long int nRead
Definition: input.h:49
rfield
t_rfield rfield
Definition: rfield.cpp:8
ioQQQ
FILE * ioQQQ
Definition: cddefines.cpp:7
elementnames
t_elementnames elementnames
Definition: elementnames.cpp:5
t_hydro::lgLymanPumping
bool lgLymanPumping
Definition: hydrogenic.h:111
realnum
float realnum
Definition: cddefines.h:103
rfield.h
t_isoCTRL::lgCS_Vriens
bool lgCS_Vriens[NISO]
Definition: iso.h:388
t_isoCTRL::lgTopoff
bool lgTopoff[NISO]
Definition: iso.h:408
t_isoCTRL::lgCS_None
bool lgCS_None[NISO]
Definition: iso.h:389
t_isoCTRL::lgPessimisticErrors
bool lgPessimisticErrors
Definition: iso.h:406
t_optimize::lgVarOn
bool lgVarOn
Definition: optimize.h:203
thirdparty.h
t_isoCTRL::lgRandErrGen
bool lgRandErrGen[NISO]
Definition: iso.h:403
phycon
t_phycon phycon
Definition: phycon.cpp:6
t_isoCTRL::lgPrintNumberOfLevels
bool lgPrintNumberOfLevels
Definition: iso.h:328
input
t_input input
Definition: input.cpp:12
ASSERT
#define ASSERT(exp)
Definition: cddefines.h:578
iso.h
ipHYDROGEN
const int ipHYDROGEN
Definition: cddefines.h:305
t_isoCTRL::lgColl_excite
bool lgColl_excite[NISO]
Definition: iso.h:342
t_isoCTRL::lgFSM
bool lgFSM[NISO]
Definition: iso.h:399
MIN2
#define MIN2
Definition: cddefines.h:761
t_isoCTRL::ipLyaRedist
int ipLyaRedist[NISO]
Definition: iso.h:374
t_isoCTRL::lgColl_l_mixing
bool lgColl_l_mixing[NISO]
Definition: iso.h:339
t_isoCTRL::nCS_new
int nCS_new[NISO]
Definition: iso.h:392
t_isoCTRL::lgNoRecombInterp
bool lgNoRecombInterp[NISO]
Definition: iso.h:385
t_isoCTRL::modelRank
int modelRank[NISO]
Definition: iso.h:411
optimize
t_optimize optimize
Definition: optimize.cpp:5
ParseAtomISO
void ParseAtomISO(long ipISO, Parser &p)
Definition: parse_atom_iso.cpp:17
t_optimize::vparm
realnum vparm[LIMEXT][LIMPAR]
Definition: optimize.h:188
t_optimize::chVarFmt
char chVarFmt[LIMPAR][FILENAME_PATH_LENGTH_2]
Definition: optimize.h:263
t_isoCTRL::lgColl_ionize
bool lgColl_ionize[NISO]
Definition: iso.h:345
EXIT_FAILURE
#define EXIT_FAILURE
Definition: cddefines.h:140
Parser::NoNumb
NORETURN void NoNumb(const char *chDesc) const
Definition: parser.cpp:233
Parser
Definition: parser.h:31
t_isoCTRL::lgCS_therm_ave
bool lgCS_therm_ave[NISO]
Definition: iso.h:391
t_isoCTRL::lgDielRecom
bool lgDielRecom[NISO]
Definition: iso.h:365
t_phycon::lgPhysOK
bool lgPhysOK
Definition: phycon.h:101
cddefines.h
t_isoCTRL::lgCS_Vrinceanu
bool lgCS_Vrinceanu[NISO]
Definition: iso.h:390
POW3
#define POW3
Definition: cddefines.h:936
iso_update_num_levels
void iso_update_num_levels(long ipISO, long nelem)
Definition: iso_create.cpp:1488
optimize.h
TotalInsanity
NORETURN void TotalInsanity(void)
Definition: service.cpp:886
t_elementnames::chElementSym
char chElementSym[LIMELM][CHARS_ELEMENT_SYM]
Definition: elementnames.h:25
RREC_MAXN
#define RREC_MAXN
Definition: iso.h:95
t_optimize::nvarxt
long int nvarxt[LIMPAR]
Definition: optimize.h:194
t_isoCTRL::lgLTE_levels
bool lgLTE_levels[NISO]
Definition: iso.h:347
MAX2
#define MAX2
Definition: cddefines.h:782
t_isoCTRL::ipResoRedist
int ipResoRedist[NISO]
Definition: iso.h:374
LIMELM
const int LIMELM
Definition: cddefines.h:258
t_isoCTRL::ipSubRedist
int ipSubRedist[NISO]
Definition: iso.h:374
cdEXIT
#define cdEXIT(FAIL)
Definition: cddefines.h:434
Parser::lgEOL
bool lgEOL(void) const
Definition: parser.h:98
t_iso_sp::nCollapsed_max
long int nCollapsed_max
Definition: iso.h:487
t_isoCTRL::nLyman
long int nLyman[NISO]
Definition: iso.h:334
hydro
t_hydro hydro
Definition: hydrogenic.cpp:5
t_hydro::DampOnFac
realnum DampOnFac
Definition: hydrogenic.h:101
Parser::GetElem
long int GetElem(void) const
Definition: parser.cpp:209
ipLY_A
const int ipLY_A
Definition: cddefines.h:296
hydrogenic.h
ipPRD
const int ipPRD
Definition: cddefines.h:290
parser.h
t_optimize::nvfpnt
long int nvfpnt[LIMPAR]
Definition: optimize.h:195
iso_ctrl
t_isoCTRL iso_ctrl
Definition: iso.cpp:6
t_isoCTRL::lgContinuumLoweringEnabled
bool lgContinuumLoweringEnabled[NISO]
Definition: iso.h:358
taulines.h
phycon.h
t_rfield::emm
realnum emm
Definition: rfield.h:49
init_genrand
void init_genrand(unsigned long s)
Definition: thirdparty.cpp:2834
lgHydroMalloc
bool lgHydroMalloc
Definition: cdinit.cpp:61
iso_sp
t_iso_sp iso_sp[NISO][LIMELM]
Definition: iso.cpp:8
ipCRDW
const int ipCRDW
Definition: cddefines.h:294
ipCRD
const int ipCRD
Definition: cddefines.h:292
t_hydro::xLymanPumpingScaleFactor
realnum xLymanPumpingScaleFactor
Definition: hydrogenic.h:116
input.h
DEBUG_ENTRY
#define DEBUG_ENTRY(funcname)
Definition: cddefines.h:684
ipH_LIKE
const int ipH_LIKE
Definition: iso.h:62
Generated by   doxygen 1.8.17