/home66/gary/public_html/cloudy/c08_branch/source/cddefines.h

Go to the documentation of this file.

/* This file is part of Cloudy and is copyright (C)1978-2008 by Gary J. Ferland and
 * others.  For conditions of distribution and use see copyright notice in license.txt */

#ifndef _CDDEFINES_H_
#define _CDDEFINES_H_

#ifdef _MSC_VER
/* disable warning that conditional expression is constant, true or false in if */
#       pragma warning( disable : 4127 )
/* we are not using MS foundation class */
#       ifndef WIN32_LEAN_AND_MEAN
#               define WIN32_LEAN_AND_MEAN
#       endif
#endif
/* these headers are needed by all files */
/*lint -e129 these resolve several issues pclint has with my system headers */
/*lint -e78 */
/*lint -e830 */
/*lint -e38 */
/*lint -e148 */
/*lint -e114 */
/*lint -e18 */
/*lint -e49 */
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <assert.h>
#include <string.h>
#include <float.h>
#include <limits.h>
#include <time.h>
#include <signal.h>
#include <string>
#include <sstream>
#include <vector>
#include <valarray>
#include <complex>
#include <map>
#include <memory>
#include <stdexcept>
#ifdef DMALLOC
#include <dmalloc.h>
#endif
/*lint +e18 */
/*lint +e49 */
/*lint +e38 */
/*lint +e148 */
/*lint +e830 */
/*lint +e78 */
/*lint -e129 */

using namespace std;

#ifndef EXTERN
#define EXTERN extern 
#endif

#undef STATIC
#ifdef USE_GPROF
#define STATIC
#else
#define STATIC static
#endif

#ifdef FLT_IS_DBL
typedef double realnum;
#else
typedef float realnum;
#endif

typedef float sys_float;
// prevent explicit float's from creeping back into the code
#define float PLEASE_USE_REALNUM_NOT_FLOAT

/* make sure this is globally visible as well! */
#include "cpu.h"

//*************************************************************************
//
//
// This implementation has been obtained from Wikipedia
//
//*************************************************************************

template<typename T> class Singleton
{
public:
        static T& Inst()
        {
                static T instance;  // assumes T has a protected default constructor
                return instance;
        }
};

/**************************************************************************
 *
 * these are variables and pointers for output from the code, used everywhere
 * declared extern here, and definition is in cddefines.cpp
 *
 **************************************************************************/

EXTERN FILE *ioQQQ;

EXTERN FILE *ioStdin;

extern FILE *ioMAP;

EXTERN FILE* ioPrnErr;

EXTERN bool lgAbort;

EXTERN bool lgTestCodeCalled; 

EXTERN bool lgTestCodeEnabled;

EXTERN bool lgPrnErr;

EXTERN long int nzone;

EXTERN double fnzone;

EXTERN long int iteration;

EXTERN long int nSimThisCoreload;

extern const double ZeroNum;

/**************************************************************************
 *
 * these are constants used to dimension several vectors and index arrays
 *
 **************************************************************************/

const int FILENAME_PATH_LENGTH = 200; 

const int FILENAME_PATH_LENGTH_2  = FILENAME_PATH_LENGTH*2; 

const int INPUT_LINE_LENGTH = 200;

const int LIMELM = 30;

const int NISO = 2;

const int NHYDRO_MAX_LEVEL = 401;

const int N_H_MOLEC = 8;

#if 0

const double TEMP_STOP_DEFAULT = 4000.;
const double TEMP_LIMIT_HIGH = 1e10;
const double TEMP_LIMIT_LOW = 2.8;
#endif

const double DEPTH_OFFSET = 1.e-30;

 /* these are flags for various colliders that are used across the code */
enum collider {
        ipELECTRON,
        ipPROTON,
        ipHE_PLUS,
        ipALPHA,
        //ipATOMH,
        //ipHE_2PLUS,
        //ipH2_ORTHO,
        //ipH2_PARA,
        ipNCOLLIDER
};

