emission.h

Go to the documentation of this file.

/* This file is part of Cloudy and is copyright (C)1978-2023 by Gary J. Ferland and
 * others.  For conditions of distribution and use see copyright notice in license.txt */

#ifndef EMISSION_H_
#define EMISSION_H_

#include "proxy_iterator.h"
#include "iter_track.h"

class TransitionListImpl;
class TransitionProxy;
class TransitionConstProxy;
class EmissionList;
class EmissionConstProxy;

//typedef iter_track_basic<realnum> tracker;
typedef secant_track tracker;

class EmissionProxy
{
public:
        typedef EmissionList list_type;
        typedef ProxyIterator<EmissionProxy,EmissionConstProxy> iterator;
        typedef ProxyIterator<EmissionConstProxy,EmissionConstProxy> const_iterator;
private:
        friend class ProxyIterator<EmissionProxy,EmissionConstProxy>;
        EmissionList *m_list;
        int m_index;
public:
        explicit EmissionProxy() : m_list(NULL), m_index(-1) {}
        explicit EmissionProxy(EmissionList *list, int index) : 
        m_list(list), m_index(index) {}
        void copy(const EmissionProxy& other);

        void check() const
        {
                ASSERT(ipTran() >= 0);
        }

        int &iRedisFun() const;

        long int &ipFine() const;

        realnum &TauIn() const;

        realnum &TauInSpecific() const;

        realnum &TauTot() const;

        tracker& TauTrack() const;

        realnum &TauCon() const;

        realnum &FracInwd() const;

        double &pump() const;

        double &xIntensity() const;

        double &xObsIntensity() const;

        realnum &gf() const;

        realnum &Pesc() const;

        realnum &Pelec_esc() const;

        realnum &Pdest() const;

        realnum Pesc_total() const { return Pesc() + Pelec_esc(); }

        realnum Ploss() const { return Pesc_total()+Pdest(); }

        realnum &dampXvel() const;

        realnum &damp() const;

        double &ColOvTot() const;

        realnum &AutoIonizFrac() const;

        realnum &opacity() const;
        // This is the summed opacity in a multiplet.
        double &mult_opac() const;

        double &PopOpc() const;

        double &VoigtLineCen() const;

        realnum &Aul() const;

        double &ots() const;

        int &ipTran() const;

        TransitionProxy Tran() const;
};
class EmissionConstProxy
{
public:
        typedef const EmissionList list_type;
        typedef ProxyIterator<EmissionConstProxy,EmissionConstProxy> iterator;
        typedef ProxyIterator<EmissionConstProxy,EmissionConstProxy> const_iterator;
private:
        friend class ProxyIterator<EmissionConstProxy,EmissionConstProxy>;
        const EmissionList *m_list;
        int m_index;
public:
        explicit EmissionConstProxy() : m_list(NULL), m_index(-1) {}
        explicit EmissionConstProxy(const EmissionList *list, int index) : 
        m_list(list), m_index(index) {}
        void copy(const EmissionConstProxy& other);

        void check() const
        {
                ASSERT(ipTran() >= 0);
        }

        int iRedisFun() const;

        long int ipFine() const;

        realnum TauIn() const;

        realnum TauInSpecific() const;

        realnum TauTot() const;

        const tracker& TauTrack() const;

        realnum TauCon() const;

        realnum FracInwd() const;

        double pump() const;

        double xIntensity() const;

        double xObsIntensity() const;

        realnum gf() const;

        realnum Pesc() const;

        realnum Pelec_esc() const;

        realnum Pdest() const;

        realnum Pesc_total() const { return Pesc() + Pelec_esc(); }

        realnum Ploss() const { return Pesc_total()+Pdest(); }

        realnum dampXvel() const;

        realnum damp() const;

        double ColOvTot() const;

        realnum AutoIonizFrac() const;

        realnum opacity() const;
        // This is the summed opacity in a multiplet.
        double mult_opac() const;

        double PopOpc() const;

        double VoigtLineCen() const;

        realnum Aul() const;

        double ots() const;

        int ipTran() const;

        TransitionConstProxy Tran() const;
};

class EmissionList
{
        TransitionListImpl *m_tlist;
        vector<realnum> m_Aul;
        vector<realnum> m_AutoIonizFrac;
        vector<double> m_ColOvTot;
        vector<realnum> m_damp;
        vector<realnum> m_dampXvel;
        vector<realnum> m_FracInwd;
        vector<realnum> m_gf;
        vector<int> m_iRedisFun;
        vector<long> m_ipFine;
        vector<realnum> m_opacity;
        vector<double> m_mult_opac;
        vector<double> m_ots;
        vector<realnum> m_Pdest;
        vector<realnum> m_Pesc;
        vector<realnum> m_Pelec_esc;
        vector<double> m_PopOpc;
        vector<double> m_VoigtLineCen;
        vector<double> m_pump;
        vector<realnum> m_TauCon;
        vector<realnum> m_TauIn;
        vector<realnum> m_TauInSpecific;
        vector<realnum> m_TauTot;
        vector<tracker > m_TauTrack;
        vector<double> m_xIntensity;
        vector<double> m_xObsIntensity;
        vector<int> m_ipTran;
        friend class EmissionProxy;
        friend class EmissionConstProxy;
public:
        typedef EmissionProxy reference;
        typedef EmissionProxy::iterator iterator;
        typedef EmissionConstProxy::iterator const_iterator;
        explicit EmissionList(TransitionListImpl *tlist, size_t i) : m_tlist(tlist)
        {
                resize(i);
        }
        explicit EmissionList(TransitionListImpl *tlist) : m_tlist(tlist) {}
        reference operator[](size_t i)
        {
                return EmissionProxy(this,i);
        }
        size_t size(void) const
        {
                return m_Aul.size();
        }
        void resize(size_t i);
        iterator begin()
        {
                return iterator(this,0);
        }
        const_iterator begin() const
        {
                return const_iterator(this,0);
        }
        iterator end()
        {
                return iterator(this,size());
        }
        const_iterator end() const
        {
                return const_iterator(this,size());
        }
};

void EmLineJunk( EmissionList::reference t );
void EmLineZero( EmissionList::reference t );
void TauZero( EmissionList::reference t );

inline void EmissionList::resize(size_t i)
{
        size_t oldsize = m_Aul.size();
        m_Aul.resize(i);
        m_AutoIonizFrac.resize(i);
        m_ColOvTot.resize(i);
        m_damp.resize(i);
        m_dampXvel.resize(i);
        m_gf.resize(i);
        m_FracInwd.resize(i);
        m_ipFine.resize(i);
        m_iRedisFun.resize(i);
        m_ots.resize(i);
        m_opacity.resize(i);
        m_mult_opac.resize(i);
        m_Pdest.resize(i);
        m_Pelec_esc.resize(i);
        m_Pesc.resize(i);
        m_PopOpc.resize(i);
        m_VoigtLineCen.resize(i);
        m_TauCon.resize(i);
        m_TauIn.resize(i);
        m_TauInSpecific.resize(i);
        m_TauTot.resize(i);
        m_TauTrack.resize(i);
        m_pump.resize(i);
        m_xIntensity.resize(i);
        m_xObsIntensity.resize(i);
        m_ipTran.resize(i,-1);
        for (size_t newelem=oldsize; newelem < size(); ++newelem)
        {
                EmLineJunk((*this)[newelem]);
        /* 
                \todo 2 Does doing EmLineZero here defeat the purpose of EmLineJunk? 
                * maybe we should pass full set of Emis components, fill everything in 
                * here, and THEN use EmLineZero?  */
                EmLineZero((*this)[newelem]);
                TauZero((*this)[newelem]);
        }
}

inline int &EmissionProxy::iRedisFun() const
{
        return m_list->m_iRedisFun[m_index];
}

inline int EmissionConstProxy::iRedisFun() const
{
        return m_list->m_iRedisFun[m_index];
}

inline long int &EmissionProxy::ipFine() const
{
        return m_list->m_ipFine[m_index];
}

inline long int EmissionConstProxy::ipFine() const
{
        return m_list->m_ipFine[m_index];
}

inline realnum &EmissionProxy::TauIn() const
{
        return m_list->m_TauIn[m_index];
}

inline realnum EmissionConstProxy::TauIn() const
{
        return m_list->m_TauIn[m_index];
}

inline realnum &EmissionProxy::TauInSpecific() const
{
        return m_list->m_TauInSpecific[m_index];
}

inline realnum EmissionConstProxy::TauInSpecific() const
{
        return m_list->m_TauInSpecific[m_index];
}

inline realnum &EmissionProxy::TauTot() const
{
        return m_list->m_TauTot[m_index];
}

inline realnum EmissionConstProxy::TauTot() const
{
        return m_list->m_TauTot[m_index];
}

inline tracker&EmissionProxy:: TauTrack() const
{
        return m_list->m_TauTrack[m_index];
}

inline const tracker&EmissionConstProxy:: TauTrack() const
{
        return m_list->m_TauTrack[m_index];
}

inline realnum &EmissionProxy::TauCon() const
{
        return m_list->m_TauCon[m_index];
}

inline realnum EmissionConstProxy::TauCon() const
{
        return m_list->m_TauCon[m_index];
}

inline realnum &EmissionProxy::FracInwd() const
{
        return m_list->m_FracInwd[m_index];
}

inline realnum EmissionConstProxy::FracInwd() const
{
        return m_list->m_FracInwd[m_index];
}

inline double &EmissionProxy::pump() const
{
        return m_list->m_pump[m_index];
}

inline double EmissionConstProxy::pump() const
{
        return m_list->m_pump[m_index];
}

inline double &EmissionProxy::xIntensity() const
{
        return m_list->m_xIntensity[m_index];
}

inline double &EmissionProxy::xObsIntensity() const
{
        return m_list->m_xObsIntensity[m_index];
}

inline double EmissionConstProxy::xIntensity() const
{
        return m_list->m_xIntensity[m_index];
}

inline double EmissionConstProxy::xObsIntensity() const
{
        return m_list->m_xObsIntensity[m_index];
}

inline int &EmissionProxy::ipTran() const
{
        return m_list->m_ipTran[m_index];
}

inline int EmissionConstProxy::ipTran() const
{
        return m_list->m_ipTran[m_index];
}

inline realnum &EmissionProxy::gf() const
{
        return m_list->m_gf[m_index];
}

inline realnum EmissionConstProxy::gf() const
{
        return m_list->m_gf[m_index];
}

inline realnum &EmissionProxy::Pesc() const
{
        return m_list->m_Pesc[m_index];
}

inline realnum EmissionConstProxy::Pesc() const
{
        return m_list->m_Pesc[m_index];
}

inline realnum &EmissionProxy::Pelec_esc() const
{
        return m_list->m_Pelec_esc[m_index];
}

inline realnum EmissionConstProxy::Pelec_esc() const
{
        return m_list->m_Pelec_esc[m_index];
}

inline realnum &EmissionProxy::Pdest() const
{
        return m_list->m_Pdest[m_index];
}

inline realnum EmissionConstProxy::Pdest() const
{
        return m_list->m_Pdest[m_index];
}

inline realnum &EmissionProxy::dampXvel() const
{
        return m_list->m_dampXvel[m_index];
}

inline realnum EmissionConstProxy::dampXvel() const
{
        return m_list->m_dampXvel[m_index];
}

inline realnum &EmissionProxy::damp() const
{
        return m_list->m_damp[m_index];
}

inline realnum EmissionConstProxy::damp() const
{
        return m_list->m_damp[m_index];
}

inline double &EmissionProxy::ColOvTot() const
{
        return m_list->m_ColOvTot[m_index];
}

inline double EmissionConstProxy::ColOvTot() const
{
        return m_list->m_ColOvTot[m_index];
}

inline realnum &EmissionProxy::AutoIonizFrac() const
{
        return m_list->m_AutoIonizFrac[m_index];
}

inline realnum EmissionConstProxy::AutoIonizFrac() const
{
        return m_list->m_AutoIonizFrac[m_index];
}

inline realnum &EmissionProxy::opacity() const
{
        return m_list->m_opacity[m_index];
}

inline realnum EmissionConstProxy::opacity() const
{
        return m_list->m_opacity[m_index];
}

inline double &EmissionProxy::mult_opac() const
{
        return m_list->m_mult_opac[m_index];
}

inline double EmissionConstProxy::mult_opac() const
{
        return m_list->m_mult_opac[m_index];
}

inline double &EmissionProxy::PopOpc() const
{
        return m_list->m_PopOpc[m_index];
}

inline double EmissionConstProxy::PopOpc() const
{
        return m_list->m_PopOpc[m_index];
}

inline double &EmissionProxy::VoigtLineCen() const
{
        return m_list->m_VoigtLineCen[m_index];
}

inline double EmissionConstProxy::VoigtLineCen() const
{
        return m_list->m_VoigtLineCen[m_index];
}

inline realnum &EmissionProxy::Aul() const
{
        return m_list->m_Aul[m_index];
}

inline realnum EmissionConstProxy::Aul() const
{
        return m_list->m_Aul[m_index];
}

inline double &EmissionProxy::ots() const
{
        return m_list->m_ots[m_index];
}

inline double EmissionConstProxy::ots() const
{
        return m_list->m_ots[m_index];
}

inline void EmissionProxy::copy(const EmissionProxy& other)
{
        iRedisFun() = other.iRedisFun();
        ipFine() = other.ipFine();
        TauIn() = other.TauIn();
        TauInSpecific() = other.TauInSpecific();
        TauTot() = other.TauTot();
        TauCon() = other.TauCon();
        FracInwd() = other.FracInwd();
        gf() = other.gf();
        Pesc() = other.Pesc();
        Pelec_esc() = other.Pelec_esc();
        Pdest() = other.Pdest();
        dampXvel() = other.dampXvel();
        damp() = other.damp();
        AutoIonizFrac() = other.AutoIonizFrac();
        opacity() = other.opacity();
        mult_opac() = other.mult_opac();
        Aul() = other.Aul();
        TauTrack() = other.TauTrack();
        pump() = other.pump();
        xIntensity() = other.xIntensity();
        xObsIntensity() = other.xObsIntensity();
        ColOvTot() = other.ColOvTot();
        PopOpc() = other.PopOpc();
        VoigtLineCen() = other.VoigtLineCen();
        ots() = other.ots();
        ipTran() = other.ipTran();
}

#endif // EMISSION_H_