save.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 SAVE_H_
#define SAVE_H_

#include "energy.h"

class diatomics;
class TransitionProxy;

/* save.h */
static const long LIMPUN = 100L;

static const long VERSION_TRNCON = 20100901L;

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

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

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_species_bands
{
public:
        string filename;
        string speciesLabel;
};

struct t_save {

        t_save()
        {
                for( long i=0; i < LIMPUN; ++i )
                {
                        nLineList[i] = -1;
                        lgFITS[i] = false;
                        FITStype[i] = -1;
                        nAverageList[i] = -1;
                        p_lgSaveTitleDone[i] = false;
                        p_lgSaveHeaderDone[i] = false;
                }
                p_lgSaveHeaderNeeded = true;
        }

        ~t_save()
        {
                for( long i=0; i < LIMPUN; ++i )
                {
                        SaveLineListFree(i);
                        SaveAverageFree(i);
                }
        }

        void SaveLineListFree(long i)
        {
                chLineListLabel[i].clear();
                wlLineList[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();
        }

        long nLineList[LIMPUN];
        vector<string> chLineListLabel[LIMPUN];
        vector<realnum> wlLineList[LIMPUN];
        bool lgLineListRatio[LIMPUN];

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

        SaveParams params[LIMPUN]; 

        bool lgNoClobber[LIMPUN];

        bool lgPrtOldStyleLogs[LIMPUN];

        bool lgPunConv_noclobber;
        bool lgDROn_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];

        int FITStype[LIMPUN];

        bool lgPunchFits;

        const char *chConSavEnr[LIMPUN];

        long int ipConPun;

        bool lgHashEndIter[LIMPUN];

        char chHashString[INPUT_LINE_LENGTH];

        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;

        /* 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];
        vector<save_species_bands> specBands;
};

extern t_save save;

#endif /* SAVE_H_ */