/* indices within recombination coefficient array */
/* ipRecEsc is state specific escape probability*/
const int ipRecEsc = 2;
/* the net escaping, including destruction by background and optical deepth*/
const int ipRecNetEsc = 1;
/* ipRecRad is state specific radiative recombination rate*/
const int ipRecRad = 0;
/* these specify the form of the line redistribution function */
/* partial redistribution with wings */
const int ipPRD = 1;
/* complete redistribution, core only, no wings, Hummer's K2 function */
const int ipCRD = -1;
/* complete redistribution with wings */
const int ipCRDW = 2;
/* redistribution function for Lya, calls Hummer routine for H-like series only */
const int ipLY_A = -2;
/* core function for K2 destruction */
const int ipDEST_K2 = 1;
/* core function for complete redist destruction */
const int ipDEST_INCOM = 2;
/* core function for simple destruction */
const int ipDEST_SIMPL = 3;

const int ipH1s = 0;
const int ipH2s = 1;
const int ipH2p = 2;
const int ipH3s = 3;
const int ipH3p = 4;
const int ipH3d = 5;
const int ipH4s = 6;
const int ipH4p = 7;
const int ipH4d = 8;
const int ipH4f = 9;
const int ipH5s = 10;
const int ipH5p = 11;
const int ipH5d = 12;
const int ipH5f = 13;
const int ipH5g = 14;
const int ipH6s = 15;

/* level 1 */
const int ipHe1s1S = 0;

/* level 2 */
const int ipHe2s3S = 1;
const int ipHe2s1S = 2;
const int ipHe2p3P0 = 3;
const int ipHe2p3P1 = 4;
const int ipHe2p3P2 = 5;
const int ipHe2p1P = 6;

/* level 3 */
const int ipHe3s3S = 7;
const int ipHe3s1S = 8;
const int ipHe3p3P = 9;
const int ipHe3d3D = 10;
const int ipHe3d1D = 11;
const int ipHe3p1P = 12;

/* level 4 */
const int ipHe4s3S = 13;
const int ipHe4s1S = 14;
const int ipHe4p3P = 15;
const int ipHe4d3D = 16;
const int ipHe4d1D = 17;
const int ipHe4f3F = 18;
const int ipHe4f1F = 19;
const int ipHe4p1P = 20;

const int ipH_LIKE = 0;
const int ipHE_LIKE = 1;
const int ipLI_LIKE = 2;
const int ipBE_LIKE = 3;
const int ipB_LIKE = 4;
const int ipC_LIKE = 5;
const int ipN_LIKE = 6;
const int ipO_LIKE = 7;
const int ipF_LIKE = 8;

const int ipHYDROGEN = 0;
const int ipHELIUM = 1;
const int ipLITHIUM = 2;
const int ipBERYLLIUM = 3;
const int ipBORON = 4;
const int ipCARBON = 5;
const int ipNITROGEN = 6;
const int ipOXYGEN = 7;
const int ipFLUORINE = 8;
const int ipNEON = 9;
const int ipSODIUM = 10;
const int ipMAGNESIUM = 11;
const int ipALUMINIUM = 12;
const int ipSILICON = 13;
const int ipPHOSPHORUS = 14;
const int ipSULPHUR = 15;
const int ipCHLORINE = 16;
const int ipARGON = 17;
const int ipPOTASSIUM = 18;
const int ipCALCIUM = 19;
const int ipSCANDIUM = 20;
const int ipTITANIUM = 21;
const int ipVANADIUM = 22;
const int ipCHROMIUM = 23;
const int ipMANGANESE = 24;
const int ipIRON = 25;
const int ipCOBALT = 26;
const int ipNICKEL = 27;
const int ipCOPPER = 28;
const int ipZINC = 29;

/***************************************************************************
 * the following are prototypes for some routines that are part of the
 * debugging process - they come and go in any particular sub.  
 * it is not necessary to declare them when used since they are defined here
 **************************************************************************/

double fudge(long int ipnt);

void broken(void);

void fixit(void);

void CodeReview(void);

void TestCode(void);

