save.h

Go to the documentation of this file.

/* This file is part of Cloudy and is copyright (C)1978-2013 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 "h2_priv.h"
 
/* save.h */
static const long LIMPUN = 100L;
static const long MAX_HEADER_SIZE = 20000L;
 
static const long VERSION_TRNCON = 20100901L;
 
void SaveDo(
        const char *chTime); 
 
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 SaveSpecies(
                FILE* ioPUN,
                long int ipPun );
 
void Save1LineData( 
        const TransitionProxy & t , 
        FILE * io,
         bool lgCS_2 ,
         bool &lgPrint);
 
void save_line(
        FILE * ip,
  const char *chDo, 
  bool lgEmergent);
 
void save_average( 
        long int ipPun);
 
void save_colden(
  /* the file we will write to */
  FILE * ioPUN );
 
void Save_Line_RT(
        FILE * ip);
 
void saveFITSfile( 
        FILE* io, 
        int option );
 
void SaveHeat(FILE* io);
 
void CoolSave(FILE * io, char chJob[]);
 
void SaveGrid(FILE* pnunit, exit_type status);
 
struct t_save {
 
        t_save()
        {
                for( long i=0; i < LIMPUN; ++i )
                {
                        nLineList[i] = -1;
                        lgFITS[i] = false;
                        FITStype[i] = -1;
                        nAverageList[i] = -1;
                }
        }
 
        ~t_save()
        {
                for( long i=0; i < LIMPUN; ++i )
                {
                        SaveLineListFree(i);
                        SaveAverageFree(i);
                }
        }
 
        void SaveLineListFree(long i)
        {
                for( unsigned j=0; j < chLineListLabel[i].size(); ++j )
                        delete[] chLineListLabel[i][j];
                chLineListLabel[i].clear();
                wlLineList[i].clear();
        }
        void SaveAverageFree(long i)
        {
                for( unsigned j=0; j < chAverageType[i].size(); ++j )
                        delete[] chAverageType[i][j];
                chAverageType[i].clear();
                for( unsigned j=0; j < chAverageSpeciesLabel[i].size(); ++j )
                        delete[] chAverageSpeciesLabel[i][j];
                chAverageSpeciesLabel[i].clear();
        }
 
        long nLineList[LIMPUN];
        vector<char*> chLineListLabel[LIMPUN];
        vector<realnum> wlLineList[LIMPUN];
        bool lgLineListRatio[LIMPUN];
 
        long nAverageList[LIMPUN];
        vector<char*> chAverageType[LIMPUN];
        vector<char*> chAverageSpeciesLabel[LIMPUN];
        vector<int> nAverageIonList[LIMPUN];
        vector<int> nAverage2ndPar[LIMPUN];
 
        FILE *ipPnunit[LIMPUN]; 
 
        bool lgNoClobber[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];
 
        long int nsave;
 
        char chSave[LIMPUN][5];
        diatomics *whichDiatomToPrint[LIMPUN];
 
        char chOpcTyp[LIMPUN][5];
 
        char chHeader[LIMPUN][MAX_HEADER_SIZE];
 
        const char *chNONSENSE;
 
        bool lgSaveToSeparateFiles[LIMPUN];
 
        bool lg_separate_iterations[LIMPUN];
 
        bool lgPunHeader[LIMPUN];
 
        bool lgPunContinuum;
 
        realnum punarg[LIMPUN][3];
 
        string optname[LIMPUN];
 
        bool lgSaveEveryZone[LIMPUN];
        long int nSaveEveryZone[LIMPUN];
 
        char chSaveArgs[LIMPUN][5];
 
        char chSaveSpecies[LIMPUN][CHARS_SPECIES];
 
        bool lgPunLstIter[LIMPUN];
 
        bool lgFITS[LIMPUN];
 
        int FITStype[LIMPUN];
 
        bool lgPunchFits;
 
        const char *chConPunEnr[LIMPUN];
 
        long int ipConPun;
 
        bool lgHashEndIter[LIMPUN];
 
        char chHashString[INPUT_LINE_LENGTH];
 
        bool lgFLUSH;
 
        string chGridPrefix;
 
        string chFilenamePrefix;
 
        string chRedirectPrefix;
 
        string chOutputFile;
 
        char chPunRltType[7];
 
        FILE* ipPoint;
        bool lgPunPoint;
 
        bool lgPunConv;
        FILE* ipPunConv;
 
        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;
 
        char chSpeciesDominantRates[LIMPUN][CHARS_SPECIES];
 
        // the frequency at which the continuum volume emissivity should be saved
        Energy emisfreq[LIMPUN];
        long ipEmisFreq[LIMPUN];
 
};
 
extern t_save save;
 
#endif /* SAVE_H_ */