rfield.h

Go to the documentation of this file.

/* This file is part of Cloudy and is copyright (C)1978-2022 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"
#include "module.h"
#include "vectorize.h"
#include "mesh.h"

const double WL_V_FILT = 5500.;

const double WL_B_FILT = 4400.;

const int LIMSPC = 100;

void rfield_opac_zero( long lo , long ihi );

extern bool lgRfieldMalloced;

namespace Illuminate {
        typedef enum { FORWARD , REVERSE , ISOTROPIC } IlluminationType ;
}

struct t_rfield : public module, public t_mesh {
        const char *chName() const
        {
                return "rfield";
        }
        
        void zero();
        void comment(t_warnings&) {}
        long int nflux;

        long int nflux_with_check;

        long int nPositive;

        double FluxFaint;

        long int *line_count;

        realnum *OccNumbContEmitOut;

        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;

        realnum *convoc;

        realnum *OccNumbIncidCont;

        realnum *OccNumbDiffCont;

        vector<double, allocator_avx<double> > ContBoltz;

        vector<double, allocator_avx<double> > ContBoltzHelp1;
        vector<double, allocator_avx<double> > ContBoltzHelp2;

        vector<double, allocator_avx<double> > vexp_arg;

        vector<double, allocator_avx<double> > ContBoltzAvg;

        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/*[rfield.nflux_with_check]*/, 
                *otscon/*[rfield.nflux_with_check]*/, 
                **otssav/*[rfield.nflux_with_check][2]*/;

        realnum **outlin,
                *outlin_noplot;

        realnum *DiffuseLineEmission;

        realnum **reflin/*[rfield.nflux_with_check]*/;

        realnum **flux_total_incident;
        realnum *flux_beam_const_save , *flux_time_beam_save , *flux_isotropic_save;

        realnum time_continuum_scale;

        realnum DiffPumpOn;

        vector<string> chLineLabel/*[rfield.nflux_with_check][5]*/;

        vector<string> chContLabel/*[rfield.nflux_with_check][5]*/;

        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;

        realnum *eeBremsDif;

        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];
        double TableRadius[LIMSPC];
        bool lgSphericalDilution[LIMSPC];
        
        long ncont[LIMSPC];

        double RSFCheck[LIMSPC];

        double range[LIMSPC][2];

        char chSpNorm[LIMSPC][5], 
                chRSpec[LIMSPC][5], 
                chSpType[LIMSPC][6],
                chCumuType[5];

        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;
        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;
        }
        
        const realnum *getCoarseTransCoef();

        void setCoarseTransCoefPtr(realnum *ptr)
                {
                        trans_coef_total = ptr;
                }
        void resetCoarseTransCoef()
                {
                        for (long i=0; i<nflux_with_check; ++i)
                                trans_coef_total[i] = 1.0;
                        trans_coef_total_stale = true;
                }
        void setTrimming();
};
extern t_rfield rfield;

double flux_correct_isotropic( const bool lgSaveIsotrp, const int nEmType, const int j );

double flux_correct_isotropic( const int nEmType, const int j );

#endif /* RFIELD_H_ */