cooling_rates.h File Reference

#include "cooling.h"
#include "utils/paramset.h"

Include dependency graph for cooling_rates.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	cooling_params

Enumerations
enum	RecombType { Cen92 = 0 , Verner96 = 1 , Badnell06 = 2 }
enum	CoolingType { KWH92 = 0 , Enzo2Nyx = 1 , Sherwood =2 }
enum	CoolProcess { RECOMB , COLLIS , FREEFREE , HEAT }

Functions
void	set_cooling_params (ParameterSet *ps)
void	set_coolpar (struct cooling_params cp)
void	init_cooling_rates (const char *TreeCoolFile, const char *MetalCoolFile, Cosmology *CP)
void	InitMetalCooling (const char *MetalCoolFile)
double	TableMetalCoolingRate (double redshift, double temp, double nHcgs)
double	get_equilib_ne (double density, double ienergy, double helium, double *logt, const struct UVBG *uvbg, double ne_init)
double	get_ne_by_nh (double density, double ienergy, double helium, const struct UVBG *uvbg, double ne_init)
double	get_heatingcooling_rate (double density, double ienergy, double helium, double redshift, double metallicity, const struct UVBG *uvbg, double *ne_equilib)
double	get_individual_cooling (enum CoolProcess process, double density, double ienergy, double helium, const struct UVBG *uvbg, double *ne_equilib)
double	get_compton_cooling (double density, double ienergy, double helium, double redshift, double nebynh)
double	get_neutral_fraction_phys_cgs (double density, double ienergy, double helium, const struct UVBG *uvbg, double *ne_init)
double	get_helium_ion_phys_cgs (int ion, double density, double ienergy, double helium, const struct UVBG *uvbg, double ne_init)

Enumeration Type Documentation

CoolingType

enum CoolingType

Enumerator
KWH92
Enzo2Nyx
Sherwood

Definition at line 16 of file cooling_rates.h.

                 {
    KWH92 = 0, //Cooling from KWH 92
    Enzo2Nyx = 1, //Updated cooling rates from Avery Meiksin, used in Nyx and Enzo 2.
    Sherwood =2 ,  //Same as KWH92, but with an improved large temperature correction factor.
};

CoolProcess

enum CoolProcess

Enumerator
RECOMB
COLLIS
FREEFREE
HEAT

Definition at line 94 of file cooling_rates.h.

                 {
    RECOMB,
    COLLIS,
    FREEFREE,
    HEAT
};

RecombType

enum RecombType

Enumerator
Cen92
Verner96
Badnell06

Definition at line 10 of file cooling_rates.h.

                {
    Cen92 = 0, // Recombination from Cen 92
    Verner96 = 1, //Verner 96 recombination rates. Basically accurate, used by Sherwood and Nyx by default.
    Badnell06 = 2, //Even more up to date rates from Badnell 2006, cloudy's current default.
};

Function Documentation

get_compton_cooling()

double get_compton_cooling	(	double	density,
		double	ienergy,
		double	helium,
		double	redshift,
		double	nebynh
	)

Definition at line 1034 of file cooling_rates.c.

{
    double nh = density * (1 - helium);
    double temp = get_temp_internal(nebynh, ienergy, helium);
    /*Compton cooling in erg/s cm^3*/
    double LambdaCmptn = -1*nebynh * cool_InverseCompton(temp, redshift) / nh;
    return LambdaCmptn * pow(1 - helium, 2) * density / PROTONMASS;
}

References cool_InverseCompton(), density(), get_temp_internal(), and PROTONMASS.

Here is the call graph for this function:

get_equilib_ne()

double get_equilib_ne	(	double	density,
		double	ienergy,
		double	helium,
		double *	logt,
		const struct UVBG *	uvbg,
		double	ne_init
	)

Definition at line 683 of file cooling_rates.c.