void *MyMalloc(size_t size, const char *file, int line);

void *MyCalloc(size_t num, size_t size);

void *MyRealloc(void *p, size_t size);

void MyAssert(const char *file, int line);

NORETURN void cdExit(int iexit);

class cloudy_exit
{
        const char* p_routine;
        const char* p_file;
        long p_line;
        int p_exit;
public:
        cloudy_exit(const char* routine, const char* file, long line, int exit_code)
        {
                p_routine = routine;
                p_file = file;
                p_line = line;
                p_exit = exit_code;
        }
        virtual ~cloudy_exit() throw()
        {
                p_routine = NULL;
                p_file = NULL;
        }
        const char* routine() const throw()
        {
                return p_routine;
        }
        const char* file() const throw()
        {
                return p_file;
        }
        long line() const
        {
                return p_line;
        }
        int exit_status() const
        {
                return p_exit;
        }
};

// workarounds for __func__ are defined in cpu.h
#define cdEXIT( FAIL ) throw cloudy_exit( __func__, __FILE__, __LINE__, FAIL )

// calls like puts( "[Stop in MyRoutine]" ) have been integrated in cdEXIT above
#define puts( STR ) Using_puts_before_cdEXIT_is_no_longer_needed

void ShowMe(void);

NORETURN void TotalInsanity(void);

NORETURN void BadRead(void);

NORETURN void BadOpen(void);

NORETURN void NoNumb(char *chCard);

int dbg_printf(int debug, const char *fmt, ...);

int dprintf(FILE *fp, const char *format, ...);

char *read_whole_line( char *chLine , int nChar , FILE *ioIN );

/**************************************************************************
 *
 * various macros used by the code
 *
 **************************************************************************/

#ifndef NDEBUG
#       define DEBUG
#else
#       undef DEBUG
#endif

#ifndef PARALLEL_MODE
#define PARALLEL_MODE false
#endif

#if defined(malloc)
/* ...but if malloc is a macro, assume it is instrumented by a memory debugging tool
 * (e.g. dmalloc) */
#       define MALLOC(exp) (malloc(exp))
#else
/* Otherwise instrument and protect it ourselves */
#       define MALLOC(exp) (MyMalloc(exp,__FILE__, __LINE__))
#endif

#if defined(calloc)
/* ...but if calloc is a macro, assume it is instrumented by a memory debugging tool */
#       define CALLOC calloc
#else
/* Otherwise instrument and protect it ourselves */
#       define CALLOC MyCalloc 
#endif

#if defined(realloc)
/* ...but if calloc is a macro, assume it is instrumented by a memory debugging tool */
#       define REALLOC realloc
#else
/* Otherwise instrument and protect it ourselves */
#       define REALLOC MyRealloc 
#endif

class bad_signal
{
        int p_sig;
public:
        explicit bad_signal(int sig)
        {
                p_sig = sig;
        }
        virtual ~bad_signal() throw() {}
        int sig() const throw()
        {
                return p_sig;
        }
};

class bad_assert
{
        const char* p_file;
        long p_line;
public:
        bad_assert(const char* file, long line)
        {
                p_file = file;
                p_line = line;
        }
        virtual ~bad_assert() throw()
        {
                p_file = NULL;
        }
        const char* file() const throw()
        {
                return p_file;
        }
        long line() const throw()
        {
                return p_line;
        }
};

class bad_mpi {
        long p_failMode;
public:
        bad_mpi(long failMode) : p_failMode(failMode) {}
        long failMode() const { return p_failMode; }
};

#undef  ASSERT
#ifndef STD_ASSERT
#       ifdef NDEBUG
#               define ASSERT(exp) ((void)0)
#       elif defined ASSERTDEBUG
#               define ASSERT(exp) if (!(exp)) MyAssert(__FILE__, __LINE__)
#       else
/* the do { ... } while ( 0 ) prevents bugs in code like this:
 * if( test )
 *      ASSERT( n == 10 );
 * else
 *      do something else...
 */
