mirror of
https://github.com/Richard-Sti/csiborgtools_public.git
synced 2025-05-12 05:38:42 +00:00
Plots of VF (#134)
* Add VF plots * Update nb * Add CMB velocity note * rm nb * Add option to return alllikelihood * Add simulation weights * Update nb * Add bulkflow * Update nb * Add values of beta * Update imports * Update imports * Add paths to Carrick and Lilow fiels * Add Carrick and Lilow fields * Add support for more fields * Update bulkflow comp * Update nb * Update script
This commit is contained in:
Richard Stiskalek
GitHub
parent
7dad6885e8
commit
c6f49790bf
13 changed files with 1208 additions and 2680 deletions
File diff suppressed because one or more lines are too long
|
|
@ -1,194 +0,0 @@
|
|||
# Copyright (C) 2024 Richard Stiskalek
|
||||
# This program is free software; you can redistribute it and/or modify it
|
||||
# under the terms of the GNU General Public License as published by the
|
||||
# Free Software Foundation; either version 3 of the License, or (at your
|
||||
# option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful, but
|
||||
# WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
|
||||
# Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License along
|
||||
# with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
"""Script to help with plots in `flow_calibration.ipynb`."""
|
||||
from copy import copy
|
||||
from os.path import join, exists
|
||||
|
||||
import numpy as np
|
||||
from getdist import MCSamples
|
||||
from h5py import File
|
||||
|
||||
import csiborgtools
|
||||
|
||||
|
||||
def read_samples(catalogue, simname, ksmooth, include_calibration=False,
|
||||
return_MCsamples=False, subtract_LG_velocity=-1):
|
||||
print(f"\nReading {catalogue} fitted to {simname} with ksmooth = {ksmooth}.", flush=True) # noqa
|
||||
paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring)
|
||||
nsims = paths.get_ics(simname)
|
||||
|
||||
# The last simulation was used to draw the mocks.
|
||||
if catalogue in ["CB2_small", "CB2_large"]:
|
||||
nsims = nsims[:-5]
|
||||
|
||||
FDIR_LG = "/mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/observer" # noqa
|
||||
|
||||
Vx, Vy, Vz, beta, sigma_v, alpha = [], [], [], [], [], []
|
||||
BIC, AIC, logZ, chi2 = [], [], [], []
|
||||
|
||||
if catalogue in ["LOSS", "Foundation"] or "Pantheon+" in catalogue:
|
||||
alpha_cal, beta_cal, mag_cal, e_mu_intrinsic = [], [], [], []
|
||||
elif catalogue in ["2MTF", "SFI_gals", "SFI_gals_masked"]:
|
||||
a, b, e_mu_intrinsic = [], [], []
|
||||
elif catalogue == "SFI_groups":
|
||||
h = []
|
||||
elif catalogue in ["CB2_small", "CB2_large"]:
|
||||
pass
|
||||
else:
|
||||
raise ValueError(f"Catalogue {catalogue} not recognized.")
|
||||
|
||||
fname = f"/mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/flow_samples_{catalogue}_{simname}_smooth_{ksmooth}.hdf5" # noqa
|
||||
with File(fname, 'r') as f:
|
||||
for i, nsim in enumerate(nsims):
|
||||
Vx.append(f[f"sim_{nsim}/Vext_x"][:])
|
||||
Vy.append(f[f"sim_{nsim}/Vext_y"][:])
|
||||
Vz.append(f[f"sim_{nsim}/Vext_z"][:])
|
||||
|
||||
alpha.append(f[f"sim_{nsim}/alpha"][:])
|
||||
beta.append(f[f"sim_{nsim}/beta"][:])
|
||||
sigma_v.append(f[f"sim_{nsim}/sigma_v"][:])
|
||||
|
||||
if subtract_LG_velocity >= 0:
|
||||
fname = join(FDIR_LG, f"{simname}_{nsim}_observer_velocity.npz") # noqa
|
||||
if not exists(fname):
|
||||
raise FileNotFoundError(f"File {fname} not found.")
|
||||
d = np.load(fname)
|
||||
R = d["smooth_scales"][subtract_LG_velocity]
|
||||
if i == 0:
|
||||
print(f"Subtracting LG velocity with kernel {R} Mpc / h.", flush=True) # noqa
|
||||
Vx_LG, Vy_LG, Vz_LG = d["vobs"][subtract_LG_velocity]
|
||||
if simname == "Carrick2015":
|
||||
Vx[-1] += beta[-1] * Vx_LG
|
||||
Vy[-1] += beta[-1] * Vy_LG
|
||||
Vz[-1] += beta[-1] * Vz_LG
|
||||
else:
|
||||
Vx[-1] += Vx_LG
|
||||
Vy[-1] += Vy_LG
|
||||
Vz[-1] += Vz_LG
|
||||
|
||||
BIC.append(f[f"sim_{nsim}/BIC"][...])
|
||||
AIC.append(f[f"sim_{nsim}/AIC"][...])
|
||||
logZ.append(f[f"sim_{nsim}/logZ"][...])
|
||||
try:
|
||||
chi2.append(f[f"sim_{nsim}/chi2"][...])
|
||||
except KeyError:
|
||||
chi2.append([0.])
|
||||
|
||||
if catalogue in ["LOSS", "Foundation"] or "Pantheon+" in catalogue: # noqa
|
||||
alpha_cal.append(f[f"sim_{nsim}/alpha_cal"][:])
|
||||
beta_cal.append(f[f"sim_{nsim}/beta_cal"][:])
|
||||
mag_cal.append(f[f"sim_{nsim}/mag_cal"][:])
|
||||
e_mu_intrinsic.append(f[f"sim_{nsim}/e_mu_intrinsic"][:])
|
||||
elif catalogue in ["2MTF", "SFI_gals"]:
|
||||
a.append(f[f"sim_{nsim}/a"][:])
|
||||
b.append(f[f"sim_{nsim}/b"][:])
|
||||
e_mu_intrinsic.append(f[f"sim_{nsim}/e_mu_intrinsic"][:])
|
||||
elif catalogue == "SFI_groups":
|
||||
h.append(f[f"sim_{nsim}/h"][:])
|
||||
elif catalogue in ["CB2_small", "CB2_large"]:
|
||||
pass
|
||||
else:
|
||||
raise ValueError(f"Catalogue {catalogue} not recognized.")
|
||||
|
||||
Vx, Vy, Vz, alpha, beta, sigma_v = np.hstack(Vx), np.hstack(Vy), np.hstack(Vz), np.hstack(alpha), np.hstack(beta), np.hstack(sigma_v) # noqa
|
||||
|
||||
gof = np.hstack(BIC), np.hstack(AIC), np.hstack(logZ), np.hstack(chi2)
|
||||
|
||||
if catalogue in ["LOSS", "Foundation"] or "Pantheon+" in catalogue:
|
||||
alpha_cal, beta_cal, mag_cal, e_mu_intrinsic = np.hstack(alpha_cal), np.hstack(beta_cal), np.hstack(mag_cal), np.hstack(e_mu_intrinsic) # noqa
|
||||
elif catalogue in ["2MTF", "SFI_gals", "SFI_gals_masked"]:
|
||||
a, b, e_mu_intrinsic = np.hstack(a), np.hstack(b), np.hstack(e_mu_intrinsic) # noqa
|
||||
elif catalogue == "SFI_groups":
|
||||
h = np.hstack(h)
|
||||
elif catalogue in ["CB2_small", "CB2_large"]:
|
||||
pass
|
||||
else:
|
||||
raise ValueError(f"Catalogue {catalogue} not recognized.")
|
||||
|
||||
# Calculate magnitude of V_ext
|
||||
|
||||
Vmag = np.sqrt(Vx**2 + Vy**2 + Vz**2)
|
||||
# Calculate direction in galactic coordinates of V_ext
|
||||
V = np.vstack([Vx, Vy, Vz]).T
|
||||
V = csiborgtools.cartesian_to_radec(V)
|
||||
l, b = csiborgtools.radec_to_galactic(V[:, 1], V[:, 2])
|
||||
|
||||
data = [alpha, beta, Vmag, l, b, sigma_v]
|
||||
names = ["alpha", "beta", "Vmag", "l", "b", "sigma_v"]
|
||||
|
||||
if include_calibration:
|
||||
if catalogue in ["LOSS", "Foundation"] or "Pantheon+" in catalogue:
|
||||
data += [alpha_cal, beta_cal, mag_cal, e_mu_intrinsic]
|
||||
names += ["alpha_cal", "beta_cal", "mag_cal", "e_mu_intrinsic"]
|
||||
elif catalogue in ["2MTF", "SFI_gals", "SFI_gals_masked"]:
|
||||
data += [a, b, e_mu_intrinsic]
|
||||
names += ["a", "b", "e_mu_intrinsic"]
|
||||
elif catalogue == "SFI_groups":
|
||||
data += [h]
|
||||
names += ["h"]
|
||||
else:
|
||||
raise ValueError(f"Catalogue {catalogue} not recognized.")
|
||||
|
||||
print("BIC = {:4f} +- {:4f}".format(np.mean(gof[0]), np.std(gof[0])))
|
||||
print("AIC = {:4f} +- {:4f}".format(np.mean(gof[1]), np.std(gof[1])))
|
||||
print("logZ = {:4f} +- {:4f}".format(np.mean(gof[2]), np.std(gof[2])))
|
||||
print("chi2 = {:4f} +- {:4f}".format(np.mean(gof[3]), np.std(gof[3])))
|
||||
|
||||
data = np.vstack(data).T
|
||||
|
||||
if return_MCsamples:
|
||||
simname = simname_to_pretty(simname)
|
||||
if ksmooth == 1:
|
||||
simname = fr"{simname} (2)"
|
||||
|
||||
if subtract_LG_velocity >= 0:
|
||||
simname += " (LG)"
|
||||
|
||||
label = fr"{catalogue}, {simname}, $\log \mathcal{{Z}} = {np.mean(gof[2]):.1f}$" # noqa
|
||||
|
||||
return MCSamples(samples=data, names=names,
|
||||
labels=names_to_latex(names), label=label)
|
||||
|
||||
return data, names, gof
|
||||
|
||||
|
||||
def simname_to_pretty(simname):
|
||||
ltx = {"Carrick2015": "C+15",
|
||||
"csiborg1": "CB1",
|
||||
"csiborg2_main": "CB2",
|
||||
}
|
||||
return ltx[simname] if simname in ltx else simname
|
||||
|
||||
|
||||
def names_to_latex(names, for_corner=False):
|
||||
ltx = {"alpha": "\\alpha",
|
||||
"beta": "\\beta",
|
||||
"Vmag": "V_{\\rm ext} ~ [\\mathrm{km} / \\mathrm{s}]",
|
||||
"sigma_v": "\\sigma_v ~ [\\mathrm{km} / \\mathrm{s}]",
|
||||
}
|
||||
|
||||
ltx_corner = {"alpha": r"$\alpha$",
|
||||
"beta": r"$\beta$",
|
||||
"Vmag": r"$V_{\rm ext}$",
|
||||
"sigma_v": r"$\sigma_v$",
|
||||
"h": r"$h$",
|
||||
}
|
||||
|
||||
labels = copy(names)
|
||||
for i, label in enumerate(names):
|
||||
if label in ltx:
|
||||
labels[i] = ltx_corner[label] if for_corner else ltx[label]
|
||||
|
||||
return labels
|
||||
293
notebooks/flow/flow_los.ipynb
Normal file
293
notebooks/flow/flow_los.ipynb
Normal file
|
|
@ -0,0 +1,293 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Density & velocity fields alond a LOS"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"The autoreload extension is already loaded. To reload it, use:\n",
|
||||
" %reload_ext autoreload\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# Copyright (C) 2024 Richard Stiskalek\n",
|
||||
"# This program is free software; you can redistribute it and/or modify it\n",
|
||||
"# under the terms of the GNU General Public License as published by the\n",
|
||||
"# Free Software Foundation; either version 3 of the License, or (at your\n",
|
||||
"# option) any later version.\n",
|
||||
"#\n",
|
||||
"# This program is distributed in the hope that it will be useful, but\n",
|
||||
"# WITHOUT ANY WARRANTY; without even the implied warranty of\n",
|
||||
"# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General\n",
|
||||
"# Public License for more details.\n",
|
||||
"#\n",
|
||||
"# You should have received a copy of the GNU General Public License along\n",
|
||||
"# with this program; if not, write to the Free Software Foundation, Inc.,\n",
|
||||
"# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n",
|
||||
"import numpy as np\n",
|
||||
"import matplotlib.pyplot as plt\n",
|
||||
"import jax\n",
|
||||
"from jax import numpy as jnp\n",
|
||||
"from numpyro.infer import MCMC, NUTS, init_to_median\n",
|
||||
"\n",
|
||||
"import csiborgtools\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"%load_ext autoreload\n",
|
||||
"%autoreload 2\n",
|
||||
"%matplotlib inline\n",
|
||||
"\n",
|
||||
"paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## LOS density & radial velocity plots "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"fpath = \"/mnt/extraspace/rstiskalek/catalogs/PV_compilation.hdf5\"\n",
|
||||
"\n",
|
||||
"loader_carrick = csiborgtools.flow.DataLoader(\"Carrick2015\", [0], \"LOSS\", fpath, paths, ksmooth=0, )\n",
|
||||
"# loaders_csiborg2X = [csiborgtools.flow.DataLoader(\"csiborg2X\", i, \"LOSS\", fpath, paths, ksmooth=1, verbose=False) for i in range(20)]\n",
|
||||
"# loaders_csiborg2 = [csiborgtools.flow.DataLoader(\"csiborg2_main\", i, \"LOSS\", fpath, paths, ksmooth=1, verbose=False) for i in range(20)]\n",
|
||||
"\n",
|
||||
"loader_CF4 = csiborgtools.flow.DataLoader(\"CF4gp\", [0], \"LOSS\", fpath, paths, ksmooth=0, )\n",
|
||||
"loader_lilow = csiborgtools.flow.DataLoader(\"Lilow2024\", [0], \"LOSS\", fpath, paths, ksmooth=0, )"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# ks = [i for i in range(50)]\n",
|
||||
"ks = [0,]\n",
|
||||
"\n",
|
||||
"for k in ks:\n",
|
||||
" fig, axs = plt.subplots(2, 1, figsize=(7, 7), sharex=True)\n",
|
||||
" fig.subplots_adjust(wspace=0)\n",
|
||||
" cols = plt.rcParams['axes.prop_cycle'].by_key()['color']\n",
|
||||
"\n",
|
||||
" # # CSiBORG2\n",
|
||||
" # x = loaders_csiborg2X[0].rdist\n",
|
||||
" # y = np.asarray([loaders_csiborg2[i].los_density[k, :] for i in range(len(loaders_csiborg2X))])\n",
|
||||
" # ylow, ymed, yhigh = np.percentile(y, [16, 50, 84], axis=0)\n",
|
||||
" # axs[0].fill_between(x, ylow, yhigh, color=cols[0], alpha=0.25)\n",
|
||||
" # axs[0].plot(x, ymed, color=cols[0], label=\"CSiBORG2\")\n",
|
||||
"\n",
|
||||
" # y = np.asarray([loaders_csiborg2[i].los_radial_velocity[k, :] for i in range(len(loaders_csiborg2X))])\n",
|
||||
" # ylow, ymed, yhigh = np.percentile(y, [16, 50, 84], axis=0)\n",
|
||||
" # axs[1].fill_between(x, ylow, yhigh, color=cols[0], alpha=0.25)\n",
|
||||
" # axs[1].plot(x, ymed, color=cols[0], label=\"CSiBORG2\")\n",
|
||||
"\n",
|
||||
" # # CSiBORG2X\n",
|
||||
" # x = loaders_csiborg2X[0].rdist\n",
|
||||
" # y = np.asarray([loaders_csiborg2X[i].los_density[k, :] for i in range(len(loaders_csiborg2X))])\n",
|
||||
" # ylow, ymed, yhigh = np.percentile(y, [16, 50, 84], axis=0)\n",
|
||||
" # axs[0].fill_between(x, ylow, yhigh, color=cols[1], alpha=0.25)\n",
|
||||
" # axs[0].plot(x, ymed, color=cols[1], label=\"CSiBORG2X\")\n",
|
||||
"\n",
|
||||
" # y = np.asarray([loaders_csiborg2X[i].los_radial_velocity[k, :] for i in range(len(loaders_csiborg2X))])\n",
|
||||
" # ylow, ymed, yhigh = np.percentile(y, [16, 50, 84], axis=0)\n",
|
||||
" # axs[1].fill_between(x, ylow, yhigh, color=cols[1], alpha=0.25)\n",
|
||||
" # axs[1].plot(x, ymed, color=cols[1], label=\"CSiBORG2X\")\n",
|
||||
"\n",
|
||||
" # Plot Carrick+2015\n",
|
||||
" axs[0].plot(loader_carrick.rdist, loader_carrick.los_density[0, k, :], color=\"red\", label=\"Carrick+2015\")\n",
|
||||
" axs[1].plot(loader_carrick.rdist, loader_carrick.los_radial_velocity[0, k, :] * 0.43, color=\"red\")\n",
|
||||
"\n",
|
||||
" # Plot CF4\n",
|
||||
" c = cols[4]\n",
|
||||
" axs[0].plot(loader_CF4.rdist, loader_CF4.los_density[0, k, :], color=c, label=\"CF4\")\n",
|
||||
" axs[1].plot(loader_CF4.rdist, loader_CF4.los_radial_velocity[0, k, :], color=c)\n",
|
||||
"\n",
|
||||
" # Plot Lilow2024\n",
|
||||
" c = cols[5]\n",
|
||||
" axs[0].plot(loader_lilow.rdist, loader_lilow.los_density[0, k, :], color=c, label=\"Lilow+2024\")\n",
|
||||
" axs[1].plot(loader_lilow.rdist, loader_lilow.los_radial_velocity[0, k, :], color=c)\n",
|
||||
"\n",
|
||||
"\n",
|
||||
" axs[1].set_xlabel(r\"$r ~ [\\mathrm{Mpc} / h]$\")\n",
|
||||
" axs[0].set_ylabel(r\"$\\rho_{\\rm LOS} / \\langle \\rho_{\\rm matter} \\rangle$\")\n",
|
||||
" axs[1].set_ylabel(r\"$v_{\\rm LOS} ~ [\\mathrm{km/s}]$\")\n",
|
||||
" axs[0].set_yscale(\"log\")\n",
|
||||
"\n",
|
||||
" axs[0].legend(loc=\"upper right\")\n",
|
||||
" axs[0].set_xlim(0, 200)\n",
|
||||
"\n",
|
||||
" fig.tight_layout(w_pad=0, h_pad=0)\n",
|
||||
" fig.savefig(f\"../../plots/LOSS_los_{k}.png\", dpi=500, bbox_inches=\"tight\")\n",
|
||||
"\n",
|
||||
" fig.show()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Test running a model"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 84,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"2024-06-29 19:40:25.229961: reading the catalogue,\n",
|
||||
"2024-06-29 19:40:25.243502: reading the interpolated field,\n",
|
||||
"2024-06-29 19:40:25.261423: calculating the radial velocity.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "stderr",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"/mnt/users/rstiskalek/csiborgtools/csiborgtools/flow/flow_model.py:91: UserWarning: The number of radial steps is even. Skipping the first step at 0.0 because Simpson's rule requires an odd number of steps.\n",
|
||||
" warn(f\"The number of radial steps is even. Skipping the first \"\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"fpath_data = \"/mnt/extraspace/rstiskalek/catalogs/PV_compilation.hdf5\"\n",
|
||||
"\n",
|
||||
"simname = \"Carrick2015\"\n",
|
||||
"catalogue = \"LOSS\"\n",
|
||||
"loader = csiborgtools.flow.DataLoader(simname, [0, 0], catalogue, fpath_data, paths, ksmooth=0, )\n",
|
||||
"\n",
|
||||
"SN_hyperparams = {\"e_mu_mean\": 0.1, \"e_mu_std\": 0.05,\n",
|
||||
" \"mag_cal_mean\": -18.25, \"mag_cal_std\": 0.5,\n",
|
||||
" \"alpha_cal_mean\": 0.148, \"alpha_cal_std\": 0.05,\n",
|
||||
" \"beta_cal_mean\": 3.112, \"beta_cal_std\": 1.0,\n",
|
||||
" }\n",
|
||||
"calibration_hyperparams = {\"Vext_std\": 250,\n",
|
||||
" \"alpha_mean\": 1.0, \"alpha_std\": 0.5,\n",
|
||||
" \"beta_mean\": 1.0, \"beta_std\": 0.5,\n",
|
||||
" \"sigma_v_mean\": 150., \"sigma_v_std\": 100.,\n",
|
||||
" \"sample_alpha\": True, \"sample_beta\": True,\n",
|
||||
" }\n",
|
||||
"get_model_kwargs = {\"zcmb_max\": 0.05}"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"#### Running HMC"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 85,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Selected 50/50 galaxies.\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"model = csiborgtools.flow.get_model(loader, **get_model_kwargs)\n",
|
||||
"model_kwargs = {\"distmod_hyperparams\": SN_hyperparams, \"calibration_hyperparams\": calibration_hyperparams,}"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 86,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stderr",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"sample: 100%|██████████| 1000/1000 [02:10<00:00, 7.68it/s, 7 steps of size 4.49e-01. acc. prob=0.90] \n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"\n",
|
||||
" mean std median 5.0% 95.0% n_eff r_hat\n",
|
||||
" Vext[0] -3.71 69.92 -3.04 -123.73 103.87 469.72 1.00\n",
|
||||
" Vext[1] -27.47 95.52 -30.48 -151.20 172.63 308.02 1.00\n",
|
||||
" Vext[2] -59.27 131.26 -57.79 -273.64 137.55 456.29 1.00\n",
|
||||
" alpha 1.09 0.38 1.10 0.50 1.69 400.05 1.00\n",
|
||||
" alpha_cal 0.13 0.03 0.13 0.09 0.17 558.81 1.00\n",
|
||||
" beta 0.43 0.11 0.44 0.27 0.61 341.86 1.00\n",
|
||||
" beta_cal 3.54 0.18 3.54 3.23 3.81 606.77 1.00\n",
|
||||
" e_mu 0.08 0.03 0.08 0.04 0.12 330.71 1.00\n",
|
||||
" mag_cal -18.19 0.04 -18.19 -18.25 -18.13 389.94 1.00\n",
|
||||
" sigma_v 176.93 52.05 169.93 102.74 267.56 315.30 1.00\n",
|
||||
"\n",
|
||||
"Number of divergences: 0\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"kernel = NUTS(model, init_strategy=init_to_median(num_samples=100))\n",
|
||||
"mcmc = MCMC(kernel, num_warmup=500, num_samples=500)\n",
|
||||
"\n",
|
||||
"rng_key = jax.random.PRNGKey(5)\n",
|
||||
"mcmc.run(rng_key, extra_fields=(\"potential_energy\",), **model_kwargs)\n",
|
||||
"mcmc.print_summary()\n",
|
||||
"samples = mcmc.get_samples()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "venv_csiborg",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.11.7"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 2
|
||||
}
|
||||
481
notebooks/flow/reconstruction_comparison.ipynb
Normal file
481
notebooks/flow/reconstruction_comparison.ipynb
Normal file
File diff suppressed because one or more lines are too long
230
notebooks/flow/reconstruction_comparison.py
Normal file
230
notebooks/flow/reconstruction_comparison.py
Normal file
|
|
@ -0,0 +1,230 @@
|
|||
# Copyright (C) 2024 Richard Stiskalek
|
||||
# This program is free software; you can redistribute it and/or modify it
|
||||
# under the terms of the GNU General Public License as published by the
|
||||
# Free Software Foundation; either version 3 of the License, or (at your
|
||||
# option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful, but
|
||||
# WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
|
||||
# Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License along
|
||||
# with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
"""Script to help with plots in `flow_calibration.ipynb`."""
|
||||
from copy import copy
|
||||
from os.path import join
|
||||
|
||||
import numpy as np
|
||||
from jax import numpy as jnp
|
||||
from getdist import MCSamples
|
||||
from h5py import File
|
||||
|
||||
import csiborgtools
|
||||
|
||||
|
||||
###############################################################################
|
||||
# Convert between coordinate systems #
|
||||
###############################################################################
|
||||
|
||||
|
||||
def cartesian_to_radec(x, y, z):
|
||||
d = (x**2 + y**2 + z**2)**0.5
|
||||
dec = np.arcsin(z / d)
|
||||
ra = np.arctan2(y, x)
|
||||
ra[ra < 0] += 2 * np.pi
|
||||
|
||||
ra *= 180 / np.pi
|
||||
dec *= 180 / np.pi
|
||||
|
||||
return d, ra, dec
|
||||
|
||||
|
||||
###############################################################################
|
||||
# Get the filename of the samples #
|
||||
###############################################################################
|
||||
|
||||
|
||||
def get_fname(simname, catalogue, ksmooth=0, nsim=None, sample_beta=True):
|
||||
"""Get the filename of the HDF5 file containing the posterior samples."""
|
||||
FDIR = "/mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/" # noqa
|
||||
fname = join(FDIR, f"samples_{simname}_{catalogue}_ksmooth{ksmooth}.hdf5")
|
||||
|
||||
if nsim is not None:
|
||||
fname = fname.replace(".hdf5", f"_nsim{nsim}.hdf5")
|
||||
|
||||
if sample_beta:
|
||||
fname = fname.replace(".hdf5", "_sample_beta.hdf5")
|
||||
|
||||
return fname
|
||||
|
||||
|
||||
###############################################################################
|
||||
# Convert names to LaTeX #
|
||||
###############################################################################
|
||||
|
||||
|
||||
def names_to_latex(names, for_corner=False):
|
||||
"""Convert the names of the parameters to LaTeX."""
|
||||
ltx = {"alpha": "\\alpha",
|
||||
"beta": "\\beta",
|
||||
"Vmag": "V_{\\rm ext}",
|
||||
"sigma_v": "\\sigma_v",
|
||||
"alpha_cal": "\\mathcal{A}",
|
||||
"beta_cal": "\\mathcal{B}",
|
||||
"mag_cal": "\\mathcal{M}",
|
||||
"e_mu": "\\sigma_\\mu",
|
||||
"aTF": "a_{\\rm TF}",
|
||||
"bTF": "b_{\\rm TF}",
|
||||
}
|
||||
|
||||
ltx_corner = {"alpha": r"$\alpha$",
|
||||
"beta": r"$\beta$",
|
||||
"Vmag": r"$V_{\rm ext}$",
|
||||
"l": r"$\ell_{V_{\rm ext}}$",
|
||||
"b": r"$b_{V_{\rm ext}}$",
|
||||
"sigma_v": r"$\sigma_v$",
|
||||
"alpha_cal": r"$\mathcal{A}$",
|
||||
"beta_cal": r"$\mathcal{B}$",
|
||||
"mag_cal": r"$\mathcal{M}$",
|
||||
"e_mu": r"$\sigma_\mu$",
|
||||
"aTF": r"$a_{\rm TF}$",
|
||||
"bTF": r"$b_{\rm TF}$",
|
||||
}
|
||||
|
||||
labels = copy(names)
|
||||
for i, label in enumerate(names):
|
||||
if for_corner:
|
||||
labels[i] = ltx_corner[label] if label in ltx_corner else label
|
||||
else:
|
||||
labels[i] = ltx[label] if label in ltx else label
|
||||
return labels
|
||||
|
||||
|
||||
def simname_to_pretty(simname):
|
||||
ltx = {"Carrick2015": "Carrick+15",
|
||||
"Lilow2024": "Lilow+24",
|
||||
"csiborg1": "CB1",
|
||||
"csiborg2_main": "CB2",
|
||||
"csiborg2X": "Manticore",
|
||||
}
|
||||
|
||||
if isinstance(simname, list):
|
||||
return [ltx[s] if s in ltx else s for s in simname]
|
||||
|
||||
return ltx[simname] if simname in ltx else simname
|
||||
|
||||
|
||||
###############################################################################
|
||||
# Read in goodness-of-fit #
|
||||
###############################################################################
|
||||
|
||||
def get_gof(kind, simname, catalogue, ksmooth=0, nsim=None, sample_beta=True):
|
||||
"""Read in the goodness-of-fit statistics `kind`."""
|
||||
if kind not in ["BIC", "AIC", "lnZ"]:
|
||||
raise ValueError("`kind` must be one of 'BIC', 'AIC', 'lnZ'")
|
||||
|
||||
fname = get_fname(simname, catalogue, ksmooth, nsim, sample_beta)
|
||||
with File(fname, 'r') as f:
|
||||
return f[f"gof/{kind}"][()]
|
||||
|
||||
|
||||
###############################################################################
|
||||
# Read in samples #
|
||||
###############################################################################
|
||||
|
||||
def get_samples(simname, catalogue, ksmooth=0, nsim=None, sample_beta=True,
|
||||
convert_Vext_to_galactic=True):
|
||||
"""Read in the samples from the HDF5 file."""
|
||||
fname = get_fname(simname, catalogue, ksmooth, nsim, sample_beta)
|
||||
samples = {}
|
||||
with File(fname, 'r') as f:
|
||||
grp = f["samples"]
|
||||
for key in grp.keys():
|
||||
samples[key] = grp[key][...]
|
||||
|
||||
# Rename TF parameters
|
||||
if "a" in samples:
|
||||
samples["aTF"] = samples.pop("a")
|
||||
|
||||
if "b" in samples:
|
||||
samples["bTF"] = samples.pop("b")
|
||||
|
||||
if convert_Vext_to_galactic:
|
||||
Vext = samples.pop("Vext")
|
||||
samples["Vmag"] = np.linalg.norm(Vext, axis=1)
|
||||
Vext = csiborgtools.cartesian_to_radec(Vext)
|
||||
samples["l"], samples["b"] = csiborgtools.radec_to_galactic(
|
||||
Vext[:, 1], Vext[:, 2])
|
||||
|
||||
return samples
|
||||
|
||||
|
||||
###############################################################################
|
||||
|
||||
|
||||
def get_bulkflow(simname, catalogue, ksmooth=0, nsim=None, sample_beta=True,
|
||||
convert_to_galactic=True, simulation_only=False):
|
||||
# Read in the samples
|
||||
fname_samples = get_fname(simname, catalogue, ksmooth, nsim, sample_beta)
|
||||
with File(fname_samples, 'r') as f:
|
||||
simulation_weights = jnp.exp(f["simulation_weights"][...])
|
||||
Vext = f["samples/Vext"][...]
|
||||
|
||||
try:
|
||||
beta = f["samples/beta"][...]
|
||||
except KeyError:
|
||||
beta = jnp.ones_like(simulation_weights)
|
||||
|
||||
# Read in the bulk flow
|
||||
f = np.load(f"/mnt/extraspace/rstiskalek/csiborg_postprocessing/field_shells/enclosed_mass_{simname}.npz") # noqa
|
||||
r, Bsim = f["distances"], f["cumulative_velocity"]
|
||||
|
||||
# Mask out the unconstrained large scales
|
||||
Rmax = 150 # Mpc/h
|
||||
mask = r < Rmax
|
||||
r = r[mask]
|
||||
Bsim = Bsim[:, mask, :]
|
||||
|
||||
# Add the external flow to the bulk flow and weight it
|
||||
B = Bsim[:, :, None, :] * beta[None, None, :, None] # noqa
|
||||
if not simulation_only:
|
||||
B += Vext[None, None, :, :]
|
||||
B = jnp.sum(B * simulation_weights.T[:, None, :, None], axis=0)
|
||||
|
||||
if convert_to_galactic:
|
||||
Bmag, Bl, Bb = cartesian_to_radec(B[..., 0], B[..., 1], B[..., 2])
|
||||
Bl, Bb = csiborgtools.radec_to_galactic(Bl, Bb)
|
||||
return r, np.stack([Bmag, Bl, Bb], axis=-1)
|
||||
|
||||
return r, B
|
||||
|
||||
###############################################################################
|
||||
# Prepare samples for plotting #
|
||||
###############################################################################
|
||||
|
||||
|
||||
def samples_for_corner(samples):
|
||||
if any(x.ndim > 1 for x in samples.values()):
|
||||
raise ValueError("All samples must be 1D arrays.")
|
||||
|
||||
data = np.vstack([x for x in samples.values()]).T
|
||||
labels = names_to_latex(list(samples.keys()), for_corner=True)
|
||||
|
||||
return data, labels
|
||||
|
||||
|
||||
def samples_to_getdist(samples, simname, catalogue=None):
|
||||
data, __ = samples_for_corner(samples)
|
||||
names = list(samples.keys())
|
||||
|
||||
if catalogue is None:
|
||||
label = simname_to_pretty(simname)
|
||||
else:
|
||||
label = catalogue
|
||||
|
||||
return MCSamples(
|
||||
samples=data, names=names,
|
||||
labels=names_to_latex(names, for_corner=False),
|
||||
label=label)
|
||||
|
|
@ -1,168 +0,0 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import numpy as np\n",
|
||||
"import scipy.integrate\n",
|
||||
"import symbolic_pofk.linear\n",
|
||||
"import symbolic_pofk.syrenhalofit as syrenhalofit"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 26,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def compute_sigma8_from_pk(k, pk):\n",
|
||||
" \"\"\"Given a power spectrum P(k), compute sigma8.\"\"\"\n",
|
||||
" R = 8.0\n",
|
||||
" x = k * R\n",
|
||||
" W = np.zeros(x.shape)\n",
|
||||
" m = x < 1.e-3\n",
|
||||
" W[m] = 1.0\n",
|
||||
" W[~m] =3.0 / x[~m]**3 * (np.sin(x[~m]) - x[~m] * np.cos(x[~m]))\n",
|
||||
" y = pk * W**2 * k**3\n",
|
||||
" sigma2 = scipy.integrate.simpson(y, x=np.log(x))\n",
|
||||
" sigma = np.sqrt(sigma2 / (2.0 * np.pi**2))\n",
|
||||
"\n",
|
||||
" return sigma\n",
|
||||
"\n",
|
||||
"# Cosmological parameters\n",
|
||||
"As = 2.105 # 10^9 A_s\n",
|
||||
"h = 0.6766\n",
|
||||
"Om = 0.3111\n",
|
||||
"Ob = 0.02242 / h ** 2\n",
|
||||
"ns = 0.9665\n",
|
||||
"tau = 0.0561\n",
|
||||
"\n",
|
||||
"# Define k integration range\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"def linear_sigma8(As, Om, Ob, h, ns):\n",
|
||||
" \"\"\"Calculated from Deaglan's emulator.\"\"\"\n",
|
||||
" return symbolic_pofk.linear.As_to_sigma8(As, Om, Ob, h, ns)\n",
|
||||
" # print('sigma8 from emulator', sigma8)\n",
|
||||
"\n",
|
||||
"# # Test linear sigma8\n",
|
||||
"# pk_lin = symbolic_pofk.linear.plin_emulated(k, sigma8, Om, Ob, h, ns,\n",
|
||||
"# emulator='fiducial', extrapolate=True)\n",
|
||||
"# new_sigma8 = compute_sigma8(k, pk_lin)\n",
|
||||
"# print('sigma8 from integral:', new_sigma8)\n",
|
||||
"\n",
|
||||
"# Get non-linear sigma8\n",
|
||||
"def nonlinear_sigma8(As, Om0, Ob, h, ns, ks):\n",
|
||||
" a = 1.\n",
|
||||
" sigma8 = linear_sigma8(As, Om0, Ob, h, ns) # Linear sigma8\n",
|
||||
" pk_nl = syrenhalofit.run_halofit(\n",
|
||||
" ks, sigma8, Om, Ob, h, ns, a, emulator='fiducial', extrapolate=True,\n",
|
||||
" which_params='Bartlett', add_correction=True)\n",
|
||||
" return compute_sigma8_from_pk(ks, pk_nl)\n",
|
||||
"# print('non-linear sigma8:', sigma8_nl)\n",
|
||||
"# print('sigma8 non-linear bigger by a factor', sigma8_nl / sigma8)\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 18,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"kmin, kmax, nk = 1e-4, 1e1, 256\n",
|
||||
"ks = np.logspace(np.log10(kmin), np.log10(kmax), nk) # Wavenumber"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 21,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"0.825706107176727"
|
||||
]
|
||||
},
|
||||
"execution_count": 21,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"linear_sigma8(As, Om, Ob, h, ns)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 20,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"0.9203769215120938"
|
||||
]
|
||||
},
|
||||
"execution_count": 20,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"nonlinear_sigma8(As, Om, Ob, h, ns, ks)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 25,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"2.1005829616811546e-09"
|
||||
]
|
||||
},
|
||||
"execution_count": 25,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
" 1e-10 * np.exp(3.0448)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "venv_csiborg",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.11.4"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 2
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue