Class for computing the standard halomodel predictions for \(P(k,z)\) plus \(n(M,z)\) or just doing spherical collapse. More...

#include <Halomodel.h>

Public Member Functions
	HaloModel (const HaloModel &)=default

HaloModel &	operator= (const HaloModel &)=default

	HaloModel ()=default

	HaloModel (SphericalCollapseModel spcmodel, Spline logDelta_of_logk_spline, double xinput_pofk=0.0, bool hmcode=false, bool verbose=false, double xini=std::log(1e-5), int npts=1000)

	~HaloModel ()=default

void	init ()

void	compute_at_redshift (double zcollapse)

void	output_pofk (std::string filename, double kmin=1e-5, double kmax=100, int npts_k=1000) const

void	output_deltac (std::string filename, double zmin=0.0, double zmax=10.0, int npts_z=100) const

void	output_nofM (std::string filename, double Mmin=1e8, double Mmax=1e16, int npts_M=100) const

void	info () const

double	get_DeltaVir_hmcode (double x) const

double	get_deltac_hmcode (double x) const

double	get_eta_hmcode (double x) const

double	get_kstar_hmcode (double x) const

double	get_f_hmcode (double x) const

double	get_cmin_hmcode (double x) const

double	get_alpha_hmcode () const

Data Fields
Timer	timer

SphericalCollapseModel	spcmodel

double	OmegaM {}

double	fnu {}

Spline	logDelta_of_logk_spline {"logDelta_lin"}

double	xinput_pofk {}

double	DeltaVir {}

double	deltac {}

double	sigma8 {}

double	sigmav {}

double	sigmav100 {}

double	xcollapse {std::numeric_limits<double>::quiet_NaN()}

double	rnl_nu {}

double	neff {}

std::string	halo_massfunction = "ShethTormen1999"

HaloMultiplicityFunction	halo_multiplicity_function = get_sheth_tormen_halo_multiplicity_function()

HaloBiasFunction	halo_bias_function = get_sheth_tormen_halo_bias_function()

double	p_ST = 0.3

double	a_ST = 0.707

double	A_ST = 0.2162

std::string	halo_profile = "NFW"

std::string	cofM_model = "Bullock2001"

RhoFunction	halo_density_profile = get_nfw_halo_density_profile()

cofMFunction	halo_mass_concentration_relation = get_nfw_halo_mass_concentration_relation()

double	kmin_pofk = 1e-5

double	kmax_pofk = 100.0

int	npts_pofk = 1000

bool	hmcode {true}

bool	verbose {true}

double	hmcode_kstar = 0.01

double	hmcode_alpha = 1.0

double	hmcode_eta = 0.0

double	hmcode_cmin = 4.0

double	hmcode_f = 0.0

double	cofM_0 = 4.75

double	cofM_M0 = 1e14

double	cofM_beta = 0.13

double	xini_spherical_collapse = std::log(1e-5)

int	npts_spherical_collapse = 1000

std::shared_ptr< DVector >	fiducial_logR_array {nullptr}

std::shared_ptr< DVector >	fiducial_logk_array {nullptr}

double	DeltaVir_multiplier = 1.0

double	cofM_multiplier = 1.0

double	deltac_multiplier = 1.0

Spline	growthfactor_of_x_spline {"Growthfactor"}

Spline	growthrate_of_x_spline {"Growthrate"}

Spline	deltac_of_x_spline {"deltac"}

Spline	DeltaVir_of_x_spline {"DeltaVir"}

Spline	xta_of_x_spline {"xta"}

Spline	xnl_of_x_spline {"xnl"}

Spline	xvir_of_x_spline {"xvir"}

Spline	delta_ini_of_x_spline {"deltaini"}

Spline	logsigma_of_logR_spline {"logsigma"}

Spline	formationredshift_of_logM_spline {"zf"}

Spline	lognu_of_logR_spline {"lognuoflogR"}

Spline	lognu_of_logM_spline {"lognuoflogM"}

Spline	logR_of_lognu_spline {"logRoflognu"}

Spline	dndlogM_of_logM_spline {"dndlogM"}

Spline	n_of_logM_spline {"nofM"}

Spline	logDeltaHM_onehalo_of_logk_spline {"logDelta_1h"}

Spline	logDeltaHM_twohalo_of_logk_spline {"logDelta_2h"}

Spline	logDeltaHM_full_of_logk_spline {"logDelta"}

Spline2D	y_of_logR_and_logk_spline {"y"}

WindowFunction	fourier_window_function = get_tophat_window_fourier()

Detailed Description

Class for computing the standard halomodel predictions for \(P(k,z)\) plus \(n(M,z)\) or just doing spherical collapse.

Contains the HMCode modifications so one can run both the standard halomodel and HMCode by setting a flag. The mass-consentration relation, PDF and bias and halo density profile can easily be modified if wanted by providing a lambda functions defining these functions..

The cosmology/gravity model is specified through the spherical-collapse model. This currently only handles scale-independent growth.

Definition at line 62 of file Halomodel.h.

Constructor & Destructor Documentation

◆ HaloModel() [1/3]

FML::COSMOLOGY::HALOMODEL::HaloModel::HaloModel ( const HaloModel & )

default

◆ HaloModel() [2/3]

FML::COSMOLOGY::HALOMODEL::HaloModel::HaloModel ( )

default

◆ HaloModel() [3/3]

FML::COSMOLOGY::HALOMODEL::HaloModel::HaloModel	(	SphericalCollapseModel	spcmodel,
		Spline	logDelta_of_logk_spline,
		double	xinput_pofk = `0.0`,
		bool	hmcode = `false`,
		bool	verbose = `false`,
		double	xini = `std::log(1e-5)`,
		int	npts = `1000`
	)

Definition at line 634 of file Halomodel.cpp.

                    :
        spcmodel(spcmodel),
        OmegaM(spcmodel.OmegaM),
        logDelta_of_logk_spline(logDelta_of_logk_spline),
        xinput_pofk(xinput_pofk),
        hmcode(hmcode),
        verbose(verbose),
        xini_spherical_collapse(xini),
        npts_spherical_collapse(npts) {
          init(); 
        }

◆ ~HaloModel()

FML::COSMOLOGY::HALOMODEL::HaloModel::~HaloModel ( )

default

Member Function Documentation

◆ compute_at_redshift()

void FML::COSMOLOGY::HALOMODEL::HaloModel::compute_at_redshift ( double zcollapse )

Definition at line 752 of file Halomodel.cpp.

                                                         {
        xcollapse = std::log(1.0/(1.0 + zcollapse));
 
        if(verbose){
          std::cout << "\n#=====================================================\n";
          std::cout << "# Compute at z = " << zcollapse << "\n";
          std::cout << "#=====================================================\n";
        }
 
        //=====================================================
        // Functions related to the variance of the smoothed
        // density field: smoothing filter and P(k)
        //=====================================================
        const double pofk_scaling_factor = std::pow(growthfactor_of_x_spline(xcollapse) / growthfactor_of_x_spline(xinput_pofk), 2);
        const Func1 logDeltaLin_of_logk = [&](double logk){
          return logDelta_of_logk_spline(logk) + std::log(pofk_scaling_factor);
        };
 
        //=====================================================
        // Density field variance when smoothed: sigma(logR)
        //=====================================================
        timer.StartTiming("sigma");
        if(verbose){
          std::cout << "Computing sigmas\n";
        }
        compute_sigma(
            logDeltaLin_of_logk,
            fourier_window_function,
            logsigma_of_logR_spline,
            fiducial_logR_array.get(),
            fiducial_logk_array.get());
        timer.EndTiming("sigma");
 
        //=====================================================
        // Set OmegaM and sigma8 at current redshift
        //=====================================================
        sigma8    = std::exp(logsigma_of_logR_spline(std::log(8.0)));
        sigmav    = compute_sigmav(logDeltaLin_of_logk, fourier_window_function, 0.0);
        sigmav100 = compute_sigmav(logDeltaLin_of_logk, fourier_window_function, 100.0);
 
        //=====================================================
        // Extract deltac and DeltaVir
        // If HMCode we use their fits
        //=====================================================
        if(verbose){
          std::cout << "Computing DeltaVir and deltac\n";
        }
        if(hmcode){
          DeltaVir     = get_DeltaVir_hmcode(xcollapse);
          deltac       = get_deltac_hmcode(xcollapse);
        } else {
          DeltaVir = DeltaVir_of_x_spline(xcollapse);
          deltac   = deltac_of_x_spline(xcollapse);
        }
        DeltaVir *= DeltaVir_multiplier;
        deltac *= deltac_multiplier;
 
        //=====================================================
        // nu(R) relation and the non-linear scale nu(R)==1
        //=====================================================
        if(verbose){
          std::cout << "Computing nu-R relation\n";
        }
        timer.StartTiming("nu");
        compute_lognu_of_logR(
            deltac, 
            logsigma_of_logR_spline, 
            lognu_of_logR_spline, 
            logR_of_lognu_spline,
            fiducial_logR_array.get());
        timer.EndTiming("nu");
 
        auto neff_data = compute_neff(logsigma_of_logR_spline, lognu_of_logR_spline);
        rnl_nu = neff_data.first;
        neff = neff_data.second;
 
        //=====================================================
        // Set the HMCode parameters
        //=====================================================
        if(hmcode){
          if(verbose)
            std::cout << "# Applying HMCode fits\n";
          cofM_model   = "Bullock2001";
          hmcode_cmin  = get_cmin_hmcode(xcollapse);
          hmcode_f     = get_f_hmcode(xcollapse);
          hmcode_kstar = get_kstar_hmcode(xcollapse);
          hmcode_eta   = get_eta_hmcode(xcollapse);
          hmcode_alpha = get_alpha_hmcode();
        }
        hmcode_cmin *= cofM_multiplier;
        cofM_0 *= cofM_multiplier;
 
        if(verbose) {
          std::cout << "# f        = " << hmcode_f << "\n";
          std::cout << "# kstar    = " << hmcode_kstar << "\n";
          std::cout << "# eta      = " << hmcode_eta << "\n";
          std::cout << "# alpha    = " << hmcode_alpha << "\n";
          std::cout << "# cmin     = " << hmcode_cmin << "\n";
          std::cout << "# deltac   = " << deltac << "\n";
          std::cout << "# DeltaVir = " << DeltaVir << "\n";
        }
 
        //=====================================================
        // The mass consentration relation as in Bullock 2001
        // needed if we want this NFW c(M,z) relation
        //=====================================================
        if(verbose)
          std::cout << "Computing formation redshifts\n";
        compute_formation_redshift_factor(
            growthfactor_of_x_spline,
            logsigma_of_logR_spline,
            formationredshift_of_logM_spline,
            deltac,
            OmegaM,
            xcollapse);
 
        //=====================================================
        // The halo density profile
        // The dimensionless combination 4pi r^3 rho(r,M) / M
        //=====================================================
        const Func2 rho_function = [&](double r, double M){
          return halo_density_profile(r, M, this);
        };
 
        //=====================================================
        // Fourier transform of halo density profiles
        //=====================================================
        if(verbose){
          std::cout << "Computing fourier transform of rho\n";
        }
        timer.StartTiming("rho");
        compute_rho_fourier(
            rho_function,
            y_of_logR_and_logk_spline,
            DeltaVir, 
            OmegaM, 
            xcollapse,
            fiducial_logR_array.get(),
            fiducial_logk_array.get());
        timer.EndTiming("rho");
 
        //=====================================================
        // Functions related to the mass-function
        //=====================================================
        const Func1 pdf_of_nu = [&](double nu){ 
          return halo_multiplicity_function(nu, this); 
        };
        const Func1 bias_of_nu = [&](double nu){ 
          return halo_bias_function(nu, this); 
        };
 
        //=====================================================
        // Prediction for the mass-function
        //=====================================================
        if(verbose){
          std::cout << "Computing massfunction\n";
        }
        timer.StartTiming("n");
        compute_massfunction(
            logR_of_lognu_spline, 
            lognu_of_logR_spline, 
            dndlogM_of_logM_spline,
            n_of_logM_spline,
            pdf_of_nu,
            OmegaM, 
            xcollapse);
        timer.EndTiming("n");
 
        //=====================================================
        // Prediction for the power-spectrum
        //=====================================================
        if(verbose){
          std::cout << "Computing halomodel pofk\n";
        }
        timer.StartTiming("Pofk");
        compute_one_and_two_halo_terms(
            logR_of_lognu_spline, 
            y_of_logR_and_logk_spline, 
            logDeltaHM_onehalo_of_logk_spline,
            logDeltaHM_twohalo_of_logk_spline,
            logDeltaHM_full_of_logk_spline,
            logDeltaLin_of_logk,
            pdf_of_nu,
            bias_of_nu,
            hmcode_eta,
            kmin_pofk,
            kmax_pofk,
            npts_pofk);
        timer.EndTiming("Pofk");
 
        //=====================================================
        // Process these in case of modifications
        //=====================================================
        if(hmcode or hmcode_f != 0.0 or hmcode_kstar > 0.0 or hmcode_alpha != 1.0){
          auto logk_array = logDeltaHM_onehalo_of_logk_spline.get_x_data();
          DVector logDeltaHM_onehalo_of_logk, logDeltaHM_twohalo_of_logk, logDeltaHM_full_of_logk;
          if(verbose)
            std::cout << "Adjusting haloterms: kstar = " << hmcode_kstar << " alpha = " << hmcode_alpha << " f = " << hmcode_f << "\n";
          for(auto logk : logk_array){
            const double k = std::exp(logk);
            double Delta_onehalo = std::exp(logDeltaHM_onehalo_of_logk_spline(logk));
            double Delta_twohalo = std::exp(logDeltaHM_twohalo_of_logk_spline(logk));
            double Delta_full    = std::exp(logDeltaHM_full_of_logk_spline(logk));
            double Delta_lin     = std::exp(logDeltaLin_of_logk(logk));
 
            // In HMCode we just use the linear power-spectrum as the twohalo term
            if(hmcode)
              Delta_twohalo = Delta_lin;
 
            // (BAO) damping of twohalo term
            if(hmcode_f != 0.0){
              Delta_twohalo *= std::max(1e-12,(1.0 - hmcode_f * std::pow( std::tanh(k * sigmav / std::sqrt(hmcode_f)), 2) ));
            }
 
            // Damping of onehalo term at low k
            if(hmcode_kstar > 0.0){
              double k_over_kstar = std::min(k/hmcode_kstar, 20.0);
              double factor = k_over_kstar < 1e-5 ? k_over_kstar*k_over_kstar : 1.0 - std::exp(-k_over_kstar*k_over_kstar);
              Delta_onehalo *= factor;
            }
 
            // Set a minimum value as we are going to spline the log of this shit
            if(Delta_onehalo < 1e-30) Delta_onehalo = 1e-30;
            if(Delta_twohalo < 1e-30) Delta_twohalo = 1e-30;
            if(Delta_full< 1e-30)     Delta_full = 1e-30;
 
            // Combine two terms using an l_alpha norm
            if(hmcode_alpha != 1.0)
              Delta_full = std::pow(std::pow(Delta_onehalo, hmcode_alpha) + std::pow(Delta_twohalo, hmcode_alpha), 1.0/hmcode_alpha);
            else
              Delta_full = Delta_onehalo + Delta_twohalo;
 
            logDeltaHM_onehalo_of_logk.push_back(std::log(Delta_onehalo));
            logDeltaHM_twohalo_of_logk.push_back(std::log(Delta_twohalo));
            logDeltaHM_full_of_logk.push_back(std::log(Delta_full));
          }
 
          // Remake splines
          logDeltaHM_onehalo_of_logk_spline = Spline(logk_array, logDeltaHM_onehalo_of_logk, "logDelta1h(logk)");
          logDeltaHM_twohalo_of_logk_spline = Spline(logk_array, logDeltaHM_twohalo_of_logk, "logDelta2h(logk)");
          logDeltaHM_full_of_logk_spline    = Spline(logk_array, logDeltaHM_full_of_logk, "logDelta(logk)");
        }
 
      }

