atmdat.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 ATMDAT_H_
#define ATMDAT_H_


double atmdat_2phot_shapefunction( double EbyE2nu, long ipISO, long nelem );

void atmdat_readin(void);

void atmdat_STOUT_readin( long intNS, char *chFileName );

void atmdat_CHIANTI_readin( long intNS, char *chFileName );

void atmdat_LAMDA_readin( long intNS, char *chFileName );


void atmdat_outer_shell(
  long int iz, 
  long int in,
  long int *imax,
  long int *ig0, 
  long int *ig1);

void ChargTranEval( void );

double ChargTranSumHeat(void);

/*ChargTranPun save charge transfer rate coefficients */
void ChargTranPun( FILE* ipPnunit , char* chSave );

double CHIANTI_Upsilon(long, long, long, long,double);

double atmdat_dielrec_fe(long int ion, double t);

void atmdat_H_phot_cs(void);

void atmdat_3body(void);

double atmdat_HS_caseB( 
        long int iHi, long int iLo, long int iZ, double TempIn,
        double DenIn,
        char chCase 
        );

// arrays for Hummer & Storey 98 He1 cross sections and energies
extern double ****HS_He1_Xsectn;
extern double ****HS_He1_Energy;

// arrays for TOPbase Helike cross sections and energies
extern double *****OP_Helike_Xsectn;
extern double *****OP_Helike_Energy;
extern long ****OP_Helike_NumPts;

/* these are the vectors that store the original Hummer and Storey case B
 * line data for H and He - the declaration for the interpolator follows */
#define NHSDIM 15 
#define NLINEHS 300  
#define HS_NZ 8 
#define NHCSTE  8 
#define NUM_HS98_DATA_POINTS 811

struct t_atmdat {
        enum {NCX=2};

        double CharExcIonOf[NCX][LIMELM][LIMELM+1], //(cm3 s-1)
          CharExcRecTo[NCX][LIMELM][LIMELM+1],          //(cm3 s-1)
          HCharHeatMax, 
          HCharCoolMax, 
          HCharHeatOn;

        /* rate coefficient (cm3 s-1) for N+(3P) + H+ -> N(2D) + H+ charge transfer*/
        double HCharExcRecTo_N0_2D;

        double CharExcIonTotal[NCX],
                CharExcRecTotal[NCX];

        double HIonFrac;

        double HIonFracMax;

        double HCTAlex;

        bool lgCTOn;

        double Density[2][HS_NZ][NHSDIM], 
                ElecTemp[2][HS_NZ][NHSDIM],
                Emiss[2][HS_NZ][NHSDIM][NHSDIM][NLINEHS];

        long int nDensity[2][HS_NZ] , ntemp[2][HS_NZ] , ncut[2][HS_NZ];

        bool lgHCaseBOK[2][HS_NZ];

        long int nsbig;

        bool lgCollIonOn;

        realnum WaveLengthCaseB[8][25][24];

        vector<realnum> CaseBWlHeI;

        long nChiantiMaxLevelsFe;
        long nChiantiMaxLevels;
        bool lgChiantiLevelsSet;
        long nStoutMaxLevels;
        const long nChiantiPhotoLevelsFe;
        const long nChiantiPhotoLevels;
        const long nChiantiCollLevelsFe;
        const long nChiantiCollLevels;
        t_atmdat() : nChiantiPhotoLevelsFe(25), nChiantiPhotoLevels(15), nChiantiCollLevelsFe(100),
                        nChiantiCollLevels(50) {}

        bool lgChiantiOn;
        bool lgChiantiHybrid;
        bool lgChiantiPrint;
        bool lgChiantiExp;
        bool lgLamdaOn;
        bool lgStoutOn;
        bool lgStoutHybrid;
        bool lgStoutPrint;
        bool lgCalpgmOn;
        bool lgGbarOn;

        double collstrDefault;

        /* type and enum for determining what collisional ionization rate coefficient data to use.
        * Dima: Cloudy original data from Voronov97
        * Hybrid: Dima version scaled by the ratio of Dere07 to Dima */
        typedef enum { DIMA, HYBRID } CollIonRC;
        CollIonRC CIRCData;

