lines.h

Go to the documentation of this file.

/* This file is part of Cloudy and is copyright (C)1978-2017 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
{
public:
        string chLabel;
        realnum wave;
};

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();

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;

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;

        char chHoldComments[NHOLDCOMMENTS][INPUT_LINE_LENGTH];

        long int ipNormWavL;

        realnum WavLNorm;

        long int sig_figs;
        static const long sig_figs_max = 6;

        int     wl_length;

        double ScaleNormLine;

        char chNormLab[NCHLAB];

        bool lgNormSet;

        realnum RecCoefCNO[4][NRECCOEFCNO];

        long findline(const char *chLabel, realnum wavelength);

        vector<LinSv> lines;
        vector<realnum> m_wavelength;
        vector<size_t> SortWL;
        void clear()
        {
                lines.clear();
                m_wavelength.clear();
        }
        void resize(long nlines);
        
        void setSortWL();
        void init(long index, char chSumTyp, const char *chComment, const char *label,
                                 bool lgAdd, realnum wavelength, const TransitionProxy& tr);
        realnum wavelength(long index)
        {
                return m_wavelength[index];
        }

        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 addComponent(const char* species,const double wavelength);
        void addComponentID(long id);
        void makeBlend(const char* species, const double wavelength, 
                                                const double width);
        const TransitionProxy getComponent(long ind)
        {
                long id = m_component[ind];
                if (id > 0)
                        return LineSave.lines[id].getTransition();
                else
                        return TransitionProxy();
        }
        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];
                                /* Null emergent emission of non-transferred lines */
                                if( id > 0 && i == 1 && LineSave.lines[id].LineType() != 't' )
                                {
                                        sum = 0.;
                                        break;
                                }
                                if (id > 0)
                                        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];
                                /* Null emergent emission of non-transferred lines */
                                if( id > 0 && i == 1 && LineSave.lines[id].LineType() != 't' )
                                {
                                        sum = 0.;
                                        break;
                                }
                                if (id > 0)
                                        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];
        }

        realnum wavelength() const
        {
                return LineSave.wavelength(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.wavelength(m_index) <= realnum(0.) )
                                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 void t_LineSave::init(long index, char chSumTyp, const char *chComment, const char *label,
                                                                          bool lgAdd, realnum wavelength, const TransitionProxy& tr)
{
        if (!lgAdd)
        {
                // number of lines OK, set parameters for first pass
                // negative wavelength means it is just label, possibly not correct
                wavelength = fabs(wavelength);
        }
        
        m_wavelength[index] = wavelength;
        lines[index].init(index,chSumTyp,chComment,label,tr);

}
inline void t_LineSave::resize(long nlines)
{
        lines.resize(nlines);
        m_wavelength.resize(nlines);
}

#endif /* LINES_H_ */