{
    /*Get hydrogen number density*/
    double nh = density * (1-helium);
    /* Avoid getting stuck in an alternate solution
     * where there is never any heating in the presence of roundoff.*/
    if(ne_init <= 0)
        ne_init = 1.0;
    return scipy_optimize_fixed_point(ne_init, nh, ienergy, helium, logt, uvbg);
}

References density(), and scipy_optimize_fixed_point().

Referenced by get_heatingcooling_rate(), get_helium_ion_phys_cgs(), get_individual_cooling(), get_ne_by_nh(), get_neutral_fraction_phys_cgs(), get_temp(), and test_rate_network().

Here is the call graph for this function:

Here is the caller graph for this function:

get_heatingcooling_rate()

double get_heatingcooling_rate	(	double	density,
		double	ienergy,
		double	helium,
		double	redshift,
		double	metallicity,
		const struct UVBG *	uvbg,
		double *	ne_equilib
	)

Definition at line 1104 of file cooling_rates.c.

{
    double logt;
    double ne = get_equilib_ne(density, ienergy, helium, &logt, uvbg, *ne_equilib);
    double nh = density * (1 - helium);
    double nebynh = ne/nh;
    /*Faster than running the exp.*/
    double temp = get_temp_internal(nebynh, ienergy, helium);
    double photofac = self_shield_corr(nh, logt, uvbg->self_shield_dens);
 
    /*The helium number fraction*/
    double yy = helium / 4 / (1 - helium);
 
    double nH0 = nH0_internal(logt, ne, uvbg, photofac);
    double nHp = nHp_internal(nH0);
    struct he_ions He = nHe_internal(nh, logt, ne, uvbg, photofac);
    /*Put the abundances in units of nH to avoid underflows*/
    He.nHep*= yy/nh;
    He.nHe0*= yy/nh;
    He.nHepp*= yy/nh;
    /*Collisional ionization and excitation rate*/
    double LambdaCollis = nebynh * (get_interpolated_recomb(logt, cool_collisH0, cool_CollisionalH0) * nH0 +
            get_interpolated_recomb(logt, cool_collisHe0, cool_CollisionalHe0) * He.nHe0 +
            get_interpolated_recomb(logt, cool_collisHeP, cool_CollisionalHeP) * He.nHep);
    double LambdaRecomb = nebynh * (get_interpolated_recomb(logt, cool_recombHp, cool_RecombHp) * nHp +
            get_interpolated_recomb(logt, cool_recombHeP, cool_RecombHeP) * He.nHep +
            get_interpolated_recomb(logt, cool_recombHePP, cool_RecombHePP) * He.nHepp);
    /*Free-free cooling rate*/
    double LambdaFF = 0;
 
    double cff = get_interpolated_recomb(logt, cool_freefree1, cool_FreeFree1);
 
    if(CoolingParams.cooling == Enzo2Nyx) {
        LambdaFF = nebynh * (cff * (nHp + He.nHep) + cool_FreeFree(temp, 2) * He.nHepp);
    } else {
        /*The factor of (zz=2)^2 has been pulled out, so if we use the Spitzer gaunt factor we don't need
         * to call the FreeFree function again.*/
        LambdaFF = nebynh * (cff * (nHp + He.nHep) + 4 * cff * He.nHepp);
    }
    /*Compton cooling in erg/s cm^3*/
    double LambdaCmptn = nebynh * cool_InverseCompton(temp, redshift) / nh;
    /*Total cooling rate per proton in erg/s cm^3*/
    double Lambda = LambdaCollis + LambdaRecomb + LambdaFF + LambdaCmptn;
 
    /*Total heating rate per proton in erg/s cm^3*/
    double Heat = (nH0 * uvbg->epsH0 + He.nHe0 * uvbg->epsHe0 + He.nHep * uvbg->epsHep)/nh;
 
    Heat *= cool_he_reion_factor(density, helium, redshift);
    /*Set external equilibrium electron density*/
    *ne_equilib = nebynh;
 
    /*Apply metal cooling. Does nothing if metal cooling is disabled*/
    double MetalCooling = metallicity * TableMetalCoolingRate(redshift, temp, nh);
 
    double LambdaNet = Heat - Lambda - MetalCooling;
 
    //message(1, "Heat = %g Lambda = %g MetalCool = %g LC = %g LR = %g LFF = %g LCmptn = %g, ne = %g, nH0 = %g, nHp = %g, nHe0 = %g, nHep = %g, nHepp = %g, nh=%g, temp=%g, ienergy=%g\n", Heat, Lambda, MetalCooling, LambdaCollis, LambdaRecomb, LambdaFF, LambdaCmptn, nebynh, nH0, nHp, nHe0, nHep, nHepp, nh, temp, ienergy);
 
    /* LambdaNet in erg cm^3 /s, Density in protons/cm^3, PROTONMASS in protons/g.
     * Convert to erg/s/g*/
    return LambdaNet * pow(1 - helium, 2) * density / PROTONMASS;
}

