rfield.h

Go to the documentation of this file.

/* This file is part of Cloudy and is copyright (C)1978-2013 by Gary J. Ferland and
 * others.  For conditions of distribution and use see copyright notice in license.txt */
 
#ifndef RFIELD_H_
#define RFIELD_H_
 
/* rfield.h */
#include "energy.h"
 
const double WL_V_FILT = 5500.;
 
const double WL_B_FILT = 4400.;
 
const int LIMSPC = 100;
 
const int NCELL = 130000;
 
void rfield_opac_zero( long lo , long ihi );
 
extern bool lgRfieldMalloced;
 
namespace Illuminate {
        typedef enum { FORWARD , REVERSE , SYMMETRIC } IlluminationType ;
}
 
struct t_rfield {
 
        long int nflux;
 
        long int nupper;
 
        realnum emm;
 
        realnum egamry;
 
        realnum FluxFaint;
 
        double *anu;
 
        double *AnuOrg;
 
        realnum *widflx;
 
        long int *line_count;
 
        realnum *OccNumbBremsCont;
 
        realnum *OccNumbContEmitOut;
 
        realnum *anulog, 
          *anusqr, 
          *anu2, 
          *anu3;
 
        realnum **flux;
 
        realnum *flux_isotropic;
 
        realnum *flux_beam_time , *flux_beam_const;
 
        realnum *flux_accum;
 
        realnum *ExtinguishFactor;
        realnum ExtinguishLeakage, 
         ExtinguishColumnDensity, 
         ExtinguishLowEnergyLimit,
         ExtinguishConvertColDen2OptDepth ,
         ExtinguishEnergyPowerLow;
 
        bool lgMustBlockHIon;
 
        /* this is set true if H-ionizing radiation is blocked with extinguish
         * command */
        bool lgBlockHIon;
 
        bool lgDoLineTrans;
 
        bool lgOpacityReevaluate;
 
        bool lgCMB_set;
 
        bool lgIonizReevaluate;
 
        bool lgMeshSetUp;
 
        realnum *convoc;
 
        realnum *OccNumbIncidCont;
 
        realnum *OccNumbDiffCont;
 
        double *ContBoltz;
 
        realnum **ConEmitLocal/* [depth][energy]*/;
 
        realnum **ConSourceFcnLocal/* [depth][energy]*/;
 
        realnum **ConEmitReflec;
 
        realnum **ConEmitOut;
 
        realnum *ConInterOut;
 
        realnum **ConRefIncid;
 
        double *SummedCon;
        realnum *SummedDif;
        realnum *SummedOcc;
        realnum *SummedDifSave;
 
        realnum *ConOTS_local_photons,
                *ConOTS_local_OTS_rate;
 
        realnum *DiffuseEscape;
 
        realnum *TotDiff2Pht;
 
        realnum 
                *otslin/*[NC_ELL]*/, 
                *otscon/*[NC_ELL]*/, 
                **otssav/*[NC_ELL][2]*/;
 
        realnum **outlin,
                *outlin_noplot;
 
        realnum *DiffuseLineEmission;
 
        realnum **reflin/*[NC_ELL]*/;
 
        realnum **flux_total_incident;
        realnum *flux_beam_const_save , *flux_time_beam_save , *flux_isotropic_save;
 
        realnum time_continuum_scale;
 
        realnum DiffPumpOn;
 
        char **chLineLabel/*[NC_ELL][5]*/;
 
        char **chContLabel/*[NC_ELL][5]*/;
 
        realnum **gff/*[LIMELM][NC_ELL]*/;
 
        bool lgCompileGauntFF;
 
        char chDffTrns[4];
 
        bool lgOutOnly;
 
        long int ipEnergyBremsThin;
        realnum EnergyBremsThin;
 
        long int ipMaxBolt;
 
        bool lgInducProcess;
 
        double *comup, 
          *comdn;
 
        long int ipB_filter , ipV_filter;
 
        long int ipG0_TH85_lo , ipG0_TH85_hi;
 
        long int ipG0_DB96_lo , ipG0_DB96_hi;
 
        long int ipG0_spec_lo , ipG0_spec_hi;
 
        long int ip1000A;
 
        double extin_mag_B_point , extin_mag_V_point;
 