#               define ASSERT(exp) \
                        do { \
                                if (!(exp)) \
                                { \
                                        if( cpu.lgAssertAbort() ) \
                                                abort();          \
                                        else \
                                                throw bad_assert(__FILE__,__LINE__); \
                                } \
                        } while( 0 )
#       endif
#else
#       define ASSERT(exp) (assert(exp))
#endif

NORETURN inline void OUT_OF_RANGE(const char* str)
{
        if( cpu.lgAssertAbort() )
                abort();
        else
                throw out_of_range( str );
}

/* Windows does not define isnan */
/* use our version on all platforms since the isnanf
 * function does not exist under Solaris 9 either */
#undef isnan
#define isnan MyIsnan

class t_debug : public Singleton<t_debug>
{
        friend class Singleton<t_debug>;
        FILE *p_fp;
        int p_callLevel;
protected:
        t_debug()
        {
                p_fp = stderr;
                p_callLevel = 0;
        }
public:
        void enter(const char *name)
        {
                ++p_callLevel;
                fprintf(p_fp,"%*c%s\n",p_callLevel,'>',name);
        }
        void leave(const char *name)
        {
                fprintf(p_fp,"%*c%s\n",p_callLevel,'<',name);
                --p_callLevel;
        }               
};

template<bool lgTrace>
class debugtrace
{
        const char *p_name;
public:
        explicit debugtrace(const char *funcname)
        {
                p_name = funcname;
#               ifdef _MSC_VER
                /* disable warning that conditional expression is constant, true or false in if */
#               pragma warning( disable : 4127 )
#               endif
                if( lgTrace )
                        t_debug::Inst().enter(p_name);
        }
        ~debugtrace()
        {
#               ifdef _MSC_VER
                /* disable warning that conditional expression is constant, true or false in if */
#               pragma warning( disable : 4127 )
#               endif
                if( lgTrace )
                        t_debug::Inst().leave(p_name);
                p_name = NULL;
        }
        const char* name() const
        {
                return p_name;
        }
};

#ifdef DEBUG_FUN
#define DEBUG_ENTRY( funcname ) debugtrace<true> DEBUG_ENTRY( funcname )
#else
#ifdef __GNUC__
#define DEBUG_ENTRY( funcname ) ((void)0)
#else
#define DEBUG_ENTRY( funcname ) debugtrace<false> DEBUG_ENTRY( funcname )
#endif
#endif

/* TorF(l) returns a 'T' or 'F' depending on the 'logical' expr 'l' */
inline char TorF( bool l ) { return l ? 'T' : 'F'; }
/* */

inline bool is_odd( int j ) { return (j&1) == 1; }
inline bool is_odd( long j ) { return (j&1L) == 1L; }
/* */

inline long nint( double x ) { return static_cast<long>( (x < 0.) ? x-0.5 : x+0.5 ); }
/* */

/* define min for mixed arguments, the rest already exists */
inline long min( int a, long b ) { long c = a; return ( (c < b) ? c : b ); }
inline long min( long a, int b ) { long c = b; return ( (a < c) ? a : c ); }
inline double min( sys_float a, double b ) { double c = a; return ( (c < b) ? c : b ); }
inline double min( double a, sys_float b ) { double c = b; return ( (a < c) ? a : c ); }

#undef MIN2

#define MIN2 min
/* */

#undef MIN3

#define MIN3(a,b,c) (min(min(a,b),c))
/* */

#undef MIN4

#define MIN4(a,b,c,d) (min(min(a,b),min(c,d)))
/* */

/* define max for mixed arguments, the rest already exists */
inline long max( int a, long b ) { long c = a; return ( (c > b) ? c : b ); }
inline long max( long a, int b ) { long c = b; return ( (a > c) ? a : c ); }
inline double max( sys_float a, double b ) { double c = a; return ( (c > b) ? c : b ); }
inline double max( double a, sys_float b ) { double c = b; return ( (a > c) ? a : c ); }

#undef MAX2

#define MAX2 max
/* */

#undef MAX3