References cool_collisH0, cool_collisHe0, cool_collisHeP, cool_CollisionalH0(), cool_CollisionalHe0(), cool_CollisionalHeP(), cool_FreeFree(), cool_freefree1, cool_FreeFree1(), cool_he_reion_factor(), cool_InverseCompton(), cool_recombHeP, cool_RecombHeP(), cool_recombHePP, cool_RecombHePP(), cool_recombHp, cool_RecombHp(), cooling_params::cooling, CoolingParams, density(), Enzo2Nyx, UVBG::epsH0, UVBG::epsHe0, UVBG::epsHep, get_equilib_ne(), get_interpolated_recomb(), get_temp_internal(), nH0_internal(), he_ions::nHe0, nHe_internal(), he_ions::nHep, he_ions::nHepp, nHp_internal(), PROTONMASS, self_shield_corr(), UVBG::self_shield_dens, and TableMetalCoolingRate().

Referenced by get_lambdanet(), GetCoolingTime(), and test_heatingcooling_rate().

Here is the call graph for this function:

Here is the caller graph for this function:

get_helium_ion_phys_cgs()

double get_helium_ion_phys_cgs	(	int	ion,
		double	density,
		double	ienergy,
		double	helium,
		const struct UVBG *	uvbg,
		double	ne_init
	)

Definition at line 1202 of file cooling_rates.c.

{
    double logt;
    double ne = get_equilib_ne(density, ienergy, helium, &logt, uvbg, ne_init);
    double yy = helium / 4 / (1 - helium);
    double nh = density * (1-helium);
    double photofac = self_shield_corr(nh, logt, uvbg->self_shield_dens);
    struct he_ions He = nHe_internal(nh, logt, ne, uvbg, photofac);
    if(ion == 0)
        return yy * He.nHe0 / nh;
    else if (ion == 1)
        return yy * He.nHep / nh;
    else
        return yy * He.nHepp / nh;
}

References density(), get_equilib_ne(), he_ions::nHe0, nHe_internal(), he_ions::nHep, he_ions::nHepp, self_shield_corr(), and UVBG::self_shield_dens.

Referenced by GetHeliumIonFraction().

Here is the call graph for this function:

Here is the caller graph for this function:

get_individual_cooling()

double get_individual_cooling	(	enum CoolProcess	process,
		double	density,
		double	ienergy,
		double	helium,
		const struct UVBG *	uvbg,
		double *	ne_equilib
	)

Definition at line 1046 of file cooling_rates.c.