◆ get_alpha_hmcode()

double FML::COSMOLOGY::HALOMODEL::HaloModel::get_alpha_hmcode ( ) const

Definition at line 1250 of file Halomodel.cpp.

                                              {
        // NB: this is only at the current redshift
        return 3.24*std::pow(1.85,neff);
      }

◆ get_cmin_hmcode()

double FML::COSMOLOGY::HALOMODEL::HaloModel::get_cmin_hmcode ( double x ) const

Definition at line 1246 of file Halomodel.cpp.

                                                                      {
        return 3.13;
      }

◆ get_deltac_hmcode()

double FML::COSMOLOGY::HALOMODEL::HaloModel::get_deltac_hmcode ( double x ) const

Definition at line 1209 of file Halomodel.cpp.

                                                       {
        double Dofx_over_Dofx_sigma = growthfactor_of_x_spline(x)/growthfactor_of_x_spline(xcollapse);
        double sigma8ofx = sigma8 * Dofx_over_Dofx_sigma;
        double OmegaMofx = spcmodel.OmegaMofx(x);
        double deltacofx = 1.59 + 0.0314*std::log(sigma8ofx);
        deltacofx *= 1.0 + 0.0123*std::log10(OmegaMofx);
        deltacofx *= (1.+0.262*fnu); 
        return deltacofx;
      }

