cloudy  trunk
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
mole_h2_etc.cpp
Go to the documentation of this file.
1 /* This file is part of Cloudy and is copyright (C)1978-2008 by Gary J. Ferland and
2  * others. For conditions of distribution and use see copyright notice in license.txt */
3 /* mole_H2_LTE sets Boltzmann factors and LTE unit population of large H2 molecular */
4 /* H2_init - called to initialize things from cdInit */
5 /*H2_init_coreload one time initialization */
6 /* H2_Zero zero out vars in the large H2 molecule, called from zero
7  * before any commands are parsed */
8 /* H2_zero_pops_too_low - zero out some H2 variables if we decide not to compute
9  * the full sim, called by H2_LevelPops*/
10 /* H2_Solomon_rate find rates between H2s and H2g and other levels,
11  * for eventual use in the chemistry */
12 /* H2_gs_rates evaluate rates between ground and star states of H2 for use in chemistry */
13 /* H2_He_coll_init initialize H2 - He collision data set
14  * H2_He_coll interpolate on h2 - He collision data set to return rate at temp*/
15 #include "cddefines.h"
16 #include "phycon.h"
17 #include "mole.h"
18 #include "hmi.h"
19 #include "taulines.h"
20 #include "h2.h"
21 #include "h2_priv.h"
22 
23 /*H2_Solomon_rate find rates between H2s and H2g and other levels,
24  * for eventual use in the chemistry */
25 void H2_Solomon_rate( void )
26 {
27 
28  long int iElecLo , iElecHi , iVibLo , iVibHi , iRotLo , iRotHi;
29 
30  DEBUG_ENTRY( "H2_Solomon_rate()" );
31 
32  /* iElecLo will always be X in this routine */
33  iElecLo = 0;
34 
35  /* find rate (s-1) h2 dissociation into X continuum by Solomon process and
36  * assign to the TH85 g and s states
37  * these will go back into the chemistry network */
38 
39  /* rates [s-1] for dissociation from s or g, into electronic excited states
40  * followed by dissociation */
43 
44  /* these are used in a print statement - are they needed? */
47 
48  /* at this point we have already evaluated the sum of the radiative rates out
49  * of the electronic excited states - this is H2_rad_rate_out[electronic][vib][rot]
50  * and this includes both decays into the continuum and bound states of X */
51 
52  /* sum over all electronic states, finding dissociation rate */
53  for( iElecHi=1; iElecHi<mole.n_h2_elec_states; ++iElecHi )
54  {
55  for( iVibHi=0; iVibHi<=h2.nVib_hi[iElecHi]; ++iVibHi )
56  {
57  for( iRotHi=h2.Jlowest[iElecHi]; iRotHi<=h2.nRot_hi[iElecHi][iVibHi]; ++iRotHi )
58  {
59  double factor = (double)H2_dissprob[iElecHi][iVibHi][iRotHi]/
60  H2_rad_rate_out[iElecHi][iVibHi][iRotHi];
61  double H2popHi = H2_populations[iElecHi][iVibHi][iRotHi];
62 
63  /* loop over all levels within X to find
64  * decay rates from H2g and H2s to continuum
65  * distinction between H2g and H2s is determined
66  * by ENERGY_H2_STAR */
67  iElecLo = 0;
68 
69  for( iVibLo=0; iVibLo<=h2.nVib_hi[iElecLo]; ++iVibLo )
70  {
71  long nr = h2.nRot_hi[iElecLo][iVibLo];
72 
73  mb6ci lgH2le = lgH2_line_exists.ptr(iElecHi,iVibHi,iRotHi,iElecLo,iVibLo,h2.Jlowest[iElecLo]);
74  mt6ci H2L = H2Lines.ptr(iElecHi,iVibHi,iRotHi,iElecLo,iVibLo,h2.Jlowest[iElecLo]);
75  for( iRotLo=h2.Jlowest[iElecLo]; iRotLo<=nr; ++iRotLo )
76  {
77  if( *lgH2le++ )
78  {
79  /* this is the rate [cm-3 s-1] that mole goes from
80  * lower level into electronic excited states then
81  * into continuum */
82  double rate_up_cont =
83  H2_populations[iElecLo][iVibLo][iRotLo]*
84  H2L->Emis->pump*factor;
85 
86  /* rate electronic state decays into H2g */
87  double elec_decay =
88  H2popHi*
89  H2L->Emis->Aul*(H2L->Emis->Pesc+H2L->Emis->Pdest+H2L->Emis->Pelec_esc);
90 
91  if( energy_wn[0][iVibLo][iRotLo] > ENERGY_H2_STAR )
92  {
93  /* this is H2g up to excited then to continuum -
94  * cm-3 s-1 at this point */
95  hmi.H2_Solomon_dissoc_rate_BigH2_H2s += rate_up_cont;
96  /* rate electronic state decays into H2g */
97  hmi.H2_Solomon_elec_decay_H2s += elec_decay;
98  }
99  else
100  {
101  /* this is H2g up to excited then to continuum -
102  * cm-3 s-1 at this point */
103  hmi.H2_Solomon_dissoc_rate_BigH2_H2g += rate_up_cont;
104  /* rate electronic state decays into H2g */
105  hmi.H2_Solomon_elec_decay_H2g += elec_decay;
106  }
107  }
108  ++H2L;
109  }
110  }
111  }/* end iRotHi */
112  }/* end iVibHi */
113  }/* end iElecHi */
114  /* at this point units of hmi.H2_Solomon_elec_decay_H2g, H2s are cm-3 s-1
115  * since H2_populations are included -
116  * div by pops to get actual dissocation rate, s-1 */
117  if( hmi.H2_total > SMALLFLOAT )
118  {
121 
122  /* will be used for H2s-> H + H */
124 
125  /* will be used for H2g-> H + H */
127 
128  }
129  else
130  {
133 
134  }
135  /*fprintf(ioQQQ,"DEBUG H2 new %.2e %.2e %.2e %.2e \n",
136  hmi.H2_Solomon_elec_decay_H2g ,
137  hmi.H2_Solomon_elec_decay_H2s ,
138  hmi.H2_Solomon_dissoc_rate_BigH2_H2s,
139  hmi.H2_Solomon_dissoc_rate_BigH2_H2g );*/
140 
141  /* rate g goes to s */
143  return;
144 }
145 
146 /*H2_gs_rates evaluate rates between ground and star states of H2 for use in chemistry */
147 void H2_gs_rates( void )
148 {
149  long int ipLoX , ip , iRotLoX , iVibLoX ,
150  iElecHi , iVibHi , ipOther , iRotOther,
151  iRotHi , iVibOther;
152 
153  DEBUG_ENTRY( "H2_gs_rates()" );
154 
155  /* rate g goes to s */
157 
158  /* loop over all levels in H2g */
159  for( ipLoX=0; ipLoX < nEner_H2_ground; ++ipLoX )
160  {
161  ip = H2_ipX_ener_sort[ipLoX];
162  iRotLoX = ipRot_H2_energy_sort[ip];
163  iVibLoX = ipVib_H2_energy_sort[ip];
164  /* now find all pumps up to electronic excited states */
165  /* sum over all electronic states, finding dissociation rate */
166  for( iElecHi=1; iElecHi<mole.n_h2_elec_states; ++iElecHi )
167  {
168  for( iVibHi=0; iVibHi<=h2.nVib_hi[iElecHi]; ++iVibHi )
169  {
170  for( iRotHi=h2.Jlowest[iElecHi]; iRotHi<=h2.nRot_hi[iElecHi][iVibHi]; ++iRotHi )
171  {
172  if( lgH2_line_exists[iElecHi][iVibHi][iRotHi][0][iVibLoX][iRotLoX] )
173  {
174  /* this is the rate {cm-3 s-1] that mole goes from
175  * lower level into electronic excited states then
176  * into continuum */
177  double rate_up_cont =
178  H2_populations[0][iVibLoX][iRotLoX]*
179  H2Lines[iElecHi][iVibHi][iRotHi][0][iVibLoX][iRotLoX].Emis->pump;
180 
181  double decay_star = H2_rad_rate_out[iElecHi][iVibHi][iRotHi] - H2_dissprob[iElecHi][iVibHi][iRotHi];
182  /* loop over all other levels in H2g, subtracting
183  * their rate - remainder is rate into star, this is
184  * usually only a few levels */
185  for( ipOther=0; ipOther < nEner_H2_ground; ++ipOther )
186  {
187  ip = H2_ipX_ener_sort[ipOther];
188  iRotOther = ipRot_H2_energy_sort[ip];
189  iVibOther = ipVib_H2_energy_sort[ip];
190  if( lgH2_line_exists[iElecHi][iVibHi][iRotHi][0][iVibOther][iRotOther] )
191  {
192  decay_star -=
193  H2Lines[iElecHi][iVibHi][iRotHi][0][iVibOther][iRotOther].Emis->Aul*(
194  H2Lines[iElecHi][iVibHi][iRotHi][0][iVibOther][iRotOther].Emis->Pesc+
195  H2Lines[iElecHi][iVibHi][iRotHi][0][iVibOther][iRotOther].Emis->Pdest+
196  H2Lines[iElecHi][iVibHi][iRotHi][0][iVibOther][iRotOther].Emis->Pelec_esc);
197  }
198  }
199  /* MAX because may underflow to negative numbers is rates very large
200  * this is fraction that returns to H2s */
201  decay_star = MAX2(0., decay_star)/SDIV(H2_rad_rate_out[iElecHi][iVibHi][iRotHi]);
202  hmi.H2_H2g_to_H2s_rate_BigH2 += rate_up_cont*decay_star;
203 
204  }/* end if line exists */
205  }/* end loop rot electronic excited */
206  }/* end loop vib electronic excited */
207  }/* end loop electronic electronic excited */
208  }
209 
210  /* at this point units are cm-3 s-1 - convert to rate s-1 */
212  return;
213 }
214 
215 /* H2_zero_pops_too_low - zero out some H2 variables if we decide not to compute
216  * the full sim, called by H2_LevelPops*/
218 {
219 
220  long int iElec, iElecHi, iElecLo, iVib , iVibLo , iVibHi ,
221  iRot , iRotHi , iRotLo;
222 
223  DEBUG_ENTRY( "H2_zero_pops_too_low()" );
224 
225  /* >>chng 05 jan 26, add this block to set populations to LTE value */
226  for( iElec=0; iElec<mole.n_h2_elec_states; ++iElec )
227  {
228  for( iVib=0; iVib<=h2.nVib_hi[iElec]; ++iVib )
229  {
230  for( iRot=h2.Jlowest[iElec]; iRot<=h2.nRot_hi[iElec][iVib]; ++iRot )
231  {
232  /* LTE populations are for unit H2 density, so need to multiply
233  * by total H2 density */
234  H2_old_populations[iElec][iVib][iRot] =
235  (realnum)H2_populations_LTE[iElec][iVib][iRot]*hmi.H2_total;
236  H2_populations[iElec][iVib][iRot] = H2_old_populations[iElec][iVib][iRot];
237  }
238  }
239  }
240  /* zero everything out - loop over all possible lines */
241  /* >>chng 05 jan 26, set to LTE values, since we still need to accumulate Lyman line
242  * optical depths to have correct self-shielding when large h2 does come on */
243  for( iElecHi=0; iElecHi<mole.n_h2_elec_states; ++iElecHi )
244  {
245  pops_per_elec[iElecHi] = 0.;
246  for( iVibHi=0; iVibHi<=h2.nVib_hi[iElecHi]; ++iVibHi )
247  {
248  pops_per_vib[iElecHi][iVibHi] = 0.;
249  for( iRotHi=h2.Jlowest[iElecHi]; iRotHi<=h2.nRot_hi[iElecHi][iVibHi]; ++iRotHi )
250  {
251  long int lim_elec_lo = 0;
252  // this will update Lo->Pop as well as Lo and Hi point to the same set of data structures
253  // the loops below are OK since Lo->Pop is only accessed after Hi->Pop has been set.
254  H2Lines[iElecHi][iVibHi][iRotHi][0][0][0].Hi->Pop = H2_populations[iElecHi][iVibHi][iRotHi];
255  /* now the lower levels
256  * NB - iElecLo the lower electronic level is only X
257  * we don't consider excited electronic to excited electronic trans here, since we are only
258  * concerned with excited electronic levels as a photodissociation process
259  * code exists to relax this assumption - simply change following to iElecHi */
260  for( iElecLo=0; iElecLo<=lim_elec_lo; ++iElecLo )
261  {
262  /* want to include all vib states in lower level if different electronic level,
263  * but only lower vib levels if same electronic level */
264  long int nv = h2.nVib_hi[iElecLo];
265  if( iElecLo==iElecHi )
266  nv = iVibHi;
267  for( iVibLo=0; iVibLo<=nv; ++iVibLo )
268  {
269  long nr = h2.nRot_hi[iElecLo][iVibLo];
270  if( iElecLo==iElecHi && iVibHi==iVibLo )
271  nr = iRotHi-1;
272 
273  for( iRotLo=h2.Jlowest[iElecLo]; iRotLo<=nr; ++iRotLo )
274  {
275  if( lgH2_line_exists[iElecHi][iVibHi][iRotHi][iElecLo][iVibLo][iRotLo] )
276  {
277  /* population of lower level with correction for stim emission */
278  H2Lines[iElecHi][iVibHi][iRotHi][iElecLo][iVibLo][iRotLo].Emis->PopOpc =
279  H2Lines[iElecHi][iVibHi][iRotHi][iElecLo][iVibLo][iRotLo].Lo->Pop -
280  H2Lines[iElecHi][iVibHi][iRotHi][iElecLo][iVibLo][iRotLo].Hi->Pop*
281  H2Lines[iElecHi][iVibHi][iRotHi][iElecLo][iVibLo][iRotLo].Lo->g /
282  H2Lines[iElecHi][iVibHi][iRotHi][iElecLo][iVibLo][iRotLo].Hi->g;
283 
284  /* following two heat exchange excitation, deexcitation */
285  H2Lines[iElecHi][iVibHi][iRotHi][iElecLo][iVibLo][iRotLo].Coll.cool = 0.;
286  H2Lines[iElecHi][iVibHi][iRotHi][iElecLo][iVibLo][iRotLo].Coll.heat = 0.;
287 
288  /* intensity of line */
289  H2Lines[iElecHi][iVibHi][iRotHi][iElecLo][iVibLo][iRotLo].Emis->xIntensity = 0.;
290 
291  H2Lines[iElecHi][iVibHi][iRotHi][iElecLo][iVibLo][iRotLo].Emis->phots = 0.;
292  H2Lines[iElecHi][iVibHi][iRotHi][iElecLo][iVibLo][iRotLo].Emis->ots = 0.;
293  H2Lines[iElecHi][iVibHi][iRotHi][iElecLo][iVibLo][iRotLo].Emis->ColOvTot = 0.;
294  }
295  }
296  }
297  }
298  }
299  }
300  }
303  hmi.HeatH2Dish_BigH2 = 0.;
304  hmi.HeatH2Dexc_BigH2 = 0.;
309  return;
310 }
311 
312 /*mole_H2_LTE sets Boltzmann factors and LTE unit population of large H2 molecular */
313 void mole_H2_LTE( void )
314 {
315  /* used to recall the temperature used for last set of Boltzmann factors */
316  static double TeUsedBoltz = -1.;
317  double part_fun;
318  long int iElec , iVib , iRot;
319 
320  DEBUG_ENTRY( "mole_H2_LTE()" );
321 
322  /* do we need to update the Boltzmann factors and unit LTE populations? */
323  if( ! fp_equal( phycon.te, TeUsedBoltz ) )
324  {
325  part_fun = 0.;
326  TeUsedBoltz = phycon.te;
327  /* loop over all levels setting H2_Boltzmann and deriving partition function */
328  for( iElec=0; iElec<mole.n_h2_elec_states; ++iElec )
329  {
330  for( iVib=0; iVib<=h2.nVib_hi[iElec]; ++iVib )
331  {
332  for( iRot=h2.Jlowest[iElec]; iRot<=h2.nRot_hi[iElec][iVib]; ++iRot )
333  {
334  H2_Boltzmann[iElec][iVib][iRot] =
335  /* energy is relative to lowest level in the molecule, v=0, J=0,
336  * so Boltzmann factor is relative to this level */
337  sexp( energy_wn[iElec][iVib][iRot] / phycon.te_wn );
338  /* sum the partition function - Boltzmann factor times statistical weight */
339  part_fun += H2_Boltzmann[iElec][iVib][iRot] * H2_stat[iElec][iVib][iRot];
340  ASSERT( part_fun > 0 );
341  }
342  }
343  }
344  /* have partition function, set H2_populations_LTE (populations for unit H2 density) */
345  for( iElec=0; iElec<mole.n_h2_elec_states; ++iElec )
346  {
347  for( iVib=0; iVib<=h2.nVib_hi[iElec]; ++iVib )
348  {
349  for( iRot=h2.Jlowest[iElec]; iRot<=h2.nRot_hi[iElec][iVib]; ++iRot )
350  {
351  /* these are the H2 LTE populations for a unit H2 density -
352  * these populations will sum up to unity */
353  H2_populations_LTE[iElec][iVib][iRot] =
354  H2_Boltzmann[iElec][iVib][iRot] *
355  H2_stat[iElec][iVib][iRot] / part_fun;
356  /*if( iElec==0 && iVib < 2)
357  fprintf(ioQQQ,"DEBUG LTE pop\t%i\t%i\t%e\n",
358  iVib,iRot,H2_populations_LTE[iElec][iVib][iRot]*hmi.H2_total);*/
359  }
360  }
361  }
363  fprintf(ioQQQ,
364  "mole_H2_LTE set H2_Boltzmann factors, T=%.2f, partition function is %.2f\n",
365  phycon.te,
366  part_fun);
367  }
368 
369  return;
370 }
371 
372 /*H2_init_coreload one time initialization */
373 void H2_init_coreload( void )
374 {
375  /* the order of the electronic states is
376  * X, B, C+, C-, B', D+, and D- */
377  /* this will be the number of vibration levels within each electronic */
378  /* number of vib states within electronic states from
379  * >>refer H2 energies Abgrall, */
380  long int nVib_hi_init[N_H2_ELEC] = {14 , 37 , 13 , 13, 9, 2 , 2};
381 
382  /* this gives the first rotational state for each electronic state - J=0 does
383  * not exist when Lambda = 1 */
384  long int Jlowest_init[N_H2_ELEC] = {0 , 0 , 1 , 1 , 0 , 1 , 1 };
385 
386  /* number of rotation levels within each electronic - vib */
387  /*lint -e785 too few init for aggregate */
388  long int nRot_hi_init[N_H2_ELEC][50]=
389  /* ground, X */
390  { {31, 30, 28, 27, 25,
391  23, 22, 20, 18, 16,
392  14, 12, 10, 7, 3 } ,
393  /* B */
394  {25,25,25,25,25,25,25,25, 25,25,
395  25,25,25,25,25,25,25,25, 25,25,
396  25,25,25,25,25,25,25,25, 23,21,
397  19,17,15,15,11,9,7, 7},
398  /* C plus */
399  { 25, 25, 25, 25, 24, 23, 21, 19, 17, 14, 12, 10, 6, 2 },
400  /* C minus (the same) */
401  { 25, 25, 25, 25, 24, 23, 21, 19, 17, 15, 13, 10, 7, 2 },
402  /* B primed */
403  {19,17, 14, 12, 9, 8, 7, 7, 4, 1 },
404  /* D plus */
405  {13, 10, 5},
406  /* D minus */
407  {25 , 25 ,25 } }
408  ;
409  /*lint +e785 too few init for aggregate */
410  /* one time init */
411 
412  long int iElec;
413 
414  DEBUG_ENTRY( "H2_init_coreload()" );
415 
416  /* the order of the electronic states is
417  * X, B, C+, C-, B', D+, and D- */
418  /* this will be the number of vibration levels within each electronic */
419  /* number of vib states within electronic states from
420  * >>refer H2 energies Abgrall, */
421  for( iElec=0; iElec<N_H2_ELEC; ++iElec )
422  {
423  int iVib;
424  h2.nVib_hi[iElec] = nVib_hi_init[iElec];
425  h2.Jlowest[iElec] = Jlowest_init[iElec];
426  for( iVib=0; iVib<=h2.nVib_hi[iElec]; ++iVib )
427  {
428  h2.nRot_hi[iElec][iVib] = nRot_hi_init[iElec][iVib];
429  /*fprintf(ioQQQ,"DEBUG h2 set %li %li %li \n",
430  iElec ,
431  iVib ,
432  h2.nRot_hi[iElec][iVib] );*/
433  }
434  }
435  strcpy( chH2ColliderLabels[0] , "H0" );
436  strcpy( chH2ColliderLabels[1] , "He" );
437  strcpy( chH2ColliderLabels[2] , "H2 o" );
438  strcpy( chH2ColliderLabels[3] , "H2 p" );
439  strcpy( chH2ColliderLabels[4] , "H+" );
440 
441  return;
442 }
443 
444 /*H2_init - called to initialize things from cdInit */
445 void H2_Init(void)
446 {
447 
448  DEBUG_ENTRY( "H2_Init()" );
449 
450  /* the number of electronic quantum states to include.
451  * To do both Lyman and Werner bands want nelec = 3,
452  * default is to do all bands included */
454  h2.nCallH2_this_zone = 0;
455  return;
456 }
457 
458 
459 /*H2_Reset called by IterRestart to reset variables that are needed after an iteration */
460 void H2_Reset( void )
461 {
462 
463  DEBUG_ENTRY( "H2_Reset()" );
464 
465  if(mole.nH2_TRACE)
466  fprintf(ioQQQ,
467  "\n***************H2_Reset called, resetting nCallH2_this_iteration, zone %.2f iteration %li\n",
468  fnzone,
469  iteration );
470 
471  /* number of times large molecules evaluated in this iteration,
472  * is false if never evaluated, on next evaluation will start with LTE populations */
474 
475  /* these remember the largest and smallest factors needed to
476  * renormalize the H2 chemistry */
477  h2.renorm_max = 1.;
478  h2.renorm_min = 1.;
479 
480  /* counters used by H2_itrzn to find number of calls of h2 per zone */
481  nH2_pops = 0;
482  nH2_zone = 0;
483  /* this is used to establish zone number for evaluation of number of levels in matrix */
484  nzone_nlevel_set = 0;
485 
486  nzoneAsEval = -1;
487  iterationAsEval = -1;
488 
489  /* zero out array used to save emission line intensities */
490  H2_SaveLine.zero();
491 
492  return;
493 }
494 
495 /*H2_Zero zero out vars in the large H2 molecule, called from zero
496  * before any commands are parsed
497  * NB - this routine is called before space allocated - must not zero out
498  * any allocated arrays */
499 void H2_Zero( void )
500 {
501 
502  DEBUG_ENTRY( "H2_Zero()" );
503 
504  /* this is the smallest ratio of H2/H where we will bother with the large H2 molecule
505  * this value was chosen so that large mole used at very start of TH85 standard PDR,
506  * NB - this appears in headinfo and must be updated there if changed here */
507  /* >>chng 03 jun 02, from 1e-6 to 1e-8 - in orion veil large H2 turned on half way
508  * across, and Solomon process was very fast since all lines optically thin. correct
509  * result has some shielding, so reset to lower value so that H2 comes on sooner. */
510  mole.H2_to_H_limit = 1e-8;
511 
512  h2.lgH2ON = false;
513  /* flag to force using LTE level populations */
514  mole.lgH2_LTE = false;
515 
516  /* counters used by H2_itrzn to find number of calls of h2 per zone */
517  nH2_pops = 0;
518  nH2_zone = 0;
519  /* this is used to establish zone number for evaluation of number of levels in matrix */
520  nzone_nlevel_set = 0;
521 
522  /* these remember the largest and smallest factors needed to
523  * renormalize the H2 chemistry */
524  h2.renorm_max = 1.;
525  h2.renorm_min = 1.;
526 
528  h2.ortho_density = 0.;
529  h2.para_density = 0.;
530 
533 
537 
538  hmi.HeatH2Dexc_BigH2 = 0.;
539 
540  /* say that H2 has never been computed */
541  hmi.lgBigH2_evaluated = false;
542 
543  hmi.lgH2_Thermal_BigH2 = true;
544  hmi.lgH2_Chemistry_BigH2 = true;
545 
546  if( !lgH2_READ_DATA )
547  {
548  /* the number of electronic levels in the H2 molecule,
549  * to just do the Lyman and Werner bands set to 3 -
550  * reset with atom h2 levels command,
551  * default is all levels with data */
553  }
554 
555  /* the number of levels used in the matrix solution
556  * of the level H2_populations - set with atom h2 matrix nlevel,
557  * >>chng 04 oct 05, make default 30 levels
558  * >>chng 04 dec 23, make default 70 levels */
559  nXLevelsMatrix = 70;
560 
561  /* this is used to establish zone number for evaluation of number of levels in matrix */
562  nzone_nlevel_set = -1;
563 
564  nzoneAsEval = -1;
565  iterationAsEval = -1;
566  return;
567 }

Generated for cloudy by doxygen 1.8.3.1