{
    double logt;
    double ne = get_equilib_ne(density, ienergy, helium, &logt, uvbg, *ne_equilib);
    double nh = density * (1 - helium);
    double nebynh = ne/nh;
    /*Faster than running the exp.*/
    double temp = get_temp_internal(nebynh, ienergy, helium);
    double photofac = self_shield_corr(nh, logt, uvbg->self_shield_dens);
    double nH0 = nH0_internal(logt, ne, uvbg, photofac);
    double nHp = nHp_internal(nH0);
    /*The helium number fraction*/
    double yy = helium / 4 / (1 - helium);
    struct he_ions He = nHe_internal(nh, logt, ne, uvbg, photofac);
    /*Put the abundances in units of nH to avoid underflows*/
    He.nHep*= yy/nh;
    He.nHe0*= yy/nh;
    He.nHepp*= yy/nh;
 
    /*Compton cooling in erg/s cm^3*/
    double Lambda = 0;
 
    if(process == FREEFREE) {
        double cff = get_interpolated_recomb(logt, cool_freefree1, cool_FreeFree1);
        if(CoolingParams.cooling == Enzo2Nyx) {
            Lambda = -1*nebynh * (cff * (nHp + He.nHep) + cool_FreeFree(temp, 2) * He.nHepp);
        } else {
            /*The factor of (zz=2)^2 has been pulled out, so if we use the Spitzer gaunt factor we don't need
            * to call the FreeFree function again.*/
            Lambda = -1*nebynh * (cff * (nHp + He.nHep) + 4 * cff * He.nHepp);
        }
    } else if(process == HEAT) {
            /*Total heating rate per proton in erg/s cm^3*/
            Lambda = (nH0 * uvbg->epsH0 + He.nHe0 * uvbg->epsHe0 + He.nHep * uvbg->epsHep)/nh;
    }
    else if(process == RECOMB) {
        Lambda = -1*nebynh * (get_interpolated_recomb(logt, cool_recombHp, cool_RecombHp) * nHp +
            get_interpolated_recomb(logt, cool_recombHeP, cool_RecombHeP) * He.nHep +
            get_interpolated_recomb(logt, cool_recombHePP, cool_RecombHePP) * He.nHepp);
    }
    else if(process == COLLIS) {
        Lambda = -1*nebynh * (get_interpolated_recomb(logt, cool_collisH0, cool_CollisionalH0) * nH0 +
            get_interpolated_recomb(logt, cool_collisHe0, cool_CollisionalHe0) * He.nHe0 +
            get_interpolated_recomb(logt, cool_collisHeP, cool_CollisionalHeP) * He.nHep);
    }
 
    return Lambda * pow(1 - helium, 2) * density / PROTONMASS;
}

References COLLIS, cool_collisH0, cool_collisHe0, cool_collisHeP, cool_CollisionalH0(), cool_CollisionalHe0(), cool_CollisionalHeP(), cool_FreeFree(), cool_freefree1, cool_FreeFree1(), cool_recombHeP, cool_RecombHeP(), cool_recombHePP, cool_RecombHePP(), cool_recombHp, cool_RecombHp(), cooling_params::cooling, CoolingParams, density(), Enzo2Nyx, UVBG::epsH0, UVBG::epsHe0, UVBG::epsHep, FREEFREE, get_equilib_ne(), get_interpolated_recomb(), get_temp_internal(), HEAT, nH0_internal(), he_ions::nHe0, nHe_internal(), he_ions::nHep, he_ions::nHepp, nHp_internal(), PROTONMASS, RECOMB, self_shield_corr(), and UVBG::self_shield_dens.

Here is the call graph for this function:

get_ne_by_nh()

double get_ne_by_nh	(	double	density,
		double	ienergy,
		double	helium,
		const struct UVBG *	uvbg,
		double	ne_init
	)

Definition at line 696 of file cooling_rates.c.

{
    double logt;
    return get_equilib_ne(density, ienergy, helium, &logt, uvbg, ne_init)/(density*(1-helium));
}

References density(), and get_equilib_ne().

Here is the call graph for this function:

get_neutral_fraction_phys_cgs()

double get_neutral_fraction_phys_cgs	(	double	density,
		double	ienergy,
		double	helium,
		const struct UVBG *	uvbg,
		double *	ne_init
	)

Definition at line 1186 of file cooling_rates.c.

{
    double logt;
    double ne = get_equilib_ne(density, ienergy, helium, &logt, uvbg, *ne_init);
    double nh = density * (1-helium);
    double photofac = self_shield_corr(nh, logt, uvbg->self_shield_dens);
    *ne_init = ne/nh;
    return nH0_internal(logt, ne, uvbg, photofac);
}