#define MAX3(a,b,c) (max(max(a,b),c))
/* */

#undef MAX4

#define MAX4(a,b,c,d) (max(max(a,b),max(c,d)))
/* */

template<class T>
inline T sign( T x, T y )
{
        return ( y < T() ) ? -abs(x) : abs(x);
}
/* */

template<class T>
inline int sign3( T x ) { return ( x < T() ) ? -1 : ( ( x > T() ) ? 1 : 0 ); }
/* */

inline bool fp_equal( sys_float x, sys_float y, int n=3 )
{
#       ifdef _MSC_VER
        /* disable warning that conditional expression is constant, true or false in if */
#               pragma warning( disable : 4127 )
#       endif
        ASSERT( n >= 1 );
        // mimic IEEE behavior
        if( isnan(x) || isnan(y) )
                return false;
        int sx = sign3(x);
        int sy = sign3(y);
        // treat zero cases first to avoid division by zero below
        if( sx == 0 && sy == 0 )
                return true;
        // either x or y is zero (but not both), or x and y have different sign
        if( sx*sy != 1 )
                return false;
        x = abs(x);
        y = abs(y);
        return ( 1.f - min(x,y)/max(x,y) < ((sys_float)n+0.1f)*FLT_EPSILON );
}

inline bool fp_equal( double x, double y, int n=3 )
{
        ASSERT( n >= 1 );
        // mimic IEEE behavior
        if( isnan(x) || isnan(y) )
                return false;
        int sx = sign3(x);
        int sy = sign3(y);
        // treat zero cases first to avoid division by zero below
        if( sx == 0 && sy == 0 )
                return true;
        // either x or y is zero (but not both), or x and y have different sign
        if( sx*sy != 1 )
                return false;
        x = abs(x);
        y = abs(y);
        return ( 1. - min(x,y)/max(x,y) < ((double)n+0.1)*DBL_EPSILON );
}

inline bool fp_equal_tol( sys_float x, sys_float y, sys_float tol )
{
        ASSERT( tol > 0.f );
        // mimic IEEE behavior
        if( isnan(x) || isnan(y) )
                return false;
        // make sure the tolerance is not too stringent
        ASSERT( tol >= FLT_EPSILON*max(abs(x),abs(y)) );
        return ( abs( x-y ) <= tol );
}

inline bool fp_equal_tol( double x, double y, double tol )
{
        ASSERT( tol > 0. );
        // mimic IEEE behavior
        if( isnan(x) || isnan(y) )
                return false;
        // make sure the tolerance is not too stringent
        ASSERT( tol >= DBL_EPSILON*max(abs(x),abs(y)) );
        return ( abs( x-y ) <= tol );
}

#undef POW2

#define POW2 pow2
template<class T>
inline T pow2(T a) { return a*a; }
/* */

#undef POW3

#define POW3 pow3
template<class T>
inline T pow3(T a) { return a*a*a; }
/* */

#undef POW4

#define POW4(X) (pow2(X)*pow2(X))
/* */

#undef SDIV

inline sys_float SDIV( sys_float x ) { return ( fabs((double)x) < (double)SMALLFLOAT ) ? (sys_float)SMALLFLOAT : x; }
/* \todo should we use SMALLDOUBLE here ? it produces overflows now... PvH */
inline double SDIV( double x ) { return ( fabs(x) < (double)SMALLFLOAT ) ? (double)SMALLFLOAT : x; }
// inline double SDIV( double x ) { return ( fabs(x) < SMALLDOUBLE ) ? SMALLDOUBLE : x; }
/* */

inline sys_float safe_div(sys_float x, sys_float y)
{
        // this should crash...
        if( isnan(x) || isnan(y) )
                return x/y;
        int sx = sign3(x);
        int sy = sign3(y);
        // 0/0 -> NaN, this should crash as well...
        if( sx == 0 && sy == 0 )
                return x/y;
        if( sx == 0 )
                return 0.;
        if( sy == 0 )
                return ( sx < 0 ) ? -FLT_MAX : FLT_MAX;
        // at this stage x != 0. and y != 0.
        sys_float ay = abs(y);
        if( ay >= 1.f )
                return x/y;
        else
        {
                // multiplication is safe since ay < 1.
                if( abs(x) < ay*FLT_MAX )
                        return x/y;
                else
                        return ( sx*sy < 0 ) ? -FLT_MAX : FLT_MAX;
        }
}

