save.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 SAVE_H_
#define SAVE_H_
 
#include "energy.h"
#include "lines.h"
#include "prt.h"
 
class diatomics;
class TransitionProxy;
 
/* save.h */
static const long LIMPUN = 100L;

static const long VERSION_TRNCON = 20190210L;

void SaveDo(
        const char *chTime); 

double PrtLogLin( double value );

void Save1Line( 
        const TransitionProxy & t , 
        FILE * io , 
        realnum xLimit , 
        long index,
        realnum DopplerWidth);

NORETURN void SaveLineData(
        FILE * io);

void save_opacity(
        FILE * io, 
        long int np);

void SaveSpecial(
        FILE* io , 
  const char *chTime);
 

void SaveAllSpeciesLabelsLevels( FILE *ioPUN );
 

void SaveSpecies(
                FILE* ioPUN,
                long int ipPun );

void SaveSpeciesPseudoCont( const long ipPun, const string &speciesLabel );

void SaveSpeciesBands( const long ipPun, const string &speciesLabel,
                        const string &fileBands, const bool lgEmergent );

void SaveSpeciesOptDep( const long int ipPun, const string &speciesLabel );
 
class molecule;
 
extern void mole_save(FILE *punit, const char speciesname[], const char args[], bool lgHeader, bool lgData, bool lgCoef, double depth);
 
// debug_list -- list of species to print -- add multiple species to get net
//    rate of change for all together, useful for understanding net sources
//    sinks to networks
// ioOut -- stream
// lgPrintReagents -- print abundances of reagents
// NPRINT -- max number of reactions
// fprint -- minimum fraction of total rate which is worth printing
extern void mole_dominant_rates( const vector<const molecule *>& debug_list, 
                                                                                        FILE *ioOut,
                                                                                        bool lgPrintReagents, size_t NPRINT, double fprint );
 
extern void mole_print_species_reactions( molecule *speciesToPrint );
 
 
/* Print header for Save1LineData() function
 * \param ioPUN         file pointer to write to
 */
void PrintLineDataHeader( FILE * ioPUN );
 

void Save1LineData( 
        const TransitionProxy & t , 
        FILE * io,
        bool lgCS_2 );

void save_line(
        FILE * ip,
        const char *chDo, 
        bool lgEmergent,
        long ipPun );

void save_average( 
        long int ipPun);

void Save_Line_RT(
        FILE * ip);

void saveFITSfile( 
        FILE* io, 
        int option,
        realnum Elo = 0.f,
        realnum Ehi = 0.f,
        realnum Enorm = 0.f);

void saveFITSimg( FILE *io, const string &extName, const string &units,
                const long nPixels,
                const multi_arr<double,2,C_TYPE> &image );

void saveFITSimg( FILE *io, const string &extName, const string &units,
                const long nCols, const valarray<double> &vec );

void SaveHeat(FILE* io);

void CoolSave(FILE * io, const char chJob[]);

void SaveGrid(FILE* pnunit, exit_type status);
 
class SaveParams
{
public:
        FILE *ipPnunit;
};
 
class adjPseudoCont
{
public:
        string speciesLabel;
        realnum wlLo,
                wlHi;
        long nBins;
};
 
class save_img_matrix : public t_prt_matrix
{
public:
        bool lgImgRates;
        bool lgFITS;
        long iteration;
        long zone;
 
        void zero();
        void comment(t_warnings&) {}
 
        const char *chName() const
        {
                return "img_matrix";
        }
 
        inline bool matchIteration( const long this_iteration ) const
        {
                return ( ( iteration > 0 && iteration == this_iteration ) ||
                                ! iteration );
        }
 
        inline bool matchZone( const long this_zone ) const
        {
                return ( ( zone > 0 && zone == this_zone ) || ! zone );
        }

        void createImage( const string &species,
                        const long iteration,
                        const long nzone,
                        const long numLevels,
                        const multi_arr<double,2,C_TYPE> &matrix,
                        const valarray<double> &creation,
                        bool haveNegPop = false );

        void createImage(
                        const long iteration,
                        const long nzone,
                        const long numLevels,
                        const multi_arr<double,2,C_TYPE> &matrix,
                        const valarray<double> &creation,
                        bool haveNegPop = false );

        void addImagePop_FITS( const string &species,
                        const long iteration,
                        const long nzone,
                        const long numLevels,
                        const valarray<double> &pop,
                        bool haveNegPop = false );

        void addImagePop_FITS(
                        const long iteration,
                        const long nzone,
                        const long numLevels,
                        const valarray<double> &pop,
                        bool haveNegPop = false );
 
private:
        string set_basename( const string &species,
                        const long iteration,
                        const long nzone,
                        bool haveNegPop = false );
 
        void createImage_PPM( const string &basename,
                        const long numLevels,
                        const multi_arr<double,2,C_TYPE> &matrix );
 
        void createImage_FITS( const string &basename,
                        const long numLevels,
                        const multi_arr<double,2,C_TYPE> &matrix,
                        const valarray<double> &creation );
};
 
struct t_save {
 
        t_save()
        {
                for( long i=0; i < LIMPUN; ++i )
                {
                        nLineList[i] = -1;
                        lgFITS[i] = false;
                        lgXSPEC[i] = false;
                        FITStype[i] = -1;
                        nAverageList[i] = -1;
                        p_lgSaveTitleDone[i] = false;
                        p_lgSaveHeaderDone[i] = false;
                }
                p_lgSaveHeaderNeeded = true;
                ipSaveGrid = -1;
        }
 
        ~t_save()
        {
                for( long i=0; i < LIMPUN; ++i )
                {
                        SaveLineListFree(i);
                        SaveAverageFree(i);
                }
        }
 