◆ get_DeltaVir_hmcode()

double FML::COSMOLOGY::HALOMODEL::HaloModel::get_DeltaVir_hmcode ( double x ) const

Definition at line 1219 of file Halomodel.cpp.

                                                         {
        double DeltaVirofx = 418.0 * std::pow(spcmodel.OmegaMofx(x),-0.352);
        DeltaVirofx *= (1.+0.916*fnu);
        return DeltaVirofx;
      }

◆ get_eta_hmcode()

double FML::COSMOLOGY::HALOMODEL::HaloModel::get_eta_hmcode ( double x ) const

Definition at line 1225 of file Halomodel.cpp.

                                                    {
        double Dofx_over_Dofx_sigma = growthfactor_of_x_spline(x)/growthfactor_of_x_spline(xcollapse);
        double sigma8ofx = sigma8 * Dofx_over_Dofx_sigma;
        double etaofx = 0.603-0.3*sigma8ofx;
        return etaofx;
      }

◆ get_f_hmcode()

double FML::COSMOLOGY::HALOMODEL::HaloModel::get_f_hmcode ( double x ) const

Definition at line 1232 of file Halomodel.cpp.

                                                  {
        double Dofx_over_Dofx_sigma = growthfactor_of_x_spline(x)/growthfactor_of_x_spline(xcollapse);
        double sigmav100ofx = sigmav100 * Dofx_over_Dofx_sigma;
        double fofx = std::max(std::min(0.0095*std::pow(sigmav100ofx, 1.37), 0.99), 1e-3);
        return fofx;
      }

◆ get_kstar_hmcode()

double FML::COSMOLOGY::HALOMODEL::HaloModel::get_kstar_hmcode ( double x ) const

Definition at line 1239 of file Halomodel.cpp.

                                                      {
        double Dofx_over_Dofx_sigma = growthfactor_of_x_spline(x)/growthfactor_of_x_spline(xcollapse);
        double sigmavofx = sigmav * Dofx_over_Dofx_sigma;
        double kstarofx = 0.584/sigmavofx;
        return kstarofx;
      }

◆ info()

void FML::COSMOLOGY::HALOMODEL::HaloModel::info ( ) const

Definition at line 1144 of file Halomodel.cpp.

                                 {
        const bool extraverbose = true;
 
        std::cout << "\n#=====================================================\n";
        std::cout << "# Halomodel info ( z = " << (isnan(xcollapse) ?  " not yet set " : std::to_string(std::exp(-xcollapse)-1.0)) << " )\n";
        std::cout << "#=====================================================\n";
        std::cout << "# OmegaM            : " << OmegaM << "\n";
        std::cout << "# fnu               : " << fnu << "\n";
        std::cout << "# DeltaVirModifier  : " << DeltaVir_multiplier << "\n";
        std::cout << "# cofMModifier      : " << cofM_multiplier << "\n";
        std::cout << "# deltacModifier    : " << deltac_multiplier << "\n";
        std::cout << "# Massfunction      : " << halo_massfunction << "\n";
        if(halo_massfunction == "ShethTormen1999")
          std::cout << "#   with a : " << a_ST << " p : " << p_ST << "\n";
        std::cout << "# Density profile   : " << halo_profile << "\n";
        if(halo_profile == "NFW")
          std::cout << "#   with c(M)     : " << cofM_model << "\n";
        if(hmcode)
          std::cout << "# Running with HMCode settings\n";
 
        if(isnan(xcollapse)){
          // Compute sigma8 to be able to output it for debug purposes
          const Func1 logDeltaLin_of_logk = [&](double logk){
            return logDelta_of_logk_spline(logk);
          };
          Spline _logsigma_of_logR_spline;
          compute_sigma(
              logDeltaLin_of_logk,
              fourier_window_function,
              _logsigma_of_logR_spline,
              fiducial_logR_array.get(),
              fiducial_logk_array.get());
          double sigma8ic = std::exp(_logsigma_of_logR_spline(std::log(8.0)));
          std::cout << "# sigma8 of provided Plin at z = " << std::exp(-xinput_pofk)-1 << " is " << sigma8ic << "\n";
          std::cout << "# NB: compute_at_redshift has not yet been run so not much more computed\n";
          return;
        }
 
        std::cout << "# Current z         : " << std::exp(-xcollapse)-1.0 << "\n";
        std::cout << "# deltaC            : " << deltac   << "\n";
        std::cout << "# DeltaVir          : " << DeltaVir << "\n";
 
        if(xta_of_x_spline and xvir_of_x_spline and xnl_of_x_spline){
          std::cout << "# znl               : " << std::exp(-xnl_of_x_spline(xcollapse))-1.0       << "\n";
          std::cout << "# zturnaround       : " << std::exp(-xta_of_x_spline(xcollapse))-1.0       << "\n";
          std::cout << "# zvir              : " << std::exp(-xvir_of_x_spline(xcollapse))-1.0      << "\n";
        }
 
        if(logsigma_of_logR_spline)
          std::cout << "# sigma8            : " << std::exp(logsigma_of_logR_spline(std::log(8.0))) << "\n";
        std::cout << "# sigmav            : " << sigmav     << " (Mpc/h)\n";
        std::cout << "# sigmav100         : " << sigmav100  << " (Mpc/h)\n";
        std::cout << "# rnl_nu            : " << rnl_nu     << " (Mpc/h)\n";
        std::cout << "# knl_nu            : " << 1.0/rnl_nu << " (h/Mpc)\n";
        std::cout << "# neff              : " << neff       << "\n";
 
        if(extraverbose){
          spcmodel.info(); 
          timer.PrintAllTimings();
        }
      }

