blackhole.h File Reference

#include "utils/paramset.h"
#include "timestep.h"
#include "forcetree.h"
#include "physconst.h"

Include dependency graph for blackhole.h:

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

Go to the source code of this file.

Enumerations
enum	BlackHoleFeedbackMethod {   BH_FEEDBACK_TOPHAT = 0x2 , BH_FEEDBACK_SPLINE = 0x4 , BH_FEEDBACK_MASS = 0x8 , BH_FEEDBACK_VOLUME = 0x10 ,   BH_FEEDBACK_OPTTHIN = 0x20 }

Functions
void	set_blackhole_params (ParameterSet *ps)
void	blackhole (const ActiveParticles *act, double atime, Cosmology *CP, ForceTree *tree, const struct UnitSystem units, FILE *FdBlackHoles, FILE *FdBlackholeDetails)
void	blackhole_make_one (int index, const double atime)
int	BHGetRepositionEnabled (void)

Enumeration Type Documentation

BlackHoleFeedbackMethod

enum BlackHoleFeedbackMethod

Enumerator
BH_FEEDBACK_TOPHAT
BH_FEEDBACK_SPLINE
BH_FEEDBACK_MASS
BH_FEEDBACK_VOLUME
BH_FEEDBACK_OPTTHIN

Definition at line 8 of file blackhole.h.

                             {
     BH_FEEDBACK_TOPHAT   = 0x2,
     BH_FEEDBACK_SPLINE   = 0x4,
     BH_FEEDBACK_MASS     = 0x8,
     BH_FEEDBACK_VOLUME   = 0x10,
     BH_FEEDBACK_OPTTHIN  = 0x20,
};

Function Documentation

BHGetRepositionEnabled()

int BHGetRepositionEnabled

(

void

)

Definition at line 60 of file blackhole.c.

{
    return blackhole_params.BlackHoleRepositionEnabled;
}

Referenced by real_drift_particle().

Here is the caller graph for this function:

blackhole()

void blackhole	(	const ActiveParticles *	act,
		double	atime,
		Cosmology *	CP,
		ForceTree *	tree,
		const struct UnitSystem	units,
		FILE *	FdBlackHoles,
		FILE *	FdBlackholeDetails
	)

Definition at line 516 of file blackhole.c.