        void SaveLineListFree(long i)
        {
                LineList[i].clear();
        }
        void SaveAverageFree(long i)
        {
                nAverageList[i] = 0;
                chAverageType[i].clear();
                chSaveSpecies[i].clear();
                /* nAverageIonList is set of ions for averages */
                nAverageIonList[i].clear();
                /* nAverage2ndPar is set of second parameters for averages */
                nAverage2ndPar[i].clear();
        }
 
        string chGridDelimeter(long n)
        {
                ostringstream oss;
                // NB NB -- do not change this format, tests in
                // check_grid_file() and fix_grid_file() depend on this
                oss << chHashString << " GRID_DELIMIT -- grid";
                oss << setfill('0') << setw(9) << n;
                return oss.str();
        }

        long nLineList[LIMPUN];
        vector<LineID> LineList[LIMPUN];
        bool lgLineListRatio[LIMPUN];

        long nAverageList[LIMPUN];
        vector<string> chAverageType[LIMPUN];
        vector<int> nAverageIonList[LIMPUN];
        vector<int> nAverage2ndPar[LIMPUN];

        SaveParams params[LIMPUN]; 

        vector<string> chFileName;

        long ipSaveGrid;

        bool lgNoClobber[LIMPUN];

        bool lgPrtOldStyleLogs[LIMPUN];

        bool lgPunConv_noclobber;
        bool lgDROn_noclobber;
        bool lgDTOn_noclobber;
        bool lgPunPoint_noclobber;
        bool lgioRecom_noclobber;
        bool lgQHSaveFile_noclobber;
        bool lgTraceConvergeBase_noclobber;
        bool lgSaveGrid_noclobber;

        bool lgRealSave[LIMPUN]; 

        bool lgEmergent[LIMPUN];

        bool lgCumulative[LIMPUN];

        bool lgSubtrCont;

        bool lgPrtIsotropicCont[LIMPUN];

        long int nsave;

        char chSave[LIMPUN][5];
        diatomics *whichDiatomToPrint[LIMPUN];

        char chOpcTyp[LIMPUN][5];

        bool lgSaveToSeparateFiles[LIMPUN];

        bool lg_separate_iterations[LIMPUN];
 
private:
        bool p_lgSaveTitleDone[LIMPUN];

        bool p_lgSaveHeaderDone[LIMPUN];

        bool p_lgSaveHeaderNeeded;
 
public:
        void SetSaveHeaderNeeded(bool lgVal) { p_lgSaveHeaderNeeded = lgVal; }

        bool lgSaveTitle(int ipPun) const
        {
                return !p_lgSaveTitleDone[ipPun] && p_lgSaveHeaderNeeded;
        }
        void SaveTitleDone(int ipPun) { p_lgSaveTitleDone[ipPun] = true; }

        bool lgSaveHeader(int ipPun) const
        {
                return !p_lgSaveHeaderDone[ipPun] && p_lgSaveHeaderNeeded;
        }
        void SaveHeaderDone(int ipPun) { p_lgSaveHeaderDone[ipPun] = true; }

        bool lgPunContinuum;

        realnum punarg[LIMPUN][3];

        string optname[LIMPUN];

        bool lgSaveEveryZone[LIMPUN];
        long int nSaveEveryZone[LIMPUN];

        char chSaveArgs[LIMPUN][5];
 
        vector<string> chSaveSpecies[LIMPUN];

        bool lgPunLstIter[LIMPUN];

        bool lgFITS[LIMPUN];

        bool lgXSPEC[LIMPUN];

        int FITStype[LIMPUN];

        bool lgPunchFits;

        const char *chConSavEnr[LIMPUN];

        long int ipConPun;

        bool lgHashEndIter[LIMPUN];

        string chHashString;

        bool lgFLUSH;

        bool lgLuminosityOld;

        string chGridPrefix;

        string chFilenamePrefix;

        string chRedirectPrefix;

        string chOutputFile;

        char chPunRltType[7];

        FILE* ipPoint;
        bool lgPunPoint;

        bool lgPunConv;
        FILE* ipPunConv;
 

        bool lgSDSOn;
        FILE* ipSDSFile;

        FILE * ipDRout;
        bool lgDROn, 
          lgDRPLst,
          lgDRHash;

        FILE * ipDTout;
        bool lgDTOn,
                lgDTPLst,
                lgDTHash;
 
        /* set true save convergence base */
        bool lgTraceConvergeBase,
                lgTraceConvergeBaseHash;
        FILE * ipTraceConvergeBase;

        FILE* ioRecom;
        bool lgioRecom;

        long int LinEvery;
        bool lgLinEvery;

        long int ncSaveSkip;

        realnum WeakHeatCool;

        realnum Resolution;
        // same thing but for absorption lines - default is unity, set to
        // SaveLWidth if ABSORPTION keyword occurs on save line width command
        realnum ResolutionAbs;
 
        string chSpeciesDominantRates[LIMPUN];
 
        // the frequency at which the continuum volume emissivity should be saved
        Energy emisfreq[LIMPUN];
        long ipEmisFreq[LIMPUN];
 
        // Switches for save Database command
        // Wavenumbers vs WLAng, Gf vs A, Collision Rates or not
        bool lgSaveDataWn, lgSaveDataGf, lgSaveDataRates;

        vector<string> contSaveSpeciesLabel;
        vector<adjPseudoCont> setPseudoCont;

        string SpeciesBandFile[LIMPUN];
 
        save_img_matrix img_matrix;
};
 
extern t_save save;
 
#endif /* SAVE_H_ */