References density(), get_equilib_ne(), nH0_internal(), self_shield_corr(), and UVBG::self_shield_dens.

Referenced by GetNeutralFraction(), and test_rate_network().

Here is the call graph for this function:

Here is the caller graph for this function:

init_cooling_rates()

void init_cooling_rates	(	const char *	TreeCoolFile,
		const char *	MetalCoolFile,
		Cosmology *	CP
	)

Definition at line 970 of file cooling_rates.c.

{
    CoolingParams.fBar = CP->OmegaBaryon / CP->OmegaCDM;
    CoolingParams.rho_crit_baryon = CP->OmegaBaryon * 3.0 * pow(CP->HubbleParam*HUBBLE,2.0) /(8.0*M_PI*GRAVITY);
 
    /* Initialize the interpolation for the self-shielding module as a function of redshift.
     * A crash has been observed in GSL with a cspline interpolator. */
    GrayOpac = gsl_interp_alloc(gsl_interp_linear,NGRAY);
    gsl_interp_init(GrayOpac,GrayOpac_zz,GrayOpac_ydata, NGRAY);
 
    if(!TreeCoolFile || strnlen(TreeCoolFile,100) == 0) {
        CoolingParams.PhotoIonizationOn = 0;
        message(0, "No TreeCool file is provided. Cooling is broken. OK for DM only runs. \n");
    }
    else {
        message(0, "Using uniform UVB from file %s\n", TreeCoolFile);
        /* Load the TREECOOL into Gamma_HI->ydata, and initialise the interpolators*/
        load_treecool(TreeCoolFile);
    }
 
    /*Initialize the recombination tables*/
    temp_tab = (double *) mymalloc("Recombination_tables", NRECOMBTAB * sizeof(double) * 14);
 
    rec_GammaH0 = temp_tab + NRECOMBTAB;
    rec_GammaHe0 = temp_tab + 2 * NRECOMBTAB;
    rec_GammaHep = temp_tab + 3 * NRECOMBTAB;
    rec_alphaHp = temp_tab + 4 * NRECOMBTAB;
    rec_alphaHep = temp_tab + 5 * NRECOMBTAB;
    rec_alphaHepp = temp_tab + 6 * NRECOMBTAB;
    cool_collisH0 = temp_tab + 7 * NRECOMBTAB;
    cool_collisHe0 = temp_tab + 8 * NRECOMBTAB;
    cool_collisHeP = temp_tab + 9 * NRECOMBTAB;
    cool_recombHp = temp_tab + 10 * NRECOMBTAB;
    cool_recombHeP = temp_tab + 11 * NRECOMBTAB;
    cool_recombHePP = temp_tab + 12 * NRECOMBTAB;
    cool_freefree1 = temp_tab + 13 * NRECOMBTAB;
 
    int i;
    for(i = 0 ; i < NRECOMBTAB; i++)
    {
        temp_tab[i] = RECOMBTMIN + (RECOMBTMAX - RECOMBTMIN) * i / NRECOMBTAB;
        double tt = exp(temp_tab[i]);
        rec_GammaH0[i] = recomb_GammaeH0(tt);
        rec_GammaHe0[i] = recomb_GammaeHe0(tt);
        rec_GammaHep[i] = recomb_GammaeHep(tt);
        rec_alphaHp[i] = recomb_alphaHp(tt);
        /* Note this includes dielectronic recombination*/
        rec_alphaHep[i] = recomb_alphaHepd(tt);
        rec_alphaHepp[i] = recomb_alphaHepp(tt);
        cool_collisH0[i] = cool_CollisionalH0(tt);
        cool_collisHe0[i] = cool_CollisionalHe0(tt);
        cool_collisHeP[i] = cool_CollisionalHeP(tt);
        cool_recombHp[i] = cool_RecombHp(tt);
        cool_recombHeP[i] = cool_RecombHeP(tt);
        cool_recombHePP[i] = cool_RecombHePP(tt);
        cool_freefree1[i] = cool_FreeFree(tt, 1);
    }
 
    /*Initialize the metal cooling table*/
    InitMetalCooling(MetalCoolFile);
}