        double extin_mag_B_extended , extin_mag_V_extended;
 
        double opac_mag_B_point, opac_mag_V_point, opac_mag_B_extended , opac_mag_V_extended;
 
        realnum *csigh, 
          *csigc;
 
        double comtot, 
          cmheat, 
          cmcool, 
          cinrat;
        bool lgComptonOn;
 
        bool lgComUndr;
 
        double totpow[LIMSPC], 
          slope[LIMSPC], 
          cutoff[LIMSPC][3], 
          spfac[LIMSPC];
 
        bool lgTimeVary[LIMSPC];
 
        /* beamed or isotropic continuum?  if isotropic then does not vary
         * with time */
        bool lgBeamed[LIMSPC];
 
        realnum OpticalDepthScaleFactor[LIMSPC];
 
        Illuminate::IlluminationType Illumination[LIMSPC];
 
        long int nShape, 
          ipSpec;
 
        vector<Energy> tNu[LIMSPC];
        vector<realnum> tslop[LIMSPC];
        vector<realnum> tFluxLog[LIMSPC];
        
        long ncont[LIMSPC];
 
        double RSFCheck[LIMSPC];
 
        bool lgContMalloc[LIMSPC];
 
        double range[LIMSPC][2];
 
        char chSpNorm[LIMSPC][5], 
          chRSpec[LIMSPC][5], 
          chSpType[LIMSPC][6];
 
        realnum qhtot, 
          qhe, 
          qheii, 
          qbal, 
          qrad, 
          qtot;
 
        realnum uh;
 
        realnum uheii;
 
        bool lgUSphON;
        realnum rstrom;
 
        bool lgHabing;
 
        long int fine_opac_nelem;
 
        long int fine_opac_nresolv;
 
        realnum fine_opac_velocity_width;
 
private:
        realnum *trans_coef_total;
 
public:
        bool trans_coef_total_stale;
 
        long int *ipnt_coarse_2_fine;
 
        realnum fine_ener_lo, fine_ener_hi;
        long nfine;
        long nfine_malloc;
        double fine_resol;
        realnum *fine_opac_zone;
        realnum *fine_opt_depth;
        realnum *fine_anu;
 
        long int ipFineConVelShift;
 
        bool lgOpacityFine;
        bool lgSaveOpacityFine;
 
        bool lgLyaOTS;
 
        bool lgHeIIOTS;
 
        bool lgKillOutLine;
 
        bool lgKillOutCont;
 
        bool lgKillOTSLine;
 
        bool lgPlasNu;
        realnum plsfrq, 
                plsfrqmax;
        // the zone where the plasma frequency is evaluated 
        long int nZonePlsFrqEval;
        long int ipPlasma, 
          ipPlasmax;
 
        bool lgMMok, 
          lgHPhtOK, 
          lgXRayOK, 
          lgGamrOK;
 
        realnum EnerGammaRay;
        long int ipEnerGammaRay;
 
        bool lgHionRad;
 
        realnum occmax, 
          occmnu, 
          tbrmax, 
          tbrmnu, 
          tbr4nu, 
          occ1nu;
 
        bool lgOcc1Hi;
 
        realnum EnergyIncidCont ,
                EnergyDiffCont;
 
        // constructor
        t_rfield( )
        {
                nZonePlsFrqEval = -1;
 
                // the constant that multiplies the column density to get optical depth at 1 Ryd
                ExtinguishConvertColDen2OptDepth = (realnum)6.22e-18;
                // the power on the energy for the extinction
                ExtinguishEnergyPowerLow = (realnum)-2.43;
 
                // these are the low and high energy bounds of the continuum
                emm = 1.001e-8f;
                egamry = 7.354e6f;
 
                // space not created yet
                for( long i=0; i < LIMSPC; i++ )
                        lgContMalloc[i] = false;
        }
        
        const realnum *getCoarseTransCoef();
 
        void setCoarseTransCoefPtr(realnum *ptr)
                {
                        trans_coef_total = ptr;
                }
        void resetCoarseTransCoef()
                {
                        for (long i=0; i<nupper; ++i)
                                trans_coef_total[i] = 1.0;
                        trans_coef_total_stale = true;
                }
};
extern t_rfield rfield;
 
 
#endif /* RFIELD_H_ */