iso.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 ISO_H_
#define ISO_H_
 
#include "two_photon.h"
 
#include "transition.h"
#include "freebound.h"
 
extern long int max_num_levels;
 
#define KILL_BELOW_PLASMA(E_)           ( (rfield.lgPlasNu && ((E_)<rfield.plsfrq) ) ? 0.:1. )
 
#define N_(A_)  (iso_sp[ipISO][nelem].st[A_].n())
#define L_(A_)  (iso_sp[ipISO][nelem].st[A_].l())
#define S_(A_)  (iso_sp[ipISO][nelem].st[A_].S())
#define J_(A_)  (iso_sp[ipISO][nelem].st[A_].j())
 
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;
 
/* 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;
 
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 ipNE_LIKE = 9;
const int ipNA_LIKE = 10;
const int ipMG_LIKE = 11;
const int ipAL_LIKE = 12;
const int ipSI_LIKE = 13;
const int ipP_LIKE = 14;
const int ipS_LIKE = 15;
const int ipCL_LIKE = 16;
const int ipAR_LIKE = 17;
 
enum {
        ipSINGLET = 1, ipDOUBLET = 2, ipTRIPLET = 3, 
        ipMULTIPLET_END, ipMULTIPLET_BEGIN=ipSINGLET
};
 
#define IPRAD   0
#define IPCOLLIS        1
/*define IPENERGY       2*/
 
/* following two macros used to define recombination coef arrays */
/* Max n desired in RRCoef file.        */
/* Hydrogen and helium atoms will have precompiled recombination coefficients up to these maximum n.    */
#define RREC_MAXN       40
 
#define LIKE_RREC_MAXN( A_ )            ( A_ == ipHELIUM ? 40 : 20 )
 
#define N_ISO_TE_RECOMB         41
 
#define SumUpToThisN    1000
 
#define RECOMBMAGIC             (130216)
 
void iso_cascade( long ipISO, long nelem );
 
void iso_charge_transfer_update( long nelem );
 
void iso_collapsed_bnl_print( long ipISO, long nelem );
 
void iso_collapsed_bnl_set( long ipISO, long nelem );
 
void iso_collapsed_Aul_update( long ipISO, long nelem );
 
void iso_collapsed_lifetimes_update( long ipISO, long nelem );
 
void iso_collide( long ipISO, long nelem );
 
void iso_collisional_ionization( long ipISO, long nelem );
 
void iso_continuum_lower( long ipISO , long nelem );
 
void iso_cool( long ipISO , long nelem );
 
void iso_create( void );
 
double iso_cross_section( double ERyd , double EthRyd, long n, long l, long S, long globalZ, long globalISO );
 
void iso_departure_coefficients( long ipISO, long nelem );
 
double iso_dielec_recomb_rate( long ipISO, long nelem, long ipLo );
 
void iso_error_generation( long ipISO, long nelem );
 
long iso_get_total_num_levels( long ipISO, long nmaxResolved, long numCollapsed );
 
void IonHydro( );
 
void iso_ionize_recombine( long ipISO , long nelem );
 
void iso_level( const long ipISO, const long nelem, double& renorm);
 
void iso_photo( long ipISO , long nelem );
 
void iso_prt_pops( long ipISO, long nelem, bool lgPrtDeparCoef );
 
void iso_put_error( long ipISO, long nelem, long ipHi, long ipLo, long whichData, realnum errorOpt, realnum errorPess);
 
void iso_radiative_recomb( long ipISO, long nelem );
 
void iso_radiative_recomb_effective( long ipISO, long nelem );
 
double iso_recomb_check( long ipISO, long nelem, long level, double temperature );
 
void iso_recomb_auxiliary_free( void );
 
void iso_recomb_malloc( void );
 
void iso_recomb_setup( long ipISO );
 
double iso_RRCoef_Te( long ipISO, long nelem , long n );
 
void iso_satellite_update( long nelem );
 
/* calculate radiative lifetime of an individual iso state 
\param ipISO
\param nelem
\param n
\param l
*/
double iso_state_lifetime( long ipISO, long nelem, long n, long l );
 
void iso_solve( long ipISO, long nelem, double &maxerr );
 
void iso_suprathermal( long ipISO, long nelem );
 
void iso_update_num_levels( long ipISO, long nelem );
 
void iso_update_rates( void );
 
void iso_collapsed_update( void );
 
void iso_set_ion_rates( long ipISO, long nelem);
 
class t_isoCTRL
{
public:
        bool lgPrintNumberOfLevels;
 
        const char *chISO[NISO];
 
        long int nLyman[NISO],
                nLyman_malloc[NISO];
 
        bool lgColl_l_mixing[NISO];
 
        bool lgColl_excite[NISO];
 
        bool lgColl_ionize[NISO];
 
        bool lgLTE_levels[NISO];
 
        bool lgCollStrenThermAver;
 
        bool lgInd2nu_On;
 
        /* option to disable continuum lowering due to stark broadening, particle packing, etc. */
        bool lgContinuumLoweringEnabled[NISO];
 
        realnum stat_ion[NISO];
 
        bool lgDielRecom[NISO];
 
        realnum SmallA;
 
        int ipLyaRedist[NISO] , ipResoRedist[NISO] , ipSubRedist[NISO];
 
        int nLyaLevel[NISO];
 
        bool lgCompileRecomb[NISO];
 
        bool lgNoRecombInterp[NISO];
 
        bool lgCS_Vriens[NISO] ,
                lgCS_None[NISO] ,
                lgCS_Vrinceanu[NISO],
                lgCS_therm_ave[NISO];
        int nCS_new[NISO];//vals are 0, 1, and 2
 
        bool lgCritDensLMix[NISO];
 
        bool lgFSM[NISO];
 
        bool lgRandErrGen[NISO];
 
 
        bool lgPessimisticErrors;
 
        bool lgTopoff[NISO];
 
        int modelRank[NISO];
};
 
extern t_isoCTRL iso_ctrl;
 
class extra_tr
{
public:
        double pestrk;
        double pestrk_up;
 
        /* NB NB NB ---  Error and ErrorFactor need one more slot than all the rest of these! */
        /* and the last dimension can just be hardwired to 3 */
 
        /* first dimension is upper level,
         * second is lower level,
         * third is for radiative, collisional, or energy errors.
         * MACROS are used for the last dimension: IPRAD, IPCOLLIS, and IPENERGY. */
        realnum Error[3];
 
        realnum ErrorFactor[3];
 
        double SigmaCascadeProb;
};
 
class t_iso_sp
{
public:
        TransitionProxy trans( const long ipHi, const long ipLo ) 
        {
                return (*tr)[ ipTrans[ipHi][ipLo] ];
        }
        multi_arr<long,2> ipTrans;
        multi_arr<extra_tr,2> ex;
        multi_arr<double,2> CascadeProb;
        multi_arr<double,2> BranchRatio;
        vector<freeBound> fb;
        qList st;
        TransitionList* tr;
 
        multi_arr<long,3> QuantumNumbers2Index;
 
        double xIonSimple;
 
        bool lgPrtDepartCoef;
 
        bool lgPrtLevelPops;
 
        bool lgLevelsLowered;
 
        bool lgLevelsEverLowered;
 
        /* flag that says we must reevaluate everything about this ion */
        bool lgMustReeval;
 
        /* set true if "element ionization" forces rescaling of pops */
        bool lgPopsRescaled;
 
        long int nCollapsed_max;
        long int nCollapsed_local;
 
        long int numLevels_max;
 
        long int numLevels_local;
 
        long int numLevels_malloc;
 
        long int n_HighestResolved_max;
        long int n_HighestResolved_local;
 
        realnum CaseBCheck;
 
        double RadRec_caseB;
 
        double RadRec_effec;
 
        double RecomCollisFrac;
 
        bool lgPopLTE_OK;
 
        double FreeBnd_net_Cool_Rate;
 
        double coll_ion;
 
        double cRest_cool;
 
        double xLineTotCool;
 
        double dLTot;
 
        double RadRecCool;
 
        double cBal_cool;
 
        double cLyrest_cool;
 
        double cLya_cool;
 
        double RecomInducCool_Rate;
 
        char chTypeAtomUsed[10];
 
        bool lgErrGenDone;
 
        double qTot2S;
 
        /* the departure coefficients of collapsed levels */
        multi_arr<double,3> bnl_effective;
        multi_arr<realnum,3> CachedAs;
        void Reset()
        {
                // this is flag indicating which type of model atom to use 
                strcpy( chTypeAtomUsed , "none" );
                CaseBCheck = 0.;
                /* a first guess at the recombination coefficients */
                RadRec_caseB = 1e-13;
                lgLevelsLowered = false;
                lgLevelsEverLowered = false;
                lgMustReeval = false;
                lgPopsRescaled = false;
                /* error generation done yet? false means not done.     */
                lgErrGenDone = false;
                for( vector<two_photon>::iterator it = TwoNu.begin(); it != TwoNu.end(); ++it )
                        (*it).Reset();
                for( vector<freeBound>::iterator it = fb.begin(); it != fb.end(); ++it )
                        (*it).Reset();
        }
        vector<two_photon> TwoNu;
 
        vector<double> HighestLevelOpacStack;
};
 
extern t_iso_sp iso_sp[NISO][LIMELM];
 
void iso_renorm( long nelem, long ipISO, double& renorm );
 
#endif /* ISO_H_ */