◆ init()

void FML::COSMOLOGY::HALOMODEL::HaloModel::init ( )

Definition at line 687 of file Halomodel.cpp.

                          {
 
        /*
        // Make a linear logR-array we can use (to ensure we have range and accuracy set just one place)
        const double Rmin = 1e-8, Rmax = 1e5;
        const int npts_R = 150 * _ACCURACY_BOOST;
        DVector logR_array = FML::MATH::linspace(std::log(Rmin), std::log(Rmax), npts_R);
        fiducial_logR_array = std::make_shared<DVector>(logR_array);
 
        // Make a linear logk-array we can use (to ensure we have range and accuracy set just one place)
        const double kmin = 1e-5, kmax = 1e6;
        const int npts_k = 150 * _ACCURACY_BOOST;
        DVector logk_array = FML::MATH::linspace(std::log(kmin), std::log(kmax), npts_k);
        fiducial_logk_array = std::make_shared<DVector>(logk_array);
        */
 
        if(verbose){
          std::cout << "\n#=====================================================\n";
          std::cout << "# Initializing the halomodel\n";
          std::cout << "#=====================================================\n";
          std::cout << "# OmegaM   " << OmegaM << "\n";
          std::cout << "# HMCode?  " << std::boolalpha << hmcode << "\n";
        }
 
        //=====================================================
        // Spherical collapse evolution
        //=====================================================
        if(not hmcode){
          if(verbose)
            std::cout << "Performing spherical collapse and computing growth\n";
          timer.StartTiming("SphericalCollapse");
 
          SphericalCollapse sc(
              spcmodel,
              verbose,
              npts_spherical_collapse,
              xini_spherical_collapse);
 
          sc.run_at_all_redshifts(
              deltac_of_x_spline,
              DeltaVir_of_x_spline,
              xta_of_x_spline,
              xnl_of_x_spline,
              xvir_of_x_spline,
              delta_ini_of_x_spline,
              growthfactor_of_x_spline,
              growthrate_of_x_spline);
 
          timer.EndTiming("SphericalCollapse");
        } else {
          if(verbose)
            std::cout << "Computing growth\n";
          FML::COSMOLOGY::SPHERICALCOLLAPSE::compute_growthfactor(
              spcmodel,
              growthfactor_of_x_spline,
              growthrate_of_x_spline);
        }
 
      }

◆ operator=()

HaloModel & FML::COSMOLOGY::HALOMODEL::HaloModel::operator= ( const HaloModel & )

default

◆ output_deltac()

void FML::COSMOLOGY::HALOMODEL::HaloModel::output_deltac	(	std::string	filename,
		double	zmin = `0.0`,
		double	zmax = `10.0`,
		int	npts_z = `100`
	)		const

Definition at line 1038 of file Halomodel.cpp.

                            {
 
        const auto x_array = FML::MATH::linspace(std::log(1.0/(1.0+zmax)), std::log(1.0/(1.0+zmin)), npts_z);;
        std::ofstream fp(filename);
 
        if(hmcode){
 
          fp << "#  z       deltaC(z)      DeltaVir(z)     kstar(z)    fdamp(z)     eta(z)     cmin(z) [HMCode]\n";
          for(const auto x : x_array){
            const double z = std::exp(-x)-1;
            fp << std::setw(10) << z                      << "  ";
            fp << std::setw(10) << get_deltac_hmcode(x)   << "  ";
            fp << std::setw(10) << get_DeltaVir_hmcode(x) << "  ";
            fp << std::setw(10) << get_kstar_hmcode(x)    << "  ";
            fp << std::setw(10) << get_f_hmcode(x)        << "  ";
            fp << std::setw(10) << get_eta_hmcode(x)      << "  ";
            fp << std::setw(10) << get_cmin_hmcode(x)     << "  ";
            fp << "\n";
 
          } 
 
        } else {
 
          fp << "#  z     deltaC(z)      DeltaVir(z)\n";
          for(const auto x : x_array){
            const double z = std::exp(-x)-1;
            fp << std::setw(10) << z                       << "  ";
            fp << std::setw(10) << deltac_of_x_spline(x)   << "  ";
            fp << std::setw(10) << DeltaVir_of_x_spline(x) << "  ";
            fp << "\n";
          }
 
        }
      }

◆ output_nofM()

void FML::COSMOLOGY::HALOMODEL::HaloModel::output_nofM	(	std::string	filename,
		double	Mmin = `1e8`,
		double	Mmax = `1e16`,
		int	npts_M = `100`
	)		const

Definition at line 1080 of file Halomodel.cpp.

                            {
        const auto logM_array = FML::MATH::linspace(std::log(Mmin), std::log(Mmax), npts_M);;
        std::ofstream fp(filename);
        fp << "#  M (Msun/h)    dlogndlogM      n (h/Mpc)^3      R (Mpc/h)    Rvir (Mpc/h)   nu  [z = " << std::to_string(std::exp(-xcollapse)-1) << "]\n";
        for(const auto logM : logM_array){
          const double M = std::exp(logM);
          const double R = RofM(M, this->OmegaM, xcollapse);
          const double Rvir = RvirofM(M, DeltaVir, this->OmegaM, xcollapse);
          const double logR = std::log(R);
          const double lognu = lognu_of_logR_spline(logR);
          const double nu = std::exp(lognu);
          const double dlogndlogM = dndlogM_of_logM_spline(logM);
          const double n = n_of_logM_spline(logM);
          fp << std::setw(10) << M          << "  ";
          fp << std::setw(10) << dlogndlogM << "  ";
          fp << std::setw(10) << n          << "  ";
          fp << std::setw(10) << R          << "  ";
          fp << std::setw(10) << Rvir       << "  ";
          fp << std::setw(10) << nu         << "  ";
          fp << "\n";
        }
      }

