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