inline double safe_div(double x, double y)
{
        // this should crash...
        if( isnan(x) || isnan(y) )
                return x/y;
        int sx = sign3(x);
        int sy = sign3(y);
        // 0/0 -> NaN, this should crash as well...
        if( sx == 0 && sy == 0 )
                return x/y;
        if( sx == 0 )
                return 0.;
        if( sy == 0 )
                return ( sx < 0 ) ? -DBL_MAX : DBL_MAX;
        // at this stage x != 0. and y != 0.
        double ay = abs(y);
        if( ay >= 1. )
                return x/y;
        else
        {
                // multiplication is safe since ay < 1.
                if( abs(x) < ay*DBL_MAX )
                        return x/y;
                else
                        return ( sx*sy < 0 ) ? -DBL_MAX : DBL_MAX;
        }
}

#undef HMRATE
/*HMRATE compile molecular rates using Hollenbach and McKee fits */
/* #define HMRATE(a,b,c) ( ((b) == 0 && (c) == 0) ? (a) : \
 *      ( ((c) == 0) ? (a)*pow(phycon.te/300.,(b)) : \
 *      ( ((c)/phycon.te > 50.) ? 0. : ( ((b) == 0) ?  (a)*exp(-(c)/phycon.te) : \
 *                                       (a)*pow(phycon.te/300.,(b))*exp(-(c)/phycon.te) ) ) ) ) */
#define HMRATE(a,b,c) hmrate4(a,b,c,phycon.te)

inline double hmrate4( double a, double b, double c, double te )
{
        if( b == 0. && c == 0. )
                return a;
        else if( c == 0. )
                return a*pow(te/300.,b);
        else if( b == 0. )
                return ( c/te <= 50. ) ? a*exp(-c/te) : 0.;
        else
                return ( c/te <= 50. ) ? a*pow(te/300.,b)*exp(-c/te) : 0.;
}

template<class T>
inline void invalidate_array(T* p, size_t size)
{
        memset( p, -1, size );
}

inline void invalidate_array(double* p, size_t size)
{
        set_NaN( p, (long)(size/sizeof(double)) );
}

inline void invalidate_array(sys_float* p, size_t size)
{
        set_NaN( p, (long)(size/sizeof(sys_float)) );
}

template<class T>
class auto_vec
{
        T* ptr;

        template<class U>
        struct auto_vec_ref
        {
                U* ptr;

                explicit auto_vec_ref( U* p )
                {
                        ptr = p;
                }
        };

public:
        typedef T element_type;

        // 20.4.5.1 construct/copy/destroy:

        explicit auto_vec( element_type* p = NULL ) throw()
        {
                ptr = p;
        }
        auto_vec( auto_vec& p ) throw()
        {
                ptr = p.release();
        }
        auto_vec& operator= ( auto_vec& p ) throw()
        {
                reset( p.release() );
                return *this;
        }
        ~auto_vec() throw()
        {
                delete[] ptr;
        }

        // 20.4.5.2 members:

        element_type& operator[] ( ptrdiff_t n ) const throw()
        {
                return *(ptr+n);
        }
        element_type* get() const throw()
        {
                return ptr;
        }
        // for consistency with other container classes
        element_type* data() const throw()
        {
                return ptr;
        }
        element_type* release() throw()
        {
                element_type* p = ptr;
                ptr = NULL;
                return p;
        }
        void reset( element_type* p = NULL ) throw()
        {
                if( p != ptr )
                {
                        delete[] ptr;
                        ptr = p;
                }
        }

        // 20.4.5.3 conversions:

