stars.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 STARS_H_
#define STARS_H_
 
 
#define MDIM 4
 
#define MNAM 6
 
typedef enum {
        IM_ILLEGAL_MODE=-1, IM_RECT_GRID, IM_COSTAR_TEFF_MODID,
        IM_COSTAR_TEFF_LOGG, IM_COSTAR_MZAMS_AGE, IM_COSTAR_AGE_MZAMS
} IntMode;
 
typedef enum {
        TL_OBSTAR, TL_BSTAR, TL_OSTAR
} tl_grid;
 
typedef enum {
        SB_TOTAL, SB_STELLAR, SB_NEBULAR
} sb_mode;
 
struct process_counter
{
        int nFound;
        int notProcessed;
        int nOK;
        int nFail;
        process_counter() : nFound(0), notProcessed(0), nOK(0), nFail(0) {}
};
 
void AtmospheresAvail(void);
 
int AtlasCompile(process_counter& pc);
long AtlasInterpolate(double val[], /* val[nval] */
                      long *nval,
                      long *ndim,
                      const char *chMetalicity,
                      const char *chODFNew,
                      bool lgList,
                      double *Tlow,
                      double *Thigh);
 
int CoStarCompile(process_counter& pc);
long CoStarInterpolate(double val[], /* requested model parameters */
                       long *nval,
                       long *ndim,
                       IntMode imode, /* which interpolation mode is requested */
                       bool lgHalo,  /* flag indicating whether solar (==0) or halo (==1) abundances */
                       bool lgList,
                       double *val0_lo,
                       double *val0_hi);
 
bool GridCompile(const char *InName);
long GridInterpolate(double val[], /* val[nval] */
                     long *nval,
                     long *ndim,
                     const char *FileName,
                     bool lgList,
                     double *Tlow,
                     double *Thigh);
 
int Kurucz79Compile(process_counter& pc);
long Kurucz79Interpolate(double val[], /* val[nval] */
                         long *nval,
                         long *ndim,
                         bool lgList,
                         double *Tlow,
                         double *Thigh);
 
int MihalasCompile(process_counter& pc);
long MihalasInterpolate(double val[], /* val[nval] */
                        long *nval,
                        long *ndim,
                        bool lgList,
                        double *Tlow,
                        double *Thigh);
 
int RauchCompile(process_counter& pc);
long RauchInterpolateHydr(double val[], /* val[nval] */
                          long *nval,
                          long *ndim,
                          bool lgList,
                          double *Tlow,
                          double *Thigh);
long RauchInterpolateHelium(double val[], /* val[nval] */
                            long *nval,
                            long *ndim,
                            bool lgList,
                            double *Tlow,
                            double *Thigh);
long RauchInterpolateHpHe(double val[], /* val[nval] */
                          long *nval,
                          long *ndim,
                          bool lgList,
                          double *Tlow,
                          double *Thigh);
long RauchInterpolatePG1159(double val[], /* val[nval] */
                            long *nval,
                            long *ndim,
                            bool lgList,
                            double *Tlow,
                            double *Thigh);
long RauchInterpolateCOWD(double val[], /* val[nval] */
                          long *nval,
                          long *ndim,
                          bool lgList,
                          double *Tlow,
                          double *Thigh);
long RauchInterpolateHCa(double val[], /* val[nval] */
                         long *nval,
                         long *ndim,
                         bool lgHalo,
                         bool lgList,
                         double *Tlow,
                         double *Thigh);
long RauchInterpolateHNi(double val[], /* val[nval] */
                         long *nval,
                         long *ndim,
                         bool lgHalo,
                         bool lgList,
                         double *Tlow,
                         double *Thigh);
 
bool StarburstInitialize(const char chInName[],
                         const char chOutName[],
                         sb_mode mode);
bool StarburstCompile(process_counter& pc);
 
int TlustyCompile(process_counter& pc);
long TlustyInterpolate(double val[], /* val[nval] */
                       long *nval,
                       long *ndim,
                       tl_grid tlg,
                       const char *chMetalicity,
                       bool lgList,
                       double *Tlow,
                       double *Thigh);
 
int WernerCompile(process_counter& pc);
long WernerInterpolate(double val[], /* val[nval] */
                       long *nval,
                       long *ndim,
                       bool lgList,
                       double *Tlow,
                       double *Thigh);
 
int WMBASICCompile(process_counter& pc);
long WMBASICInterpolate(double val[], /* val[nval] */
                        long *nval,
                        long *ndim,
                        bool lgList,
                        double *Tlow,
                        double *Thigh);
 
#endif /* STARS_H_ */