00001 /* This file is part of Cloudy and is copyright (C)1978-2010 by Gary J. Ferland and 00002 * others. For conditions of distribution and use see copyright notice in license.txt */ 00003 /*InitDefaultsPreparse initialization at start of simulation, called from cloudy 00004 * before parser, sets initial values of quantities changed by parser 00005 * called for each point in a grid but one time in multi-iteration sims */ 00006 #include "cddefines.h" 00007 #include "physconst.h" 00008 #include "phycon.h" 00009 #include "radius.h" 00010 #include "trace.h" 00011 #include "dynamics.h" 00012 #include "geometry.h" 00013 #include "noexec.h" 00014 #include "rfield.h" 00015 #include "opacity.h" 00016 #include "stopcalc.h" 00017 #include "atomfeii.h" 00018 #include "plot.h" 00019 #include "rt.h" 00020 #include "fudgec.h" 00021 #include "abund.h" 00022 #include "h2.h" 00023 #include "hextra.h" 00024 #include "mole.h" 00025 #include "wind.h" 00026 #include "pressure.h" 00027 #include "thermal.h" 00028 #include "optimize.h" 00029 #include "save.h" 00030 #include "dense.h" 00031 #include "hcmap.h" 00032 #include "prt.h" 00033 #include "init.h" 00034 #include "taulines.h" 00035 #include "lines_service.h" 00036 00037 /*InitDefaultsPreparse initialization at start of simulation, called from cloudy 00038 * before parser, will now be called one time per sim in grid but long term 00039 * goal is to call parser only one time in a grid. This would be called 00040 * first to set defaults that may be changed by the parser. This routine 00041 * should only set defaults for variables that change in the parser. 00042 * It does not initialize variables for the start of a calculation. That 00043 * is done by InitSimPostparse 00044 * called one time in multi iteration sim */ 00045 void InitDefaultsPreparse( void ) 00046 { 00047 long int i, 00048 ipISO, 00049 nelem; 00050 00051 DEBUG_ENTRY( "InitDefaultsPreparse()" ); 00052 00053 /* init vars before parsing commands for each sim */ 00054 00055 /* drChange was reset to get orion flux in h-beta correct 00056 * drChange is really tau of current zone */ 00057 radius.drChange = 0.15f; 00058 00059 radius.glbdst = 0.; 00060 radius.glbrad = 0.; 00061 00062 /* option to read in all input quantiles and NOT execute the actual model 00063 * only check on input parameters - set by calling cdNoExec */ 00064 noexec.lgNoExec = false; 00065 00066 /* constant for the extinguish command */ 00067 rfield.ExtinguishColumnDensity = 0.; 00068 rfield.ExtinguishLeakage = 0.; 00069 rfield.ExtinguishLowEnergyLimit = 1.; 00070 00071 /* parameters having to do with thermal map */ 00072 hcmap.RangeMap[0] = 10.f; 00073 hcmap.RangeMap[1] = .99e10f; 00074 /* zone where map is to be done */ 00075 hcmap.MapZone = -1; 00076 hcmap.nMapStep = 20; 00077 00078 thermal.ConstGrainTemp = 0.; 00079 thermal.lgTemperatureConstant = false; 00080 thermal.lgTemperatureConstantCommandParsed = false; 00081 thermal.ConstTemp = 0.; 00082 thermal.lgTeHigh = false; 00083 thermal.lgTeBD96 = false; 00084 thermal.lgTLaw = false; 00085 thermal.lgTeSN99 = false; 00086 /* try toe predict next zone's temperature in constant density models, 00087 * as done in ZoneStart. Turned off with no tepred command */ 00088 thermal.lgPredNextTe = true; 00089 00090 /* turbulent heating - set with hextra command */ 00091 hextra.TurbHeat = 0.; 00092 /* set true with TIME option on hextra command for time dependent sims */ 00093 hextra.lgTurbHeatVaryTime = false; 00094 /* options for for extra heating to depend on scale radius */ 00095 hextra.lgHextraDepth = false; 00096 /* options for for extra heating to depend on density */ 00097 hextra.lgHextraDensity = false; 00098 00099 /* options set by cosmic ray command */ 00100 hextra.cryden = 0.; 00101 hextra.cryden_ov_background = 0.; 00102 hextra.lg_CR_B_equipartition = false; 00103 hextra.crtemp = 0.; 00104 hextra.crpowr = 0.; 00105 hextra.cr_energydensity = 0; 00106 00107 /* this is number of electronic levels to include in the print and save output 00108 * changed with the PRINT LINE H2 ELECTRONIC and PUNCH H2 commands 00109 * by default only include X */ 00110 h2.nElecLevelOutput = 1; 00111 00112 /* holds options for trace set with atom h2 command */ 00113 mole.nH2_TRACE = false; 00114 00115 /* option to scramble collision data */ 00116 mole.lgH2_NOISE = false; 00117 mole.lgH2_NOISECOSMIC = false; 00118 00119 /* option to turn off or on gbar collisions of the collision rate, 00120 * default is to have it on */ 00121 /* turn mole.lgColl_gbar on/off with atom h2 gbar on off */ 00122 mole.lgColl_gbar = true; 00123 00124 /* include collision rates that come from real calculations, 00125 * off with atom h2 collisions off command */ 00126 mole.lgColl_deexec_Calc = true; 00127 00128 mole.lgColl_dissoc_coll = true; 00129 00130 /* option to turn off H2 - grain collision & deexcitation, 00131 * atom h2 grain collision on/off */ 00132 mole.lgH2_grain_deexcitation = false; 00133 00134 /* option to turn off ortho-para collisions, command ATOM H2 COLLISIONS ORTHO PARA OFF */ 00135 mole.lgH2_ortho_para_coll_on = true; 00136 00137 /* which set of H2 - He collision data to use? default is ORNL data set 00138 * also Le Bourlot Meudon set available, 00139 * set to ORNL with command 00140 * atom H2 He collisions ORNL */ 00141 mole.lgH2_He_ORNL = true; 00142 00143 /*>>chng 08 feb 27, GS, ORNL or Meudon H2 - H2 collision data 00144 * >>chng 09 may 11, make it the default */ 00145 mole.lgH2_ORH2_ORNL = true; 00146 mole.lgH2_PAH2_ORNL = true; 00147 00148 /* use 1999 or 2007 H2 - H collision set atomic data mole H2 h */ 00149 h2.lgH2_H_coll_07 = true; 00150 00151 /* set with coronal equilibrium init time command */ 00152 dynamics.lg_coronal_time_init = false; 00153 dynamics.lgTracePrint = false; 00154 00155 /* parameters to do with wind */ 00156 wind.lgWindOK = true; 00157 wind.DiskRadius = 0; 00158 wind.lgDisk = false; 00159 wind.windv0 = 0.; 00160 wind.setStatic(); 00161 wind.comass = 0.; 00162 wind.windv = 0.; 00163 wind.dvdr = 0.; 00164 wind.emdot = 0.; 00165 wind.AccelAver = 0.; 00166 wind.acldr = 0.; 00167 wind.AccelGravity = 0.; 00168 wind.AccelTotalOutward = 0.; 00169 wind.AccelCont = 0.; 00170 wind.AccelElectron = 0.; 00171 wind.AccelLine = 0.; 00172 wind.AccelMax = 0.; 00173 wind.fmul = 0.; 00174 wind.lgVelPos = true; 00175 00176 /* argument on ELEMENT LIMIT OFF XXX command, lowest abundance 00177 * element to include in the calculation */ 00178 dense.AbundanceLimit = 0.; 00179 00180 /* controls density fluctuations, when true variations are due to density changing, 00181 * when false are due to abundances changing if changes are on */ 00182 dense.lgDenFlucOn = true; 00183 dense.lgDenFlucRadius = true; 00184 dense.flong = 0.; 00185 dense.flcPhase = 0.; 00186 00187 /* this says keep initial density constant, 00188 * so pressure from iter to iter not really const */ 00189 dense.lgDenseInitConstant = true; 00190 00191 // pressure does not vary with time by default 00192 dense.lgPressureVaryTime = false; 00193 // required number is timescale for time variation 00194 dense.PressureVaryTimeTimescale = -1.; 00195 // optional number is index for time variation 00196 dense.PressureVaryTimeIndex = 0.; 00197 00198 /* individual terms for the pressure equation of state */ 00199 /* >>chng 05 jan 01, all three are set true at start * 00200 * code default is constant density, so all this is ignored 00201 * is turned to constant pressure then these flags must be adjusted so 00202 * that we get the pressure we expect. with all true, all three 00203 * contributors to pressure will be counted - with constant gas pressure 00204 * these are turned off */ 00205 pressure.lgPres_radiation_ON = true; 00206 pressure.lgPres_magnetic_ON = true; 00207 pressure.lgPres_ram_ON = true; 00208 /* flag for constant pressure, include continuum too */ 00209 pressure.lgContRadPresOn = true; 00210 /* constant density is the default */ 00211 strcpy( dense.chDenseLaw, "CDEN" ); 00212 /* number on line is log of nT - option to specify initial pressure */ 00213 pressure.lgPressureInitialSpecified = false; 00214 /* this is log of nT product - if not present then set zero */ 00215 pressure.PressureInitialSpecified = 0; 00216 00217 /* select certain atomic data, changed with set atomic data command 00218 * this says to use Zeippen 1982 [OII] transition probabilities */ 00219 dense.lgAsChoose[ipOXYGEN][1] = false; 00220 00221 abund.lgAbnSolar = false; 00222 00223 /* the ipSolar array is a set of pointers used for reading 00224 * in abundances with the "abundances" command 00225 * the hydrogen abundance of unity is not read in */ 00226 abund.npSolar = LIMELM - 1; 00227 for( i=0; i < abund.npSolar; i++ ) 00228 { 00229 abund.ipSolar[i] = i + 2; 00230 } 00231 00232 /* option to turn off an element */ 00233 for( nelem=0; nelem < LIMELM; nelem++ ) 00234 { 00235 /* set of scale factors for changing abundances with elements command */ 00236 abund.ScaleElement[nelem] = 1.; 00237 abund.solar[nelem] = abund.SolarSave[nelem]; 00238 } 00239 00240 abund.lgAbTaON = false; 00241 00242 /* option to turn off an element */ 00243 for( nelem=0; nelem < LIMELM; nelem++ ) 00244 { 00245 /* option to have abundances from table */ 00246 abund.lgAbunTabl[nelem] = false; 00247 } 00248 00249 /* threshold for faintest heating cooling to save with save heating or 00250 * save cooling commands, reset with PUNCH WEAKHEATCOOL command */ 00251 save.WeakHeatCool = 0.05f; 00252 00253 /* set of variables used to control save command */ 00254 save.nsave = 0; 00255 save.lgPunContinuum = false; 00256 save.lgDRPLst = false; 00257 save.lgDRHash = true; 00258 save.lgTraceConvergeBaseHash = true; 00259 /* this is the string that will appear after each model in the save output, 00260 * reset with the "set save hash" command */ 00261 strcpy( save.chHashString , "###########################" ); 00262 /* save every one continuum point, set skip save command */ 00263 save.ncSaveSkip = 1; 00264 /* flush file after every iteration - set save flush */ 00265 save.lgFLUSH = false; 00266 for( i=0; i<LIMPUN; ++i ) 00267 { 00268 save.lgHashEndIter[i] = true; 00269 /* set false for time dependent calculations*/ 00270 save.lg_separate_iterations[i] = true; 00271 save.lgSaveEveryZone[i] = false; 00272 save.nSaveEveryZone[i] = -1; 00273 } 00274 00275 /* default is to conserve energy, reset with 00276 * set save line width / resolution command */ 00277 save.Resolution = realnum(-1.); 00278 save.ResolutionAbs = realnum(-1.); 00279 save.emisfreq.set( -1. ); 00280 save.ipEmisFreq = -1; 00281 00282 /* default no printing of optical depths, TooFaint is .1 */ 00283 prt.lgPrtTau = false; 00284 prt.PrtTauFnt = 0.1f; 00285 prt.lgPrtShort = false; 00286 prt.TooFaint = 1e-3f; 00287 prt.lgFaintOn = true; 00288 prt.lgFntSet = false; 00289 prt.lgPrnLineCell = false; 00290 prt.nPrnLineCell = -1000; 00291 prt.lgPrtCitations = false; 00292 00293 /* change angle of illumination 00294 * this is angle away from the normal, so 0 is a normal ray, the default*/ 00295 geometry.DirectionalCosin = 1.; 00296 geometry.size = 1.f; 00297 geometry.lgSizeSet = false; 00298 geometry.covaper = -1.f; 00299 00300 /* if true then print main block of lines as array, 00301 * set false with print lines column, will then 00302 * do a single column of lines */ 00303 prt.lgPrtLineArray = true; 00304 00305 /* when printing a column this is option to print linear rather than log */ 00306 prt.lgPrtLineLog = true; 00307 00308 /* print ages */ 00309 prt.lgPrnAges = false; 00310 00311 /* print column densities */ 00312 prt.lgPrintColumns = true; 00313 00314 /* option to sort lines by wavelength, print sort command */ 00315 prt.lgSortLines = false; 00316 00317 prt.lgPrtMaser = false; 00318 prt.lgPrintTime = true; 00319 00320 prt.lgPrtContIndices = false; 00321 prt.lgPrtCont = false; 00322 prt.lgPrnDiff = false; 00323 prt.lgPrnPump = false; 00324 prt.lgPrnInwd = false; 00325 prt.lgPrnColl = false; 00326 prt.lgPrnHeat = false; 00327 /* >>chng 00 dec 08, these determine the standard items included in "nFnu", PvH */ 00328 prt.lgSourceReflected = true; 00329 prt.lgSourceTransmitted = false; 00330 prt.lgDiffuseInward = true; 00331 prt.lgDiffuseOutward = true; 00332 prt.lgPrtLastIt = false; 00333 prt.lgOnlyZone = false; 00334 prt.lgOnlyHead = false; 00335 prt.lgPrtStart = false; 00336 prt.nstart = 0; 00337 /* print predictions from collapsed levels of iso sequences */ 00338 prt.lgPrnIsoCollapsed = false; 00339 00340 /* turn off printing of heating agents */ 00341 prt.lgPrintHeating = false; 00342 00343 /* flag saying to print all matrix elements for ionization balance 00344 * set with PRINT ARRAYS command */ 00345 for( nelem=ipHYDROGEN; nelem<LIMELM; ++nelem ) 00346 { 00347 prt.lgPrtArry[nelem] = false; 00348 } 00349 00350 /* print line flux at earth */ 00351 prt.lgPrintFluxEarth = false; 00352 00353 /* print line surface brightness, def sr, option arcsec */ 00354 prt.lgSurfaceBrightness = false; 00355 prt.lgSurfaceBrightness_SR = true; 00356 00357 /* print line cumulative sets true, print integrated line intensity over 00358 * time in temp dependent simulation */ 00359 prt.lgPrintLineCumulative = false; 00360 00361 prt.nzdump = -100; 00362 00363 trace.lgSecIon = false; 00364 trace.lgTrOvrd = true; 00365 trace.lgOpacBug = false; 00366 trace.nTrConvg = 0; 00367 trace.lgTr8446 = false; 00368 trace.lgTrLevN = false; 00369 trace.lgTrGant = false; 00370 trace.lgOptcBug = false; 00371 trace.lgTrace3Bod = false; 00372 trace.lgOTSBug = false; 00373 trace.lgESOURCE = false; 00374 trace.lgTr_CO_Mole = false; 00375 trace.lgTr_H2_Mole = false; 00376 trace.lgHeatBug = false; 00377 trace.lgHeavyBug = false; 00378 trace.lgBug2nu = false; 00379 trace.lgDrBug = false; 00380 trace.lgWind = false; 00381 trace.lgPtrace = false; 00382 trace.lgDrv_cdLine = false; 00383 trace.lgDustBug = false; 00384 trace.lgComBug = false; 00385 trace.lgHeBug = false; 00386 trace.lgCarBug = false; 00387 trace.lgCalBug = false; 00388 trace.lgConBug = false; 00389 trace.lgNeBug = false; 00390 trace.lgFeBug = false; 00391 trace.lgHBug = false; 00392 trace.lgTrLine = false; 00393 trace.nznbug = 10000; 00394 trace.npsbug = 10000; 00395 trace.lgTrace = false; 00396 trace.lgPointBug = false; 00397 trace.lgNeonBug = false; 00398 trace.lgCoolTr = false; 00399 trace.lgTrDiff = false; 00400 for( ipISO=ipH_LIKE; ipISO<NISO; ++ipISO ) 00401 trace.lgIsoTraceFull[ipISO] = false; 00402 00403 /* variables used in stop ... command */ 00404 00405 /* various criteria for stopping model */ 00406 /* >>chng 04 dec 21, remove from here and init to 1e30 in zero */ 00407 /*StopCalc.tauend = 0.;*/ 00408 StopCalc.tauend = 1e30f; 00409 00410 /* >>chng 05 nov 22 - NPA. Stop calculation when fraction of oxygen frozen 00411 * out on grains ices gets too high - formation of ices */ 00412 /*StopCalc.StopDepleteFrac = 0.99f;*/ 00413 /* >>chng 05 dec 16, with revised ion solver logic, code should be able to 00414 * converge away from situation where ices have disturbed the chemistry and 00415 * net negative atomic abundances result. now we say solution not converged and 00416 * soldier on 00417 * this test should not be necessary */ 00418 StopCalc.StopDepleteFrac = 1.02f; 00419 00420 StopCalc.xMass = 0.; 00421 StopCalc.taunu = 0.; 00422 StopCalc.iptnu = -1; 00423 /* stopping AV */ 00424 StopCalc.AV_extended = 1e30f; 00425 StopCalc.AV_point = 1e30f; 00426 /* highest allowed temperature */ 00427 StopCalc.TempHiStopZone = (realnum)phycon.TEMP_LIMIT_HIGH; 00428 StopCalc.TempHiStopIteration = (realnum)phycon.TEMP_LIMIT_HIGH; 00429 00430 /* the floor sets a limit to the temperature in the calculation - 00431 * if te falls below this, we do a constant temperature cloud at 00432 * this temperature */ 00433 StopCalc.TeFloor = 0.; 00434 00435 /* stop zone calculations when Te falls below this, 00436 * TEMP_STOP_DEFAULT in cddefines.h and is 4000 */ 00437 StopCalc.TempLoStopZone = (realnum)phycon.TEMP_STOP_DEFAULT; 00438 /* stop iterations, used to stop time dependent command */ 00439 StopCalc.TempLoStopIteration = -1.; 00440 00441 /* ending column densities */ 00442 StopCalc.HColStop = COLUMN_INIT; 00443 StopCalc.colpls = COLUMN_INIT; 00444 StopCalc.colnut = COLUMN_INIT; 00445 StopCalc.col_h2 = COLUMN_INIT; 00446 StopCalc.col_h2_nut = COLUMN_INIT; 00447 StopCalc.col_H0_ov_Tspin = COLUMN_INIT; 00448 StopCalc.col_monoxco = COLUMN_INIT; 00449 00450 StopCalc.lgStopSpeciesColumn = false; 00451 StopCalc.chSpeciesColumn[0] = '\0'; 00452 StopCalc.col_species = COLUMN_INIT; 00453 00454 /* stopping electron density */ 00455 StopCalc.StopElecDensity = -COLUMN_INIT; 00456 00457 /* stopping electron and molecular fractions */ 00458 StopCalc.StopElecFrac = -FLT_MAX; 00459 StopCalc.StopHPlusFrac = -FLT_MAX; 00460 /* stopping molecular fraction has opposite sign - want to stop when 2H_2/NH gt this */ 00461 StopCalc.StopH2MoleFrac = FLT_MAX; 00462 /* this flag says that 21cm line optical depth is the stop quantity */ 00463 StopCalc.lgStop21cm = false; 00464 /* debugging aid - stop when conv.nTotalIoniz reaches this value */ 00465 StopCalc.nTotalIonizStop = 0; 00466 /* stop when absolute value of velocity falls below this */ 00467 StopCalc.StopVelocity = 0.; 00468 /* number of stop line commands entered */ 00469 StopCalc.nstpl = 0; 00470 00471 /* initialize some variables for the optimizer */ 00472 optimize.nIterOptim = 400; 00473 optimize.OptGlobalErr = 0.10f; 00474 optimize.nEmergent.clear(); 00475 optimize.chLineLabel.clear(); 00476 optimize.wavelength.clear(); 00477 optimize.errorwave.clear(); 00478 optimize.ipobs.clear(); 00479 optimize.xLineInt_Obs.clear(); 00480 optimize.xLineInt_error.clear(); 00481 optimize.chTempLab.clear(); 00482 optimize.ionTemp.clear(); 00483 optimize.temp_obs.clear(); 00484 optimize.temp_error.clear(); 00485 optimize.chTempWeight.clear(); 00486 optimize.chColDen_label.clear(); 00487 optimize.ion_ColDen.clear(); 00488 optimize.ColDen_Obs.clear(); 00489 optimize.ColDen_error.clear(); 00490 optimize.ContIndex.clear(); 00491 optimize.ContEner.clear(); 00492 optimize.ContNFnu.clear(); 00493 optimize.ContNFnuErr.clear(); 00494 optimize.nRangeSet = 0; 00495 strcpy( optimize.chOptRtn, "PHYM" ); 00496 00497 /* flags says what is to be matched */ 00498 optimize.lgOptLum = false; 00499 optimize.lgOptDiam = false; 00500 optimize.lgOptimize = false; 00501 00502 /* trace flag for optimization process */ 00503 optimize.lgTrOpt = false; 00504 00505 optimize.lgOptimFlow = false; 00506 optimize.optint = 0.; 00507 optimize.optier = 0.; 00508 # ifdef __unix 00509 optimize.lgParallel = !cpu.lgMPISingleRankMode(); 00510 # else 00511 optimize.lgParallel = false; 00512 # endif 00513 if( optimize.lgParallel ) 00514 optimize.useCPU = cpu.nCPU(); 00515 else 00516 optimize.useCPU = 1; 00517 optimize.lgOptCont = false; 00518 00519 /* the fudge factors command */ 00520 fudgec.nfudge = 0; 00521 fudgec.lgFudgeUsed = false; 00522 for( i=0; i < NFUDGC; i++ ) 00523 fudgec.fudgea[i] = 0.; 00524 00525 EmLineZero( &DummyEmis ); 00526 DummyEmis.iRedisFun = 0; 00527 DummyEmis.ipFine = -1; 00528 DummyEmis.gf = 0.; 00529 DummyEmis.damp = 0.; 00530 DummyEmis.dampXvel = 0.; 00531 DummyEmis.opacity = 0.; 00532 DummyEmis.Aul = 1e-30f; 00533 DummyEmis.tran = NULL; 00534 DummyEmis.next = NULL; 00535 00536 /* parameters dealing with printer plots */ 00537 for( i=0; i < NDPLOT; i++ ) 00538 { 00539 plotCom.lgPltTrace[i] = false; 00540 } 00541 00542 /* this says what types of printer plots we will make */ 00543 for( i=0; i < NDPLOT; i++ ) 00544 { 00545 strcpy( plotCom.chPType[i], "NONE" ); 00546 } 00547 plotCom.lgPlotON = false; 00548 00549 /* following were block data logic */ 00550 rt.lgStarkON = true; 00551 00552 /* by default use Federman form of shielding function */ 00553 rt.nLineContShield = LINE_CONT_SHIELD_FEDERMAN; 00554 00555 /* parameters set with Case A and Case B commands */ 00556 /* this is flag for turning on case b */ 00557 opac.lgCaseB = false; 00558 00559 /* this is separate flag for turning off collisions from n=2 */ 00560 opac.lgCaseB_HummerStorey = false; 00561 00562 /* this is separate flag for turning off excited state photoionization */ 00563 opac.lgCaseB_no_photo = false; 00564 /* another case b option, turn off background opacities, no Pdest */ 00565 opac.lgCaseB_no_pdest = false; 00566 00567 /* smallest allowed line and Lya optical depths, reset with 00568 * Case B command */ 00569 opac.tlamin = 1e-20f; 00570 00571 /* taumin command minimum optical depths for lines default 1e-20 */ 00572 opac.taumin = 1e-20f; 00573 00574 /* set false with no induced processes */ 00575 rfield.lgInducProcess = true; 00576 00577 /* this flag says that CMB has been set */ 00578 rfield.lgCMB_set = false; 00579 00580 for( i=0; i < LIMSPC; i++ ) 00581 { 00582 /* this is set true if particular continuum source can vary with time 00583 * set true if TIME appears on intensity / luminosity command line */ 00584 rfield.lgTimeVary[i] = false; 00585 /* most continua enter as a beam rather than isotropic */ 00586 rfield.lgBeamed[i] = true; 00587 // default is radiation from the "illuminated" face 00588 rfield.Illumination[i] = Illuminate::FORWARD; 00589 // optical depth = normal optical depth * this scale factor, 00590 // is 1 / cos theta 00591 rfield.OpticalDepthScaleFactor[i] = 1.; 00592 /* default energy range is H-ionizing radiation */ 00593 rfield.range[i][0] = HIONPOT; 00594 rfield.range[i][1] = rfield.egamry; 00595 rfield.RSFCheck[i] = 0.; 00596 } 00597 00598 /* line overlap opacity, turn off with no fine opacity command */ 00599 rfield.lgOpacityFine = true; 00600 00601 /* lower and upper wavelength bounds, Angstroms, for the FeII continuum */ 00602 FeII.feconwlLo = 1000.; 00603 FeII.feconwlHi = 7000.; 00604 FeII.nfe2con = 1000; 00605 00606 /* this is the faintest the high-energy tail of the continuum be */ 00607 rfield.FluxFaint = 1e-10f; 00608 00609 /* >>chng 01 jul 26, moved next statement from below loop to avoid bug in gcc 2.95.3, PvH */ 00610 /* default diffuse fields is outward only */ 00611 strcpy( rfield.chDffTrns, "OU2" ); 00612 rfield.lgOutOnly = true; 00613 00614 /* flags for whether continuum is defined over all energies */ 00615 rfield.lgMMok = true; 00616 rfield.lgHPhtOK = true; 00617 rfield.lgXRayOK = true; 00618 rfield.lgGamrOK = true; 00619 00620 for( rfield.ipSpec=0; rfield.ipSpec < LIMSPC; rfield.ipSpec++ ) 00621 { 00622 if( rfield.lgContMalloc[rfield.ipSpec] ) 00623 { 00624 rfield.tNu[rfield.ipSpec].clear(); 00625 rfield.tslop[rfield.ipSpec].clear(); 00626 rfield.tFluxLog[rfield.ipSpec].clear(); 00627 rfield.lgContMalloc[rfield.ipSpec] = false; 00628 } 00629 } 00630 00631 return; 00632 }