◆ output_pofk()

void FML::COSMOLOGY::HALOMODEL::HaloModel::output_pofk	(	std::string	filename,
		double	kmin = `1e-5`,
		double	kmax = `100`,
		int	npts_k = `1000`
	)		const

Definition at line 1110 of file Halomodel.cpp.

                            {
 
#ifdef HMCODETESTING
        Spline logDeltaNL_of_logk_spline;
        read_pofk_file("pofk_nl_hmcode.txt",logDeltaNL_of_logk_spline);
#endif
 
        //const auto logk_array = logDeltaHM_full_of_logk_spline.get_x_data();
        const auto logk_array = FML::MATH::linspace(std::log(kmin),std::log(kmax), npts_k);
        std::ofstream fp(filename);
        fp << "#  k (h/Mpc)     P_NL(k)     P_Lin(k)     P_1h(k)   P_2h(k)  (Mpc/h)^3  [z = " << std::to_string(std::exp(-xcollapse)-1) << "]\n";
        for(const auto logk : logk_array){
          const double k = std::exp(logk);
          const double Delta_over_P = 2.0 * M_PI * M_PI / (k*k*k);
          const double scaling = std::pow(growthfactor_of_x_spline(xcollapse) / growthfactor_of_x_spline(xinput_pofk), 2);
          fp << std::setw(10) << k << " ";
          fp << std::setw(10) << Delta_over_P * std::exp(logDeltaHM_full_of_logk_spline(logk))    << " ";
          fp << std::setw(10) << Delta_over_P * std::exp(logDelta_of_logk_spline(logk)) * scaling << " ";
          fp << std::setw(10) << Delta_over_P * std::exp(logDeltaHM_onehalo_of_logk_spline(logk)) << " ";
          fp << std::setw(10) << Delta_over_P * std::exp(logDeltaHM_twohalo_of_logk_spline(logk)) << " ";
#ifdef HMCODETESTING
          fp << std::exp(logDeltaHM_full_of_logk_spline(logk))/std::exp(logDeltaNL_of_logk_spline(logk)) << " ";
#endif
          fp << "\n";
        }
      }

Field Documentation

◆ a_ST

double FML::COSMOLOGY::HALOMODEL::HaloModel::a_ST = 0.707

Definition at line 100 of file Halomodel.h.

◆ A_ST

double FML::COSMOLOGY::HALOMODEL::HaloModel::A_ST = 0.2162

Definition at line 101 of file Halomodel.h.

◆ cofM_0

double FML::COSMOLOGY::HALOMODEL::HaloModel::cofM_0 = 4.75

Definition at line 131 of file Halomodel.h.

◆ cofM_beta

double FML::COSMOLOGY::HALOMODEL::HaloModel::cofM_beta = 0.13

Definition at line 133 of file Halomodel.h.

◆ cofM_M0

double FML::COSMOLOGY::HALOMODEL::HaloModel::cofM_M0 = 1e14

Definition at line 132 of file Halomodel.h.

◆ cofM_model

std::string FML::COSMOLOGY::HALOMODEL::HaloModel::cofM_model = "Bullock2001"

Definition at line 110 of file Halomodel.h.

◆ cofM_multiplier

double FML::COSMOLOGY::HALOMODEL::HaloModel::cofM_multiplier = 1.0

Definition at line 155 of file Halomodel.h.

◆ delta_ini_of_x_spline

Spline FML::COSMOLOGY::HALOMODEL::HaloModel::delta_ini_of_x_spline {"deltaini"}

Definition at line 168 of file Halomodel.h.

◆ deltac

double FML::COSMOLOGY::HALOMODEL::HaloModel::deltac {}

Definition at line 82 of file Halomodel.h.

◆ deltac_multiplier

double FML::COSMOLOGY::HALOMODEL::HaloModel::deltac_multiplier = 1.0

Definition at line 156 of file Halomodel.h.

◆ deltac_of_x_spline

Spline FML::COSMOLOGY::HALOMODEL::HaloModel::deltac_of_x_spline {"deltac"}

Definition at line 163 of file Halomodel.h.

◆ DeltaVir

double FML::COSMOLOGY::HALOMODEL::HaloModel::DeltaVir {}

Definition at line 81 of file Halomodel.h.

◆ DeltaVir_multiplier

double FML::COSMOLOGY::HALOMODEL::HaloModel::DeltaVir_multiplier = 1.0

Definition at line 154 of file Halomodel.h.

◆ DeltaVir_of_x_spline

Spline FML::COSMOLOGY::HALOMODEL::HaloModel::DeltaVir_of_x_spline {"DeltaVir"}

Definition at line 164 of file Halomodel.h.

◆ dndlogM_of_logM_spline

Spline FML::COSMOLOGY::HALOMODEL::HaloModel::dndlogM_of_logM_spline {"dndlogM"}

Definition at line 174 of file Halomodel.h.

◆ fiducial_logk_array

std::shared_ptr<DVector> FML::COSMOLOGY::HALOMODEL::HaloModel::fiducial_logk_array {nullptr}

Definition at line 147 of file Halomodel.h.

◆ fiducial_logR_array

std::shared_ptr<DVector> FML::COSMOLOGY::HALOMODEL::HaloModel::fiducial_logR_array {nullptr}

Definition at line 146 of file Halomodel.h.

◆ fnu

double FML::COSMOLOGY::HALOMODEL::HaloModel::fnu {}

Definition at line 67 of file Halomodel.h.