{
    /* Do nothing if no black holes*/
    int64_t totbh;
    MPI_Allreduce(&SlotsManager->info[5].size, &totbh, 1, MPI_INT64, MPI_SUM, MPI_COMM_WORLD);
    if(totbh == 0)
        return;
    int i;
 
    walltime_measure("/Misc");
    struct BHPriv priv[1] = {0};
    priv->units = units;
 
    /*************************************************************************/
    TreeWalk tw_dynfric[1] = {{0}};
    tw_dynfric->ev_label = "BH_DYNFRIC";
    tw_dynfric->visit = (TreeWalkVisitFunction) treewalk_visit_ngbiter;
    tw_dynfric->ngbiter_type_elsize = sizeof(TreeWalkNgbIterBHDynfric);
    tw_dynfric->ngbiter = (TreeWalkNgbIterFunction) blackhole_dynfric_ngbiter;
    tw_dynfric->haswork = blackhole_dynfric_haswork;
    tw_dynfric->postprocess = (TreeWalkProcessFunction) blackhole_dynfric_postprocess;
    tw_dynfric->fill = (TreeWalkFillQueryFunction) blackhole_dynfric_copy;
    tw_dynfric->reduce = (TreeWalkReduceResultFunction) blackhole_dynfric_reduce;
    tw_dynfric->query_type_elsize = sizeof(TreeWalkQueryBHDynfric);
    tw_dynfric->result_type_elsize = sizeof(TreeWalkResultBHDynfric);
    tw_dynfric->tree = tree;
    tw_dynfric->priv = priv;
 
    /*************************************************************************/
    TreeWalk tw_accretion[1] = {{0}};
 
    tw_accretion->ev_label = "BH_ACCRETION";
    tw_accretion->visit = (TreeWalkVisitFunction) treewalk_visit_ngbiter;
    tw_accretion->ngbiter_type_elsize = sizeof(TreeWalkNgbIterBHAccretion);
    tw_accretion->ngbiter = (TreeWalkNgbIterFunction) blackhole_accretion_ngbiter;
    tw_accretion->haswork = blackhole_dynfric_haswork;
    tw_accretion->postprocess = (TreeWalkProcessFunction) blackhole_accretion_postprocess;
    tw_accretion->preprocess = (TreeWalkProcessFunction) blackhole_accretion_preprocess;
    tw_accretion->fill = (TreeWalkFillQueryFunction) blackhole_accretion_copy;
    tw_accretion->reduce = (TreeWalkReduceResultFunction) blackhole_accretion_reduce;
    tw_accretion->query_type_elsize = sizeof(TreeWalkQueryBHAccretion);
    tw_accretion->result_type_elsize = sizeof(TreeWalkResultBHAccretion);
    tw_accretion->tree = tree;
    tw_accretion->priv = priv;
 
    /*************************************************************************/
 
    TreeWalk tw_feedback[1] = {{0}};
    tw_feedback->ev_label = "BH_FEEDBACK";
    tw_feedback->visit = (TreeWalkVisitFunction) treewalk_visit_ngbiter;
    tw_feedback->ngbiter_type_elsize = sizeof(TreeWalkNgbIterBHFeedback);
    tw_feedback->ngbiter = (TreeWalkNgbIterFunction) blackhole_feedback_ngbiter;
    tw_feedback->haswork = blackhole_feedback_haswork;
    tw_feedback->fill = (TreeWalkFillQueryFunction) blackhole_feedback_copy;
    tw_feedback->postprocess = (TreeWalkProcessFunction) blackhole_feedback_postprocess;
    tw_feedback->reduce = (TreeWalkReduceResultFunction) blackhole_feedback_reduce;
    tw_feedback->query_type_elsize = sizeof(TreeWalkQueryBHFeedback);
    tw_feedback->result_type_elsize = sizeof(TreeWalkResultBHFeedback);
    tw_feedback->tree = tree;
    tw_feedback->priv = priv;
    tw_feedback->repeatdisallowed = 1;
 
    priv->atime = atime;
    priv->a3inv = 1./(atime * atime * atime);
    priv->hubble = hubble_function(CP, atime);
    priv->CP = CP;
 
    /* Build the queue once, since it is really 'all black holes' and similar for all treewalks*/
    treewalk_build_queue(tw_dynfric, act->ActiveParticle, act->NumActiveParticle, 0);
    /* Now we have a BH queue and we can re-use it*/
    int * ActiveBlackHoles = tw_dynfric->WorkSet;
    int64_t NumActiveBlackHoles = tw_dynfric->WorkSetSize;
    /* If this queue is empty, nothing to do.*/
    MPI_Allreduce(&NumActiveBlackHoles, &totbh, 1, MPI_INT64, MPI_SUM, MPI_COMM_WORLD);
    if(totbh == 0) {
        myfree(ActiveBlackHoles);
        return;
    }
 
    /* We can re-use the current queue for these treewalks*/
    tw_accretion->haswork = NULL;
    tw_dynfric->haswork = NULL;
 
    /*************************************************************************/
    /*  Dynamical Friction Treewalk */
 
    /* Environment variables for DF */
    priv->BH_SurroundingRmsVel = (MyFloat *) mymalloc("BH_SurroundingRmsVel", SlotsManager->info[5].size * sizeof(priv->BH_SurroundingRmsVel));
    priv->BH_SurroundingVel = (MyFloat (*) [3]) mymalloc("BH_SurroundingVel", 3* SlotsManager->info[5].size * sizeof(priv->BH_SurroundingVel[0]));
    priv->BH_SurroundingParticles = (int *)mymalloc("BH_SurroundingParticles", SlotsManager->info[5].size * sizeof(priv->BH_SurroundingParticles));
    priv->BH_SurroundingDensity = (MyFloat *) mymalloc("BH_SurroundingDensity", SlotsManager->info[5].size * sizeof(priv->BH_SurroundingDensity));
    /* guard treewalk */
    if (blackhole_params.BH_DynFrictionMethod > 0)
        treewalk_run(tw_dynfric, ActiveBlackHoles, NumActiveBlackHoles);
 
    /*************************************************************************/
 
    walltime_measure("/BH/DynFric");
 
    /* Let's determine which particles may be swallowed and calculate total feedback weights */
    priv->SPH_SwallowID = (MyIDType *) mymalloc("SPH_SwallowID", SlotsManager->info[0].size * sizeof(MyIDType));
    memset(priv->SPH_SwallowID, 0, SlotsManager->info[0].size * sizeof(MyIDType));
 
    /* Computed in accretion, used in feedback*/
    priv->BH_FeedbackWeightSum = (MyFloat *) mymalloc("BH_FeedbackWeightSum", SlotsManager->info[5].size * sizeof(MyFloat));
 
    /* These are initialized in preprocess and used to reposition the BH in postprocess*/
    priv->MinPot = (MyFloat *) mymalloc("BH_MinPot", SlotsManager->info[5].size * sizeof(MyFloat));
 
    /* Local to this treewalk*/
    priv->BH_Entropy = (MyFloat *) mymalloc("BH_Entropy", SlotsManager->info[5].size * sizeof(MyFloat));
    priv->BH_SurroundingGasVel = (MyFloat (*) [3]) mymalloc("BH_SurroundVel", 3* SlotsManager->info[5].size * sizeof(priv->BH_SurroundingGasVel[0]));
    
    /* For AGN kinetic feedback */
    priv->NumDM = mymalloc("NumDM", SlotsManager->info[5].size * sizeof(MyFloat));
    priv->V2sumDM = mymalloc("V2sumDM", SlotsManager->info[5].size * sizeof(MyFloat));
    priv->V1sumDM = (MyFloat (*) [3]) mymalloc("V1sumDM", 3* SlotsManager->info[5].size * sizeof(priv->V1sumDM[0]));
    priv->MgasEnc = mymalloc("MgasEnc", SlotsManager->info[5].size * sizeof(MyFloat));
    /* mark the state of AGN kinetic feedback */
    priv->KEflag = mymalloc("KEflag", SlotsManager->info[5].size * sizeof(int));
 
    /* This allocates memory*/
    treewalk_run(tw_accretion, ActiveBlackHoles, NumActiveBlackHoles);
 
    /*************************************************************************/
 
    walltime_measure("/BH/Accretion");
    MPIU_Barrier(MPI_COMM_WORLD);
 
    /* Now do the swallowing of particles and dump feedback energy */
 
    /* Ionization counters*/
    priv[0].N_sph_swallowed = ta_malloc("n_sph_swallowed", int64_t, omp_get_max_threads());
    priv[0].N_BH_swallowed = ta_malloc("n_BH_swallowed", int64_t, omp_get_max_threads());
    memset(priv[0].N_sph_swallowed, 0, sizeof(int64_t) * omp_get_max_threads());
    memset(priv[0].N_BH_swallowed, 0, sizeof(int64_t) * omp_get_max_threads());
 
    priv->BH_accreted_Mass = (MyFloat *) mymalloc("BH_accretedmass", SlotsManager->info[5].size * sizeof(MyFloat));
    priv->BH_accreted_BHMass = (MyFloat *) mymalloc("BH_accreted_BHMass", SlotsManager->info[5].size * sizeof(MyFloat));
    priv->BH_accreted_Mtrack = (MyFloat *) mymalloc("BH_accreted_Mtrack", SlotsManager->info[5].size * sizeof(MyFloat));
    priv->BH_accreted_momentum = (MyFloat (*) [3]) mymalloc("BH_accretemom", 3* SlotsManager->info[5].size * sizeof(priv->BH_accreted_momentum[0]));
 
    treewalk_run(tw_feedback, ActiveBlackHoles, NumActiveBlackHoles);
 
    /*************************************************************************/
    walltime_measure("/BH/Feedback");
 
    if(FdBlackholeDetails){
        collect_BH_info(ActiveBlackHoles, NumActiveBlackHoles, priv, FdBlackholeDetails);
    }
 
    myfree(priv->BH_accreted_momentum);
    myfree(priv->BH_accreted_Mtrack);
    myfree(priv->BH_accreted_BHMass);
    myfree(priv->BH_accreted_Mass);
 
    /*****************************************************************/
    myfree(priv->KEflag);
    myfree(priv->MgasEnc);
    myfree(priv->V1sumDM);
    myfree(priv->V2sumDM);
    myfree(priv->NumDM);
    
    myfree(priv->BH_SurroundingGasVel);
    myfree(priv->BH_Entropy);
    myfree(priv->MinPot);
 
    myfree(priv->BH_FeedbackWeightSum);
    myfree(priv->SPH_SwallowID);
 
    /*****************************************************************/
    myfree(priv->BH_SurroundingDensity);
    myfree(priv->BH_SurroundingParticles);
    myfree(priv->BH_SurroundingVel);
    myfree(priv->BH_SurroundingRmsVel);
 
    /*****************************************************************/
    myfree(ActiveBlackHoles);
 
    int64_t Ntot_gas_swallowed, Ntot_BH_swallowed;
    int64_t N_sph_swallowed = 0, N_BH_swallowed = 0;
    for(i = 0; i < omp_get_max_threads(); i++) {
        N_sph_swallowed += priv[0].N_sph_swallowed[i];
        N_BH_swallowed += priv[0].N_BH_swallowed[i];
    }
    ta_free(priv[0].N_BH_swallowed);
    ta_free(priv[0].N_sph_swallowed);
 
    MPI_Reduce(&N_sph_swallowed, &Ntot_gas_swallowed, 1, MPI_INT64, MPI_SUM, 0, MPI_COMM_WORLD);
    MPI_Reduce(&N_BH_swallowed, &Ntot_BH_swallowed, 1, MPI_INT64, MPI_SUM, 0, MPI_COMM_WORLD);
 
    MPIU_Barrier(MPI_COMM_WORLD);
    message(0, "Accretion done: %d gas particles swallowed, %d BH particles swallowed\n",
                Ntot_gas_swallowed, Ntot_BH_swallowed);
 
    int total_bh;
    double total_mdoteddington;
    double total_mass_holes, total_mdot;
 
    double Local_BH_mass = 0;
    double Local_BH_Mdot = 0;
    double Local_BH_Medd = 0;
    int Local_BH_num = 0;
    /* Compute total mass of black holes
     * present by summing contents of black hole array*/
    #pragma omp parallel for reduction(+ : Local_BH_num) reduction(+: Local_BH_mass) reduction(+: Local_BH_Mdot) reduction(+: Local_BH_Medd)
    for(i = 0; i < SlotsManager->info[5].size; i ++)
    {
        if(BhP[i].SwallowID != (MyIDType) -1)
            continue;
        Local_BH_num++;
        Local_BH_mass += BhP[i].Mass;
        Local_BH_Mdot += BhP[i].Mdot;
        Local_BH_Medd += BhP[i].Mdot/BhP[i].Mass;
    }
 
    MPI_Reduce(&Local_BH_mass, &total_mass_holes, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
    MPI_Reduce(&Local_BH_Mdot, &total_mdot, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
    MPI_Reduce(&Local_BH_Medd, &total_mdoteddington, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
    MPI_Reduce(&Local_BH_num, &total_bh, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
 
    if(FdBlackHoles)
    {
        /* convert to solar masses per yr */
        double mdot_in_msun_per_year =
            total_mdot * (units.UnitMass_in_g / SOLAR_MASS) / (units.UnitTime_in_s / SEC_PER_YEAR);
 
        total_mdoteddington *= 1.0 / ((4 * M_PI * GRAVITY * LIGHTCGS * PROTONMASS /
                    (0.1 * LIGHTCGS * LIGHTCGS * THOMPSON)) * units.UnitTime_in_s);
 
        fprintf(FdBlackHoles, "%g %d %g %g %g %g\n",
                atime, total_bh, total_mass_holes, total_mdot, mdot_in_msun_per_year, total_mdoteddington);
        fflush(FdBlackHoles);
    }
    walltime_measure("/BH/Info");
}

References BHPriv::a3inv, ActiveParticles::ActiveParticle, BHPriv::atime, BHPriv::BH_accreted_BHMass, BHPriv::BH_accreted_Mass, BHPriv::BH_accreted_momentum, BHPriv::BH_accreted_Mtrack, BlackholeParams::BH_DynFrictionMethod, BHPriv::BH_Entropy, BHPriv::BH_FeedbackWeightSum, BHPriv::BH_SurroundingDensity, BHPriv::BH_SurroundingGasVel, BHPriv::BH_SurroundingParticles, BHPriv::BH_SurroundingRmsVel, BHPriv::BH_SurroundingVel, BhP, blackhole_accretion_copy(), blackhole_accretion_ngbiter(), blackhole_accretion_postprocess(), blackhole_accretion_preprocess(), blackhole_accretion_reduce(), blackhole_dynfric_copy(), blackhole_dynfric_haswork(), blackhole_dynfric_ngbiter(), blackhole_dynfric_postprocess(), blackhole_dynfric_reduce(), blackhole_feedback_copy(), blackhole_feedback_haswork(), blackhole_feedback_ngbiter(), blackhole_feedback_postprocess(), blackhole_feedback_reduce(), blackhole_params, collect_BH_info(), BHPriv::CP, CP, TreeWalk::ev_label, TreeWalk::fill, GRAVITY, TreeWalk::haswork, BHPriv::hubble, hubble_function(), slots_manager_type::info, BHPriv::KEflag, LIGHTCGS, message(), BHPriv::MgasEnc, BHPriv::MinPot, MPI_INT64, MPIU_Barrier, myfree, mymalloc, BHPriv::N_BH_swallowed, BHPriv::N_sph_swallowed, TreeWalk::ngbiter, TreeWalk::ngbiter_type_elsize, ActiveParticles::NumActiveParticle, BHPriv::NumDM, TreeWalk::postprocess, TreeWalk::preprocess, TreeWalk::priv, PROTONMASS, TreeWalk::query_type_elsize, TreeWalk::reduce, TreeWalk::repeatdisallowed, TreeWalk::result_type_elsize, SEC_PER_YEAR, slot_info::size, SlotsManager, SOLAR_MASS, BHPriv::SPH_SwallowID, ta_free, ta_malloc, THOMPSON, TreeWalk::tree, treewalk_build_queue(), treewalk_run(), treewalk_visit_ngbiter(), UnitSystem::UnitMass_in_g, BHPriv::units, UnitSystem::UnitTime_in_s, BHPriv::V1sumDM, BHPriv::V2sumDM, TreeWalk::visit, walltime_measure, TreeWalk::WorkSet, and TreeWalk::WorkSetSize.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

blackhole_make_one()

void blackhole_make_one	(	int	index,
		const double	atime
	)

Definition at line 1576 of file blackhole.c.

                                                       {
    if(P[index].Type != 0)
        endrun(7772, "Only Gas turns into blackholes, what's wrong?");
 
    int child = index;
 
    /* Make the new particle a black hole: use all the P[i].Mass
     * so we don't have lots of low mass tracers.
     * If the BH seed mass is small this may lead to a mismatch
     * between the gas and BH mass. */
    child = slots_convert(child, 5, -1, PartManager, SlotsManager);
 
    BHP(child).base.ID = P[child].ID;
    /* The accretion mass should always be the seed black hole mass,
     * irrespective of the gravitational mass of the particle.*/
    if(blackhole_params.MaxSeedBlackHoleMass > 0)
        BHP(child).Mass = bh_powerlaw_seed_mass(P[child].ID);
    else
        BHP(child).Mass = blackhole_params.SeedBlackHoleMass;
 
    BHP(child).Mseed = BHP(child).Mass;
    BHP(child).Mdot = 0;
    BHP(child).FormationTime = atime;
    BHP(child).SwallowID = (MyIDType) -1;
    BHP(child).Density = 0;
 
    /* It is important to initialize MinPotPos to the current position of
     * a BH to avoid drifting to unknown locations (0,0,0) immediately
     * after the BH is created. */
    int j;
    for(j = 0; j < 3; j++) {
        BHP(child).MinPotPos[j] = P[child].Pos[j];
        BHP(child).DFAccel[j] = 0;
        BHP(child).DragAccel[j] = 0;
    }
    BHP(child).JumpToMinPot = 0;
    BHP(child).CountProgs = 1;
 
    if (blackhole_params.SeedBHDynMass>0){
        BHP(child).Mtrack = P[child].Mass;
        P[child].Mass = blackhole_params.SeedBHDynMass;
    }
    else{
        BHP(child).Mtrack = -1; /* This column is not used then. */
    }
    /* Initialize KineticFdbkEnergy, keep zero if BlackHoleKineticOn is not turned on */
    BHP(child).KineticFdbkEnergy = 0;
}

References BHPriv::atime, bh_powerlaw_seed_mass(), BHP, blackhole_params, endrun(), BlackholeParams::MaxSeedBlackHoleMass, P, PartManager, BlackholeParams::SeedBHDynMass, BlackholeParams::SeedBlackHoleMass, slots_convert(), and SlotsManager.

Referenced by fof_seed_make_one().

Here is the call graph for this function:

Here is the caller graph for this function:

set_blackhole_params()

void set_blackhole_params

(

ParameterSet *

ps

)

Definition at line 257 of file blackhole.c.

{
    int ThisTask;
    MPI_Comm_rank(MPI_COMM_WORLD, &ThisTask);
    if(ThisTask == 0) {
        blackhole_params.BlackHoleAccretionFactor = param_get_double(ps, "BlackHoleAccretionFactor");
        blackhole_params.BlackHoleEddingtonFactor = param_get_double(ps, "BlackHoleEddingtonFactor");
 
        blackhole_params.BlackHoleFeedbackFactor = param_get_double(ps, "BlackHoleFeedbackFactor");
 
        blackhole_params.BlackHoleFeedbackMethod = (enum BlackHoleFeedbackMethod) param_get_enum(ps, "BlackHoleFeedbackMethod");
        blackhole_params.BlackHoleRepositionEnabled = param_get_int(ps, "BlackHoleRepositionEnabled");
        
        blackhole_params.BlackHoleKineticOn = param_get_int(ps,"BlackHoleKineticOn");
        blackhole_params.BHKE_EddingtonThrFactor = param_get_double(ps, "BHKE_EddingtonThrFactor");
        blackhole_params.BHKE_EddingtonMFactor = param_get_double(ps, "BHKE_EddingtonMFactor");
        blackhole_params.BHKE_EddingtonMPivot = param_get_double(ps, "BHKE_EddingtonMPivot");
        blackhole_params.BHKE_EddingtonMIndex = param_get_double(ps, "BHKE_EddingtonMIndex");
        blackhole_params.BHKE_EffRhoFactor = param_get_double(ps, "BHKE_EffRhoFactor");
        blackhole_params.BHKE_EffCap = param_get_double(ps, "BHKE_EffCap");
        blackhole_params.BHKE_InjEnergyThr = param_get_double(ps, "BHKE_InjEnergyThr");
        blackhole_params.BHKE_SfrCritOverDensity = param_get_double(ps, "CritOverDensity");
        /***********************************************************************************/
        blackhole_params.BH_DynFrictionMethod = param_get_int(ps, "BH_DynFrictionMethod");
        blackhole_params.BH_DFBoostFactor = param_get_int(ps, "BH_DFBoostFactor");
        blackhole_params.BH_DFbmax = param_get_double(ps, "BH_DFbmax");
        blackhole_params.BH_DRAG = param_get_int(ps, "BH_DRAG");
        blackhole_params.MergeGravBound = param_get_int(ps, "MergeGravBound");
        blackhole_params.SeedBHDynMass = param_get_double(ps,"SeedBHDynMass");
 
        blackhole_params.SeedBlackHoleMass = param_get_double(ps, "SeedBlackHoleMass");
        blackhole_params.MaxSeedBlackHoleMass = param_get_double(ps,"MaxSeedBlackHoleMass");
        blackhole_params.SeedBlackHoleMassIndex = param_get_double(ps,"SeedBlackHoleMassIndex");
        /***********************************************************************************/
    }
    MPI_Bcast(&blackhole_params, sizeof(struct BlackholeParams), MPI_BYTE, 0, MPI_COMM_WORLD);
}

References BlackholeParams::BH_DFbmax, BlackholeParams::BH_DFBoostFactor, BlackholeParams::BH_DRAG, BlackholeParams::BH_DynFrictionMethod, BlackholeParams::BHKE_EddingtonMFactor, BlackholeParams::BHKE_EddingtonMIndex, BlackholeParams::BHKE_EddingtonMPivot, BlackholeParams::BHKE_EddingtonThrFactor, BlackholeParams::BHKE_EffCap, BlackholeParams::BHKE_EffRhoFactor, BlackholeParams::BHKE_InjEnergyThr, BlackholeParams::BHKE_SfrCritOverDensity, blackhole_params, BlackholeParams::BlackHoleAccretionFactor, BlackholeParams::BlackHoleEddingtonFactor, BlackholeParams::BlackHoleFeedbackFactor, BlackholeParams::BlackHoleFeedbackMethod, BlackholeParams::BlackHoleKineticOn, BlackholeParams::BlackHoleRepositionEnabled, BlackholeParams::MaxSeedBlackHoleMass, BlackholeParams::MergeGravBound, param_get_double(), param_get_enum(), param_get_int(), BlackholeParams::SeedBHDynMass, BlackholeParams::SeedBlackHoleMass, BlackholeParams::SeedBlackHoleMassIndex, and ThisTask.

Referenced by read_parameter_file().

Here is the call graph for this function:

Here is the caller graph for this function: