lines.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 LINES_H_
#define LINES_H_
 
#include <cstdio>
#include "module.h"
#include "transition.h"
#include "atmdat_adfa.h" // For NRECCOEFCNO
 
class cdstream;
 
class LineID
{
        string p_chLabel;
        // the constructors will make sure that this is always a wavelength in vacuum
        t_wavl p_wave;
        // the remaining parameters are optional, used for line disambiguation
        int p_indLo;
        int p_indHi;
        realnum p_ELo;
public:
        LineID() :
                p_indLo(-1), p_indHi(-1), p_ELo(-1_r) {}
        LineID(string lbl, t_wavl wv) :
                p_chLabel(lbl), p_wave(wv), p_indLo(-1), p_indHi(-1), p_ELo(-1_r) {}
        LineID(string lbl, t_wavl wv, realnum e) :
                p_chLabel(lbl), p_wave(wv), p_indLo(-1), p_indHi(-1), p_ELo(e) {}
        LineID(string lbl, t_wavl wv, int ilo, int ihi) :
                p_chLabel(lbl), p_wave(wv), p_indLo(ilo), p_indHi(ihi), p_ELo(-1_r) {}
        LineID(string lbl, t_wavl wv, int ilo, int ihi, realnum e) :
                p_chLabel(lbl), p_wave(wv), p_indLo(ilo), p_indHi(ihi), p_ELo(e) {}
        string chLabel() const { return p_chLabel; }
        realnum wavlVac() const { return p_wave.wavlVac(); }
        t_wavl twav() const { return p_wave; }
        string str() const { return "\"" + p_chLabel + "\" " + p_wave.sprt_wl(); }
        int indLo() const { return p_indLo; }
        int indHi() const { return p_indHi; }
        realnum ELo() const { return p_ELo; }
};

void lines(void);

void lines_general(void);

void lines_hydro(void);

void LineStackCreate(void);

void lines_grains(void);

void lines_setup(void);

void lines_continuum(void);

void lines_molecules(void);

void lines_helium(void);

void lines_lv1_li_ne(void);

void lines_lv1_k_zn(void);

long int StuffComment( const char * chComment );

int lines_table();

void clear_lines_table();
 
class LinSv;
 
void cdEmis(
        const LinSv* line,
        /* the vol emissivity of this line in last computed zone */
        double *emiss ,
        // intrinsic or emergent
        bool lgEmergent );
 
static const int NHOLDCOMMENTS = 100;
 
extern const t_wavl Hbeta_WavLen;

struct t_LineSave : public module {
        const char *chName() const
        {
                return "LineSave";
        }
        void zero();
        void comment(t_warnings&) {}

        long int nsum;

        long int nComment;

        long int ipass;

        string chHoldComments[NHOLDCOMMENTS];

        LineID NormLine;

        long int ipNormLine;

        double ScaleNormLine;

        long int sig_figs;
        static const long sig_figs_max = 6;

        int     wl_length;

        realnum RecCoefCNO[4][NRECCOEFCNO];
 
        long findline(const LineID& line, bool lgQuiet=false);

        vector<LinSv> lines;
        vector<realnum> m_wavelength;
        vector<size_t> SortWL;
        void clear()
        {
                lines.clear();
                m_wavelength.clear();
        }
        size_t size() const;
        void resize(long nlines);
        
        void setSortWL();
        void init(long index, char chSumTyp, const char *chComment, const char *label,
                          bool lgAdd, t_wavl wavelength, const TransitionProxy& tr);
        realnum wavlVac(long index) const
        {
                return m_wavelength[index];
        }
        t_wavl twav(long index) const
        {
                return t_vac(wavlVac(index));
        }
 
        void resetWavlVac( long index, realnum wl )
        {
                m_wavelength[index] = wl;
        }
 
        bool lgIsoContSubSignif;
};
extern t_LineSave LineSave;
 
class LinSv {
        long m_index;
        char m_chSumTyp;
        char m_chALab[NCHLAB];
        char m_chCLab[NCHLAB];
        double m_SumLine[4];   
        double m_emslin[2];
        string m_chComment;
        vector<long> m_component;
        TransitionProxy m_tr;
        enum { DEFAULT, SEPARATOR, UNIT, UNITD, INWARD, INWARDTOTAL, INWARDCONTINUUM,
                         COLLISIONAL, PUMP, HEAT, CASEA, CASEB, NINU, NFNU, PHOPLUS, PCON, QH }
                m_type;
        // private accessors
        void chALabSet(const char *that);
public:

        TransitionProxy getTransition()
        {
                return m_tr;
        }

        char chSumTyp() const
        {
                return m_chSumTyp;
        }

        const char *chALab() const
        {
                return m_chALab;
        }

        const char *chCLab() const
        {
                return m_chCLab;
        }

        bool isBlend() const
        {
                return !m_component.empty();
        }
        char LineType() const
        {
                return  m_chSumTyp;
        }
        void addComponentID(long id);
        void makeBlend(const char* species, const t_wavl& wavelength, const realnum width);
        void setBlendWavl();
 
        const TransitionProxy getComponent(long ind)
        {
                long id = m_component[ind];
                return LineSave.lines[id].getTransition();
        }
        double SumLine(int i) const
        {
                if (!isBlend())
                {
                        return m_SumLine[i];
                }
                else
                {
                        double sum = 0.;
                        for (size_t j=0; j<m_component.size(); ++j)
                        {
                                long id = m_component[j];
                                sum += LineSave.lines[id].SumLine(i);
                        }
                        return sum;
                }
        }
        void SumLineAdd(int i, double val)
        {
                if (!isBlend())
                        m_SumLine[i] += val;
        }
        void SumLineAccum(double cumulative_factor)
        {
                if (!isBlend())
                {
                        for( long nEmType=0; nEmType<2; ++nEmType )
                        {
                                m_SumLine[nEmType+2] += cumulative_factor*m_SumLine[nEmType];
                        }
                }
        }
        void SumLineZero()
        {
                if (!isBlend())
                        m_SumLine[0] = m_SumLine[1] = 0.0;
        }
        void SumLineZeroAccum()
        {
                if (!isBlend())
                        m_SumLine[2] = m_SumLine[3] = 0.0;
        }
        void SumLineThin()
        {
                if (!isBlend() && m_chSumTyp == 't')
                        m_SumLine[1] = m_SumLine[0];
        }

        double emslin(int i) const
        {
                if (!isBlend())
                {
                        return m_emslin[i];
                }
                else
                {
                        double sum = 0.;
                        for (size_t j=0; j<m_component.size(); ++j) 
                        {
                                long id = m_component[j];
                                sum += LineSave.lines[id].emslin(i);
                        }
                        return sum;
                }
        }
        void emslinZero()
        {
                if (!isBlend())
                {
                        m_emslin[0] = 0.0;
                        m_emslin[1] = 0.0;
                }
        }
        void emslinSet(int i, double v)
        {
                if (!isBlend())
                        m_emslin[i] = v;
        }
        void emslinThin()
        {
                if (!isBlend() && m_chSumTyp == 't')
                        m_emslin[1] = m_emslin[0];
        }

        void prt_blend() const;

        realnum wavlVac() const
        {
                return LineSave.wavlVac(m_index);
        }
        t_wavl twav() const
        {
                return LineSave.twav(m_index);
        }

        string chComment() const;
        void init(long index, char chSumTyp, const char *chComment, const char *label,
                                 const TransitionProxy& tr);
 
        void prt(FILE *fp) const;
        string label() const;
        string biglabel() const;
        bool isCat(const char *s) const;
        bool isSeparator() const
        {
                return m_type == SEPARATOR;
        }
        bool isUnit() const
        {
                return m_type == UNIT;
        }
        bool isUnitD() const
        {
                return m_type == UNITD;
        }
        bool isInward() const
        {
                return m_type == INWARD;
        }
        bool isInwardTotal() const
        {
                return m_type == INWARDTOTAL;
        }
        bool isInwardContinuum() const
        {
                return m_type == INWARDCONTINUUM;
        }
        bool isCollisional() const
        {
                return m_type == COLLISIONAL;
        }
        bool isPump() const
        {
                return m_type == PUMP;
        }
        bool isHeat() const
        {
                return m_type == HEAT;
        }
        bool isCaseA() const
        {
                return m_type == CASEA;
        }
        bool isCaseB() const
        {
                return m_type == CASEB;
        }
        bool isNInu() const
        {
                return m_type == NINU;
        }
        bool isNFnu() const
        {
                return m_type == NFNU;
        }
        bool isPhoPlus() const
        {
                return m_type == PHOPLUS;
        }
        bool isPcon() const
        {
                return m_type == PCON;
        }
        bool isQH() const
        {
                return m_type == QH;
        }
 
#ifndef NDEBUG
        void checkEmergent( const long ipEmType ) const
        {
                /* Pick instantaneous or cumulative */
                int ipIntr, ipEmer;
                if( ipEmType == 1 )
                {
                        ipIntr = 0;
                        ipEmer = 1;
                }
                else if( ipEmType == 3 )
                {
                        ipIntr = 2;
                        ipEmer = 3;
                }
                else
                        return;
 
                if( !isBlend() )
                {
                        if( m_chSumTyp != 't' || LineSave.wavlVac(m_index) <= 0_r )
                                ASSERT( m_SumLine[ipEmer] == 0. );
                        else
                                ASSERT( m_SumLine[ipIntr] > m_SumLine[ipEmer] ||
                                        fp_equal( m_SumLine[ipIntr], m_SumLine[ipEmer], 10 ) );
                }
        }
#else
        void checkEmergent( const long ) const
        {
                (void)0;
        }
#endif
};
 
inline size_t t_LineSave::size() const
{
        ASSERT( lines.size() == m_wavelength.size() );
        return lines.size();
}
 
inline void t_LineSave::resize(long nlines)
{
        lines.resize(nlines);
        m_wavelength.resize(nlines);
}
 
long findComponent(const LineID& line, bool lgQuiet);
 
#endif /* LINES_H_ */