◆ formationredshift_of_logM_spline

Spline FML::COSMOLOGY::HALOMODEL::HaloModel::formationredshift_of_logM_spline {"zf"}

Definition at line 170 of file Halomodel.h.

◆ fourier_window_function

WindowFunction FML::COSMOLOGY::HALOMODEL::HaloModel::fourier_window_function = get_tophat_window_fourier()

Definition at line 201 of file Halomodel.h.

◆ growthfactor_of_x_spline

Spline FML::COSMOLOGY::HALOMODEL::HaloModel::growthfactor_of_x_spline {"Growthfactor"}

Definition at line 161 of file Halomodel.h.

◆ growthrate_of_x_spline

Spline FML::COSMOLOGY::HALOMODEL::HaloModel::growthrate_of_x_spline {"Growthrate"}

Definition at line 162 of file Halomodel.h.

◆ halo_bias_function

HaloBiasFunction FML::COSMOLOGY::HALOMODEL::HaloModel::halo_bias_function = get_sheth_tormen_halo_bias_function()

Definition at line 96 of file Halomodel.h.

◆ halo_density_profile

RhoFunction FML::COSMOLOGY::HALOMODEL::HaloModel::halo_density_profile = get_nfw_halo_density_profile()

Definition at line 111 of file Halomodel.h.

◆ halo_mass_concentration_relation

cofMFunction FML::COSMOLOGY::HALOMODEL::HaloModel::halo_mass_concentration_relation = get_nfw_halo_mass_concentration_relation()

Definition at line 112 of file Halomodel.h.

◆ halo_massfunction

std::string FML::COSMOLOGY::HALOMODEL::HaloModel::halo_massfunction = "ShethTormen1999"

Definition at line 94 of file Halomodel.h.

◆ halo_multiplicity_function

HaloMultiplicityFunction FML::COSMOLOGY::HALOMODEL::HaloModel::halo_multiplicity_function = get_sheth_tormen_halo_multiplicity_function()

Definition at line 95 of file Halomodel.h.

◆ halo_profile

std::string FML::COSMOLOGY::HALOMODEL::HaloModel::halo_profile = "NFW"

Definition at line 109 of file Halomodel.h.

◆ hmcode

bool FML::COSMOLOGY::HALOMODEL::HaloModel::hmcode {true}

Definition at line 124 of file Halomodel.h.

◆ hmcode_alpha

double FML::COSMOLOGY::HALOMODEL::HaloModel::hmcode_alpha = 1.0

Definition at line 127 of file Halomodel.h.

◆ hmcode_cmin

double FML::COSMOLOGY::HALOMODEL::HaloModel::hmcode_cmin = 4.0

Definition at line 129 of file Halomodel.h.

◆ hmcode_eta

double FML::COSMOLOGY::HALOMODEL::HaloModel::hmcode_eta = 0.0

Definition at line 128 of file Halomodel.h.

◆ hmcode_f

double FML::COSMOLOGY::HALOMODEL::HaloModel::hmcode_f = 0.0

Definition at line 130 of file Halomodel.h.

◆ hmcode_kstar

double FML::COSMOLOGY::HALOMODEL::HaloModel::hmcode_kstar = 0.01

Definition at line 126 of file Halomodel.h.

◆ kmax_pofk

double FML::COSMOLOGY::HALOMODEL::HaloModel::kmax_pofk = 100.0

Definition at line 118 of file Halomodel.h.

◆ kmin_pofk

double FML::COSMOLOGY::HALOMODEL::HaloModel::kmin_pofk = 1e-5

Definition at line 117 of file Halomodel.h.

◆ logDelta_of_logk_spline

Spline FML::COSMOLOGY::HALOMODEL::HaloModel::logDelta_of_logk_spline {"logDelta_lin"}

Definition at line 74 of file Halomodel.h.

◆ logDeltaHM_full_of_logk_spline

Spline FML::COSMOLOGY::HALOMODEL::HaloModel::logDeltaHM_full_of_logk_spline {"logDelta"}

Definition at line 178 of file Halomodel.h.

◆ logDeltaHM_onehalo_of_logk_spline

Spline FML::COSMOLOGY::HALOMODEL::HaloModel::logDeltaHM_onehalo_of_logk_spline {"logDelta_1h"}

Definition at line 176 of file Halomodel.h.

◆ logDeltaHM_twohalo_of_logk_spline

Spline FML::COSMOLOGY::HALOMODEL::HaloModel::logDeltaHM_twohalo_of_logk_spline {"logDelta_2h"}

Definition at line 177 of file Halomodel.h.

◆ lognu_of_logM_spline

Spline FML::COSMOLOGY::HALOMODEL::HaloModel::lognu_of_logM_spline {"lognuoflogM"}

Definition at line 172 of file Halomodel.h.

◆ lognu_of_logR_spline

Spline FML::COSMOLOGY::HALOMODEL::HaloModel::lognu_of_logR_spline {"lognuoflogR"}

Definition at line 171 of file Halomodel.h.

◆ logR_of_lognu_spline

Spline FML::COSMOLOGY::HALOMODEL::HaloModel::logR_of_lognu_spline {"logRoflognu"}

Definition at line 173 of file Halomodel.h.

◆ logsigma_of_logR_spline

Spline FML::COSMOLOGY::HALOMODEL::HaloModel::logsigma_of_logR_spline {"logsigma"}

Definition at line 169 of file Halomodel.h.

◆ n_of_logM_spline

Spline FML::COSMOLOGY::HALOMODEL::HaloModel::n_of_logM_spline {"nofM"}

Definition at line 175 of file Halomodel.h.

◆ neff

double FML::COSMOLOGY::HALOMODEL::HaloModel::neff {}

Definition at line 88 of file Halomodel.h.