References cool_collisH0, cool_collisHe0, cool_collisHeP, cool_CollisionalH0(), cool_CollisionalHe0(), cool_CollisionalHeP(), cool_FreeFree(), cool_freefree1, cool_recombHeP, cool_RecombHeP(), cool_recombHePP, cool_RecombHePP(), cool_recombHp, cool_RecombHp(), CoolingParams, CP, cooling_params::fBar, GRAVITY, GrayOpac, GrayOpac_ydata, GrayOpac_zz, HUBBLE, Cosmology::HubbleParam, InitMetalCooling(), load_treecool(), message(), mymalloc, NGRAY, NRECOMBTAB, Cosmology::OmegaBaryon, Cosmology::OmegaCDM, cooling_params::PhotoIonizationOn, rec_alphaHep, rec_alphaHepp, rec_alphaHp, rec_GammaH0, rec_GammaHe0, rec_GammaHep, recomb_alphaHepd(), recomb_alphaHepp(), recomb_alphaHp(), recomb_GammaeH0(), recomb_GammaeHe0(), recomb_GammaeHep(), RECOMBTMAX, RECOMBTMIN, cooling_params::rho_crit_baryon, temp_tab, and tt.

Referenced by init_cooling(), test_heatingcooling_rate(), test_rate_network(), test_recomb_rates(), and test_uvbg_loader().

Here is the call graph for this function:

Here is the caller graph for this function:

InitMetalCooling()

void InitMetalCooling

(

const char *

MetalCoolFile

)

Definition at line 193 of file cooling_uvfluc.c.

{
    /* now initialize the metal cooling table from cloudy; we got this file
     * from vogelsberger's Arepo simulations; it is supposed to be
     * cloudy + UVB - H and He; look so.
     * the table contains only 1 Z_sun values. Need to be scaled to the
     * metallicity.
     *
     * */
    /* let's see if the Metal Cool File is magic NoMetal */
    if(strlen(MetalCoolFile) == 0) {
        MetalCool.CoolingNoMetal = 1;
        return;
    } else {
        MetalCool.CoolingNoMetal = 0;
    }
 
    int size;
    //This is never used if MetalCoolFile == ""
    double * tabbedmet = read_big_array(MetalCoolFile, "MetallicityInSolar_bins", &size);
 
    if(size != 1 || tabbedmet[0] != 0.0) {
        endrun(123, "MetalCool file %s is wrongly tabulated\n", MetalCoolFile);
    }
    myfree(tabbedmet);
 
    MetalCool.Redshift_bins = read_big_array(MetalCoolFile, "Redshift_bins", &MetalCool.NRedshift_bins);
    MetalCool.HydrogenNumberDensity_bins = read_big_array(MetalCoolFile, "HydrogenNumberDensity_bins", &MetalCool.NHydrogenNumberDensity_bins);
    MetalCool.Temperature_bins = read_big_array(MetalCoolFile, "Temperature_bins", &MetalCool.NTemperature_bins);
    MetalCool.Lmet_table = read_big_array(MetalCoolFile, "NetCoolingRate", &size);
 
    int64_t dims[] = {MetalCool.NRedshift_bins, MetalCool.NHydrogenNumberDensity_bins, MetalCool.NTemperature_bins};
 
    interp_init(&MetalCool.interp, 3, dims);
    interp_init_dim(&MetalCool.interp, 0, MetalCool.Redshift_bins[0], MetalCool.Redshift_bins[MetalCool.NRedshift_bins - 1]);
    interp_init_dim(&MetalCool.interp, 1, MetalCool.HydrogenNumberDensity_bins[0],
                    MetalCool.HydrogenNumberDensity_bins[MetalCool.NHydrogenNumberDensity_bins - 1]);
    interp_init_dim(&MetalCool.interp, 2, MetalCool.Temperature_bins[0],
                    MetalCool.Temperature_bins[MetalCool.NTemperature_bins - 1]);
}

