grainvar.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 GRAINVAR_H_
#define GRAINVAR_H_
 
/* grainvar.h */
 
#include "container_classes.h"

const bool ENABLE_QUANTUM_HEATING=false;

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 = 50;
const int NCHU = NCHS/5;
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_SIC    
} 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_SIC,    

 
        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();
        }
        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();
        }
        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();
        }
        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();
 
        vector<ChargeBin> pool; 
public:
        GrainBin()
        {
                p_clear1();
        }
        void clear()
        {
                p_clear0();
                p_clear1();
        }

        df_type nDustFunc;      
        bool lgPAHsInIonizedRegion;
        bool lgIterStart;       

        char chDstLab[13];      
        double eec;             
        double eyc;             
        double dustp[6];        
        realnum AvRadius,       
          AvArea,               
          AvVol;                
        double IntRadius,       
          IntArea,              
          IntVol,               
          elmAbund[LIMELM];      
        realnum 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;    
        vector<double> dstab1_x_anu; 

        double dstems[NDEMS],   
          dstslp[NDEMS],        
          dstslp2[NDEMS];       
 
        bool lgTdustConverged;  
        realnum tedust,         
          TeGrainMax,           
          avdust;               

        long LowestZg;          
        long nfill;             
        vector<ShellData> sd;   
        vector<realnum> y0b06;  
        double AveDustZ;        
        long ZloSave;           
        double Capacity;        
        double dstpot,          
          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;           
        double qtmin_zone1;     
        double 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_ELRD;
        double rate_h2_form_grains_used;

        realnum DustDftVel,     
          avdft;                
 
        long nChrgOrg;          
        long nChrg;             
        long ichrg[NCHS];       
        ChargeBin& chrg(long nz) { return pool[ichrg[nz]]; }
        const ChargeBin& chrg(long nz) const { return pool[ichrg[nz]]; }
};

 
class GrainVar
{
        void p_clear0();
        void p_clear1();
 
public:
        GrainVar()
        {
                p_clear1();
        }
        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;
 
        long nCalledGrainDrive;        
 
        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];

        long nzone;                    
        vector<double> dstab;          
        vector<double> dstsc;          

        double TotalEden;              
        realnum GrnElecDonateMax;      
        realnum GrnElecHoldMax;        
        double GrnRecomTe;             
        long 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;               
        bool 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_ */