        static const int iVersionLength = 10;
        char chVersion[iVersionLength];

        char chStoutFile[FILENAME_PATH_LENGTH];

        char chCloudyChiantiFile[FILENAME_PATH_LENGTH];

        };
extern t_atmdat atmdat;

typedef enum { PHFIT_UNDEF, PHFIT95, PHFIT96 } phfit_version;

class t_ADfA : public Singleton<t_ADfA>
{
        friend class Singleton<t_ADfA>;
protected: 
        t_ADfA();
private:
        phfit_version version;
        /* phfit.dat */
        long int L[7];
        long int NINN[30];
        long int NTOT[30];
        realnum PH1[7][30][30][6];
        realnum PH2[30][30][7];
        /* hpfit.dat */
        realnum PHH[NHYDRO_MAX_LEVEL][5];
        /* rec_lines.dat */
        realnum P[8][110];
        realnum ST[9][405];
        /* rad_rec.dat */
        realnum rrec[30][30][2];
        realnum rnew[30][30][4];
        realnum fe[13][3];
        /* h_rad_rec */
        realnum HRF[NHYDRO_MAX_LEVEL][9];
        /* h_phot_cs.dat */
        realnum STH[NHYDRO_MAX_LEVEL];
        /* coll_ion.dat */
        double CF[30][30][5];
        /* h_coll_str.dat */
        /* >>refer      H1      cs      Anderson, H., Ballance, C.P., Badnell, N.R., & Summers, H.P., 
         * >>refercon   2000, J Phys B, 33, 1255; erratum, 2002 */
        double HCS[14][10][8];
public:
        void set_version(phfit_version val) { version = val; }

        phfit_version get_version() const { return version; }

        realnum ph1(int i, int j, int k, int l) const { return PH1[i][j][k][l]; }

        realnum sth(int i) const { return STH[i]; }

        double phfit(long int nz, long int ne, long int is, double e);

        double hpfit(long int iz, long int n, double e);

        void rec_lines(double t, realnum r[][471]);

        double rad_rec(long int iz, long int in, double t);

        double H_rad_rec(long int iz, long int n, double t);

        double coll_ion(long int iz, long int in, double t);

        double coll_ion_wrapper(long int z, long int n, double t);

        /* coll_ion_hybrid computes hybrid collisional ionization rates */
        double coll_ion_hybrid( long int z, long int n, double t);

        realnum h_coll_str( long ipLo, long ipHi, long ipTe );
};

class Funct 
{
public:
        virtual void operator()( long&, long&, const char*, long&) = 0;
        virtual ~Funct() = 0;
};
 
inline Funct::~Funct() {};

typedef Funct* FunctPtr;

class FunctLAMDA : public Funct 
{
public:
        explicit FunctLAMDA(void) { }
        virtual void operator()( long& ipHi, long& ipLo, const char* chLine, long& i) 
        { 
                bool lgEOL;
                long index = (long)FFmtRead( chLine, &i, strlen(chLine), &lgEOL );
                ASSERT( index > 0 );
                ipHi = (long)FFmtRead( chLine, &i, strlen(chLine), &lgEOL ) - 1;
                ipLo = (long)FFmtRead( chLine, &i, strlen(chLine), &lgEOL ) - 1;
                return;
        }
private:
};

#include "h2_priv.h"

class FunctDiatoms : public Funct 
{
public:
        explicit FunctDiatoms(const diatomics& diatom) : diatom_(diatom) { }
        virtual void operator()( long& ipHi, long& ipLo, const char* chLine, long& i) 
        { 
                diatom_.GetIndices( ipHi, ipLo, chLine, i );
        }
private:
        const diatomics& diatom_;
};

void ReadCollisionRateTable( CollRateCoeffArray& coll_rate_table, FILE* io, FunctPtr GetIndices, long nMolLevs, long nTemps = -1, long nTrans = -1 );

double InterpCollRate( const CollRateCoeffArray& rate_table, const long& ipHi, const long& ipLo, const double& ftemp);

#endif /* ATMDAT_H_ */