◆ npts_pofk

int FML::COSMOLOGY::HALOMODEL::HaloModel::npts_pofk = 1000

Definition at line 119 of file Halomodel.h.

◆ npts_spherical_collapse

int FML::COSMOLOGY::HALOMODEL::HaloModel::npts_spherical_collapse = 1000

Definition at line 139 of file Halomodel.h.

◆ OmegaM

double FML::COSMOLOGY::HALOMODEL::HaloModel::OmegaM {}

Definition at line 66 of file Halomodel.h.

◆ p_ST

double FML::COSMOLOGY::HALOMODEL::HaloModel::p_ST = 0.3

Definition at line 99 of file Halomodel.h.

◆ rnl_nu

double FML::COSMOLOGY::HALOMODEL::HaloModel::rnl_nu {}

Definition at line 87 of file Halomodel.h.

◆ sigma8

double FML::COSMOLOGY::HALOMODEL::HaloModel::sigma8 {}

Definition at line 83 of file Halomodel.h.

◆ sigmav

double FML::COSMOLOGY::HALOMODEL::HaloModel::sigmav {}

Definition at line 84 of file Halomodel.h.

◆ sigmav100

double FML::COSMOLOGY::HALOMODEL::HaloModel::sigmav100 {}

Definition at line 85 of file Halomodel.h.

◆ spcmodel

SphericalCollapseModel FML::COSMOLOGY::HALOMODEL::HaloModel::spcmodel

Definition at line 65 of file Halomodel.h.

◆ timer

Timer FML::COSMOLOGY::HALOMODEL::HaloModel::timer

Definition at line 64 of file Halomodel.h.

◆ verbose

bool FML::COSMOLOGY::HALOMODEL::HaloModel::verbose {true}

Definition at line 125 of file Halomodel.h.

◆ xcollapse

double FML::COSMOLOGY::HALOMODEL::HaloModel::xcollapse {std::numeric_limits<double>::quiet_NaN()}

Definition at line 86 of file Halomodel.h.

◆ xini_spherical_collapse

double FML::COSMOLOGY::HALOMODEL::HaloModel::xini_spherical_collapse = std::log(1e-5)

Definition at line 138 of file Halomodel.h.

◆ xinput_pofk

double FML::COSMOLOGY::HALOMODEL::HaloModel::xinput_pofk {}

Definition at line 75 of file Halomodel.h.

◆ xnl_of_x_spline

Spline FML::COSMOLOGY::HALOMODEL::HaloModel::xnl_of_x_spline {"xnl"}

Definition at line 166 of file Halomodel.h.

◆ xta_of_x_spline

Spline FML::COSMOLOGY::HALOMODEL::HaloModel::xta_of_x_spline {"xta"}

Definition at line 165 of file Halomodel.h.

◆ xvir_of_x_spline

Spline FML::COSMOLOGY::HALOMODEL::HaloModel::xvir_of_x_spline {"xvir"}

Definition at line 167 of file Halomodel.h.

◆ y_of_logR_and_logk_spline

Spline2D FML::COSMOLOGY::HALOMODEL::HaloModel::y_of_logR_and_logk_spline {"y"}

Definition at line 179 of file Halomodel.h.

The documentation for this class was generated from the following files:

/Users/hansw/local/FML/FML/HaloModel/Halomodel.h
/Users/hansw/local/FML/FML/HaloModel/Halomodel.cpp

Public Member Functions

Data Fields

Detailed Description

Constructor & Destructor Documentation

◆ HaloModel() [1/3]

◆ HaloModel() [2/3]

◆ HaloModel() [3/3]

◆ ~HaloModel()

Member Function Documentation

◆ compute_at_redshift()

◆ get_alpha_hmcode()

◆ get_cmin_hmcode()

◆ get_deltac_hmcode()

◆ get_DeltaVir_hmcode()

◆ get_eta_hmcode()

◆ get_f_hmcode()

◆ get_kstar_hmcode()

◆ info()

◆ init()

◆ operator=()

◆ output_deltac()

◆ output_nofM()

◆ output_pofk()

Field Documentation

◆ a_ST

◆ A_ST

◆ cofM_0

◆ cofM_beta

◆ cofM_M0

◆ cofM_model

◆ cofM_multiplier

◆ delta_ini_of_x_spline

◆ deltac

◆ deltac_multiplier

◆ deltac_of_x_spline

◆ DeltaVir

◆ DeltaVir_multiplier

◆ DeltaVir_of_x_spline

◆ dndlogM_of_logM_spline

◆ fiducial_logk_array

◆ fiducial_logR_array

◆ fnu

◆ formationredshift_of_logM_spline

◆ fourier_window_function

◆ growthfactor_of_x_spline

◆ growthrate_of_x_spline

◆ halo_bias_function

◆ halo_density_profile

◆ halo_mass_concentration_relation

◆ halo_massfunction

◆ halo_multiplicity_function

◆ halo_profile

◆ hmcode

◆ hmcode_alpha

◆ hmcode_cmin

◆ hmcode_eta

◆ hmcode_f

◆ hmcode_kstar

◆ kmax_pofk

◆ kmin_pofk

◆ logDelta_of_logk_spline

◆ logDeltaHM_full_of_logk_spline

◆ logDeltaHM_onehalo_of_logk_spline

◆ logDeltaHM_twohalo_of_logk_spline

◆ lognu_of_logM_spline

◆ lognu_of_logR_spline

◆ logR_of_lognu_spline

◆ logsigma_of_logR_spline

◆ n_of_logM_spline

◆ neff

◆ npts_pofk

◆ npts_spherical_collapse

◆ OmegaM

◆ p_ST

◆ rnl_nu

◆ sigma8

◆ sigmav

◆ sigmav100

◆ spcmodel

◆ timer