dense.h

Go to the documentation of this file.

/* This file is part of Cloudy and is copyright (C)1978-2025 by Gary J. Ferland and
 * others.  For conditions of distribution and use see copyright notice in license.txt */
 
#ifndef DENSE_H_
#define DENSE_H_
 
/* dense.h density related variables */
 
#include "global.h"
#include "module.h"
#include "depth_table.h"
 
class molezone;

double dense_fabden(double radius, 
  double depth);
 
/*dense_parametric_wind called by dlaw command, returns density for any density law */
double dense_parametric_wind(double rad);

class t_dense : public module
{
public:
        t_dense()
        {
                /* list of atomic weights, mass in AMU, used for thermal line widths */
                /* >>refer      all     atomic weight   Coplen, T.B. 2001, J. Phys. Chem Ref Data, 30, 701 */
                AtomicWeight[0] = 1.00794f;
                AtomicWeight[1] = 4.0026022f;
                AtomicWeight[2] = 6.9412f;
                AtomicWeight[3] = 9.0121823f;
                AtomicWeight[4] = 10.8117f;
                AtomicWeight[5] = 12.01078f;
                AtomicWeight[6] = 14.00672f;
                AtomicWeight[7] = 15.99943f;
                AtomicWeight[8] = 18.9984032f;
                AtomicWeight[9] = 20.17976f;
                AtomicWeight[10] = 22.989770f;
                AtomicWeight[11] = 24.30506f;
                AtomicWeight[12] = 26.9815382f;
                AtomicWeight[13] = 28.08553f;
                AtomicWeight[14] = 30.9737612f;
                AtomicWeight[15] = 32.0655f;
                AtomicWeight[16] = 35.4532f;
                AtomicWeight[17] = 39.9481f;
                AtomicWeight[18] = 39.09831f;
                AtomicWeight[19] = 40.0784f;
                AtomicWeight[20] = 44.9559108f;
                AtomicWeight[21] = 47.8671f;
                AtomicWeight[22] = 50.94151f;
                AtomicWeight[23] = 51.99616f;
                AtomicWeight[24] = 54.9380499f;
                AtomicWeight[25] = 55.8472f;
                AtomicWeight[26] = 58.9332009f;
                AtomicWeight[27] = 58.69342f;
                AtomicWeight[28] = 63.5463f;
                AtomicWeight[29] = 65.392f;
 
                /* smallest density to permit in any ion - if smaller then set to zero */
                density_low_limit = max( SMALLFLOAT * 1e3, 1e-50 );
 
                for (long nelem=0; nelem<LIMELM; ++nelem)
                {
                        /* turn element on if this is first call to this routine,
                         * but do not reset otherwise since would clobber how elements were set up */
 
                        /* never turn on element if turned off on first iteration */
                        lgElmtOn[nelem] = true;
                        /* no elements yet explicitly turned off */
                        lgElmtSetOff[nelem] = false;
 
                        /* option to set ionization with element ioniz cmnd,
                         * default (false) is to solve for ionization */
                        lgSetIoniz[nelem] = false;
                
                        for (long ion=0; ion<LIMELM+1; ++ion)
                        {
                                // are we using Chianti for this ion?
                                lgIonChiantiOn[nelem][ion] = false;
                                lgIonStoutOn[nelem][ion] = false;
                                maxWN[nelem][ion] = 0.;
                                ionMole[nelem][ion] = NULL;
                        }
                }
                zero();
        }

        realnum gas_phase[LIMELM];
        void SetGasPhaseDensity( const long nelem, const realnum density );

        realnum AtomicWeight[LIMELM];
 
private:
        realnum m_xMolecules[LIMELM];
 
public:
        realnum xMolecules(long nelem)
        {
                return m_xMolecules[nelem];
        }
        void updateXMolecules();
        void zero();
        void comment(t_warnings&) {}
        const char* chName() const
        {
                return "dense";
        }

        realnum xMassDensity;
                        
        realnum xMassDensity0;
                
        realnum pden;
                
        realnum wmole;
                
        realnum xNucleiTotal;
                
        realnum xMassTotal;

        realnum HCorrFac;

        long int IonLow[LIMELM+1];
        long int IonHigh[LIMELM+1];

        double xIonDense[LIMELM][LIMELM+1];
 
        molezone* ionMole[LIMELM][LIMELM+1];

        bool lgIonChiantiOn[LIMELM][LIMELM+1];

        bool lgIonStoutOn[LIMELM][LIMELM+1];

        double maxWN[LIMELM][LIMELM+1];

        realnum AbundanceLimit;

        bool lgElmtOn[LIMELM];
        bool lgElmtSetOff[LIMELM];

        bool lgSetIoniz[LIMELM];

        realnum SetIoniz[LIMELM][LIMELM+1];

        char chDenseLaw[5];
 
        /* this says keep initial density constant, 
         * so pressure from iter to iter not really const */
        bool lgDenseInitConstant;
 
        // let initial pressure vary with time
        bool lgPressureVaryTime;
 
        //  required number is timescale for time variation
        double PressureVaryTimeTimescale;
        //  optional number is index for time variation
        double PressureVaryTimeIndex;

        double DensityLaw[10];

        bool lgAsChoose[LIMELM][LIMELM];
        bool lgCSChoose[LIMELM][LIMELM];

        DepthTable DLW;

        double eden;

        double EdenMax , EdenMin;

        double density_low_limit;

        long int nzEdenBad;

        realnum EdenSet;

        realnum EdenExtra;

        realnum EdenFraction;

        double SqrtEden;

        double EdenHCorr;
 
        realnum EdenHCorr_f;

        double EdenTrue;

        double eden_from_metals;

        bool lgEdenBad;

        double edensqte; 

        double cdsqte;

        realnum DensityPower;
        realnum rscale;
        realnum den0;

        bool lgDenFlucOn;

        bool lgDenFlucRadius;

        realnum flong;
        realnum cfirst; 
        realnum csecnd;
        realnum flcPhase;
 
};
extern t_dense dense;
 
// test whether nuclei conservation holds
bool lgElemsConserved();
 
class qList;
 
// test whether the sum of a set of states agrees with the ion population to the requested tolerance.
void lgStatesConserved ( long nelem, long ionStage, qList states,  long numStates, realnum err_tol, long loop_ion );
 
void SumDensities();
 
void ScaleAllDensities( const realnum factor );
void ScaleIonDensities( const long nelem, const realnum factor );
bool AbundChange();
 
realnum scalingDensity();
realnum scalingZoneDensity(long i);
 
#endif /* DENSE_H_ */