        auto_vec( auto_vec_ref<element_type> r ) throw()
        {
                ptr = r.ptr;
        }
        auto_vec& operator= ( auto_vec_ref<element_type> r ) throw()
        {
                if( r.ptr != ptr )
                {
                        delete[] ptr;
                        ptr = r.ptr;
                }
                return *this;
        }
        operator auto_vec_ref<element_type>() throw()
        {
                return auto_vec_ref<element_type>( this->release() );
        }
};

#include "container_classes.h"

/*Many structure were intoduced by Humeshkar B Nemala as a part of his Thesis 
 *The structures were designed to read in transition,radiative and collisional data
 *from two major databases:LEIDEN and CHIANTI

 * these structures define the emission, collision, state, and transition classes*/

typedef struct t_transition transition;
typedef struct t_quantumState quantumState;
typedef struct t_emission emission;
typedef struct t_collision collision;
typedef struct t_species species;

struct t_emission
{
        int iRedisFun;

        long int ipFine;

        realnum TauIn;

        realnum TauTot;

        realnum TauCon;

        realnum FracInwd;

        double pump;

        double xIntensity;

        double phots;

        realnum gf;

        realnum Pesc;

        realnum Pelec_esc;

        realnum Pdest;

        realnum dampXvel;

        realnum damp;

        double ColOvTot;

        realnum opacity;

        double PopOpc;

        realnum Aul;

        double ots;

        /* this points back to the transition that points here.  */
        transition *tran;
        
        /* linked-list */
        emission *next;

};

/*The species structure is used to hold information about a particular atom,ion or molecule
mentioned in the species.ini file.The name of the atom/ion/molecule is used to obtain the density
of molecules in the case of the Leiden Database and along with atomic number and ion stage the 
density of atoms/ions in the case of the CHIANTI database */
struct t_species
{
        /*Name of the atom/ion/ molecule*/
        char *chptrSpName;
        /*Atomic Number*/
        int intAtNo;
        /*Ionization Stage*/
        int intIonStage;
        /*Actual Number of energy levels in the data file*/
        long numLevels_max;
        /*Number of energy levels used locally*/
        long numLevels_local;
        /*Molecular weight*/
        realnum fmolweight;
        

};

/*This structure is specifically used to hold the collision data in the format given in the LEIDEN Database
The data is available as collsion rate coefficients(cm3 s-1) over different temperatures*/
typedef struct t_CollRatesArray
{
        /*Number of temps*/
        long ntemps;
        /*Array of temps*/
        double *temps;
        /*Matrix of collision rates(temp,up,lo)*/
        double ***collrates;
        
} CollRateCoeffArray ;

/*This structure is specifically used to hold the collision data in the format given in the CHIANTI Database
The data is available as spline fits to the maxwellian averaged collision strengths */
typedef struct t_CollSplinesArray
{
        /*Matrix of spline fits(hi,lo,spline index)*
         *The first five columns gives the no of spline pts,transition type,gf value,delta E
         *& Scaling parameter ,in the specified order*/
        /*The transition type basically tells how the temperature and collision
        strengths have been scaled*/
        double *collspline;
        double *SplineSecDer;

        long nSplinePts; 
        long intTranType;
        double gf;
        double EnergyDiff;
        double ScalingParam;

} CollSplinesArray ;

struct t_collision
{
        /*      species *collider;*/
        /* Linked list for possible colliders */
        /* collision *next; */
        
        realnum ColUL;

        realnum cs;

        realnum csi[ipNCOLLIDER];

        double cool , heat;

};

/*Generalized structure used to hold the energy level information for both atoms/ions and molecules*/
struct t_quantumState
{
        char chLabel[5];
        char chConfig[11];

        species   *sp;

        realnum energy;

        realnum    g;
        
        double  Pop;

        int IonStg;
        int nelem;

        double ConBoltz;

        /* S is multiplicity. */
        long n, l, S, j;

        double lifetime;

        /* linked-list */
        quantumState *next;
};

/*Generalized structure used to hold the transition information for both atoms/ions and molecules*/
struct t_transition
{
        quantumState *Lo, *Hi;
        emission *Emis;
        collision Coll;

