/home66/gary/public_html/cloudy/c13_branch/source/save.h

Go to the documentation of this file.

/* This file is part of Cloudy and is copyright (C)1978-2011 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;

        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;
        long ipEmisFreq;

};

extern t_save save;

#endif /* SAVE_H_ */

---