From 9c1aa2642828c9ed805457a45a6d7687cf527b04 Mon Sep 17 00:00:00 2001 From: Richard Stiskalek Date: Mon, 16 Sep 2024 12:12:32 +0200 Subject: [PATCH] Attempt at absolute calibration and more (#146) * Update nb * Update defaults * Add absolute calibration to fpath * Add basic absolute calibration * Switch to log density * Feed in r directly * Add more complex spacing option * Update script * Comment out abs calibration for now * Update script * Add MB profile * Add script * Update submit for all profiles * Update * Add option * Add iterator over sims * Update defaults on alpha * Update script * Parallelise script * Switch to feasible init * Switch to median init * Add vext option * Remove file if exists * Add optional sample_Vext * Add param * rm print * Add more iterator * Update script * Update nb * Update nb --- csiborgtools/field/interp.py | 12 +- csiborgtools/flow/flow_model.py | 225 +++++++++++++++--- csiborgtools/params.py | 1 + csiborgtools/read/paths.py | 20 +- .../flow/reconstruction_comparison.ipynb | 201 ++++++++++++++-- scripts/field_prop/field_los.py | 64 +++-- scripts/field_prop/field_los.sh | 5 +- scripts/field_prop/field_los_indranil_void.py | 40 ++-- scripts/field_prop/field_los_indranil_void.sh | 32 +++ scripts/flow/flow_validation.py | 76 ++++-- scripts/flow/flow_validation.sh | 52 ++-- 11 files changed, 568 insertions(+), 160 deletions(-) create mode 100755 scripts/field_prop/field_los_indranil_void.sh diff --git a/csiborgtools/field/interp.py b/csiborgtools/field/interp.py index 432dae6..bcf3d48 100644 --- a/csiborgtools/field/interp.py +++ b/csiborgtools/field/interp.py @@ -198,7 +198,7 @@ def observer_peculiar_velocity(velocity_field, smooth_scales=None, ############################################################################### -def evaluate_los(*fields, sky_pos, boxsize, rmax, dr, smooth_scales=None, +def evaluate_los(*fields, sky_pos, boxsize, rdist, smooth_scales=None, interpolation_method="cic", verbose=False): """ Interpolate the fields for a set of lines of sights from the observer @@ -212,10 +212,8 @@ def evaluate_los(*fields, sky_pos, boxsize, rmax, dr, smooth_scales=None, Query positions in spherical coordinates (RA, dec) in degrees. boxsize : float Box size in `Mpc / h`. - rmax : float - Maximum radial distance in `Mpc / h`. - dr : float - Radial distance step in `Mpc / h`. + rdist : 1-dimensional array + Radial positions in `Mpc / h` where the fields are evaluated. smooth_scales : (list of) float, optional Smoothing scales in `Mpc / h`. interpolation_method : str, optional @@ -238,12 +236,10 @@ def evaluate_los(*fields, sky_pos, boxsize, rmax, dr, smooth_scales=None, raise ValueError("`sky_pos` must be a 2D array.") nsamples = len(sky_pos) + rmax = np.max(rdist) if interpolation_method == "cic" and rmax > 0.5 * boxsize: raise ValueError("The maximum radius must be within the box.") - # Radial positions to evaluate for each line of sight. - rdist = np.arange(0, rmax, dr, dtype=fields[0].dtype) - # Create an array of radial positions and sky coordinates of each line of # sight. pos = np.empty((nsamples * len(rdist), 3), dtype=fields[0].dtype) diff --git a/csiborgtools/flow/flow_model.py b/csiborgtools/flow/flow_model.py index 1c9d878..731f188 100644 --- a/csiborgtools/flow/flow_model.py +++ b/csiborgtools/flow/flow_model.py @@ -363,12 +363,11 @@ def predict_zobs(dist, beta, Vext_radial, vpec_radial, Omega_m): ############################################################################### -def ptilde_wo_bias(xrange, mu, err_squared, r_squared_xrange): +def log_ptilde_wo_bias(xrange, mu, err_squared, log_r_squared_xrange): """Calculate `ptilde(r)` without imhomogeneous Malmquist bias.""" - ptilde = jnp.exp(-0.5 * (xrange - mu)**2 / err_squared) - ptilde /= jnp.sqrt(2 * np.pi * err_squared) - ptilde *= r_squared_xrange - return ptilde + return (-0.5 * (xrange - mu)**2 / err_squared + - 0.5 * jnp.log(2 * np.pi * err_squared) + + log_r_squared_xrange) def likelihood_zobs(zobs, zobs_pred, e2_cz): @@ -406,8 +405,7 @@ class BaseFlowValidationModel(ABC): setattr(self, f"{name}", jnp.asarray(value)) def _set_calibration_params(self, calibration_params): - names = [] - values = [] + names, values = [], [] for key, value in calibration_params.items(): names.append(key) values.append(value) @@ -421,6 +419,28 @@ class BaseFlowValidationModel(ABC): self._setattr_as_jax(names, values) + def _set_abs_calibration_params(self, abs_calibration_params): + self.with_absolute_calibration = abs_calibration_params is not None + + if abs_calibration_params is None: + self.with_absolute_calibration = False + return + + self.calibration_distmod = jnp.asarray( + abs_calibration_params["calibration_distmod"][..., 0]) + self.calibration_edistmod = jnp.asarray( + abs_calibration_params["calibration_distmod"][..., 1]) + self.data_with_calibration = jnp.asarray( + abs_calibration_params["data_with_calibration"]) + self.data_wo_calibration = ~self.data_with_calibration + + # Calculate the log of the number of calibrators. Where there is no + # calibrator set the number of calibrators to 1 to avoid log(0) and + # this way only zeros are being added. + length_calibration = abs_calibration_params["length_calibration"] + length_calibration[length_calibration == 0] = 1 + self.log_length_calibration = jnp.log(length_calibration) + def _set_radial_spacing(self, r_xrange, Omega_m): cosmo = FlatLambdaCDM(H0=H0, Om0=Omega_m) @@ -428,21 +448,19 @@ class BaseFlowValidationModel(ABC): r2_xrange = r_xrange**2 r2_xrange /= r2_xrange.mean() self.r_xrange = r_xrange - self.r2_xrange = r2_xrange + self.log_r2_xrange = jnp.log(r2_xrange) # Require `zmin` < 0 because the first radial step is likely at 0. z_xrange = z_at_value( cosmo.comoving_distance, r_xrange * u.Mpc, zmin=-0.01) mu_xrange = cosmo.distmod(z_xrange).value + # In case the first distance is 0 and its distance modulus is infinite. + if not np.isfinite(mu_xrange[0]): + mu_xrange[0] = mu_xrange[1] - 1 + self.z_xrange = jnp.asarray(z_xrange) self.mu_xrange = jnp.asarray(mu_xrange) - # Get the stepsize, we need it to be constant for Simpson's rule. - dr = np.diff(r_xrange) - if not np.all(np.isclose(dr, dr[0], atol=1e-5)): - raise ValueError("The radial step size must be constant.") - self.dr = dr[0] - @property def ndata(self): """Number of PV objects in the catalogue.""" @@ -451,7 +469,7 @@ class BaseFlowValidationModel(ABC): @property def num_sims(self): """Number of simulations.""" - return len(self.los_density) + return len(self.log_los_density) @abstractmethod def __call__(self, **kwargs): @@ -580,26 +598,38 @@ def sample_simple(e_mu_min, e_mu_max, dmu_min, dmu_max, alpha_min, alpha_max, def sample_calibration(Vext_min, Vext_max, Vmono_min, Vmono_max, beta_min, - beta_max, sigma_v_min, sigma_v_max, sample_Vmono, - sample_beta): + beta_max, sigma_v_min, sigma_v_max, h_min, h_max, + sample_Vext, sample_Vmono, sample_beta, sample_h): """Sample the flow calibration.""" sigma_v = sample("sigma_v", Uniform(sigma_v_min, sigma_v_max)) - Vext = sample("Vext", Uniform(Vext_min, Vext_max).expand([3])) if sample_beta: beta = sample("beta", Uniform(beta_min, beta_max)) else: beta = 1.0 + if sample_Vext: + Vext = sample("Vext", Uniform(Vext_min, Vext_max).expand([3])) + else: + Vext = jnp.zeros(3) + if sample_Vmono: Vmono = sample("Vmono", Uniform(Vmono_min, Vmono_max)) else: Vmono = 0.0 + if sample_h: + h = sample("h", Uniform(h_min, h_max)) + else: + h = 1.0 + return {"Vext": Vext, "Vmono": Vmono, "sigma_v": sigma_v, - "beta": beta} + "beta": beta, + "h": h, + "sample_h": sample_h, + } ############################################################################### @@ -630,10 +660,12 @@ class PV_LogLikelihood(BaseFlowValidationModel): Observed redshifts. e_zobs : 1-dimensional array of shape (n_objects) Errors on the observed redshifts. - calibration_params: dict + calibration_params : dict Calibration parameters of each object. + abs_calibration_params : dict + Absolute calibration parameters. mag_selection : dict - Magnitude selection parameters. + Magnitude selection parameters, optional. r_xrange : 1-dimensional array Radial distances where the field was interpolated for each object. Omega_m : float @@ -645,22 +677,23 @@ class PV_LogLikelihood(BaseFlowValidationModel): """ def __init__(self, los_density, los_velocity, RA, dec, z_obs, e_zobs, - calibration_params, mag_selection, r_xrange, Omega_m, - kind, name): + calibration_params, abs_calibration_params, mag_selection, + r_xrange, Omega_m, kind, name): if e_zobs is not None: e2_cz_obs = jnp.asarray((SPEED_OF_LIGHT * e_zobs)**2) else: e2_cz_obs = jnp.zeros_like(z_obs) # Convert RA/dec to radians. - RA = np.deg2rad(RA) - dec = np.deg2rad(dec) + RA, dec = np.deg2rad(RA), np.deg2rad(dec) - names = ["los_density", "los_velocity", "RA", "dec", "z_obs", + names = ["log_los_density", "los_velocity", "RA", "dec", "z_obs", "e2_cz_obs"] - values = [los_density, los_velocity, RA, dec, z_obs, e2_cz_obs] + values = [jnp.log(los_density), los_velocity, RA, dec, z_obs, + e2_cz_obs] self._setattr_as_jax(names, values) self._set_calibration_params(calibration_params) + self._set_abs_calibration_params(abs_calibration_params) self._set_radial_spacing(r_xrange, Omega_m) self.kind = kind @@ -765,6 +798,10 @@ class PV_LogLikelihood(BaseFlowValidationModel): mu = distmod_SN( mag_true, x1_true, c_true, mag_cal, alpha_cal, beta_cal) + + if field_calibration_params["sample_h"]: + raise NotImplementedError("H0 for SN not implemented.") + elif self.kind == "TFR": a = distmod_params["a"] b = distmod_params["b"] @@ -834,6 +871,11 @@ class PV_LogLikelihood(BaseFlowValidationModel): e2_mu = jnp.ones_like(mag_true) * e_mu**2 mu = distmod_TFR(mag_true, eta_true, a, b, c) + + if field_calibration_params["sample_h"]: + raise NotImplementedError("H0 for TFR not implemented.") + # mu -= 5 * jnp.log10(field_calibration_params["h"]) + elif self.kind == "simple": dmu = distmod_params["dmu"] @@ -852,19 +894,25 @@ class PV_LogLikelihood(BaseFlowValidationModel): e2_mu = jnp.ones_like(mag_true) * e_mu**2 mu = mu_true + dmu + + if field_calibration_params["sample_h"]: + raise NotImplementedError("H0 for simple not implemented.") else: raise ValueError(f"Unknown kind: `{self.kind}`.") # Calculate p(r) (Malmquist bias). Shape is (ndata, nxrange) - ptilde = ptilde_wo_bias( + log_ptilde = log_ptilde_wo_bias( self.mu_xrange[None, :], mu[:, None], e2_mu[:, None], - self.r2_xrange[None, :]) + self.log_r2_xrange[None, :]) + # Inhomogeneous Malmquist bias. Shape is (n_sims, ndata, nxrange) alpha = distmod_params["alpha"] - ptilde = ptilde[None, ...] * self.los_density**alpha + log_ptilde = log_ptilde[None, ...] + alpha * self.log_los_density + + ptilde = jnp.exp(log_ptilde) # Normalization of p(r). Shape is (n_sims, ndata) - pnorm = simpson(ptilde, dx=self.dr, axis=-1) + pnorm = simpson(ptilde, x=self.r_xrange, axis=-1) # Calculate z_obs at each distance. Shape is (n_sims, ndata, nxrange) vrad = field_calibration_params["beta"] * self.los_velocity @@ -872,10 +920,34 @@ class PV_LogLikelihood(BaseFlowValidationModel): zobs = (1 + self.z_xrange[None, None, :]) * (1 + vrad / SPEED_OF_LIGHT) zobs -= 1. + # Shape remains (n_sims, ndata, nxrange) ptilde *= likelihood_zobs( self.z_obs[None, :, None], zobs, e2_cz[None, :, None]) - ll = jnp.log(simpson(ptilde, dx=self.dr, axis=-1)) - jnp.log(pnorm) + if self.with_absolute_calibration: + raise NotImplementedError("Absolute calibration not implemented.") + # Absolute calibration likelihood, the shape is now + # (ndata_with_calibration, ncalib, nxrange) + # ll_calibration = normal_logpdf( + # self.mu_xrange[None, None, :], + # self.calibration_distmod[..., None], + # self.calibration_edistmod[..., None]) + + # # Average the likelihood over the calibration points. The shape + # is + # # now (ndata, nxrange) + # ll_calibration = logsumexp( + # jnp.nan_to_num(ll_calibration, nan=-jnp.inf), axis=1) + # # This is the normalisation because we want the *average*. + # ll_calibration -= self.log_length_calibration[:, None] + + # ptilde = ptilde.at[:, self.data_with_calibration, :]. + # multiply(jnp.exp(ll_calibration)) + + # Integrate over the radial distance. Shape is (n_sims, ndata) + ll = jnp.log(simpson(ptilde, x=self.r_xrange, axis=-1)) + ll -= jnp.log(pnorm) + return ll0 + jnp.sum(logsumexp(ll, axis=0)) + self.norm @@ -923,7 +995,54 @@ def PV_validation_model(models, distmod_hyperparams_per_model, ############################################################################### -def get_model(loader, zcmb_min=None, zcmb_max=None, mag_selection=None): +def read_absolute_calibration(kind, data_length, calibration_fpath): + """ + Read the absolute calibration for the CF4 TFR sample from LEDA but + preprocessed by me. + + Parameters + ---------- + kind : str + Calibration kind: `Cepheids`, `TRGB`, `SBF`, ... + data_length : int + Number of samples in CF4 TFR (should be 9,788). + calibration_fpath : str + Path to the preprocessed calibration file. + + Returns + ------- + data : 3-dimensional array of shape (data_length, max_calib, 2) + Absolute calibration data. + with_calibration : 1-dimensional array of shape (data_length) + Whether the sample has a calibration. + length_calibration : 1-dimensional array of shape (data_length) + Number of calibration points per sample. + """ + data = {} + with File(calibration_fpath, 'r') as f: + for key in f[kind].keys(): + x = f[kind][key][:] + + # Get rid of points without uncertainties + x = x[~np.isnan(x[:, 1])] + + data[key] = x + + max_calib = max(len(val) for val in data.values()) + + out = np.full((data_length, max_calib, 2), np.nan) + with_calibration = np.full(data_length, False) + length_calibration = np.full(data_length, 0) + for i in data.keys(): + out[int(i), :len(data[i]), :] = data[i] + with_calibration[int(i)] = True + length_calibration[int(i)] = len(data[i]) + + return out, with_calibration, length_calibration + + +def get_model(loader, zcmb_min=None, zcmb_max=None, mag_selection=None, + absolute_calibration=None, calibration_fpath=None): """ Get a model and extract the relevant data from the loader. @@ -937,6 +1056,9 @@ def get_model(loader, zcmb_min=None, zcmb_max=None, mag_selection=None): Maximum observed redshift in the CMB frame to include. mag_selection : dict, optional Magnitude selection parameters. + add_absolute_calibration : bool, optional + Whether to add an absolute calibration for CF4 TFRs. + calibration_fpath : str, optional Returns ------- @@ -949,6 +1071,9 @@ def get_model(loader, zcmb_min=None, zcmb_max=None, mag_selection=None): los_velocity = loader.los_radial_velocity kind = loader._catname + if absolute_calibration is not None and "CF4_TFR_" not in kind: + raise ValueError("Absolute calibration supported only for the CF4 TFR sample.") # noqa + if kind in ["LOSS", "Foundation"]: keys = ["RA", "DEC", "z_CMB", "mB", "x1", "c", "e_mB", "e_x1", "e_c"] RA, dec, zCMB, mag, x1, c, e_mag, e_x1, e_c = ( @@ -963,7 +1088,8 @@ def get_model(loader, zcmb_min=None, zcmb_max=None, mag_selection=None): model = PV_LogLikelihood( los_overdensity[:, mask], los_velocity[:, mask], RA[mask], dec[mask], zCMB[mask], e_zCMB, calibration_params, - mag_selection, loader.rdist, loader._Omega_m, "SN", name=kind) + None, mag_selection, loader.rdist, loader._Omega_m, "SN", + name=kind) elif "Pantheon+" in kind: keys = ["RA", "DEC", "zCMB", "mB", "x1", "c", "biasCor_m_b", "mBERR", "x1ERR", "cERR", "biasCorErr_m_b", "zCMB_SN", "zCMB_Group", @@ -991,7 +1117,8 @@ def get_model(loader, zcmb_min=None, zcmb_max=None, mag_selection=None): model = PV_LogLikelihood( los_overdensity[:, mask], los_velocity[:, mask], RA[mask], dec[mask], zCMB[mask], e_zCMB[mask], calibration_params, - mag_selection, loader.rdist, loader._Omega_m, "SN", name=kind) + None, mag_selection, loader.rdist, loader._Omega_m, "SN", + name=kind) elif kind in ["SFI_gals", "2MTF", "SFI_gals_masked"]: keys = ["RA", "DEC", "z_CMB", "mag", "eta", "e_mag", "e_eta"] RA, dec, zCMB, mag, eta, e_mag, e_eta = (loader.cat[k] for k in keys) @@ -1001,7 +1128,7 @@ def get_model(loader, zcmb_min=None, zcmb_max=None, mag_selection=None): "e_mag": e_mag[mask], "e_eta": e_eta[mask]} model = PV_LogLikelihood( los_overdensity[:, mask], los_velocity[:, mask], - RA[mask], dec[mask], zCMB[mask], None, calibration_params, + RA[mask], dec[mask], zCMB[mask], None, calibration_params, None, mag_selection, loader.rdist, loader._Omega_m, "TFR", name=kind) elif "CF4_TFR_" in kind: # The full name can be e.g. "CF4_TFR_not2MTForSFI_i" or "CF4_TFR_i". @@ -1039,12 +1166,34 @@ def get_model(loader, zcmb_min=None, zcmb_max=None, mag_selection=None): else: mask &= Qs == 5 + # Read the absolute calibration + if absolute_calibration is not None: + CF4_length = len(RA) + distmod, with_calibration, length_calibration = read_absolute_calibration( # noqa + "Cepheids", CF4_length, calibration_fpath) + + distmod = distmod[mask] + with_calibration = with_calibration[mask] + length_calibration = length_calibration[mask] + fprint(f"found {np.sum(with_calibration)} galaxies with absolute calibration.") # noqa + + distmod = distmod[with_calibration] + length_calibration = length_calibration[with_calibration] + + abs_calibration_params = { + "calibration_distmod": distmod, + "data_with_calibration": with_calibration, + "length_calibration": length_calibration} + else: + abs_calibration_params = None + calibration_params = {"mag": mag[mask], "eta": eta[mask], "e_mag": e_mag[mask], "e_eta": e_eta[mask]} model = PV_LogLikelihood( los_overdensity[:, mask], los_velocity[:, mask], RA[mask], dec[mask], z_obs[mask], None, calibration_params, - mag_selection, loader.rdist, loader._Omega_m, "TFR", name=kind) + abs_calibration_params, mag_selection, loader.rdist, + loader._Omega_m, "TFR", name=kind) elif kind in ["CF4_GroupAll"]: # Note, this for some reason works terribly. keys = ["RA", "DE", "Vcmb", "DMzp", "eDM"] @@ -1059,7 +1208,7 @@ def get_model(loader, zcmb_min=None, zcmb_max=None, mag_selection=None): calibration_params = {"mu": mu[mask], "e_mu": e_mu[mask]} model = PV_LogLikelihood( los_overdensity[:, mask], los_velocity[:, mask], - RA[mask], dec[mask], zCMB[mask], None, calibration_params, + RA[mask], dec[mask], zCMB[mask], None, calibration_params, None, mag_selection, loader.rdist, loader._Omega_m, "simple", name=kind) else: diff --git a/csiborgtools/params.py b/csiborgtools/params.py index 99a3fe3..d9c0030 100644 --- a/csiborgtools/params.py +++ b/csiborgtools/params.py @@ -106,6 +106,7 @@ def simname2Omega_m(simname): "Lilow2024": 0.3175, "IndranilVoid_exp": 0.3, "IndranilVoid_gauss": 0.3, + "IndranilVoid_mb": 0.3, "no_field": 0.3, "CLONES": 0.307115, } diff --git a/csiborgtools/read/paths.py b/csiborgtools/read/paths.py index 491f2fb..8c0a1c0 100644 --- a/csiborgtools/read/paths.py +++ b/csiborgtools/read/paths.py @@ -129,7 +129,7 @@ class Paths: files = [0] elif "IndranilVoid" in simname: kind = simname.split("_")[-1] - if kind not in ["exp", "gauss"]: + if kind not in ["exp", "gauss", "mb"]: raise ValueError(f"Unknown void kind `{simname}`.") kind = kind.upper() @@ -649,7 +649,7 @@ class Paths: """ return self.tng300_1_dir - def field_los(self, simnname, catalogue): + def field_los(self, simname, catalogue): """ Path to the files containing the line-of-sight fields. @@ -666,13 +666,14 @@ class Paths: """ fdir = join(self.postdir, "field_los") try_create_directory(fdir) - return join(fdir, f"los_{catalogue}_{simnname}.hdf5") + return join(fdir, f"los_{catalogue}_{simname}.hdf5") def flow_validation(self, fdir, simname, catalogue, inference_method, smooth=None, nsim=None, zcmb_min=None, zcmb_max=None, mag_selection=None, sample_alpha=False, - sample_beta=False, sample_Vmono=False, - sample_mag_dipole=False, sample_curvature=False): + sample_beta=False, sample_Vext=None, + sample_Vmono=False, sample_mag_dipole=False, + sample_curvature=False, absolute_calibration=None): """Flow validation file path.""" if isinstance(catalogue, list) and len(catalogue) == 1: catalogue = catalogue[0] @@ -686,11 +687,12 @@ class Paths: fname = f"samples_{simname}_{catalogue}_{inference_method}_" keys = ["smooth", "nsim", "zcmb_min", "zcmb_max", "mag_selection", - "sample_alpha", "sample_beta", "sample_Vmono", - "sample_mag_dipole", "sample_curvature"] + "sample_alpha", "sample_beta", "sample_Vext", "sample_Vmono", + "sample_mag_dipole", "sample_curvature", + "absolute_calibration"] values = [smooth, nsim, zcmb_min, zcmb_max, mag_selection, - sample_alpha, sample_beta, sample_Vmono, sample_mag_dipole, - sample_curvature] + sample_alpha, sample_beta, sample_Vext, sample_Vmono, + sample_mag_dipole, sample_curvature, absolute_calibration] for key, value in zip(keys, values): diff --git a/notebooks/flow/reconstruction_comparison.ipynb b/notebooks/flow/reconstruction_comparison.ipynb index 3fd677d..743e05d 100644 --- a/notebooks/flow/reconstruction_comparison.ipynb +++ b/notebooks/flow/reconstruction_comparison.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -315,9 +315,76 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_Carrick2015_2MTF_mike_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 30/08/2024 15:27:56\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_Carrick2015_2MTF_mike_smooth_1_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 13/09/2024 11:32:04\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_Carrick2015_2MTF_mike_smooth_2_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 13/09/2024 11:35:10\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_Carrick2015_2MTF_mike_smooth_3_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 13/09/2024 11:35:08\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_Carrick2015_2MTF_mike_smooth_4_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 13/09/2024 11:34:31\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_Carrick2015_SFI_gals_mike_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 30/08/2024 15:28:34\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_Carrick2015_SFI_gals_mike_smooth_1_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 13/09/2024 11:37:11\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_Carrick2015_SFI_gals_mike_smooth_2_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 13/09/2024 11:39:21\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_Carrick2015_SFI_gals_mike_smooth_3_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 13/09/2024 11:41:15\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_Carrick2015_SFI_gals_mike_smooth_4_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 13/09/2024 11:43:31\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_Carrick2015_CF4_TFR_i_mike_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 12/09/2024 10:48:49\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_Carrick2015_CF4_TFR_i_mike_smooth_1_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 13/09/2024 11:44:13\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_Carrick2015_CF4_TFR_i_mike_smooth_2_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 13/09/2024 11:46:11\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_Carrick2015_CF4_TFR_i_mike_smooth_3_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 13/09/2024 11:46:57\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_Carrick2015_CF4_TFR_i_mike_smooth_4_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 13/09/2024 11:48:46\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_csiborg2_main_2MTF_mike_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 30/08/2024 12:03:40\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_csiborg2_main_2MTF_mike_smooth_1_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 13/09/2024 11:52:24\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_csiborg2_main_2MTF_mike_smooth_2_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 13/09/2024 11:53:39\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_csiborg2_main_2MTF_mike_smooth_3_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 13/09/2024 11:58:54\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_csiborg2_main_2MTF_mike_smooth_4_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 13/09/2024 11:59:21\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_csiborg2_main_SFI_gals_mike_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 30/08/2024 12:05:48\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_csiborg2_main_SFI_gals_mike_smooth_1_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 13/09/2024 12:07:50\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_csiborg2_main_SFI_gals_mike_smooth_2_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 13/09/2024 12:06:30\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_csiborg2_main_SFI_gals_mike_smooth_3_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 13/09/2024 12:06:41\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_csiborg2_main_SFI_gals_mike_smooth_4_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 13/09/2024 12:14:03\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_csiborg2_main_CF4_TFR_i_mike_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 12/09/2024 11:13:55\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_csiborg2_main_CF4_TFR_i_mike_smooth_1_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 13/09/2024 12:20:28\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_csiborg2_main_CF4_TFR_i_mike_smooth_2_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 13/09/2024 12:27:13\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_csiborg2_main_CF4_TFR_i_mike_smooth_3_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 13/09/2024 12:32:47\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_csiborg2_main_CF4_TFR_i_mike_smooth_4_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 13/09/2024 12:36:56\n" + ] + } + ], "source": [ "zcmb_max = 0.05\n", "\n", @@ -344,9 +411,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Carrick2015 2MTF 322.1943359375\n", + "Carrick2015 SFI_gals 414.5947265625\n", + "Carrick2015 CF4_TFR_i 835.421875\n", + "csiborg2_main 2MTF 760.97265625\n", + "csiborg2_main SFI_gals 800.328125\n", + "csiborg2_main CF4_TFR_i 1914.80859375\n" + ] + } + ], "source": [ "for i, simname in enumerate(sims):\n", " for j, catalogue in enumerate(catalogues):\n", @@ -355,9 +435,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "with plt.style.context('science'):\n", " plt.rcParams.update({'font.size': 9})\n", @@ -743,11 +834,66 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_Carrick2015_2MTF_bayes_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 30/08/2024 16:26:54\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_Carrick2015_SFI_gals_bayes_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 30/08/2024 16:28:43\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_Carrick2015_CF4_TFR_i_bayes_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 12/09/2024 12:20:11\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_Carrick2015_CF4_TFR_w1_bayes_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 12/09/2024 12:19:39\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_Lilow2024_2MTF_bayes_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 30/08/2024 16:27:13\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_Lilow2024_SFI_gals_bayes_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 30/08/2024 16:28:48\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_Lilow2024_CF4_TFR_i_bayes_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 12/09/2024 12:19:59\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_Lilow2024_CF4_TFR_w1_bayes_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 12/09/2024 12:26:53\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_csiborg2_main_2MTF_bayes_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 30/08/2024 16:54:29\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_csiborg2_main_SFI_gals_bayes_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 30/08/2024 17:10:19\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_csiborg2_main_CF4_TFR_i_bayes_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 12/09/2024 13:27:52\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_csiborg2_main_CF4_TFR_w1_bayes_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 12/09/2024 12:58:15\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_csiborg2X_2MTF_bayes_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 30/08/2024 16:59:53\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_csiborg2X_SFI_gals_bayes_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 30/08/2024 17:16:15\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_csiborg2X_CF4_TFR_i_bayes_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 12/09/2024 13:39:34\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_csiborg2X_CF4_TFR_w1_bayes_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 12/09/2024 13:01:55\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_CLONES_2MTF_bayes_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 12/09/2024 13:49:16\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_CLONES_SFI_gals_bayes_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 12/09/2024 13:50:20\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_CLONES_CF4_TFR_i_bayes_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 12/09/2024 13:52:12\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_CLONES_CF4_TFR_w1_bayes_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 12/09/2024 13:51:03\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_CF4_2MTF_bayes_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 30/08/2024 17:12:11\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_CF4_SFI_gals_bayes_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 12/09/2024 14:07:26\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_CF4_CF4_TFR_i_bayes_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 12/09/2024 13:23:47\n", + "File: /mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity/samples_CF4_CF4_TFR_w1_bayes_zcmb_max_0.05_sample_alpha.hdf5\n", + "Last modified: 12/09/2024 13:19:35\n" + ] + } + ], "source": [ - "sims = [\"Carrick2015\", \"Lilow2024\", \"csiborg2_main\", \"csiborg2X\"]\n", + "sims = [\"Carrick2015\", \"Lilow2024\", \"csiborg2_main\", \"csiborg2X\", \"CLONES\", \"CF4\"]\n", "# cats = [[\"LOSS\", \"Foundation\"], \"2MTF\", \"SFI_gals\", \"CF4_TFR_i\"]\n", "cats = [\"2MTF\", \"SFI_gals\", \"CF4_TFR_i\", \"CF4_TFR_w1\"]\n", "\n", @@ -775,9 +921,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "with plt.style.context('science'):\n", " plt.rcParams.update({'font.size': 9})\n", @@ -785,7 +942,7 @@ " ncols = 3\n", "\n", " figwidth = 8.3\n", - " fig, axs = plt.subplots(nrows, ncols, figsize=(figwidth, 0.75 * figwidth), sharex=True, sharey=\"col\")\n", + " fig, axs = plt.subplots(nrows, ncols, figsize=(figwidth, 1.25 * figwidth), sharex=True, )\n", " cols = plt.rcParams['axes.prop_cycle'].by_key()['color']\n", " # fig.suptitle(f\"Calibrated against {catalogue}\")\n", "\n", @@ -796,7 +953,7 @@ " for n in range(3):\n", " ylow, ymed, yhigh = np.percentile(B[..., n], [16, 50, 84], axis=-1)\n", " axs[i, n].fill_between(\n", - " r, ylow, yhigh, alpha=0.5, color=c,\n", + " r, ylow, yhigh, alpha=0.5, color=c, edgecolor=c,\n", " label=catalogue_to_pretty(catalogue) if i == 1 else None)\n", "\n", "\n", @@ -825,15 +982,15 @@ " axs[n, 2].set_ylabel(r\"$b ~ [\\mathrm{deg}]$\")\n", "\n", " for i, sim in enumerate(sims):\n", - " xpos, ypos = get_ax_centre(axs[i, 0])\n", - " fig.text(0.95, ypos, simname_to_pretty(sim),\n", - " va='center', ha='center', fontsize=9, rotation=270)\n", + " ax = axs[i, -1].twinx()\n", + " ax.set_ylabel(simname_to_pretty(sim), rotation=270, labelpad=7.5)\n", + " ax.set_yticklabels([])\n", "\n", " axs[0, 0].set_xlim(r.min(), r.max())\n", "\n", " axs[0, 0].legend()\n", " handles, labels = axs[1, 0].get_legend_handles_labels() # get the labels from the first axis\n", - " fig.legend(handles, labels, loc='upper center', bbox_to_anchor=(0.5, 1.00), ncol=len(cats) + 2)\n", + " fig.legend(handles, labels, loc='upper center', bbox_to_anchor=(0.5, 0.975), ncol=len(cats) + 2)\n", "\n", " fig.tight_layout(rect=[0, 0, 0.95, 0.95])\n", " fig.savefig(f\"../../plots/bulkflow_CMB.pdf\", dpi=450)\n", @@ -986,12 +1143,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 33, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1008,12 +1165,12 @@ "\n", " plt.figure()\n", "\n", - " sns.barplot(x=np.arange(len(catalogues)), y=bayes_factor, color=\"#21456D\")\n", + " sns.barplot(x=np.arange(len(catalogues)), y=bayes_factor / np.log(10), color=\"#21456D\")\n", " plt.xticks(\n", " np.arange(len(catalogues)),\n", " [catalogue_to_pretty(cat) for cat in catalogues],\n", " rotation=35, fontsize=\"small\", minor=False)\n", - " plt.ylabel(r\"$\\ln \\left(\\mathcal{Z}_{\\rm Manticore} / \\mathcal{Z}_{\\rm linear}\\right)$\")\n", + " plt.ylabel(r\"$\\log \\left(\\mathcal{Z}_{\\rm Manticore} / \\mathcal{Z}_{\\rm linear}\\right)$\")\n", " plt.tick_params(axis='x', which='both', bottom=False, top=False)\n", "\n", " plt.tight_layout()\n", diff --git a/scripts/field_prop/field_los.py b/scripts/field_prop/field_los.py index ade3f71..f164576 100644 --- a/scripts/field_prop/field_los.py +++ b/scripts/field_prop/field_los.py @@ -23,16 +23,19 @@ from os import makedirs, remove, rmdir from os.path import exists, join from warnings import warn -import csiborgtools import numpy as np from astropy import units as u from astropy.coordinates import SkyCoord +from astropy.cosmology import FlatLambdaCDM from astropy.io import fits from h5py import File from mpi4py import MPI from numba import jit +from scipy.interpolate import interp1d from taskmaster import work_delegation # noqa +import csiborgtools + sys.path.append("../") from utils import get_nsims # noqa @@ -41,6 +44,35 @@ from utils import get_nsims # noqa ############################################################################### +def make_spacing(rmax, dr, dense_mu_min, dense_mu_max, dmu, Om0): + """ + Make radial spacing that at low distance is with constant spacing in + distance modulus and at higher distances is with constant spacing in + comoving distance. + """ + # Create interpolant to go from distance modulus to comoving distance. + cosmo = FlatLambdaCDM(H0=100, Om0=Om0) + + z_range = np.linspace(0, 0.1, 1000000)[1:] + r_range = cosmo.comoving_distance(z_range).value + mu_range = cosmo.distmod(z_range).value + + mu2r = interp1d(mu_range, r_range, kind='cubic') + + # Create the spacing in distance modulus. + mu = np.arange(dense_mu_min, dense_mu_max, dmu) + rmin_dense = mu2r(np.min(mu)) + rmax_dense = mu2r(np.max(mu)) + + # Create the spacing in comoving distance below and above. + rlow = np.arange(0, rmin_dense, dr) + rmed = mu2r(mu) + rhigh = np.arange(rmax_dense, rmax, dr)[1:] + + # Combine the spacings. + return np.hstack([rlow, rmed, rhigh]) + + def get_los(catalogue_name, simname, comm): """ Get the line of sight RA/dec coordinates for the given catalogue. @@ -296,8 +328,8 @@ def replace_nan_with_last_finite(x, y, apply_decay): return y, rmax -def interpolate_field(pos, simname, nsim, MAS, grid, dump_folder, rmax, - dr, smooth_scales, verbose=False): +def interpolate_field(pos, simname, nsim, MAS, grid, dump_folder, r, + smooth_scales, verbose=False): """ Interpolate the density and velocity fields along the line of sight. @@ -315,10 +347,8 @@ def interpolate_field(pos, simname, nsim, MAS, grid, dump_folder, rmax, Grid resolution. dump_folder : str Folder where the temporary files are stored. - rmax : float - Maximum distance along the line of sight. - dr : float - Distance spacing along the line of sight. + r : 1-dimensional array + Radial spacing. smooth_scales : list Smoothing scales. @@ -335,7 +365,7 @@ def interpolate_field(pos, simname, nsim, MAS, grid, dump_folder, rmax, flush=True) density = get_field(simname, nsim, "density", MAS, grid) rdist, finterp = csiborgtools.field.evaluate_los( - density, sky_pos=pos, boxsize=boxsize, rmax=rmax, dr=dr, + density, sky_pos=pos, boxsize=boxsize, rdist=r, smooth_scales=smooth_scales, verbose=verbose, interpolation_method="linear") @@ -361,9 +391,8 @@ def interpolate_field(pos, simname, nsim, MAS, grid, dump_folder, rmax, velocity = get_field(simname, nsim, "velocity", MAS, grid) rdist, finterp = csiborgtools.field.evaluate_los( velocity[0], velocity[1], velocity[2], - sky_pos=pos, boxsize=boxsize, rmax=rmax, dr=dr, - smooth_scales=smooth_scales, verbose=verbose, - interpolation_method="linear") + sky_pos=pos, boxsize=boxsize, rdist=r, smooth_scales=smooth_scales, + verbose=verbose, interpolation_method="linear") rmax_velocity = np.full((3, len(pos), len(smooth_scales)), np.nan) for k in range(3): @@ -398,16 +427,15 @@ if __name__ == "__main__": parser.add_argument("--grid", type=int, help="Grid resolution.") args = parser.parse_args() - rmax = 200 - if args.catalogue == "CF4_GroupAll": - dr = 1 - else: - dr = 0.75 + Om0 = csiborgtools.simname2Omega_m(args.simname) + # r = make_spacing(200, 0.75, 23.25, 34, 0.01, Om0) + r = np.arange(0, 200, 0.75) # smooth_scales = [0, 2, 4, 6, 8] smooth_scales = [0] - print(f"Running catalogue {args.catalogue} for simulation {args.simname}.") + print(f"Running catalogue {args.catalogue} for simulation {args.simname} " + f"with {len(r)} radial points.") comm = MPI.COMM_WORLD paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring) @@ -429,7 +457,7 @@ if __name__ == "__main__": def main(nsim): interpolate_field(pos, args.simname, nsim, args.MAS, args.grid, - dump_folder, rmax, dr, smooth_scales, + dump_folder, r, smooth_scales, verbose=comm.Get_size() == 1) work_delegation(main, nsims, comm, master_verbose=True) diff --git a/scripts/field_prop/field_los.sh b/scripts/field_prop/field_los.sh index 5989a81..dc5efb7 100755 --- a/scripts/field_prop/field_los.sh +++ b/scripts/field_prop/field_los.sh @@ -19,9 +19,10 @@ fi # for simname in "csiborg1" "csiborg2_main" "csiborg2X" "Lilow2024" "Carrick2015" "CF4"; do -for simname in "CLONES"; do +for simname in "Carrick2015"; do # for catalogue in "2MTF" "SFI_gals" "CF4_TFR"; do - for catalogue in "Foundation" "2MTF" "SFI_gals" "CF4_TFR"; do + # for catalogue in "Foundation" "2MTF" "SFI_gals" "CF4_TFR"; do + for catalogue in "CF4_TFR"; do pythoncm="$env $file --catalogue $catalogue --nsims $nsims --simname $simname --MAS $MAS --grid $grid" if [ $on_login -eq 1 ]; then echo $pythoncm diff --git a/scripts/field_prop/field_los_indranil_void.py b/scripts/field_prop/field_los_indranil_void.py index b7a72a8..772e83a 100644 --- a/scripts/field_prop/field_los_indranil_void.py +++ b/scripts/field_prop/field_los_indranil_void.py @@ -12,29 +12,35 @@ # with this program; if not, write to the Free Software Foundation, Inc., # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. """Script to interpolate the Indranil void profiles for lines of sight.""" -from os.path import join +from argparse import ArgumentParser +from os.path import join, exists +from os import remove import csiborgtools import numpy as np from astropy.coordinates import SkyCoord, angular_separation +from field_los import get_los from h5py import File from mpi4py import MPI from scipy.interpolate import RegularGridInterpolator from tqdm import trange -from field_los import get_los - def interpolate_indranil_void(kind, nsims, RA, dec, rmax, dr, dump_folder, catalogue): - if kind not in ["exp", "gauss"]: + if kind not in ["exp", "gauss", "mb"]: raise ValueError(f"Unknown void kind: `{kind}`.") kind = kind.upper() fdir = join("/mnt/extraspace/rstiskalek/catalogs", "IndranilVoid", f"{kind}profile") - fname_out = join(dump_folder, f"los_{catalogue}_IndranilVoid_{kind}.hdf5") + fname_out = join( + dump_folder, f"los_{catalogue}_IndranilVoid_{kind.lower()}.hdf5") + if exists(fname_out): + print(f"Fname `{fname_out}` already exists. Removing.") + remove(fname_out) + print(f"Writing to `{fname_out}`.") for k in trange(len(nsims), desc="LG observers"): nsim = nsims[k] @@ -69,7 +75,7 @@ def interpolate_indranil_void(kind, nsims, RA, dec, rmax, dr, dump_folder, # Write the output, homogenous density. density = np.ones_like(result) - with File(fname_out, 'w') as f_out: + with File(fname_out, 'a') as f_out: f_out.create_dataset(f"rdist_{k}", data=r_eval * 0.674) f_out.create_dataset(f"density_{k}", data=density) f_out.create_dataset(f"velocity_{k}", data=result) @@ -81,19 +87,21 @@ def interpolate_indranil_void(kind, nsims, RA, dec, rmax, dr, dump_folder, if __name__ == "__main__": - kind = "gauss" + parser = ArgumentParser() + parser.add_argument("--kind", type=str, choices=["exp", "gauss", "mb"], + help="Kind of void profile.") + parser.add_argument("--catalogue", type=str, help="Catalogue name.") + args = parser.parse_args() + rmax = 165 - dr = 1 + dr = 0.75 comm = MPI.COMM_WORLD paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring) - nsims = paths.get_ics(f"IndranilVoid_{kind}") - + nsims = paths.get_ics(f"IndranilVoid_{args.kind}") out_folder = "/mnt/extraspace/rstiskalek/csiborg_postprocessing/field_los" - for catalogue in ["LOSS", "Foundation", "2MTF", "SFI_gals", "CF4_TFR"]: - print(f"Running kind `{kind}` for catalogue `{catalogue}`.") - - RA, dec = get_los(catalogue, "", comm).T - interpolate_indranil_void( - kind, nsims, RA, dec, rmax, dr, out_folder, catalogue) + print(f"Running kind `{args.kind}` for catalogue `{args.catalogue}`.") + RA, dec = get_los(args.catalogue, "", comm).T + interpolate_indranil_void( + args.kind, nsims, RA, dec, rmax, dr, out_folder, args.catalogue) diff --git a/scripts/field_prop/field_los_indranil_void.sh b/scripts/field_prop/field_los_indranil_void.sh new file mode 100755 index 0000000..e47d54b --- /dev/null +++ b/scripts/field_prop/field_los_indranil_void.sh @@ -0,0 +1,32 @@ +nthreads=1 +memory=7 +on_login=${1} +queue="berg" +env="/mnt/users/rstiskalek/csiborgtools/venv_csiborg/bin/python" +file="field_los_indranil_void.py" + + +if [ "$on_login" != "1" ] && [ "$on_login" != "0" ] +then + echo "'on_login' (1) must be either 0 or 1." + exit 1 +fi + + +for kind in "exp" "gauss" "mb"; do + for catalogue in "2MTF" "SFI_gals" "CF4_TFR"; do + pythoncm="$env $file --kind $kind --catalogue $catalogue" + + if [ $on_login -eq 1 ]; then + echo $pythoncm + eval $pythoncm + else + cm="addqueue -q $queue -n $nthreads -m $memory $pythoncm" + echo "Submitting:" + echo $cm + echo + eval $cm + fi + done +done + diff --git a/scripts/flow/flow_validation.py b/scripts/flow/flow_validation.py index 9b46cc6..36889be 100644 --- a/scripts/flow/flow_validation.py +++ b/scripts/flow/flow_validation.py @@ -22,6 +22,19 @@ from argparse import ArgumentParser, ArgumentTypeError def none_or_int(value): if value.lower() == "none": return None + + if "_" in value: + args = value.split("_") + if len(args) == 2: + k0, kf = args + dk = 1 + elif len(args) == 3: + k0, kf, dk = args + else: + raise ArgumentTypeError(f"Invalid length of arguments: `{value}`.") + + return [int(k) for k in range(int(k0), int(kf), int(dk))] + try: return int(value) except ValueError: @@ -73,17 +86,17 @@ def print_variables(names, variables): print(flush=True) -def get_models(get_model_kwargs, mag_selection, verbose=True): +def get_models(ksim, get_model_kwargs, mag_selection, verbose=True): """Load the data and create the NumPyro models.""" paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring) folder = "/mnt/extraspace/rstiskalek/catalogs/" nsims = paths.get_ics(ARGS.simname) - if ARGS.ksim is None: + if ksim is None: nsim_iterator = [i for i in range(len(nsims))] else: - nsim_iterator = [ARGS.ksim] - nsims = [nsims[ARGS.ksim]] + nsim_iterator = [ksim] + nsims = [nsims[ksim]] if verbose: print(f"{'Simulation:':<20} {ARGS.simname}") @@ -114,7 +127,7 @@ def get_models(get_model_kwargs, mag_selection, verbose=True): models[i] = csiborgtools.flow.get_model( loader, mag_selection=mag_selection[i], **get_model_kwargs) - print(f"\n{'Num. radial steps':<20} {len(loader.rdist)}\n", flush=True) + fprint(f"num. radial steps is {len(loader.rdist)}") return models @@ -143,7 +156,7 @@ def run_model(model, nsteps, nburn, model_kwargs, out_folder, raise AttributeError("The models must have an attribute `ndata` " "indicating the number of data points.") from e - nuts_kernel = NUTS(model, init_strategy=init_to_median(num_samples=1000)) + nuts_kernel = NUTS(model, init_strategy=init_to_median(num_samples=10000)) mcmc = MCMC(nuts_kernel, num_warmup=nburn, num_samples=nsteps) rng_key = jax.random.PRNGKey(42) @@ -283,11 +296,14 @@ if __name__ == "__main__": num_epochs = 50 inference_method = "mike" mag_selection = None - sample_alpha = True + sample_alpha = False if "IndranilVoid_" in ARGS.simname else True sample_beta = None + sample_Vext = None sample_Vmono = False sample_mag_dipole = False + absolute_calibration = None calculate_harmonic = False if inference_method == "bayes" else True + sample_h = True if absolute_calibration is not None else False fname_kwargs = {"inference_method": inference_method, "smooth": ARGS.ksmooth, @@ -297,8 +313,10 @@ if __name__ == "__main__": "mag_selection": mag_selection, "sample_alpha": sample_alpha, "sample_beta": sample_beta, + "sample_Vext": sample_Vext, "sample_Vmono": sample_Vmono, "sample_mag_dipole": sample_mag_dipole, + "absolute_calibration": absolute_calibration, } main_params = {"nsteps": nsteps, "nburn": nburn, @@ -310,6 +328,8 @@ if __name__ == "__main__": "num_epochs": num_epochs, "inference_method": inference_method, "sample_mag_dipole": sample_mag_dipole, + "absolute_calibration": absolute_calibration, + "sample_h": sample_h, } print_variables(main_params.keys(), main_params.values()) @@ -335,8 +355,11 @@ if __name__ == "__main__": "Vmono_min": -1000, "Vmono_max": 1000, "beta_min": -10.0, "beta_max": 10.0, "sigma_v_min": 1.0, "sigma_v_max": 750., + "h_min": 0.01, "h_max": 5.0, + "sample_Vext": True if sample_Vext is None else sample_Vext, # noqa "sample_Vmono": sample_Vmono, "sample_beta": sample_beta, + "sample_h": sample_h, } print_variables( calibration_hyperparams.keys(), calibration_hyperparams.values()) @@ -353,17 +376,34 @@ if __name__ == "__main__": ########################################################################### - get_model_kwargs = {"zcmb_min": zcmb_min, "zcmb_max": zcmb_max} - models = get_models(get_model_kwargs, mag_selection) - model_kwargs = { - "models": models, - "field_calibration_hyperparams": calibration_hyperparams, - "distmod_hyperparams_per_model": distmod_hyperparams_per_catalogue, - "inference_method": inference_method, + get_model_kwargs = { + "zcmb_min": zcmb_min, + "zcmb_max": zcmb_max, + "absolute_calibration": absolute_calibration, + "calibration_fpath": "/mnt/extraspace/rstiskalek/catalogs/PV/CF4/CF4_TF_calibration.hdf5", # noqa } - model = csiborgtools.flow.PV_validation_model + # In case we want to run multiple simulations independently. + if not isinstance(ARGS.ksim, list): + ksim_iterator = [ARGS.ksim] + else: + ksim_iterator = ARGS.ksim - run_model(model, nsteps, nburn, model_kwargs, out_folder, - calculate_harmonic, nchains_harmonic, num_epochs, kwargs_print, - fname_kwargs) + for i, ksim in enumerate(ksim_iterator): + if len(ksim_iterator) > 1: + print(f"{'Current simulation:':<20} {i + 1} ({ksim}) out of {len(ksim_iterator)}.") # noqa + + fname_kwargs["nsim"] = ksim + models = get_models(ksim, get_model_kwargs, mag_selection) + model_kwargs = { + "models": models, + "field_calibration_hyperparams": calibration_hyperparams, + "distmod_hyperparams_per_model": distmod_hyperparams_per_catalogue, + "inference_method": inference_method, + } + + model = csiborgtools.flow.PV_validation_model + + run_model(model, nsteps, nburn, model_kwargs, out_folder, + calculate_harmonic, nchains_harmonic, num_epochs, + kwargs_print, fname_kwargs) diff --git a/scripts/flow/flow_validation.sh b/scripts/flow/flow_validation.sh index c2b96bb..48dca22 100755 --- a/scripts/flow/flow_validation.sh +++ b/scripts/flow/flow_validation.sh @@ -37,42 +37,36 @@ else fi -# for simname in "CLONES"; do -# for simname in "csiborg2_main" "csiborg2X" ; do -# for simname in "carrick2015" "lilow2024" "csiborg2_main" "csiborg2x" "cf4" "clones"; do -for simname in "Carrick2015" "csiborg2_main"; do -# for simname in "Carrick2015" "csiborg2X" "csiborg2_main"; do -# for simname in "Carrick2015"; do - # for catalogue in "LOSS" "Foundation" "2MTF" "SFI_gals" "CF4_TFR_i" "CF4_TFR_w1"; do - for catalogue in "SFI_gals" "2MTF" "CF4_TFR_i"; do +for simname in "IndranilVoid_exp" "IndranilVoid_gauss" "IndranilVoid_mb"; do + # for catalogue in "2MTF" "SFI_gals" "CF4_TFR_i" "CF4_TFR_w1"; do # for catalogue in "CF4_TFR_i" "CF4_TFR_w1"; do - # for catalogue in "2MTF" "SFI" "CF4_TFR_not2MTForSFI_i"; do - # for catalogue in "2MTF" "SFI_gals" "CF4_TFR_i"; do - # for catalogue in "CF4_TFR_w1"; do - # for catalogue in "CF4_GroupAll"; do - for ksmooth in 1 2 3 4; do - for ksim in "none"; do + for catalogue in "2MTF" "SFI_gals" "CF4_TFR_i" "CF4_TFR_w1"; do + # for ksim in "none"; do + # for ksim in 0; do + # for ksim in $(seq 0 5 500); do + for ksim in "0_100_5" "100_200_5" "200_300_5" "300_400_5" "400_500_5"; do # for ksim in {0..500}; do - pythoncm="$env $file --catalogue $catalogue --simname $simname --ksim $ksim --ksmooth $ksmooth --ndevice $ndevice --device $device" + for ksmooth in 0; do + pythoncm="$env $file --catalogue $catalogue --simname $simname --ksim $ksim --ksmooth $ksmooth --ndevice $ndevice --device $device" - if [ "$on_login" == "1" ]; then - echo $pythoncm - eval $pythoncm - else - if [ "$device" == "gpu" ]; then - cm="addqueue -q $queue -s -m $memory --gpus 1 --gputype $gputype $pythoncm" + if [ "$on_login" == "1" ]; then + echo $pythoncm + eval $pythoncm else - cm="addqueue -s -q $queue -n 1 -m $memory $pythoncm" + if [ "$device" == "gpu" ]; then + cm="addqueue -q $queue -s -m $memory --gpus 1 --gputype $gputype $pythoncm" + else + cm="addqueue -s -q $queue -n 1 -m $memory $pythoncm" + fi + echo "Submitting:" + echo $cm + eval $cm fi - echo "Submitting:" - echo $cm - eval $cm - fi - echo - sleep 0.01 + echo + sleep 0.001 + done done done -done done \ No newline at end of file