stars.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 STARS_H_
#define STARS_H_
 

static const int MDIM = 4;

static const int 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();

bool AtlasCompile(process_counter& pc);
long AtlasInterpolate(double val[], /* val[nval] */
                      long *nval,
                      long *ndim,
                      const string& chMetalicity,
                      const string& chODFNew,
                      bool lgList,
                      double *Tlow,
                      double *Thigh);

bool 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 string& InName);
long GridInterpolate(double val[], /* val[nval] */
                     long *nval,
                     long *ndim,
                     const string& InName,
                     bool lgList,
                     double *Tlow,
                     double *Thigh);

bool HaardtMadauCompile(process_counter& pc);
long HaardtMadauInterpolate(double val,
                            int version,
                            bool lgQuasar,
                            double *zlow,
                            double *zhigh);

bool KhaireSrianandCompile(process_counter& pc);
long KhaireSrianandInterpolate(double val,
                               int Q,
                               double *zlow,
                               double *zhigh);

bool Kurucz79Compile(process_counter& pc);
long Kurucz79Interpolate(double val[], /* val[nval] */
                         long *nval,
                         long *ndim,
                         bool lgList,
                         double *Tlow,
                         double *Thigh);

bool MihalasCompile(process_counter& pc);
long MihalasInterpolate(double val[], /* val[nval] */
                        long *nval,
                        long *ndim,
                        bool lgList,
                        double *Tlow,
                        double *Thigh);

bool 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 string& chInName,
                         const string& chOutName,
                         sb_mode mode);
bool StarburstCompile(process_counter& pc);

bool TlustyCompile(process_counter& pc);
long TlustyInterpolate(double val[], /* val[nval] */
                       long *nval,
                       long *ndim,
                       tl_grid tlg,
                       const string& chMetalicity,
                       bool lgList,
                       double *Tlow,
                       double *Thigh);

bool WernerCompile(process_counter& pc);
long WernerInterpolate(double val[], /* val[nval] */
                       long *nval,
                       long *ndim,
                       bool lgList,
                       double *Tlow,
                       double *Thigh);

bool WMBASICCompile(process_counter& pc);
long WMBASICInterpolate(double val[], /* val[nval] */
                        long *nval,
                        long *ndim,
                        bool lgList,
                        double *Tlow,
                        double *Thigh);
 
#endif /* STARS_H_ */