References endrun(), interp_init(), interp_init_dim(), MetalCool, myfree, and read_big_array().

Referenced by init_cooling_rates().

Here is the call graph for this function:

Here is the caller graph for this function:

set_cooling_params()

void set_cooling_params

(

ParameterSet *

ps

)

Definition at line 942 of file cooling_rates.c.

{
    int ThisTask;
    MPI_Comm_rank(MPI_COMM_WORLD, &ThisTask);
    if(ThisTask == 0) {
        /*Cooling rate network parameters*/
        CoolingParams.CMBTemperature = param_get_double(ps, "CMBTemperature");
        CoolingParams.cooling = (enum CoolingType) param_get_enum(ps, "CoolingRates"); // Sherwood;
        CoolingParams.recomb = (enum RecombType) param_get_enum(ps, "RecombRates"); // Verner96;
        CoolingParams.SelfShieldingOn = param_get_int(ps, "SelfShieldingOn");
        CoolingParams.PhotoIonizeFactor = param_get_double(ps, "PhotoIonizeFactor");
        CoolingParams.PhotoIonizationOn = param_get_int(ps, "PhotoIonizationOn");
        CoolingParams.MinGasTemp = param_get_double(ps, "MinGasTemp");
        CoolingParams.UVRedshiftThreshold = param_get_double(ps, "UVRedshiftThreshold");
        CoolingParams.HydrogenHeatAmp = log10(param_get_double(ps, "HydrogenHeatAmp"));
 
        /*Helium model parameters*/
        CoolingParams.HeliumHeatOn = param_get_int(ps, "HeliumHeatOn");
        CoolingParams.HeliumHeatThresh = param_get_double(ps, "HeliumHeatThresh");
        CoolingParams.HeliumHeatAmp = param_get_double(ps, "HeliumHeatAmp");
        CoolingParams.HeliumHeatExp = param_get_double(ps, "HeliumHeatExp");
    }
    MPI_Bcast(&CoolingParams, sizeof(struct cooling_params), MPI_BYTE, 0, MPI_COMM_WORLD);
}

References cooling_params::CMBTemperature, cooling_params::cooling, CoolingParams, cooling_params::HeliumHeatAmp, cooling_params::HeliumHeatExp, cooling_params::HeliumHeatOn, cooling_params::HeliumHeatThresh, cooling_params::HydrogenHeatAmp, cooling_params::MinGasTemp, param_get_double(), param_get_enum(), param_get_int(), cooling_params::PhotoIonizationOn, cooling_params::PhotoIonizeFactor, cooling_params::recomb, cooling_params::SelfShieldingOn, ThisTask, and cooling_params::UVRedshiftThreshold.

Referenced by read_parameter_file().

Here is the call graph for this function:

Here is the caller graph for this function:

set_coolpar()

void set_coolpar

(

struct cooling_params

cp

)

Definition at line 936 of file cooling_rates.c.

{
    CoolingParams = cp;
}

References CoolingParams.

Referenced by test_DoCooling(), test_heatingcooling_rate(), test_rate_network(), test_recomb_rates(), and test_uvbg_loader().

Here is the caller graph for this function:

TableMetalCoolingRate()

double TableMetalCoolingRate	(	double	redshift,
		double	temp,
		double	nHcgs
	)

Definition at line 235 of file cooling_uvfluc.c.

{
    if(MetalCool.CoolingNoMetal)
        return 0;
 
    double lognH = log10(nHcgs);
    double logT = log10(temp);
 
    double x[] = {redshift, lognH, logT};
    int status[3];
    double rate = interp_eval(&MetalCool.interp, x, MetalCool.Lmet_table, status);
    /* XXX: in case of very hot / very dense we just use whatever the table says at
     * the limit. should be OK. */
    return rate;
}

References interp_eval(), and MetalCool.

Referenced by get_heatingcooling_rate().

Here is the call graph for this function:

Here is the caller graph for this function: