prt.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 PRT_H_
#define PRT_H_

#include "module.h"
#include "container_classes.h"
#include "lines.h"

class TransitionProxy;

//* Maximum number of columns in output print
const long NCOLMAX=132;

void PrtZone(void);

void PrtComment(void);

void PrtFinal(void);


void SetPrintLineCol ();

void prt_wl( 
        FILE *io , 
        realnum wavelength );

void sprt_wl( 
        string& chString,
        realnum wl );

void prt_line_err( FILE *ioOUT, const string& label, realnum wvlng );
void prt_line_err( FILE *ioOUT, const LineID& lineid );

/* prt_line_inlist print line suitable for output list, label not enclosed in quotation marks
\param *ioOUT           output file handle
\param *label           line label
\param wvlng            line wavelength
 */
void prt_line_inlist ( FILE *ioOUT, const char *label, realnum wvlng );

void PrtHeader(void);

void prt_LineLabels(
        FILE * io,
        bool lgPrintAll,
        bool lgPrintIndex
        );

void prtmet(void);

void PrtMeanIon( char chType , 
                        bool lgDensity,
                        FILE *);

double PrtLineSum(void);

void PrtLinePres(FILE *ioPRESSURE);

void PrtColumns(
         FILE *ioMEAN  );

void CloudyPrintReference();

void DatabasePrintReference();

void PrtAllTau(void);

class t_prt_matrix : public module {
public:
        string species;
        string speciesLevels;
        vector<long> speciesLevelList;
        bool lgLevelsResolved = false;

        void zero();
        void comment(t_warnings&) {}

        const char *chName() const
        {
                return "prt_matrix";
        }

        void setSpecies( const string &sspec );
        void resolveLevels();
        void prtRates( const long numLevels,
                        const multi_arr<double,2,C_TYPE> &matrix,
                        valarray<double> &b );
};

struct t_blend {
        string chLabel;
        realnum wave;
        bool lgQuiet;
        bool lgIgnore;
        vector<LineID> component;
        t_blend() : chLabel("Blnd"), wave(0_r), lgQuiet(false), lgIgnore(false) {}
};

struct t_prt {

        bool lgPrintBlock;

        bool lgPrintBlockIntrinsic;

        bool lgPrintBlockEmergent;

        bool lgSortLines;

        bool lgSortLineWavelength , lgSortLineIntensity;

        realnum wlSort1 , wlSort2;

        bool lgPrintColumns;

        bool lgPrintTime;

        bool lgPrnAges;

        bool lgPrtMaser;

        bool lgPrtTau;

        bool lgPrintFluxEarth;

        bool lgSurfaceBrightness , lgSurfaceBrightness_SR;

        realnum PrtTauFnt;

        bool lgPrnPump, 
          lgPrnHeat, 
          lgPrnColl, 
          lgPrnInwd;

        bool lgPrnIsoCollapsed;

        /* flag set with print continuum index command, to identify all lines
         * that lie within a continuum cell */
        bool lgPrtContIndices;
        /* these are lower and upper limits to the energy range in Rydbergs.
         * they are the first and second number on the command line, lower and
         * upper bounds of the code are used if not specified */
        realnum lgPrtContIndices_lo_E , 
                lgPrtContIndices_hi_E;

        bool lgSourceReflected;
        bool lgSourceTransmitted;
        bool lgDiffuseInward;
        bool lgDiffuseOutward;

        bool lgPrtBN;

        bool lgPrtLastIt;

        bool lgPrtShort;

        bool lgOnlyZone;
        bool lgOnlyHead;

        bool lgPrtStart;

        long int nstart;

        bool lgPrintHeating;

        bool lgPrtArry[LIMELM];

        t_prt_matrix matrix;

        realnum TooFaint;
        bool lgFaintOn;

        bool lgFntSet;

        bool lgPrnLineCell;
        long int nPrnLineCell;

        bool lgPrtLineArray;

        bool lgPrtLineLog;

        bool lgPrintLineCumulative;

        bool lgPrintLineAirWavelengths;

        /* Generate output in HTML format */
        bool lgPrintHTML;

        realnum qx, 
          powion, 
          xpow, 
          pbal, 
          q, 
          qgam, 
          pradio, 
          fx1ryd;
        long int ipeak;
        realnum GammaLumin;

        long int nzdump;

        bool lgPrtCitations;

        vector<t_blend> blend;

        bool lgIncludeBlends;

        t_prt()
        {
                // make sure this has the correct value before main() starts
                // this is needed by check_data() and possibly others
                lgPrintTime = true;
                // this needs to be set before the code starts reading the input script
                lgIncludeBlends = true;
        }
};
extern t_prt prt;



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

        int     absint_len;

        int     relint_len;

        int     column_len;

        int     col_gap_len;

        string  relint_outrange;

        string  col_gap;
};
extern struct t_line_col prt_linecol;

#endif /* PRT_H_ */