grainvar.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 GRAINVAR_H_
#define GRAINVAR_H_
 
/* grainvar.h */
 
#define IGNORE_QUANTUM_HEATING 1
 
const int NDEMS = 200;
 
const double GRAIN_TMIN = 1.e-3;
const double GRAIN_TMID = 5.e3;
const double GRAIN_TMAX = 1.2e9;
 
const int NCHS = 30;
const int NCHU = NCHS/3;
const int NCHRG_DEFAULT= 2;
 
const int NQGRID = 10000;
 
const double CONSERV_TOL = 1.e-3;
 
typedef enum {
        DF_STANDARD,      
        DF_USER_FUNCTION, 
        DF_SUBLIMATION    
} df_type;
 
typedef enum {
        ENTH_CAR,   
        ENTH_CAR2,  
        ENTH_SIL,   
        ENTH_SIL2,  
        ENTH_PAH,   
        ENTH_PAH2   
} enth_type;
 
typedef enum {
        ZMIN_CAR,   
        ZMIN_SIL    
} zmin_type;
 
typedef enum {
        POT_CAR,    
        POT_SIL     
} pot_type;
 
typedef enum {
        IAL_CAR,    
        IAL_SIL     
} ial_type;
 
typedef enum {
        PE_CAR,     
        PE_SIL      
} pe_type;
 
typedef enum {
        STRG_CAR,   
        STRG_SIL    
} strg_type;
 
typedef enum {
        H2_ICE,     
        H2_SIL,     
        H2_CAR,     
        H2_TOP      
} H2_type;
 
typedef enum {
        MAT_USR=0,  
        MAT_CAR,    
        MAT_SIL,    
        MAT_PAH,    
        MAT_CAR2,   
        MAT_SIL2,   
        MAT_PAH2,   
        MAT_TOP     
} mat_type;
 
struct GrainPar {
        double dep;
        df_type nDustFunc;
        bool lgForbidQHeating,
          lgGreyGrain,
          lgRequestQHeating;
};
 
class ShellData
{
        void p_clear0();
        void p_clear1();
 
public:
        ShellData()
        {
                p_clear1();
        }
        ~ShellData()
        {
                p_clear0();
        }
        void clear()
        {
                p_clear0();
                p_clear1();
        }
 
        long nelem;             
        long ns;                
        double ionPot;          
        long ipLo;              
        flex_arr<realnum> p;    
        flex_arr<realnum> y01;  
        long nData;             
        vector<double> AvNr;    
        vector<double> Ener;    
        vector< flex_arr<realnum> > y01A;
};
 
class AEInfo
{
        void p_clear0();
        void p_clear1();
 
public:
        AEInfo()
        {
                p_clear1();
        }
        ~AEInfo()
        {
                p_clear0();
        }
        void clear()
        {
                p_clear0();
                p_clear1();
        }
 
        unsigned int nSubShell;  
        vector<unsigned int> nData;
        vector<double> IonThres; 
        vector< vector<double> > AvNumber;
        vector< vector<double> > Energy;
};
 
class ChargeBin
{
        void p_clear0();
        void p_clear1();
 
public:
        ChargeBin()
        {
                p_clear1();
        }
        ~ChargeBin()
        {
                p_clear0();
        }
        void clear()
        {
                p_clear0();
                p_clear1();
        }
 
        long DustZ,             
          ipThresInf,           
          ipThresInfVal,        
          nfill;                
        double FracPop,         
          Emin,                 
          EminInc,              
          PotSurf,              
          PotSurfInc,           
          ThresInf,             
          ThresInfInc,          
          ThresInfVal,          
          ThresSurf,            
          ThresSurfInc,         
          ThresSurfVal,         
          ThermRate;            
        flex_arr<realnum> yhat; 
        flex_arr<realnum> yhat_primary;
        flex_arr<realnum> ehat; 
        flex_arr<double> cs_pdt;
        long RecomZ0[LIMELM][LIMELM+1];
        double eta[LIMELM+2],   
          xi[LIMELM+2];         
        double RSum1;           
        double RSum2;           
        double ESum1a;          
        double ESum1b;          
        double ESum2;           
        realnum tedust;         
        double hcon1;           
        double hots1;           
        double bolflux1;        
        double pe1;             
        flex_arr<double> fac1;  
        flex_arr<double> fac2;  
        realnum RecomEn[LIMELM][LIMELM+1];
        realnum ChemEn[LIMELM][LIMELM+1];
        double BolFlux,         
          GrainHeat,            
          GrainHeatColl,        
          GasHeatPhotoEl,       
          GasHeatTherm,         
          GrainCoolTherm,       
          ChemEnIon,            
          ChemEnH2;             
        double HeatingRate2;    
};
 
class GrainBin
{
        void p_clear0();
        void p_clear1();
 
public:
        GrainBin()
        {
                p_clear1();
        }
        ~GrainBin()
        {
                p_clear0();
        }
        void clear()
        {
                p_clear0();
                p_clear1();
        }
 