        /* Possible linked-list optimization */
        /*transition *nextemis, *nextcoll; */

        realnum WLAng;

        realnum EnergyK;

        realnum EnergyErg;

        realnum EnergyWN;

        long ipCont;
};

/* Explicit instantiations for debugging purposes */
INSTANTIATE_MULTI_ARR( quantumState, MEM_LAYOUT_VAL, lgBOUNDSCHECKVAL );
INSTANTIATE_MULTI_ARR( transition, MEM_LAYOUT_VAL, lgBOUNDSCHECKVAL );


/***************************************************************************
 *
 * a series of Cloudy service routines, used throughout code,
 *
 **************************************************************************/

typedef enum { SPM_RELAX, SPM_KEEP_EMPTY, SPM_STRICT } split_mode;

void Split(const string& str,   // input string
           const string& sep,   // separator, may be multiple characters
           vector<string>& lst, // the separated items will be appended here
           split_mode mode);    // see above

inline bool FindAndReplace(string& str,
                           const string& substr,
                           const string& newstr)
{
        string::size_type ptr = str.find( substr );
        if( ptr != string::npos )
                str.replace( ptr, substr.length(), newstr );
        return ptr != string::npos;
}

inline bool FindAndErase(string& str,
                         const string& substr)
{
        return FindAndReplace( str, substr, "" );
}

double csphot(long int inu, long int ithr, long int iofset);

double RandGauss(double xMean, double s );

double MyGaussRand( double PctUncertainty );

double AnuUnit(realnum energy);

void cap4(char *chCAP , char *chLab);

void uncaps(char *chCard );

void caps(char *chCard );

double e2(
          double t );

double ee1(double x);

double ee1_safe(double x);

double FFmtRead(const char *chCard, 
                long int *ipnt, 
                long int last, 
                bool *lgEOL);

long nMatch(const char *chKey, 
            const char *chCard);

long int GetElem( char *chCARD_CAPS );

int GetQuote(char *chLabel,     char *chCard, bool lgABORT );

/* want to define this only if no native os support exists */
#if !HAVE_POWI

double powi( double , long int );
#endif

long int ipow( long, long );

void PrintE82( FILE*, double );

void PrintE71( FILE*, double );

void PrintE93( FILE*, double );

char *PrintEfmt(const char *fmt, double val );

const double SEXP_LIMIT = 84.;
sys_float sexp(sys_float x);
double sexp(double x);

double dsexp(double x);

double plankf(long int ip);

double qg32( double, double, double(*)(double) );
/* declar of optimize_func, the last arg, changed from double(*)() to above,
 * seemed to fix flags that were raised */


void spsort( realnum x[], long int n, long int iperm[], int kflag, int *ier);

/*vfun approximate form of Voigt function */
inline double vfun(double damp, double x)
{
        // constant is SQRTPI
        return sexp(x*x) + damp/1.772453850905516027298167/(1. + x*x);
}

/**************************************************************************
 *
 * disable some bogus errors in the ms c compiler
 *
 **************************************************************************/

/* */
#ifdef _MSC_VER
        /* disable warning that conditional expression is constant, true or false in if */
#       pragma warning( disable : 4127 )
        /* disable strcat warning */
#       pragma warning( disable : 4996 )
        /* disable bogus underflow warning in MS VS*/
#       pragma warning( disable : 4056 )
        /* disable "inline function removed since not used", MS VS*/
#       pragma warning( disable : 4514 )
        /* disable "assignment operator could not be generated", cddefines.h
         * line 126 */
#       pragma warning( disable : 4512 )
#endif
#ifdef __INTEL_COMPILER
#       pragma warning( disable : 1572 )
#endif
/* */

/*lint +e129 these resolve several issues pclint has with my system headers */
/*lint +e78 */
/*lint +e830 */
/*lint +e38 */
/*lint +e148 */
/*lint +e114 */
/*lint +e18 */
/*lint +e49 */

#endif /* _CDDEFINES_H_ */

---