        df_type nDustFunc;      
        bool lgPAHsInIonizedRegion;
        char chDstLab[13];      
        double eec;             
        double eyc;             
        realnum dustp[5],       
          AvRadius,             
          AvArea,               
          AvVol,                
          IntRadius,            
          IntArea,              
          IntVol,               
          elmAbund[LIMELM],     
          atomWeight,           
          Tsublimat,            
          DustWorkFcn,          
          BandGap,              
          ThermEff,             
          avDGRatio;            
        mat_type matType;       
        realnum dstfactor,      
          dstAbund,             
          GrnDpth;              
        double cnv_H_pGR,       
          cnv_H_pCM3,           
          cnv_CM3_pGR,          
          cnv_CM3_pH,           
          cnv_GR_pH,            
          cnv_GR_pCM3;          
        double RSFCheck;        
        vector<double> dstab1;  
        vector<double> pure_sc1;
        vector<double> asym;    
        double dstems[NDEMS],   
          dstslp[NDEMS],        
          dstslp2[NDEMS];       
        bool lgTdustConverged;  
        realnum tedust,         
          TeGrainMax,           
          avdust;               
        bool lgChrgConverged;   
        long LowestZg;          
        long nfill;             
        vector<ShellData*> sd;  
        vector<realnum> y0b06;  
        double AveDustZ,        
          Capacity,             
          dstpot,               
          dstpotsav,            
          LowestPot,            
          RateUp,               
          RateDn,               
          StickElecNeg,         
          StickElecPos;         
        realnum avdpot,         
          le_thres;             
        vector<realnum> inv_att_len;
        double AccomCoef[LIMELM];
        double BolFlux,         
          GrainCoolTherm,       
          GasHeatPhotoEl,       
          GrainHeat,            
          GrainHeatColl,        
          GrainGasCool,         
          ChemEn,               
          ChemEnH2,             
          thermionic;           
        bool lgQHeat,           
          lgUseQHeat,           
          lgEverQHeat,          
          lgQHTooWide;          
        long QHeatFailures,     
          qnflux,               
          qnflux2;              
        double
          qtmin,                
          qtmin_zone1,          
          HeatingRate1;         
        double DustEnth[NDEMS], 
          EnthSlp[NDEMS],       
          EnthSlp2[NDEMS];      
        double rate_h2_form_grains_HM79;
        double rate_h2_form_grains_CT02;
        double rate_h2_form_grains_used;
        realnum DustDftVel,     
          avdft;                
        long nChrgOrg;          
        long nChrg;             
        ChargeBin *chrg[NCHS];  
};
 
class GrainVar
{
        void p_clear0();
        void p_clear1();
 
public:
        GrainVar()
        {
                p_clear1();
        }
        ~GrainVar()
        {
                p_clear0();
        }
        void clear()
        {
                p_clear0();
                p_clear1();
        }
 
        bool lgDustOn() const          
        {
                return ( bin.size() > 0 );
        }
        bool lgWD01,                   
          lgReevaluate,                
          lgGrainPhysicsOn,            
          lgAnyDustVary,               
          lgBakesPAH_heat;             
        bool lgNegGrnDrg;              
        bool lgDHetOn,                 
          lgQHeatOn;                   
        bool lgDColOn;                 
        bool lgGrainElectrons;
 
        vector<string> ReadRecord;     
        string chPAH_abundance;    
        realnum GrainMetal,            
          elmSumAbund[LIMELM];         
        enth_type which_enth[MAT_TOP]; 
        zmin_type which_zmin[MAT_TOP]; 
        pot_type which_pot[MAT_TOP];   
        ial_type which_ial[MAT_TOP];   
        pe_type which_pe[MAT_TOP];     
        strg_type which_strg[MAT_TOP]; 
        H2_type which_H2distr[MAT_TOP];
        vector<realnum> anumin;        
        vector<realnum> anumax;        
        long nzone;                    
        vector<double> dstab;          
        vector<double> dstsc;          
        double TotalEden;              
        realnum GrnElecDonateMax,      
          GrnElecHoldMax;              
        double GrnRecomTe;             
        long HighestIon,               
          nChrgRequested;              
        AEInfo *AugerData[LIMELM];     
        realnum GrainChTrRate[LIMELM][LIMELM+1][LIMELM+1];
        
        double GasCoolColl,            
          GasHeatPhotoEl,              
          GasHeatTherm,                
          GasHeatNet,                  
          GrainHeatSum,                
          GrainHeatLya,                
          GrainHeatDif,                
          GrainHeatInc,                
          GrainHeatCollSum,            
          GrainHeatChem;               
        double dHeatdT;                
        realnum GrainHeatScaleFactor;  
        realnum TotalDustHeat,         
          dphmax,                      
          dclmax;                      
        double dsttmp[NDEMS];          
        realnum dstAbundThresholdNear; 
        realnum dstAbundThresholdFar;  
        bool lgQHeatAll,               
          lgQHPunLast;                 
        FILE *QHSaveFile;             
        double rate_h2_form_grains_used_total; 
        vector<realnum> GrainEmission; 
        vector<realnum> GraphiteEmission;
        vector<realnum> SilicateEmission;
        vector<GrainBin*> bin;         
};
extern GrainVar gv;
 
 
#endif /* GRAINVAR_H_ */