From 2b938c112cb715901086cc2719783d906805bee9 Mon Sep 17 00:00:00 2001 From: Richard Stiskalek Date: Wed, 11 Sep 2024 08:45:42 +0200 Subject: [PATCH] More flow preparation & Olympics (#143) * Add more comments * Add flow paths * Simplify paths * Update default arguemnts * Update paths * Update param names * Update some of scipts for reading files * Add the Mike method option * Update plotting * Update fnames * Simplify things * Make more default options * Add print * Update * Downsample CF4 * Update numpyro selection * Add selection fitting nb * Add coeffs * Update script * Add nb * Add label * Increase number of steps * Update default params * Add more labels * Improve file name * Update nb * Fix little bug * Remove import * Update scales * Update labels * Add script * Update script * Add more * Add more labels * Add script * Add submit * Update spacing * Update submit scrips * Update script * Update defaults * Update defaults * Update nb * Update test * Update imports * Add script * Add support for Indranil void * Add a dipole * Update nb * Update submit * Update Om0 * Add final * Update default params * Fix bug * Add option to fix to LG frame * Add Vext label * Add Vext label * Update script * Rm fixed LG * rm LG stuff * Update script * Update bulk flow plotting * Update nb * Add no field option * Update defaults * Update nb * Update script * Update nb * Update nb * Add names to plots * Update nb * Update plot * Add more latex names * Update default * Update nb * Update np * Add plane slicing * Add nb with slices * Update nb * Update script * Upddate nb * Update nb --- csiborgtools/field/__init__.py | 2 +- csiborgtools/field/interp.py | 68 ++ csiborgtools/field/utils.py | 14 +- csiborgtools/flow/flow_model.py | 170 ++-- csiborgtools/flow/selection.py | 68 +- csiborgtools/params.py | 3 + csiborgtools/read/paths.py | 61 +- notebooks/flow/PV_data.ipynb | 588 ++++++++++++ .../flow/reconstruction_comparison.ipynb | 889 +++++++++++++++--- notebooks/flow/reconstruction_comparison.py | 248 +++-- notebooks/flow/reconstruction_slice.ipynb | 506 ++++++++++ notebooks/flow/selection.ipynb | 586 ++++++++++++ scripts/field_prop/clear.sh | 2 + scripts/field_prop/field_los.py | 11 +- scripts/field_prop/field_los.sh | 15 +- scripts/field_prop/field_los_indranil_void.py | 95 ++ scripts/flow/clear.sh | 2 + scripts/flow/flow_validation.py | 124 ++- scripts/flow/flow_validation.sh | 21 +- scripts/flow/test_harmonic.py | 12 +- 20 files changed, 3106 insertions(+), 379 deletions(-) create mode 100644 notebooks/flow/PV_data.ipynb create mode 100644 notebooks/flow/reconstruction_slice.ipynb create mode 100644 notebooks/flow/selection.ipynb create mode 100755 scripts/field_prop/clear.sh create mode 100644 scripts/field_prop/field_los_indranil_void.py create mode 100755 scripts/flow/clear.sh diff --git a/csiborgtools/field/__init__.py b/csiborgtools/field/__init__.py index 1570096..0625dd3 100644 --- a/csiborgtools/field/__init__.py +++ b/csiborgtools/field/__init__.py @@ -20,7 +20,7 @@ try: VelocityField, radial_velocity, power_spectrum, # noqa overdensity_field) # noqa from .interp import (evaluate_cartesian_cic, evaluate_los, field2rsp, # noqa - fill_outside, make_sky, # noqa + fill_outside, make_sky, xy_supergalactic_slice, # noqa observer_peculiar_velocity, smoothen_field, # noqa field_at_distance) # noqa except ImportError: diff --git a/csiborgtools/field/interp.py b/csiborgtools/field/interp.py index e27bea5..432dae6 100644 --- a/csiborgtools/field/interp.py +++ b/csiborgtools/field/interp.py @@ -20,6 +20,8 @@ import numpy as np import smoothing_library as SL from numba import jit from scipy.interpolate import RegularGridInterpolator +from astropy.coordinates import SkyCoord, Supergalactic, Galactic, ICRS +from astropy.coordinates import CartesianRepresentation from tqdm import tqdm from ..utils import periodic_wrap_grid, radec_to_cartesian @@ -351,6 +353,72 @@ def make_sky(field, angpos, rmax, dr, boxsize, interpolation_method="cic", return finterp +############################################################################### +# Supergalactic plane slice # +############################################################################### + + +def xy_supergalactic_slice(field, boxsize, xmin, xmax, ngrid, field_frame, + z_value=0): + """ + Create a 2D slice of a scalar field in the x-y supergalactic plane. + + Parameters + ---------- + field : 3-dimensional array of shape `(grid, grid, grid)` + Field to be interpolated. + boxsize : float + Box size in `Mpc / h`. + xmin, xmax : float + Minimum and maximum x and y values in supergalactic coordinates. + ngrid : int + Number of grid points along each axis. + field_frame : str + Frame of the field. Must be one of `galactic`, `supergalactic` or + `icrs`. + z_value : float, optional + Value of the z-coordinate in supergalactic coordinates. + + Returns + ------- + 2-dimensional array of shape `(ngrid, ngrid)` + """ + # Coordinates of the 2D slice in supergalactic coordinates + xgrid = np.linspace(xmin, xmax, ngrid) + ygrid = np.copy(xgrid) + grid = np.stack(np.meshgrid(xgrid, ygrid)) + + grid = grid.reshape(2, -1).T + grid = np.hstack([grid, np.ones(ngrid**2).reshape(-1, 1) * z_value]) + + supergalactic_coord = SkyCoord(CartesianRepresentation( + grid[:, 0], grid[:, 1], grid[:, 2]), frame=Supergalactic) + + # Create a Supergalactic SkyCoord object from Cartesian coordinates + if field_frame == "galactic": + original_frame = Galactic + elif field_frame == "supergalactic": + original_frame = Supergalactic + elif field_frame == "icrs": + original_frame = ICRS + else: + raise ValueError(f"Unknown field frame: {field_frame}") + + # Convert to field frame + coords = supergalactic_coord.transform_to(original_frame).cartesian + pos = np.stack([coords.x, coords.y, coords.z]).value + pos = pos.T + + # Convert to appropriate box units + pos /= boxsize + pos += 0.5 + + if np.any(pos <= 0) or np.any(pos >= 1): + raise ValueError("Some positions are outside the box.") + + return evaluate_cartesian_cic(field, pos=pos).reshape(ngrid, ngrid) + + ############################################################################### # Average field at a radial distance # ############################################################################### diff --git a/csiborgtools/field/utils.py b/csiborgtools/field/utils.py index 0f83c4d..e87dc97 100644 --- a/csiborgtools/field/utils.py +++ b/csiborgtools/field/utils.py @@ -17,14 +17,14 @@ Utility functions used in the rest of the `field` module to avoid circular imports. """ from numba import jit -import numpy +import numpy as np import healpy def force_single_precision(x): """Attempt to convert an array `x` to float32.""" - if x.dtype != numpy.float32: - x = x.astype(numpy.float32) + if x.dtype != np.float32: + x = x.astype(np.float32) return x @@ -46,10 +46,10 @@ def nside2radec(nside): Generate RA [0, 360] deg and declination [-90, 90] deg for HEALPix pixel centres at a given nside. """ - pixs = numpy.arange(healpy.nside2npix(nside)) + pixs = np.arange(healpy.nside2npix(nside)) theta, phi = healpy.pix2ang(nside, pixs) - ra = 180 / numpy.pi * phi - dec = 90 - 180 / numpy.pi * theta + ra = 180 / np.pi * phi + dec = 90 - 180 / np.pi * theta - return numpy.vstack([ra, dec]).T + return np.vstack([ra, dec]).T diff --git a/csiborgtools/flow/flow_model.py b/csiborgtools/flow/flow_model.py index f015480..0190433 100644 --- a/csiborgtools/flow/flow_model.py +++ b/csiborgtools/flow/flow_model.py @@ -22,6 +22,7 @@ References [1] https://arxiv.org/abs/1912.09383. """ from abc import ABC, abstractmethod +from os.path import join import numpy as np from astropy import units as u @@ -100,12 +101,17 @@ class DataLoader: d1, d2 = self._cat["RA"], self._cat["DEC"] num_sims = len(self._los_density) - radvel = np.empty((num_sims, nobject, len(self._field_rdist)), dtype) - for k in range(num_sims): - for i in range(nobject): - radvel[k, i, :] = radial_velocity_los( - self._los_velocity[k, :, i, ...], d1[i], d2[i]) - self._los_radial_velocity = radvel + if "IndranilVoid" in simname: + self._los_radial_velocity = self._los_velocity + self._los_velocity = None + else: + radvel = np.empty( + (num_sims, nobject, len(self._field_rdist)), dtype) + for k in range(num_sims): + for i in range(nobject): + radvel[k, i, :] = radial_velocity_los( + self._los_velocity[k, :, i, ...], d1[i], d2[i]) + self._los_radial_velocity = radvel if not store_full_velocity: self._los_velocity = None @@ -182,6 +188,13 @@ class DataLoader: if isinstance(ksims, int): ksims = [ksims] + # For no-field read in Carrick+2015 but then zero it. + if simname == "no_field": + simname = "Carrick2015" + to_wipe = True + else: + to_wipe = False + if not all(0 <= ksim < len(nsims) for ksim in ksims): raise ValueError(f"Invalid simulation index: `{ksims}`") @@ -189,6 +202,14 @@ class DataLoader: fpath = paths.field_los(simname, "Pantheon+") elif "CF4_TFR" in catalogue: fpath = paths.field_los(simname, "CF4_TFR") + elif "IndranilVoid" in catalogue: + fdir = "/mnt/extraspace/rstiskalek/csiborg_postprocessing/field_los" # noqa + if "exp" in catalogue: + fpath = join(fdir, "v_pec_EXP_IndranilVoid.dat") + elif "gauss" in catalogue: + fpath = join(fdir, "v_pec_GAUSS_IndranilVoid.dat") + else: + raise ValueError("Unknown `IndranilVoid` catalogue.") else: fpath = paths.field_los(simname, catalogue) @@ -212,6 +233,10 @@ class DataLoader: los_density = np.stack(los_density) los_velocity = np.stack(los_velocity) + if to_wipe: + los_density = np.ones_like(los_density) + los_velocity = np.zeros_like(los_velocity) + return rdist, los_density, los_velocity def _read_catalogue(self, catalogue, catalogue_fpath): @@ -507,22 +532,18 @@ def e2_distmod_TFR(e2_mag, e2_eta, eta, b, c, e_mu_intrinsic): def sample_TFR(e_mu_min, e_mu_max, a_mean, a_std, b_mean, b_std, c_mean, c_std, alpha_min, alpha_max, sample_alpha, - sample_curvature, a_dipole_mean, a_dipole_std, sample_a_dipole, - name): + a_dipole_mean, a_dipole_std, sample_a_dipole, name): """Sample Tully-Fisher calibration parameters.""" e_mu = sample(f"e_mu_{name}", Uniform(e_mu_min, e_mu_max)) a = sample(f"a_{name}", Normal(a_mean, a_std)) if sample_a_dipole: - ax, ay, az = sample(f"a_dipole_{name}", Normal(0, 5).expand([3])) + ax, ay, az = sample(f"a_dipole_{name}", Normal(a_dipole_mean, a_dipole_std).expand([3])) # noqa else: ax, ay, az = 0.0, 0.0, 0.0 b = sample(f"b_{name}", Normal(b_mean, b_std)) - if sample_curvature: - c = sample(f"c_{name}", Normal(c_mean, c_std)) - else: - c = 0.0 + c = sample(f"c_{name}", Normal(c_mean, c_std)) alpha = sample_alpha_bias(name, alpha_min, alpha_max, sample_alpha) @@ -571,8 +592,8 @@ 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): """Sample the flow calibration.""" - Vext = sample("Vext", Uniform(Vext_min, Vext_max).expand([3])) 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)) @@ -620,8 +641,8 @@ class PV_LogLikelihood(BaseFlowValidationModel): Errors on the observed redshifts. calibration_params: dict Calibration parameters of each object. - magmax_selection : float - Maximum magnitude selection if strict threshold. + mag_selection : dict + Magnitude selection parameters. r_xrange : 1-dimensional array Radial distances where the field was interpolated for each object. Omega_m : float @@ -630,13 +651,11 @@ class PV_LogLikelihood(BaseFlowValidationModel): Catalogue kind, either "TFR", "SN", or "simple". name : str Name of the catalogue. - toy_selection : tuple of length 3, optional - Toy magnitude selection paramers `m1`, `m2` and `a`. Optional. """ def __init__(self, los_density, los_velocity, RA, dec, z_obs, e_zobs, - calibration_params, maxmag_selection, r_xrange, Omega_m, - kind, name, toy_selection=None): + 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: @@ -657,8 +676,24 @@ class PV_LogLikelihood(BaseFlowValidationModel): self.name = name self.Omega_m = Omega_m self.norm = - self.ndata * jnp.log(self.num_sims) - self.maxmag_selection = maxmag_selection - self.toy_selection = toy_selection + + if mag_selection is not None: + self.mag_selection_kind = mag_selection["kind"] + + if self.mag_selection_kind == "hard": + self.mag_selection_max = mag_selection["coeffs"] + fprint(f"catalogue {name} with selection mmax = {self.mag_selection_max}.") # noqa + elif self.mag_selection_kind == "soft": + self.m1, self.m2, self.a = mag_selection["coeffs"] + fprint(f"catalogue {name} with selection m1 = {self.m1}, m2 = {self.m2}, a = {self.a}.") # noqa + self.log_Fm = toy_log_magnitude_selection( + self.mag, self.m1, self.m2, self.a) + else: + self.mag_selection_kind = None + + if mag_selection is not None and kind != "TFR": + raise ValueError("Magnitude selection is only implemented " + "for TFRs.") if kind == "TFR": self.mag_min, self.mag_max = jnp.min(self.mag), jnp.max(self.mag) @@ -675,23 +710,13 @@ class PV_LogLikelihood(BaseFlowValidationModel): else: raise RuntimeError("Support most be added for other kinds.") - if maxmag_selection is not None and self.maxmag_selection > self.mag_max: # noqa - raise ValueError("The maximum magnitude cannot be larger than the selection threshold.") # noqa - - if toy_selection is not None and self.maxmag_selection is not None: - raise ValueError("`toy_selection` and `maxmag_selection` cannot be used together.") # noqa - - if toy_selection is not None: - self.m1, self.m2, self.a = toy_selection - self.log_Fm = toy_log_magnitude_selection( - self.mag, self.m1, self.m2, self.a) - - if toy_selection is not None and self.kind != "TFR": - raise ValueError("Toy selection is only implemented for TFRs.") + if self.mag_selection_kind == "hard" and self.mag_selection_max > self.mag_max: # noqa + raise ValueError("The maximum magnitude cannot be larger than " + "the selection threshold.") def __call__(self, field_calibration_params, distmod_params, inference_method): - if inference_method not in ["mike", "bayes"]: + if inference_method not in ["mike", "bayes", "delta"]: raise ValueError(f"Unknown method: `{inference_method}`.") ll0 = 0.0 @@ -717,7 +742,7 @@ class PV_LogLikelihood(BaseFlowValidationModel): "c", self.name, self.c_min, self.c_max) # NOTE: that the true variables are currently uncorrelated. - with plate("true_SN", self.ndata): + with plate(f"true_SN_{self.name}", self.ndata): mag_true = sample( f"mag_true_{self.name}", Normal(mag_mean, mag_std)) x1_true = sample( @@ -726,7 +751,7 @@ class PV_LogLikelihood(BaseFlowValidationModel): f"c_true_{self.name}", Normal(c_mean, c_std)) # Log-likelihood of the observed magnitudes. - if self.maxmag_selection is None: + if self.mag_selection_kind is None: ll0 += jnp.sum(normal_logpdf( mag_true, self.mag, self.e_mag)) else: @@ -740,9 +765,12 @@ class PV_LogLikelihood(BaseFlowValidationModel): mag_true = self.mag x1_true = self.x1 c_true = self.c - e2_mu = e2_distmod_SN( - self.e2_mag, self.e2_x1, self.e2_c, alpha_cal, beta_cal, - e_mu) + if inference_method == "mike": + e2_mu = e2_distmod_SN( + self.e2_mag, self.e2_x1, self.e2_c, alpha_cal, + beta_cal, e_mu) + else: + e2_mu = jnp.ones_like(mag_true) * e_mu**2 mu = distmod_SN( mag_true, x1_true, c_true, mag_cal, alpha_cal, beta_cal) @@ -761,22 +789,25 @@ class PV_LogLikelihood(BaseFlowValidationModel): "mag", self.name, self.mag_min, self.mag_max) eta_mean, eta_std = sample_gaussian_hyperprior( "eta", self.name, self.eta_min, self.eta_max) - corr_mag_eta = sample("corr_mag_eta", Uniform(-1, 1)) + corr_mag_eta = sample( + f"corr_mag_eta_{self.name}", Uniform(-1, 1)) loc = jnp.array([mag_mean, eta_mean]) cov = jnp.array( [[mag_std**2, corr_mag_eta * mag_std * eta_std], [corr_mag_eta * mag_std * eta_std, eta_std**2]]) - with plate("true_TFR", self.ndata): - x_true = sample("x_TFR", MultivariateNormal(loc, cov)) + with plate(f"true_TFR_{self.name}", self.ndata): + x_true = sample( + f"x_TFR_{self.name}", MultivariateNormal(loc, cov)) mag_true, eta_true = x_true[..., 0], x_true[..., 1] # Log-likelihood of the observed magnitudes. - if self.maxmag_selection is not None: + if self.mag_selection_kind == "hard": ll0 += jnp.sum(upper_truncated_normal_logpdf( - self.mag, mag_true, self.e_mag, self.maxmag_selection)) - elif self.toy_selection is not None: + self.mag, mag_true, self.e_mag, + self.mag_selection_max)) + elif self.mag_selection_kind == "soft": ll_mag = self.log_Fm ll_mag += normal_logpdf(self.mag, mag_true, self.e_mag) @@ -805,8 +836,11 @@ class PV_LogLikelihood(BaseFlowValidationModel): else: eta_true = self.eta mag_true = self.mag - e2_mu = e2_distmod_TFR( - self.e2_mag, self.e2_eta, eta_true, b, c, e_mu) + if inference_method == "mike": + e2_mu = e2_distmod_TFR( + self.e2_mag, self.e2_eta, eta_true, b, c, e_mu) + else: + e2_mu = jnp.ones_like(mag_true) * e_mu**2 mu = distmod_TFR(mag_true, eta_true, a, b, c) elif self.kind == "simple": @@ -821,7 +855,10 @@ class PV_LogLikelihood(BaseFlowValidationModel): raise NotImplementedError("Bayes for simple not implemented.") else: mu_true = self.mu - e2_mu = e_mu**2 + self.e2_mu + if inference_method == "mike": + e2_mu = e_mu**2 + self.e2_mu + else: + e2_mu = jnp.ones_like(mag_true) * e_mu**2 mu = mu_true + dmu else: @@ -895,8 +932,7 @@ def PV_validation_model(models, distmod_hyperparams_per_model, ############################################################################### -def get_model(loader, zcmb_min=0.0, zcmb_max=None, maxmag_selection=None, - toy_selection=None): +def get_model(loader, zcmb_min=None, zcmb_max=None, mag_selection=None): """ Get a model and extract the relevant data from the loader. @@ -908,25 +944,20 @@ def get_model(loader, zcmb_min=0.0, zcmb_max=None, maxmag_selection=None, Minimum observed redshift in the CMB frame to include. zcmb_max : float, optional Maximum observed redshift in the CMB frame to include. - maxmag_selection : float, optional - Maximum magnitude selection threshold. - toy_selection : tuple of length 3, optional - Toy magnitude selection paramers `m1`, `m2` and `a` for TFRs of the - Boubel+24 model. + mag_selection : dict, optional + Magnitude selection parameters. Returns ------- model : NumPyro model """ + zcmb_min = 0.0 if zcmb_min is None else zcmb_min zcmb_max = np.infty if zcmb_max is None else zcmb_max los_overdensity = loader.los_density los_velocity = loader.los_radial_velocity kind = loader._catname - if maxmag_selection is not None and kind != "2MTF": - raise ValueError("Threshold magnitude selection implemented only for 2MTF.") # 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 = ( @@ -941,7 +972,7 @@ def get_model(loader, zcmb_min=0.0, zcmb_max=None, maxmag_selection=None, model = PV_LogLikelihood( los_overdensity[:, mask], los_velocity[:, mask], RA[mask], dec[mask], zCMB[mask], e_zCMB, calibration_params, - maxmag_selection, loader.rdist, loader._Omega_m, "SN", name=kind) + 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", @@ -969,25 +1000,18 @@ def get_model(loader, zcmb_min=0.0, zcmb_max=None, maxmag_selection=None, model = PV_LogLikelihood( los_overdensity[:, mask], los_velocity[:, mask], RA[mask], dec[mask], zCMB[mask], e_zCMB[mask], calibration_params, - maxmag_selection, loader.rdist, loader._Omega_m, "SN", name=kind) + 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) - if kind == "SFI_gals" and toy_selection is not None: - if len(toy_selection) != 3: - raise ValueError("Toy selection must be a tuple with 3 elements.") # noqa - m1, m2, a = toy_selection - fprint(f"using toy selection with m1 = {m1}, m2 = {m2}, a = {a}.") - mask = (zCMB < zcmb_max) & (zCMB > zcmb_min) 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], zCMB[mask], None, calibration_params, - maxmag_selection, loader.rdist, loader._Omega_m, "TFR", name=kind, - toy_selection=toy_selection) + 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". band = kind.split("_")[-1] @@ -1001,7 +1025,7 @@ def get_model(loader, zcmb_min=0.0, zcmb_max=None, maxmag_selection=None, not_matched_to_2MTF_or_SFI = not_matched_to_2MTF_or_SFI.astype(bool) # NOTE: fiducial uncertainty until we can get the actual values. - e_mag = 0.001 * np.ones_like(mag) + e_mag = 0.05 * np.ones_like(mag) z_obs /= SPEED_OF_LIGHT eta -= 2.5 @@ -1026,7 +1050,7 @@ def get_model(loader, zcmb_min=0.0, zcmb_max=None, maxmag_selection=None, model = PV_LogLikelihood( los_overdensity[:, mask], los_velocity[:, mask], RA[mask], dec[mask], z_obs[mask], None, calibration_params, - maxmag_selection, loader.rdist, loader._Omega_m, "TFR", name=kind) + 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"] @@ -1042,7 +1066,7 @@ def get_model(loader, zcmb_min=0.0, zcmb_max=None, maxmag_selection=None, model = PV_LogLikelihood( los_overdensity[:, mask], los_velocity[:, mask], RA[mask], dec[mask], zCMB[mask], None, calibration_params, - maxmag_selection, loader.rdist, loader._Omega_m, "simple", + mag_selection, loader.rdist, loader._Omega_m, "simple", name=kind) else: raise ValueError(f"Catalogue `{kind}` not recognized.") diff --git a/csiborgtools/flow/selection.py b/csiborgtools/flow/selection.py index 9fb3a58..ad9ec7f 100644 --- a/csiborgtools/flow/selection.py +++ b/csiborgtools/flow/selection.py @@ -13,56 +13,64 @@ # with this program; if not, write to the Free Software Foundation, Inc., # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. """Selection functions for peculiar velocities.""" -import numpy as np from jax import numpy as jnp -from scipy.integrate import quad -from scipy.optimize import minimize +from numpyro import factor, sample +from numpyro.distributions import Normal, Uniform +from quadax import simpson class ToyMagnitudeSelection: """ - Toy magnitude selection according to Boubel et al 2024. + Toy magnitude selection according to Boubel+2024 [1]. + + References + ---------- + [1] https://www.arxiv.org/abs/2408.03660 """ def __init__(self): - pass + self.mrange = jnp.linspace(0, 25, 1000) - def log_true_pdf(self, m, m1): + def log_true_pdf(self, m, alpha, m1): """Unnormalized `true' PDF.""" - return 0.6 * (m - m1) + return alpha * (m - m1) def log_selection_function(self, m, m1, m2, a): - return np.where(m <= m1, - 0, - a * (m - m2)**2 - a * (m1 - m2)**2 - 0.6 * (m - m1)) + """Logarithm of the Boubel+2024 selection function.""" + return jnp.where(m <= m1, + 0, + a * (m - m2)**2 - a * (m1 - m2)**2 - 0.6 * (m - m1)) - def log_observed_pdf(self, m, m1, m2, a): - # Calculate the normalization constant - f = lambda m: 10**(self.log_true_pdf(m, m1) # noqa - + self.log_selection_function(m, m1, m2, a)) - mmin, mmax = 0, 25 - norm = quad(f, mmin, mmax)[0] + def log_observed_pdf(self, m, alpha, m1, m2, a): + """ + Logarithm of the unnormalized observed PDF, which is the product + of the true PDF and the selection function. + """ + y = 10**(self.log_true_pdf(self.mrange, alpha, m1) + + self.log_selection_function(self.mrange, m1, m2, a) + ) + norm = simpson(y, x=self.mrange) - return (self.log_true_pdf(m, m1) + return (self.log_true_pdf(m, alpha, m1) + self.log_selection_function(m, m1, m2, a) - - np.log10(norm)) + - jnp.log10(norm)) - def fit(self, mag): + def __call__(self, mag): + """NumPyro model, uses an informative prior on `alpha`.""" + alpha = sample("alpha", Normal(0.6, 0.1)) + m1 = sample("m1", Uniform(0, 25)) + m2 = sample("m2", Uniform(0, 25)) + a = sample("a", Uniform(-10, 0)) - def loss(x): - m1, m2, a = x - - if a >= 0: - return np.inf - - return -np.sum(self.log_observed_pdf(mag, m1, m2, a)) - - x0 = [12.0, 12.5, -0.1] - return minimize(loss, x0, method="Nelder-Mead") + ll = jnp.sum(self.log_observed_pdf(mag, alpha, m1, m2, a)) + factor("ll", ll) def toy_log_magnitude_selection(mag, m1, m2, a): - """JAX implementation of `ToyMagnitudeSelection` but natural logarithm.""" + """ + JAX implementation of `ToyMagnitudeSelection` but natural logarithm, + whereas the one in `ToyMagnitudeSelection` is base 10. + """ return jnp.log(10) * jnp.where( mag <= m1, 0, diff --git a/csiborgtools/params.py b/csiborgtools/params.py index 8ecf05f..7cf8fe9 100644 --- a/csiborgtools/params.py +++ b/csiborgtools/params.py @@ -103,6 +103,9 @@ def simname2Omega_m(simname): "CF4": 0.3, "CF4gp": 0.3, "Lilow2024": 0.3175, + "IndranilVoid_exp": 0.3, + "IndranilVoid_gauss": 0.3, + "no_field": 0.3, } omega_m = d.get(simname, None) diff --git a/csiborgtools/read/paths.py b/csiborgtools/read/paths.py index a66c1a3..8f15032 100644 --- a/csiborgtools/read/paths.py +++ b/csiborgtools/read/paths.py @@ -15,11 +15,12 @@ """ CSiBORG paths manager. """ +import datetime from glob import glob -from os import makedirs, listdir -from os.path import isdir, join -from warnings import warn +from os import listdir, makedirs +from os.path import exists, getmtime, isdir, join from re import search +from warnings import warn import numpy @@ -117,15 +118,15 @@ class Paths: files = glob(join(self.quijote_dir, "fiducial_processed", "chain_*")) files = [int(search(r'chain_(\d+)', f).group(1)) for f in files] - elif simname == "Carrick2015": - return [0] elif simname == "CF4": files = glob(join(self.CF4_dir, "CF4_new_128-z008_realization*_delta.fits")) # noqa files = [search(r'realization(\d+)_delta\.fits', file).group(1) for file in files if search(r'realization(\d+)_delta\.fits', file)] # noqa files = [int(file) for file in files] - elif simname == "Lilow2024": - return [0] + # Downsample to only 20 realisations + files = files[::5] + elif simname in ["Carrick2015", "Lilow2024", "no_field"] or "IndranilVoid" in simname: # noqa + files = [0] else: raise ValueError(f"Unknown simulation name `{simname}`.") @@ -635,6 +636,50 @@ class Paths: try_create_directory(fdir) return join(fdir, f"los_{catalogue}_{simnname}.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): + """Flow validation file path.""" + if isinstance(catalogue, list) and len(catalogue) == 1: + catalogue = catalogue[0] + + if isinstance(catalogue, list): + catalogue = "_".join(catalogue) + + if smooth == 0: + smooth = None + + 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"] + values = [smooth, nsim, zcmb_min, zcmb_max, mag_selection, + sample_alpha, sample_beta, sample_Vmono, sample_mag_dipole, + sample_curvature] + + for key, value in zip(keys, values): + + if isinstance(value, bool): + if value: + fname += f"{key}_" + elif value is not None: + fname += f"{key}_{value}_" + + fname = fname.strip("_") + fname = join(fdir, f"{fname}.hdf5") + # Print the last modified time of the file if it exists. + if exists(fname): + mtime = getmtime(fname) + mtime = datetime.datetime.fromtimestamp(mtime) + mtime = mtime.strftime("%d/%m/%Y %H:%M:%S") + print(f"File: {fname}") + print(f"Last modified: {mtime}") + + return fname + def field_projected(self, simname, kind): """ Path to the files containing the projected fields on the sky. @@ -653,5 +698,3 @@ class Paths: fdir = join(self.postdir, "field_projected") try_create_directory(fdir) return join(fdir, f"{simname}_{kind}_volume_weighted.hdf5") - - diff --git a/notebooks/flow/PV_data.ipynb b/notebooks/flow/PV_data.ipynb new file mode 100644 index 0000000..90661f7 --- /dev/null +++ b/notebooks/flow/PV_data.ipynb @@ -0,0 +1,588 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import scienceplots\n", + "import seaborn as sns\n", + "from h5py import File\n", + "\n", + "\n", + "from reconstruction_comparison import *\n", + "SPEED_OF_LIGHT = 299_792.458\n", + "from csiborgtools import radec_to_galactic\n", + "\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Paper plots" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "with File(\"/mnt/extraspace/rstiskalek/catalogs/PV_compilation.hdf5\", 'r') as f:\n", + " SFI = {}\n", + " for key in f[\"SFI_gals\"].keys():\n", + " SFI[key] = f[\"SFI_gals\"][key][...]\n", + " \n", + " TWOMTF = {}\n", + " for key in f[\"2MTF\"].keys():\n", + " TWOMTF[key] = f[\"2MTF\"][key][...]\n", + " \n", + " FOUNDATION = {}\n", + " for key in f[\"Foundation\"].keys():\n", + " FOUNDATION[key] = f[\"Foundation\"][key][...]\n", + " \n", + " LOSS = {}\n", + " for key in f[\"LOSS\"].keys():\n", + " LOSS[key] = f[\"LOSS\"][key][...]\n", + "\n", + "\n", + "\n", + "with File(\"/mnt/extraspace/rstiskalek/catalogs/PV/CF4/CF4_TF-distances.hdf5\", 'r') as f:\n", + " CF4_TFR = {}\n", + " for key in f.keys():\n", + " CF4_TFR[key] = f[key][...]\n", + " \n", + " RA = f[\"RA\"][...] * 360 / 24\n", + " CF4_TFR[\"RA\"] = RA\n", + " \n", + " CF4_TFR[\"DEC\"] = f[\"DE\"][...]\n", + "\n", + " l, b = radec_to_galactic(CF4_TFR[\"RA\"], CF4_TFR[\"DE\"])\n", + " m = np.abs(b) > 7.5\n", + " for key in CF4_TFR.keys():\n", + " CF4_TFR[key] = CF4_TFR[key][m]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1. Redshift distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "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", + " plt.figure()\n", + "\n", + " sns.kdeplot(LOSS[\"z_CMB\"], label=\"LOSS\", fill=True, bw_adjust=0.75)\n", + " sns.kdeplot(FOUNDATION[\"z_CMB\"], label=\"Foundation\", fill=True, bw_adjust=0.75)\n", + " sns.kdeplot(SFI[\"z_CMB\"], label=\"SFI\", fill=True, bw_adjust=0.75)\n", + " sns.kdeplot(TWOMTF[\"z_CMB\"], label=\"2MTF\", fill=True, bw_adjust=0.75)\n", + "\n", + " m = CF4_TFR[\"i\"] > 5\n", + " sns.kdeplot(CF4_TFR[\"Vcmb\"][m] / SPEED_OF_LIGHT, label=catalogue_to_pretty(\"CF4_TFR_i\"), fill=True)\n", + "\n", + " m = CF4_TFR[\"w1\"] > 5\n", + " sns.kdeplot(CF4_TFR[\"Vcmb\"][m] / SPEED_OF_LIGHT, label=catalogue_to_pretty(\"CF4_TFR_w1\"), fill=True)\n", + "\n", + " plt.xlabel(r\"$z_{\\rm CMB}$\")\n", + " plt.ylabel(\"Normalised PDF\")\n", + "\n", + " plt.legend()\n", + " plt.xlim(0, 0.07)\n", + "\n", + " plt.tight_layout()\n", + " plt.savefig(f\"../../plots/zcmb_dist.pdf\", dpi=450)\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2. Sky distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "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", + " figwidth = 8.3\n", + " fig, axs = plt.subplots(2, 3, figsize=(figwidth, 0.4 * figwidth),\n", + " sharex=True, sharey=True)\n", + "\n", + "\n", + " names = [\"LOSS\", \"Foundation\", \"SFI\", \"2MTF\", \"CF4_TFR_i\", \"CF4_TFR_w1\"]\n", + " vals = [LOSS, FOUNDATION, SFI, TWOMTF, CF4_TFR, CF4_TFR]\n", + " for i, ax in enumerate(axs.flat):\n", + " RA = vals[i][\"RA\"]\n", + " DEC = vals[i][\"DEC\"]\n", + "\n", + " if names[i] == \"CF4_TFR_i\":\n", + " m = vals[i][\"i\"] > 5\n", + " RA = RA[m]\n", + " DEC = DEC[m]\n", + "\n", + " if names[i] == \"CF4_TFR_w1\":\n", + " m = vals[i][\"w1\"] > 5\n", + " RA = RA[m]\n", + " DEC = DEC[m]\n", + "\n", + " sns.scatterplot(x=RA, y=DEC, ax=ax, s=1.5, rasterized=True)\n", + "\n", + " # Add panel name in top-left corner of each subplot\n", + " ax.text(0.04, 0.16, catalogue_to_pretty(names[i]), transform=ax.transAxes, \n", + " fontsize=9, verticalalignment='top', \n", + " bbox=dict(boxstyle=\"round\", facecolor='lightgray', alpha=1),\n", + " zorder=10) # Ensure text is on top of other plot elements\n", + "\n", + " axs[0, 0].set_xlim(0, 360)\n", + " axs[0, 0].set_ylim(-90, 90)\n", + "\n", + " for i in range(3):\n", + " axs[-1, i].set_xlabel(r\"$\\mathrm{RA} ~ [\\mathrm{deg}]$\")\n", + "\n", + " for i in range(2):\n", + " axs[i, 0].set_ylabel(r\"$\\delta ~ [\\mathrm{deg]}$\")\n", + "\n", + " fig.tight_layout()\n", + " plt.savefig(f\"../../plots/sky_dist.pdf\", dpi=350)\n", + " fig.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Experimenting" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "l, b = radec_to_galactic(CF4_TFR[\"RA\"], CF4_TFR[\"DE\"])\n", + "# l, b = radec_to_galactic(SFI[\"RA\"], SFI[\"DEC\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.06692355049302931" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.abs(b).min()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "232" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(np.abs(b) < 10).sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.hist(np.abs(b), bins=\"auto\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "with File(\"/mnt/extraspace/rstiskalek/catalogs/PV_compilation.hdf5\", 'r') as f:\n", + " print(f[\"SFI_gals\"].keys())\n", + "\n", + " zCMB_sfi = f[\"SFI_gals\"][\"z_CMB\"][...]\n", + " mag_sfi = f[\"SFI_gals\"][\"mag\"][...]\n", + " eta_sfi = f[\"SFI_gals\"][\"eta\"][...]\n", + " e_mag_sfi = f[\"SFI_gals\"][\"e_mag\"][...]\n", + " e_eta_sfi = f[\"SFI_gals\"][\"e_eta\"][...]\n", + "\n", + " zCMB_2MTF = f[\"2MTF\"][\"z_CMB\"][...]\n", + " mag_2MTF = f[\"2MTF\"][\"mag\"][...]\n", + " eta_2MTF = f[\"2MTF\"][\"eta\"][...]\n", + " e_mag_2MTF = f[\"2MTF\"][\"e_mag\"][...]\n", + " e_eta_2MTF = f[\"2MTF\"][\"e_eta\"][...]" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "with File(\"/mnt/extraspace/rstiskalek/catalogs/PV/CF4/CF4_TF-distances.hdf5\", 'r') as f:\n", + " zCMB = f[\"Vcmb\"][...] / 3e5\n", + " rband = f[\"r\"][...]\n", + " iband = f[\"i\"][...]\n", + " w1band = f[\"w1\"][...]\n", + " RA = f[\"RA\"][...] * 360 / 24\n", + " dec = f[\"DE\"][...]\n", + "\n", + "# m = (iband > 5) #& (w1band > 5)\n", + "m = (w1band> 5) #& (w1band > 5)\n", + "w1band = w1band[m]\n", + "iband = iband[m]\n", + "RA = RA[m]\n", + "dec = dec[m]" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "dmag = iband - w1band" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.scatter(RA, dec, c=dmag, s=1)\n", + "plt.colorbar()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGdCAYAAAA44ojeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAiGklEQVR4nO3df3AU9f3H8deFkAM0lxgguWQ8SECNjvwGucZafpTUJDAII9WCsQZlQBnAQrRCOgqEaScpUMuoVNoZhToFUWcQKlQcCEK0hgiBDIqaIUwAKUmsMORIKMeP7PcPx/t6JiCHd9znLs/HzM6wn/3s3nv5HN7Lz+3e2izLsgQAAGCQmHAXAAAA8H0EFAAAYBwCCgAAMA4BBQAAGIeAAgAAjENAAQAAxiGgAAAA4xBQAACAcWLDXcC1aG1t1YkTJxQfHy+bzRbucgAAwFWwLEtnzpxRWlqaYmKuPEcSkQHlxIkTcrlc4S4DAABcgy+//FI333zzFftEZECJj4+X9M0JOhyOMFcDAACuhsfjkcvl8n2OX0lEBpRvv9ZxOBwEFAAAIszVXJ7BRbIAAMA4BBQAAGAcAgoAADAOAQUAABiHgAIAAIxDQAEAAMYhoAAAAOMQUAAAgHEIKAAAwDgEFAAAYBwCCgAAMA4BBQAAGIeAAgAAjENAAQAAxokNdwEAzJa+YEtA/Y+UjgtRJQA6EmZQAACAcQgoAADAOAQUAABgHAIKAAAwDgEFAAAYh4ACAACMQ0ABAADGIaAAAADjEFAAAIBxCCgAAMA4BBQAAGAcAgoAADAOAQUAABiHgAIAAIxDQAEAAMYhoAAAAOMQUAAAgHEIKAAAwDgBB5Ty8nKNHz9eaWlpstls2rhxo992m83W7rJs2TJfn/T09DbbS0tLf/TJAACA6BBwQGlpadHAgQO1cuXKdrfX19f7La+++qpsNpsmTZrk12/JkiV+/ebMmXNtZwAAAKJObKA75OXlKS8v77LbnU6n3/qmTZs0evRo9enTx689Pj6+TV8AAAApxNegNDY2asuWLZo2bVqbbaWlperevbsGDx6sZcuW6eLFi5c9jtfrlcfj8VsAAED0CngGJRB///vfFR8fr/vvv9+v/cknn9SQIUOUlJSkjz76SEVFRaqvr9fzzz/f7nFKSkpUXFwcylKBDiV9wZZwlwAAVxTSgPLqq68qPz9fXbp08WsvLCz0/XnAgAGKi4vT448/rpKSEtnt9jbHKSoq8tvH4/HI5XKFrnAAABBWIQsoH3zwgWpqavTGG2/8YF+3262LFy/qyJEjyszMbLPdbre3G1wAAEB0Ctk1KK+88oqGDh2qgQMH/mDf6upqxcTEKDk5OVTlAACACBLwDEpzc7Nqa2t963V1daqurlZSUpJ69eol6ZuvYN566y396U9/arN/RUWFKisrNXr0aMXHx6uiokLz5s3Tww8/rJtuuulHnAoAAIgWAQeUvXv3avTo0b71b68NKSgo0Jo1ayRJ69evl2VZmjJlSpv97Xa71q9fr8WLF8vr9SojI0Pz5s3zu8YEAAB0bDbLsqxwFxEoj8ejhIQENTU1yeFwhLscIOKE8i6eI6XjQnZsAJEtkM9vnsUDAACMQ0ABAADGIaAAAADjEFAAAIBxQvpLsgA6nkAuwOWCWgCXwwwKAAAwDgEFAAAYh4ACAACMQ0ABAADGIaAAAADjEFAAAIBxCCgAAMA4BBQAAGAcAgoAADAOAQUAABiHgAIAAIxDQAEAAMYhoAAAAOMQUAAAgHFiw10AgI4rfcGWgPofKR0XokoAmIYZFAAAYBxmUIAoEOhMBACYjhkUAABgHAIKAAAwDgEFAAAYh2tQAENxXQmAjowZFAAAYBwCCgAAMA4BBQAAGIeAAgAAjENAAQAAxiGgAAAA4xBQAACAcQgoAADAOAQUAABgHAIKAAAwTsABpby8XOPHj1daWppsNps2btzot33q1Kmy2Wx+S25url+fU6dOKT8/Xw6HQ4mJiZo2bZqam5t/1IkAAIDoEXBAaWlp0cCBA7Vy5crL9snNzVV9fb1vef311/225+fn6+DBg9q2bZs2b96s8vJyzZgxI/DqAQBAVAr4YYF5eXnKy8u7Yh+73S6n09nuts8//1xbt27Vnj17NGzYMEnSiy++qLFjx2r58uVKS0sLtCQAABBlQnINys6dO5WcnKzMzEzNnDlTJ0+e9G2rqKhQYmKiL5xIUnZ2tmJiYlRZWdnu8bxerzwej98CAACiV9ADSm5url577TWVlZXpj3/8o3bt2qW8vDxdunRJktTQ0KDk5GS/fWJjY5WUlKSGhoZ2j1lSUqKEhATf4nK5gl02AAAwSMBf8fyQyZMn+/7cv39/DRgwQH379tXOnTs1ZsyYazpmUVGRCgsLfesej4eQAgBAFAv5bcZ9+vRRjx49VFtbK0lyOp366quv/PpcvHhRp06duux1K3a7XQ6Hw28BAADRK+QB5fjx4zp58qRSU1MlSVlZWTp9+rSqqqp8fXbs2KHW1la53e5QlwMAACJAwF/xNDc3+2ZDJKmurk7V1dVKSkpSUlKSiouLNWnSJDmdTh0+fFjPPPOMbrnlFuXk5EiS7rjjDuXm5mr69OlatWqVLly4oNmzZ2vy5MncwQMAACRdwwzK3r17NXjwYA0ePFiSVFhYqMGDB2vhwoXq1KmTDhw4oPvuu0+33Xabpk2bpqFDh+qDDz6Q3W73HWPt2rW6/fbbNWbMGI0dO1b33HOP/va3vwXvrAAAQEQLeAZl1KhRsizrstvfe++9HzxGUlKS1q1bF+hLAwCADoJn8QAAAOMQUAAAgHEIKAAAwDgEFAAAYBwCCgAAMA4BBQAAGIeAAgAAjENAAQAAxiGgAAAA4xBQAACAcQgoAADAOAQUAABgHAIKAAAwDgEFAAAYh4ACAACMQ0ABAADGIaAAAADjEFAAAIBxCCgAAMA4BBQAAGAcAgoAADAOAQUAABiHgAIAAIxDQAEAAMYhoAAAAOMQUAAAgHEIKAAAwDgEFAAAYBwCCgAAMA4BBQAAGIeAAgAAjENAAQAAxiGgAAAA4xBQAACAcQgoAADAOAQUAABgnIADSnl5ucaPH6+0tDTZbDZt3LjRt+3ChQuaP3+++vfvrxtuuEFpaWl65JFHdOLECb9jpKeny2az+S2lpaU/+mQAAEB0CDigtLS0aODAgVq5cmWbbWfPntW+ffv03HPPad++fdqwYYNqamp03333tem7ZMkS1dfX+5Y5c+Zc2xkAAICoExvoDnl5ecrLy2t3W0JCgrZt2+bX9tJLL2n48OE6duyYevXq5WuPj4+X0+kM9OUBAEAHEPJrUJqammSz2ZSYmOjXXlpaqu7du2vw4MFatmyZLl68eNljeL1eeTwevwUAAESvgGdQAnHu3DnNnz9fU6ZMkcPh8LU/+eSTGjJkiJKSkvTRRx+pqKhI9fX1ev7559s9TklJiYqLi0NZKgAAMEjIAsqFCxf04IMPyrIsvfzyy37bCgsLfX8eMGCA4uLi9Pjjj6ukpER2u73NsYqKivz28Xg8crlcoSodAACEWUgCyrfh5OjRo9qxY4ff7El73G63Ll68qCNHjigzM7PNdrvd3m5wAQAA0SnoAeXbcHLo0CG9//776t69+w/uU11drZiYGCUnJwe7HAAAEIECDijNzc2qra31rdfV1am6ulpJSUlKTU3VL3/5S+3bt0+bN2/WpUuX1NDQIElKSkpSXFycKioqVFlZqdGjRys+Pl4VFRWaN2+eHn74Yd10003BOzMAABCxAg4oe/fu1ejRo33r314bUlBQoMWLF+uf//ynJGnQoEF++73//vsaNWqU7Ha71q9fr8WLF8vr9SojI0Pz5s3zu8YEAAB0bAEHlFGjRsmyrMtuv9I2SRoyZIh2794d6MsCAIAOhGfxAAAA4xBQAACAcUL6Q21ANEtfsCWg/kdKx4WoEgCIPsygAAAA4xBQAACAcQgoAADAOAQUAABgHAIKAAAwDgEFAAAYh4ACAACMQ0ABAADGIaAAAADjEFAAAIBxCCgAAMA4BBQAAGAcAgoAADAOAQUAABgnNtwFAB1F+oIt4S4BACIGMygAAMA4BBQAAGAcAgoAADAOAQUAABiHgAIAAIzDXTwAIkYgd0IdKR0XwkoAhBozKAAAwDgEFAAAYBwCCgAAMA4BBQAAGIeAAgAAjENAAQAAxiGgAAAA4xBQAACAcQgoAADAOAQUAABgHAIKAAAwDgEFAAAYJ+CAUl5ervHjxystLU02m00bN270225ZlhYuXKjU1FR17dpV2dnZOnTokF+fU6dOKT8/Xw6HQ4mJiZo2bZqam5t/1IkAAIDoEXBAaWlp0cCBA7Vy5cp2ty9dulQvvPCCVq1apcrKSt1www3KycnRuXPnfH3y8/N18OBBbdu2TZs3b1Z5eblmzJhx7WcBAACiSmygO+Tl5SkvL6/dbZZlacWKFXr22Wc1YcIESdJrr72mlJQUbdy4UZMnT9bnn3+urVu3as+ePRo2bJgk6cUXX9TYsWO1fPlypaWl/YjTAQAA0SCo16DU1dWpoaFB2dnZvraEhAS53W5VVFRIkioqKpSYmOgLJ5KUnZ2tmJgYVVZWtntcr9crj8fjtwAAgOgV8AzKlTQ0NEiSUlJS/NpTUlJ82xoaGpScnOxfRGyskpKSfH2+r6SkRMXFxcEsFWhX+oIt4S4BAKAIuYunqKhITU1NvuXLL78Md0kAACCEgjqD4nQ6JUmNjY1KTU31tTc2NmrQoEG+Pl999ZXffhcvXtSpU6d8+3+f3W6X3W4PZqnoIJgRAYDIFNQZlIyMDDmdTpWVlfnaPB6PKisrlZWVJUnKysrS6dOnVVVV5euzY8cOtba2yu12B7McAAAQoQKeQWlublZtba1vva6uTtXV1UpKSlKvXr00d+5c/f73v9ett96qjIwMPffcc0pLS9PEiRMlSXfccYdyc3M1ffp0rVq1ShcuXNDs2bM1efJk7uABAACSriGg7N27V6NHj/atFxYWSpIKCgq0Zs0aPfPMM2ppadGMGTN0+vRp3XPPPdq6dau6dOni22ft2rWaPXu2xowZo5iYGE2aNEkvvPBCEE4HAABEA5tlWVa4iwiUx+NRQkKCmpqa5HA4wl0ODMY1KB3XkdJx4S4BwPcE8vkdEXfxAACAjoWAAgAAjBPU24wBwBSBfr3HV0KAWZhBAQAAxiGgAAAA4xBQAACAcQgoAADAOAQUAABgHAIKAAAwDgEFAAAYh4ACAACMQ0ABAADGIaAAAADjEFAAAIBxCCgAAMA4BBQAAGAcAgoAADAOAQUAABiHgAIAAIxDQAEAAMYhoAAAAOMQUAAAgHEIKAAAwDgEFAAAYBwCCgAAMA4BBQAAGIeAAgAAjENAAQAAxiGgAAAA4xBQAACAcQgoAADAOAQUAABgHAIKAAAwDgEFAAAYh4ACAACMQ0ABAADGCXpASU9Pl81ma7PMmjVLkjRq1Kg225544olglwEAACJYbLAPuGfPHl26dMm3/umnn+oXv/iFHnjgAV/b9OnTtWTJEt96t27dgl0GAACIYEEPKD179vRbLy0tVd++fTVy5EhfW7du3eR0OoP90gAAIEqE9BqU8+fP6x//+Icee+wx2Ww2X/vatWvVo0cP9evXT0VFRTp79uwVj+P1euXxePwWAAAQvYI+g/JdGzdu1OnTpzV16lRf20MPPaTevXsrLS1NBw4c0Pz581VTU6MNGzZc9jglJSUqLi4OZakAAMAgNsuyrFAdPCcnR3FxcXrnnXcu22fHjh0aM2aMamtr1bdv33b7eL1eeb1e37rH45HL5VJTU5McDkfQ60b0SF+wJdwlIEIcKR0X7hKAqOfxeJSQkHBVn98hm0E5evSotm/ffsWZEUlyu92SdMWAYrfbZbfbg14jAAAwU8iuQVm9erWSk5M1btyV/6+kurpakpSamhqqUgAAQIQJyQxKa2urVq9erYKCAsXG/v9LHD58WOvWrdPYsWPVvXt3HThwQPPmzdOIESM0YMCAUJQCAAAiUEgCyvbt23Xs2DE99thjfu1xcXHavn27VqxYoZaWFrlcLk2aNEnPPvtsKMoAAAARKiQB5d5771V71966XC7t2rUrFC8JAACiCM/iAQAAxiGgAAAA4xBQAACAcQgoAADAOAQUAABgHAIKAAAwDgEFAAAYh4ACAACMQ0ABAADGIaAAAADjhOSn7oFQSl+wJdwlAABCjBkUAABgHGZQEHbMiAAAvo8ZFAAAYBwCCgAAMA4BBQAAGIeAAgAAjENAAQAAxiGgAAAA4xBQAACAcQgoAADAOAQUAABgHAIKAAAwDgEFAAAYh4ACAACMQ0ABAADGIaAAAADjEFAAAIBxCCgAAMA4BBQAAGAcAgoAADAOAQUAABiHgAIAAIxDQAEAAMYhoAAAAOMQUAAAgHFig33AxYsXq7i42K8tMzNTX3zxhSTp3Llzeuqpp7R+/Xp5vV7l5OToL3/5i1JSUoJdCgBctfQFWwLqf6R0XIgqASCFaAblzjvvVH19vW/58MMPfdvmzZund955R2+99ZZ27dqlEydO6P777w9FGQAAIEIFfQZFkmJjY+V0Otu0NzU16ZVXXtG6dev085//XJK0evVq3XHHHdq9e7d+8pOfhKIcAAAQYUIyg3Lo0CGlpaWpT58+ys/P17FjxyRJVVVVunDhgrKzs319b7/9dvXq1UsVFRWXPZ7X65XH4/FbAABA9Ap6QHG73VqzZo22bt2ql19+WXV1dfrZz36mM2fOqKGhQXFxcUpMTPTbJyUlRQ0NDZc9ZklJiRISEnyLy+UKdtkAAMAgQf+KJy8vz/fnAQMGyO12q3fv3nrzzTfVtWvXazpmUVGRCgsLfesej4eQAgBAFAv5bcaJiYm67bbbVFtbK6fTqfPnz+v06dN+fRobG9u9ZuVbdrtdDofDbwEAANEr5AGlublZhw8fVmpqqoYOHarOnTurrKzMt72mpkbHjh1TVlZWqEsBAAARIuhf8Tz99NMaP368evfurRMnTmjRokXq1KmTpkyZooSEBE2bNk2FhYVKSkqSw+HQnDlzlJWVxR08AADAJ+gB5fjx45oyZYpOnjypnj176p577tHu3bvVs2dPSdKf//xnxcTEaNKkSX4/1AYAAPAtm2VZVriLCJTH41FCQoKampq4HiUKBPoLnoAJ+CVZIHCBfH7zLB4AAGAcAgoAADAOAQUAABiHgAIAAIxDQAEAAMYhoAAAAOMQUAAAgHEIKAAAwDgEFAAAYBwCCgAAMA4BBQAAGIeAAgAAjENAAQAAxiGgAAAA4xBQAACAcQgoAADAOAQUAABgHAIKAAAwDgEFAAAYh4ACAACMExvuAhAZ0hdsCaj/kdJxIaoEANARMIMCAACMQ0ABAADG4SsehESgXwkBAPBdzKAAAADjMIMCANcgkFlCLhoHAscMCgAAMA4BBQAAGIeAAgAAjENAAQAAxiGgAAAA4xBQAACAcQgoAADAOAQUAABgHAIKAAAwDgEFAAAYJ+gBpaSkRHfddZfi4+OVnJysiRMnqqamxq/PqFGjZLPZ/JYnnngi2KUAAIAIFfSAsmvXLs2aNUu7d+/Wtm3bdOHCBd17771qaWnx6zd9+nTV19f7lqVLlwa7FAAAEKGC/rDArVu3+q2vWbNGycnJqqqq0ogRI3zt3bp1k9PpDPbLAwCAKBDya1CampokSUlJSX7ta9euVY8ePdSvXz8VFRXp7Nmzlz2G1+uVx+PxWwAAQPQK+gzKd7W2tmru3Ln66U9/qn79+vnaH3roIfXu3VtpaWk6cOCA5s+fr5qaGm3YsKHd45SUlKi4uDiUpQIAAIPYLMuyQnXwmTNn6t1339WHH36om2+++bL9duzYoTFjxqi2tlZ9+/Zts93r9crr9frWPR6PXC6Xmpqa5HA4QlI7/KUv2BLuEoCIdaR0XLhLAIzg8XiUkJBwVZ/fIZtBmT17tjZv3qzy8vIrhhNJcrvdknTZgGK322W320NSJwAAME/QA4plWZozZ47efvtt7dy5UxkZGT+4T3V1tSQpNTU12OUAAIAIFPSAMmvWLK1bt06bNm1SfHy8GhoaJEkJCQnq2rWrDh8+rHXr1mns2LHq3r27Dhw4oHnz5mnEiBEaMGBAsMsBAAARKOgB5eWXX5b0zY+xfdfq1as1depUxcXFafv27VqxYoVaWlrkcrk0adIkPfvss8EuBQAARKiQfMVzJS6XS7t27Qr2ywIAgCjCs3gAAIBxCCgAAMA4BBQAAGAcAgoAADAOAQUAABiHgAIAAIwT0ocFAgACf5YVz+4BmEEBAAAGIqAAAADjEFAAAIBxCCgAAMA4BBQAAGAc7uIBgA4kkDuKuJsI4cQMCgAAMA4zKB1UoL/LAADA9cQMCgAAMA4BBQAAGIeAAgAAjMM1KABgGO60AZhBAQAABiKgAAAA4xBQAACAcQgoAADAOFwkG0X48TUAQLRgBgUAABiHgAIAAIxDQAEAAMYhoAAAAOMQUAAAgHG4i8dg3JUDAOiomEEBAADGYQYFANCuQGdxeXAhgokZFAAAYBxmUK4zrisBAGZn8MOYQQEAAMZhBuVHYkYEAL7Bfw8RTGGdQVm5cqXS09PVpUsXud1uffzxx+EsBwAAGCJsMyhvvPGGCgsLtWrVKrndbq1YsUI5OTmqqalRcnJyuMoCgIjCrAWilc2yLCscL+x2u3XXXXfppZdekiS1trbK5XJpzpw5WrBgwRX39Xg8SkhIUFNTkxwOR9Br4x88AOByTLlgN9SfVaE4z0A+v8Myg3L+/HlVVVWpqKjI1xYTE6Ps7GxVVFS06e/1euX1en3rTU1Nkr450VBo9Z4NyXEBAJEvVJ89gQr1Z1UozvPbY17N3EhYAsrXX3+tS5cuKSUlxa89JSVFX3zxRZv+JSUlKi4ubtPucrlCViMAAO1JWBHuCq6PUJ7nmTNnlJCQcMU+EXEXT1FRkQoLC33rra2tOnXqlLp37y6bzRbQsTwej1wul7788suQfD2EH8YYmIFxMAPjEH6MwfVjWZbOnDmjtLS0H+wbloDSo0cPderUSY2NjX7tjY2Ncjqdbfrb7XbZ7Xa/tsTExB9Vg8Ph4I0YZoyBGRgHMzAO4ccYXB8/NHPyrbDcZhwXF6ehQ4eqrKzM19ba2qqysjJlZWWFoyQAAGCQsH3FU1hYqIKCAg0bNkzDhw/XihUr1NLSokcffTRcJQEAAEOELaD86le/0n//+18tXLhQDQ0NGjRokLZu3drmwtlgs9vtWrRoUZuvjHD9MAZmYBzMwDiEH2NgprD9DgoAAMDl8LBAAABgHAIKAAAwDgEFAAAYh4ACAACME/UB5Q9/+IPuvvtudevW7ap/3G3q1Kmy2Wx+S25ubmgLjXLXMg6WZWnhwoVKTU1V165dlZ2drUOHDoW20Ch36tQp5efny+FwKDExUdOmTVNzc/MV9xk1alSbfw9PPPHEdao4OqxcuVLp6enq0qWL3G63Pv744yv2f+utt3T77berS5cu6t+/v/71r39dp0qjVyBjsGbNmjbv+S5dulzHaiF1gIBy/vx5PfDAA5o5c2ZA++Xm5qq+vt63vP766yGqsGO4lnFYunSpXnjhBa1atUqVlZW64YYblJOTo3PnzoWw0uiWn5+vgwcPatu2bdq8ebPKy8s1Y8aMH9xv+vTpfv8eli5deh2qjQ5vvPGGCgsLtWjRIu3bt08DBw5UTk6Ovvrqq3b7f/TRR5oyZYqmTZum/fv3a+LEiZo4caI+/fTT61x59Ah0DKRvflX2u+/5o0ePXseKIUmyOojVq1dbCQkJV9W3oKDAmjBhQkjr6aiudhxaW1stp9NpLVu2zNd2+vRpy263W6+//noIK4xen332mSXJ2rNnj6/t3XfftWw2m/Wf//znsvuNHDnS+s1vfnMdKoxOw4cPt2bNmuVbv3TpkpWWlmaVlJS02//BBx+0xo0b59fmdrutxx9/PKR1RrNAxyCQzwuETtTPoFyrnTt3Kjk5WZmZmZo5c6ZOnjwZ7pI6lLq6OjU0NCg7O9vXlpCQILfbrYqKijBWFrkqKiqUmJioYcOG+dqys7MVExOjysrKK+67du1a9ejRQ/369VNRUZHOng3tY96jxfnz51VVVeX3Po6JiVF2dvZl38cVFRV+/SUpJyeH9/01upYxkKTm5mb17t1bLpdLEyZM0MGDB69HufiOiHia8fWWm5ur+++/XxkZGTp8+LB+97vfKS8vTxUVFerUqVO4y+sQGhoaJKnNLwunpKT4tiEwDQ0NSk5O9muLjY1VUlLSFf9OH3roIfXu3VtpaWk6cOCA5s+fr5qaGm3YsCHUJUe8r7/+WpcuXWr3ffzFF1+0u09DQwPv+yC6ljHIzMzUq6++qgEDBqipqUnLly/X3XffrYMHD+rmm2++HmVDEXoNyoIFC9pcwPT95XJvvKsxefJk3Xffferfv78mTpyozZs3a8+ePdq5c2fwTiIKhHoccHVCPQ4zZsxQTk6O+vfvr/z8fL322mt6++23dfjw4SCeBWCOrKwsPfLIIxo0aJBGjhypDRs2qGfPnvrrX/8a7tI6lIicQXnqqac0derUK/bp06dP0F6vT58+6tGjh2prazVmzJigHTfShXIcnE6nJKmxsVGpqam+9sbGRg0aNOiajhmtrnYcnE5nm4sCL168qFOnTvn+vq+G2+2WJNXW1qpv374B19uR9OjRQ506dVJjY6Nfe2Nj42X/zp1OZ0D9cWXXMgbf17lzZw0ePFi1tbWhKBGXEZEBpWfPnurZs+d1e73jx4/r5MmTfh+UCO04ZGRkyOl0qqyszBdIPB6PKisrA74jK9pd7ThkZWXp9OnTqqqq0tChQyVJO3bsUGtrqy90XI3q6mpJ4t/DVYiLi9PQoUNVVlamiRMnSpJaW1tVVlam2bNnt7tPVlaWysrKNHfuXF/btm3blJWVdR0qjj7XMgbfd+nSJX3yyScaO3ZsCCtFG+G+SjfUjh49au3fv98qLi62brzxRmv//v3W/v37rTNnzvj6ZGZmWhs2bLAsy7LOnDljPf3001ZFRYVVV1dnbd++3RoyZIh16623WufOnQvXaUS8QMfBsiyrtLTUSkxMtDZt2mQdOHDAmjBhgpWRkWH973//C8cpRIXc3Fxr8ODBVmVlpfXhhx9at956qzVlyhTf9uPHj1uZmZlWZWWlZVmWVVtbay1ZssTau3evVVdXZ23atMnq06ePNWLEiHCdQsRZv369ZbfbrTVr1lifffaZNWPGDCsxMdFqaGiwLMuyfv3rX1sLFizw9f/3v/9txcbGWsuXL7c+//xza9GiRVbnzp2tTz75JFynEPECHYPi4mLrvffesw4fPmxVVVVZkydPtrp06WIdPHgwXKfQIUV9QCkoKLAktVnef/99Xx9J1urVqy3LsqyzZ89a9957r9WzZ0+rc+fOVu/eva3p06f73si4NoGOg2V9c6vxc889Z6WkpFh2u90aM2aMVVNTc/2LjyInT560pkyZYt14442Ww+GwHn30Ub+QWFdX5zcux44ds0aMGGElJSVZdrvduuWWW6zf/va3VlNTU5jOIDK9+OKLVq9evay4uDhr+PDh1u7du33bRo4caRUUFPj1f/PNN63bbrvNiouLs+68805ry5Yt17ni6BPIGMydO9fXNyUlxRo7dqy1b9++MFTdsdksy7LCMnUDAABwGRF5Fw8AAIhuBBQAAGAcAgoAADAOAQUAABiHgAIAAIxDQAEAAMYhoAAAAOMQUAAAgHEIKAAAwDgEFAAAYBwCCgAAMA4BBQAAGOf/APHzzGB7glc0AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.hist(iband - w1band, bins=\"auto\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "m = rband > 0\n", + "\n", + "plt.figure()\n", + "plt.hist(rband[m], bins=\"auto\")\n", + "plt.axvline(17.6, c=\"red\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.hist(zCMB, bins=\"auto\")\n", + "plt.xlabel(r\"$z_{\\rm CMB}$\")\n", + "plt.ylabel(\"Counts\")\n", + "plt.xlim(0)\n", + "plt.tight_layout()\n", + "plt.savefig(\"../../plots/zCMB_CF4.png\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "df_sfi = pd.DataFrame({\n", + " r\"$z_{\\rm CMB}$\": zCMB_sfi,\n", + " r\"$m$\": mag_sfi,\n", + " r\"$\\eta$\": eta_sfi,\n", + " r\"$\\sigma_{m}$\": e_mag_sfi,\n", + " r\"$\\sigma_\\eta$\": e_eta_sfi,\n", + " \"Dataset\": \"SFI\"\n", + "})\n", + "\n", + "df_2mtf = pd.DataFrame({\n", + " r\"$z_{\\rm CMB}$\": zCMB_2MTF,\n", + " r\"$m$\": mag_2MTF,\n", + " r\"$\\eta$\": eta_2MTF,\n", + " r\"$\\sigma_{m}$\": e_mag_2MTF,\n", + " r\"$\\sigma_\\eta$\": e_eta_2MTF,\n", + " \"Dataset\": \"2MTF\"\n", + "})\n", + "\n", + "df_combined = pd.concat([df_sfi, df_2mtf])\n", + "g = sns.pairplot(df_combined, hue=\"Dataset\", kind=\"kde\", diag_kind=\"kde\",\n", + " palette=\"Set1\", corner=True, plot_kws={\"alpha\": 0.75},\n", + " diag_kws={\"fill\": True})\n", + "sns.move_legend(g, \"upper right\", bbox_to_anchor=(0.7, 0.7))\n", + "\n", + "# Show the plot\n", + "plt.tight_layout()\n", + "plt.savefig(\"../../plots/TFR_data.pdf\", dpi=450)\n", + "plt.show()\n" + ] + }, + { + "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 +} diff --git a/notebooks/flow/reconstruction_comparison.ipynb b/notebooks/flow/reconstruction_comparison.ipynb index dc48964..ce1bbef 100644 --- a/notebooks/flow/reconstruction_comparison.ipynb +++ b/notebooks/flow/reconstruction_comparison.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 4, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -24,6 +24,9 @@ "import matplotlib.pyplot as plt\n", "from corner import corner\n", "from getdist import plots\n", + "import scienceplots\n", + "from os.path import exists\n", + "import seaborn as sns\n", "\n", "\n", "from reconstruction_comparison import *\n", @@ -32,14 +35,15 @@ "%autoreload 2\n", "%matplotlib inline\n", "\n", - "paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring)" + "paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring)\n", + "fdir = \"/mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### $\\log Z$ and BIC for simulations/catalogues" + "## Quick checks" ] }, { @@ -48,33 +52,175 @@ "metadata": {}, "outputs": [], "source": [ - "sims = [\"Carrick2015\", \"Lilow2024\", \"CF4\", \"CF4gp\", \"csiborg2_main\", \"csiborg2X\"]\n", - "catalogues = [\"LOSS\", \"Foundation\", \"Pantheon+\", \"2MTF\", \"SFI_gals\"]\n", + "catalogue = \"CF4_TFR_i\"\n", + "simname = \"Carrick2015\"\n", + "zcmb_max=0.05\n", + "sample_beta = None\n", + "sample_alpha = True\n", "\n", - "for catalogue in catalogues:\n", - " y_BIC = np.asarray([get_gof(\"BIC\", sim, catalogue) for sim in sims])\n", - " y_BIC -= y_BIC.min()\n", - " y_lnZ = np.full_like(y_BIC, np.nan)\n", - " # y_lnZ = np.asarray([get_gof(\"lnZ\", sim, catalogue) for sim in sims])\n", - " # y_lnZ -= y_lnZ.min()\n", + "fname_bayes = paths.flow_validation(\n", + " fdir, simname, catalogue, inference_method=\"bayes\",\n", + " sample_alpha=sample_alpha, sample_beta=sample_beta,\n", + " zcmb_max=zcmb_max)\n", "\n", - " fig, ax_left = plt.subplots()\n", - " fig.suptitle(f\"{catalogue}\")\n", - " ax_right = ax_left.twinx()\n", + "fname_mike = paths.flow_validation(\n", + " fdir, simname, catalogue, inference_method=\"mike\",\n", + " sample_alpha=sample_alpha, sample_beta=sample_beta,\n", + " zcmb_max=zcmb_max)\n", "\n", "\n", - " ax_left.plot(np.arange(len(sims)), y_lnZ, 'bo')\n", - " ax_right.plot(np.arange(len(sims)), y_BIC, 'rx')\n", + "X = []\n", + "labels = [\"Full posterior\", \"Delta posterior\"]\n", + "for i, fname in enumerate([fname_bayes, fname_mike]):\n", + " samples = get_samples(fname)\n", + " if i == 1:\n", + " print(samples.keys())\n", "\n", - " # y-ticks\n", - " ax_left.set_ylabel(r\"$-\\Delta \\log \\mathcal{Z}$\", color=\"blue\")\n", - " ax_left.tick_params(axis='y', labelcolor=\"blue\")\n", - " ax_right.set_ylabel(r\"$\\Delta \\mathrm{BIC}$\", color=\"red\")\n", - " ax_right.tick_params(axis='y', labelcolor=\"red\")\n", + " X.append(samples_to_getdist(samples, labels[i]))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "params = [f\"a_{catalogue}\", f\"b_{catalogue}\", f\"c_{catalogue}\", f\"e_mu_{catalogue}\",\n", + " \"Vmag\", \"l\", \"b\", \"sigma_v\", \"beta\", f\"alpha_{catalogue}\"]\n", + "# params = [\"beta\", f\"a_{catalogue}\", f\"b_{catalogue}\", f\"e_mu_{catalogue}\"]\n", + "# params = [\"Vmag\", \"l\", \"b\", \"sigma_v\", \"beta\", f\"mag_cal_{catalogue}\", f\"alpha_cal_{catalogue}\", f\"beta_cal_{catalogue}\", f\"e_mu_{catalogue}\"]\n", "\n", - " ax_left.set_xticks(np.arange(len(sims)), simname_to_pretty(sims), rotation=35)\n", - " fig.tight_layout()\n", - " fig.savefig(f\"../../plots/GOF_{catalogue}.png\", dpi=450)\n", + "\n", + "g = plots.get_subplot_plotter()\n", + "g.settings.figure_legend_frame = False\n", + "g.settings.alpha_filled_add = 0.75\n", + "\n", + "g.triangle_plot(X, params=params, filled=True, legend_loc='upper right')\n", + "plt.gcf().suptitle(catalogue_to_pretty(catalogue), y=1.025)\n", + "plt.gcf().tight_layout()\n", + "# plt.gcf().savefig(f\"../../plots/method_comparison_{simname}_{catalogue}.png\", dpi=500, bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# catalogue = [\"LOSS\", \"Foundation\"]\n", + "catalogue = \"CF4_TFR_i\"\n", + "simname = \"IndranilVoid_exp\"\n", + "zcmb_max = 0.05\n", + "sample_alpha = False\n", + "\n", + "fname = paths.flow_validation(\n", + " fdir, simname, catalogue, inference_method=\"mike\",\n", + " sample_mag_dipole=True,\n", + " sample_beta=False,\n", + " sample_alpha=sample_alpha, zcmb_max=zcmb_max)\n", + "\n", + "\n", + "samples = get_samples(fname, convert_Vext_to_galactic=True)\n", + "\n", + "samples, labels, keys = samples_for_corner(samples)\n", + "fig = corner(samples, labels=labels, show_titles=True,\n", + " title_kwargs={\"fontsize\": 12}, smooth=1)\n", + "# fig.savefig(\"../../plots/test.png\", dpi=250)\n", + "fig.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Paper plots" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1. Evidence comparison" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "zcmb_max = 0.05\n", + "\n", + "sims = [\"Carrick2015\", \"Lilow2024\", \"csiborg2_main\", \"csiborg2X\", \"CF4\"]\n", + "catalogues = [\"LOSS\", \"Foundation\", \"2MTF\", \"SFI_gals\", \"CF4_TFR_i\", \"CF4_TFR_w1\"]\n", + "\n", + "y_BIC = np.full((len(catalogues), len(sims)), np.nan)\n", + "y_lnZ = np.full_like(y_BIC, np.nan)\n", + "\n", + "for i, catalogue in enumerate(catalogues):\n", + " for j, simname in enumerate(sims):\n", + " fname = paths.flow_validation(\n", + " fdir, simname, catalogue, inference_method=\"mike\",\n", + " sample_alpha=simname != \"IndranilVoid_exp\",\n", + " zcmb_max=zcmb_max)\n", + "\n", + " # y_BIC[i, j] = get_gof(\"BIC\", fname)\n", + " y_lnZ[i, j] = get_gof(\"neg_lnZ_harmonic\", fname)\n", + "\n", + " y_lnZ[i] -= y_lnZ[i].min()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "with plt.style.context('science'):\n", + " plt.rcParams.update({'font.size': 9})\n", + " figwidth = 8.3\n", + " fig, axs = plt.subplots(2, 3, figsize=(figwidth, 0.35 * figwidth))\n", + " fig.subplots_adjust(hspace=0)\n", + "\n", + " x = np.arange(len(sims))\n", + " y = y_lnZ\n", + " for n in range(len(catalogues)):\n", + " i, j = n // 3, n % 3\n", + " ax = axs[i, j]\n", + " ax.text(0.5, 0.875, catalogue_to_pretty(catalogues[n]),\n", + " transform=ax.transAxes, fontsize=\"small\",\n", + " verticalalignment='center', horizontalalignment='center',\n", + " bbox=dict(facecolor='white', alpha=0.5))\n", + " ax.scatter(x, y[n], c=\"k\", s=5)\n", + "\n", + " y_min, y_max = ax.get_ylim()\n", + " y_offset = (y_max - y_min) * 0.075 # Adjust the fraction (0.05) as needed\n", + "\n", + " for k, txt in enumerate(y[n]):\n", + " ax.text(x[k], y[n, k] + y_offset, f\"({y[n, k]:.1f})\",\n", + " ha='center', fontsize=\"x-small\")\n", + "\n", + " ax.set_ylim(y_min, y_max + 2 * y_offset)\n", + "\n", + " for i in range(3):\n", + " axs[1, i].set_xticks(\n", + " np.arange(len(sims)),\n", + " [simname_to_pretty(sim) for sim in sims], rotation=35,\n", + " fontsize=\"small\")\n", + " axs[0, i].set_xticks([], [])\n", + "\n", + " for i in range(2):\n", + " for j in range(3):\n", + " axs[i, j].set_xlim(-0.75, len(sims) - 0.25)\n", + "\n", + " axs[i, j].tick_params(axis='x', which='major', top=False)\n", + " axs[i, j].tick_params(axis='x', which='minor', top=False, length=0)\n", + " axs[i, j].tick_params(axis='y', which='minor', length=0)\n", + "\n", + " axs[i, 0].set_ylabel(r\"$-\\Delta \\ln \\mathcal{Z}$\")\n", + "\n", + " fig.tight_layout(h_pad=0)\n", + " fig.savefig(f\"../../plots/lnZ_comparison.pdf\", dpi=500, bbox_inches='tight')\n", " fig.show()" ] }, @@ -82,7 +228,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Setting $\\beta = 1$?" + "### 2. Dependence of the evidence on smoothing scale" ] }, { @@ -91,38 +237,195 @@ "metadata": {}, "outputs": [], "source": [ - "sims = [\"Lilow2024\", \"CF4\", \"CF4gp\", \"csiborg1\", \"csiborg2_main\", \"csiborg2X\"]\n", - "catalogues = [\"LOSS\", \"Foundation\", \"Pantheon+\", \"2MTF\", \"SFI_gals\"]\n", + "zcmb_max = 0.05\n", "\n", - "for catalogue in catalogues:\n", - " y_lnZ = [get_gof(\"lnZ\", sim, catalogue, sample_beta=True) - get_gof(\"lnZ\", sim, catalogue, sample_beta=False) for sim in sims]\n", - " y_BIC = [get_gof(\"BIC\", sim, catalogue, sample_beta=True) - get_gof(\"BIC\", sim, catalogue, sample_beta=False) for sim in sims]\n", + "ksmooth = [0, 1, 2, 3, 4]\n", + "scales = [0, 2, 4, 6, 8]\n", + "sims = [\"Carrick2015\", \"csiborg2_main\"]\n", + "catalogues = [\"2MTF\", \"SFI_gals\", \"CF4_TFR_i\"]\n", "\n", - " fig, ax_left = plt.subplots()\n", - " fig.suptitle(rf\"{catalogue} (higher signifies preference for $\\beta = 1$)\")\n", - " ax_right = ax_left.twinx()\n", + "y = np.full((len(sims), len(catalogues), len(ksmooth)), np.nan)\n", + "for i, simname in enumerate(sims):\n", + " for j, catalogue in enumerate(catalogues):\n", + " for n, k in enumerate(ksmooth):\n", + " fname = paths.flow_validation(\n", + " fdir, simname, catalogue, inference_method=\"mike\",\n", + " sample_alpha=True, smooth=k,\n", + " zcmb_max=zcmb_max)\n", + " if not exists(fname):\n", + " raise FileNotFoundError(fname)\n", "\n", - " ax_left.plot(np.arange(len(sims)), y_lnZ, 'bo')\n", - " ax_right.plot(np.arange(len(sims)), y_BIC, 'rx')\n", + " y[i, j, n] = get_gof(\"neg_lnZ_harmonic\", fname)\n", "\n", - " # y-ticks\n", - " ax_left.set_ylabel(r\"$\\log \\mathcal{Z}_{\\beta} - \\log \\mathcal{Z}_{\\beta = 1}$\", color=\"blue\")\n", - " ax_left.tick_params(axis='y', labelcolor=\"blue\")\n", - " ax_right.set_ylabel(r\"$\\mathrm{BIC}_{\\beta} - \\mathrm{BIC}_{\\beta = 1}$\", color=\"red\")\n", - " ax_right.tick_params(axis='y', labelcolor=\"red\")\n", + " y[i, j, :] -= y[i, j, :].min()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for i, simname in enumerate(sims):\n", + " for j, catalogue in enumerate(catalogues):\n", + " print(simname, catalogue, y[i, j, -1])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "with plt.style.context('science'):\n", + " plt.rcParams.update({'font.size': 9})\n", + " cols = plt.rcParams['axes.prop_cycle'].by_key()['color']\n", + " plt.figure()\n", "\n", - " ax_left.set_xticks(np.arange(len(sims)), simname_to_pretty(sims), rotation=35)\n", - " ax_left.axhline(0, color=\"black\", linestyle=\"--\", linewidth=1)\n", - " fig.tight_layout()\n", - " fig.savefig(f\"../../plots/GOF_beta_{catalogue}.png\", dpi=450)\n", - " fig.show()\n" + " ls = [\"-\", \"--\", \"-.\", \":\"]\n", + " for i, simname in enumerate(sims):\n", + " for j, catalogue in enumerate(catalogues):\n", + " plt.plot(scales, y[i, j], marker='o', ms=2.5, ls=ls[i],\n", + " label=catalogue_to_pretty(catalogue) if i == 0 else None, c=cols[j],)\n", + "\n", + " plt.xlabel(r\"$R_{\\rm smooth} ~ [\\mathrm{Mpc} / h]$\")\n", + " plt.ylabel(r\"$-\\Delta \\ln \\mathcal{Z}$\")\n", + " plt.legend()\n", + "\n", + " plt.tight_layout()\n", + " plt.savefig(\"../../plots/smoothing_comparison.pdf\", dpi=450)\n", + " plt.show()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### What $\\beta$ is preferred by the data? " + "### 3. TFR intercept consistency" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cats = [\"2MTF\", \"SFI_gals\", \"CF4_TFR_i\", \"CF4_TFR_w1\"]\n", + "sims = [\"Carrick2015\", \"Lilow2024\", \"csiborg2_main\", \"csiborg2X\"]\n", + "labels_x = [r\"$a_{\\rm TF}^{\\rm 2MTF}$\", r\"$a_{\\rm TF}^{\\rm SFI}$\", r\"$a_{\\rm TF}^{\\mathrm{CF4~TFR~}i}$\", r\"$a_{\\rm TF}^{\\mathrm{CF4~TFR~W1}}$\"]\n", + "\n", + "data = {}\n", + "for cat in cats:\n", + " for sim in sims:\n", + " fname = paths.flow_validation(\n", + " fdir, sim, cat, inference_method=\"bayes\",\n", + " sample_alpha=True, zcmb_max=0.05)\n", + " \n", + " if not exists(fname):\n", + " raise FileNotFoundError(fname)\n", + " \n", + " with File(fname, 'r') as f:\n", + " data[f\"{sim}_{cat}\"] = f[f\"samples/a_{cat}\"][...]\n", + " # samples = get_samples(fname)\n", + " # samples = samples_to_getdist(samples, simname_to_pretty(sim))\n", + " # X.append(samples)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "with plt.style.context('science'):\n", + " plt.rcParams.update({'font.size': 9})\n", + " figwidth = 8.3\n", + " fig, axs = plt.subplots(1, 4, figsize=(figwidth, 0.75 * 2.65))\n", + " fig.subplots_adjust(hspace=0)\n", + " # plt.figure()\n", + "\n", + " for i, cat in enumerate(cats):\n", + " for sim in sims:\n", + " x = data[f\"{sim}_{cat}\"]\n", + " sns.kdeplot(x, fill=True, bw_adjust=0.75, ax=axs[i],\n", + " label=simname_to_pretty(sim) if i == 0 else None)\n", + "\n", + " axs[i].set_ylabel(None)\n", + " axs[i].set_yticklabels([])\n", + "\n", + " axs[i].set_xlabel(labels_x[i])\n", + "\n", + " axs[0].set_ylabel(\"Normalised density\")\n", + "\n", + " handles, labels = axs[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.075), ncol=len(cats) + 2)\n", + "\n", + " fig.tight_layout(h_pad=0)\n", + " fig.savefig(f\"../../plots/TFR_intercept.pdf\", dpi=450)\n", + " fig.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4. External flow consistency" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sim = \"csiborg2_main\"\n", + "# cats = [[\"LOSS\", \"Foundation\"], \"2MTF\", \"SFI_gals\", \"CF4_TFR_not2MTForSFI_i\"]\n", + "# cats = [[\"LOSS\", \"Foundation\"], \"CF4_TFR_not2MTForSFI_i\", \"2MTF\", \"SFI_gals\"]\n", + "# cats = [\"CF4_TFR_not2MTForSFI_i\", \"2MTF\", \"SFI_gals\"]\n", + "cats = [\"2MTF\", \"SFI_gals\", \"CF4_TFR_i\", \"CF4_TFR_w1\"]\n", + "\n", + "X = []\n", + "for cat in cats:\n", + " fname = paths.flow_validation(\n", + " fdir, sim, cat, inference_method=\"bayes\",\n", + " sample_alpha=True, zcmb_max=0.05)\n", + "\n", + " if not exists(fname):\n", + " raise FileNotFoundError(fname)\n", + "\n", + " samples = get_samples(fname)\n", + " if sim == \"csiborg2_main\":\n", + " m = samples[\"l\"] > 250\n", + " for key in samples.keys():\n", + " samples[key] = samples[key][m]\n", + " samples = samples_to_getdist(samples, catalogue_to_pretty(cat))\n", + " X.append(samples)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "params = [\"Vmag\", \"l\", \"b\"]\n", + "\n", + "with plt.style.context('science'):\n", + " g = plots.get_subplot_plotter()\n", + " g.settings.figure_legend_frame = False\n", + " g.settings.alpha_filled_add = 0.75\n", + "\n", + " g.triangle_plot(X, params=params, filled=True, legend_loc='upper right')\n", + " # plt.gcf().suptitle(simname_to_pretty(sim), y=1.025)\n", + " plt.gcf().tight_layout()\n", + " plt.gcf().savefig(f\"../../plots/flow_{sim}.pdf\", dpi=500, bbox_inches='tight')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 5. What $\\beta$ is preferred by the data? " ] }, { @@ -131,28 +434,365 @@ "metadata": {}, "outputs": [], "source": [ - "# sims = [\"Lilow2024\", \"CF4\", \"CF4gp\", \"csiborg1\", \"csiborg2_main\", \"csiborg2X\"]\n", - "sims = [\"csiborg2_main\", \"csiborg2X\"]\n", - "catalogues = [\"LOSS\", \"Foundation\", \"Pantheon+\", \"2MTF\", \"SFI_gals\"]\n", "key = \"beta\"\n", + "sim = \"csiborg2X\"\n", + "cats = [[\"LOSS\", \"Foundation\"], \"2MTF\", \"SFI_gals\", \"CF4_TFR_i\", \"CF4_TFR_w1\"]\n", + "# cats = [\"2MTF\", \"SFI_gals\", \"CF4_TFR_not2MTForSFI_i\"]\n", "\n", - "for sim in sims:\n", + "X = []\n", + "\n", + "for cat in cats:\n", + " fname = paths.flow_validation(\n", + " fdir, sim, cat, inference_method=\"bayes\",\n", + " sample_alpha=True, zcmb_max=0.05, sample_beta=True)\n", + "\n", + " if not exists(fname):\n", + " raise FileNotFoundError(fname)\n", + "\n", + " with File(fname, 'r') as f:\n", + " X.append(f[f\"samples/beta\"][...])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "with plt.style.context('science'):\n", " plt.figure()\n", - " plt.title(simname_to_pretty(sim))\n", - "\n", - " for catalogue in catalogues:\n", - " beta = get_samples(sim, catalogue)[key]\n", - " plt.hist(beta, bins=\"auto\", histtype=\"step\", label=catalogue, density=1)\n", "\n", + " for i, cat in enumerate(cats):\n", + " sns.kdeplot(X[i], label=catalogue_to_pretty(cat), fill=True)\n", "\n", " plt.xlabel(names_to_latex([key], True)[0])\n", - " plt.ylabel(\"Normalized PDF\")\n", - " # plt.xlim(0., 1.5)\n", - " plt.legend()\n", - " plt.savefig(f\"../../plots/what_beta_{sim}.png\", dpi=450)\n", + " plt.ylabel(\"PDF\")\n", + " plt.legend(ncols=1, fontsize=\"small\", loc=\"upper left\")\n", + " if \"csiborg\" in sim:\n", + " plt.axvline(1, color='k', linestyle='--')\n", + " # plt.xlim(0.15, 0.6)\n", + " plt.xlim(0.5, 1.5)\n", "\n", " plt.tight_layout()\n", - " plt.show()\n" + " plt.savefig(f\"../../plots/what_beta_{sim}.pdf\", dpi=450)\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 6. Bulk flow in the simulation rest frame " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sims = [\"Carrick2015\", \"Lilow2024\", \"csiborg2_main\", \"csiborg2X\"]\n", + "\n", + "\n", + "with plt.style.context('science'):\n", + " plt.rcParams.update({'font.size': 9})\n", + " cols = plt.rcParams['axes.prop_cycle'].by_key()['color']\n", + "\n", + " plt.figure()\n", + " for i, sim in enumerate(sims):\n", + " r, B = get_bulkflow_simulation(sim, convert_to_galactic=True)\n", + " B = B[..., 0]\n", + "\n", + " if sim == \"Carrick2015\":\n", + " B *= 0.43\n", + "\n", + " if sim in [\"Carrick2015\", \"Lilow2024\"]:\n", + " plt.plot(r, B[0], label=simname_to_pretty(sim), color=cols[i])\n", + " else:\n", + " ylow, yhigh = np.percentile(B, [16, 84], axis=0)\n", + " plt.fill_between(r, ylow, yhigh, alpha=0.5,\n", + " label=simname_to_pretty(sim), color=cols[i])\n", + "\n", + " plt.xlabel(r\"$R ~ [\\mathrm{Mpc} / h]$\")\n", + " plt.ylabel(r\"$|\\mathbf{B}| ~ [\\mathrm{km} / \\mathrm{s}]$\")\n", + " plt.xlim(5, 200)\n", + " plt.legend()\n", + "\n", + " plt.tight_layout()\n", + " plt.savefig(\"../../plots/bulkflow_simulations_restframe.pdf\", dpi=450)\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 7. Bulk flow in the CMB frame" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sims = [\"Carrick2015\", \"Lilow2024\", \"csiborg2_main\", \"csiborg2X\"]\n", + "# cats = [[\"LOSS\", \"Foundation\"], \"2MTF\", \"SFI_gals\", \"CF4_TFR_i\"]\n", + "cats = [\"2MTF\", \"SFI_gals\", \"CF4_TFR_i\", \"CF4_TFR_w1\"]\n", + "\n", + "\n", + "data = {}\n", + "for sim in sims:\n", + " for cat in cats:\n", + " fname = paths.flow_validation(\n", + " fdir, sim, cat, inference_method=\"bayes\",\n", + " sample_alpha=True, zcmb_max=0.05)\n", + " \n", + " data[f\"{sim}_{cat}\"] = get_bulkflow(fname, sim)\n", + "\n", + "def get_ax_centre(ax):\n", + " # Get the bounding box of the specific axis in relative figure coordinates\n", + " bbox = ax.get_position()\n", + "\n", + " # Extract the position and size of the axis\n", + " x0, y0, width, height = bbox.x0, bbox.y0, bbox.width, bbox.height\n", + "\n", + " # Calculate the center of the axis\n", + " center_x = x0 + width / 2\n", + " center_y = y0 + height / 2\n", + " return center_x, center_y" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "with plt.style.context('science'):\n", + " plt.rcParams.update({'font.size': 9})\n", + " nrows = len(sims)\n", + " ncols = 3\n", + "\n", + " figwidth = 8.3\n", + " fig, axs = plt.subplots(nrows, ncols, figsize=(figwidth, 0.75 * figwidth), sharex=True, sharey=\"col\")\n", + " cols = plt.rcParams['axes.prop_cycle'].by_key()['color']\n", + " # fig.suptitle(f\"Calibrated against {catalogue}\")\n", + "\n", + " for i, sim in enumerate(sims):\n", + " for j, catalogue in enumerate(cats):\n", + " r, B = data[f\"{sim}_{catalogue}\"]\n", + " c = cols[j]\n", + " 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", + " label=catalogue_to_pretty(catalogue) if i == 1 else None)\n", + "\n", + "\n", + " # CMB-LG velocity\n", + " kwargs = {\"color\": \"mediumblue\", \"alpha\": 0.5, \"zorder\": 10, \"hatch\": \"x\"}\n", + " for n in range(len(sims)):\n", + " axs[n, 0].fill_between([r.min(), 15.], [627 - 22, 627 - 22], [627 + 22, 627 + 22], label=\"CMB-LG\" if n == 0 else None, **kwargs)\n", + " axs[n, 1].fill_between([r.min(), 15.], [276 - 3, 276 - 3], [276 + 3, 276 + 3], **kwargs)\n", + " axs[n, 2].fill_between([r.min(), 15.], [30 - 3, 30 - 3], [30 + 3, 30 + 3], **kwargs)\n", + "\n", + " # LCDM expectation\n", + " Rs,mean,std,mode,p05,p16,p84,p95 = np.load(\"/mnt/users/rstiskalek/csiborgtools/data/BulkFlowPlot.npy\")\n", + " m = Rs < 175\n", + " kwargs = {\"color\": \"black\", \"zorder\": 0, \"hatch\": \"//\", \"alpha\": 0.25}\n", + " for n in range(len(sims)):\n", + " axs[n, 0].fill_between(\n", + " Rs[m], p16[m], p84[m],\n", + " label=r\"$\\Lambda\\mathrm{CDM}$\" if n == 0 else None, **kwargs)\n", + "\n", + " for n in range(3):\n", + " axs[-1, n].set_xlabel(r\"$R ~ [\\mathrm{Mpc} / h]$\")\n", + "\n", + " for n in range(len(sims)):\n", + " axs[n, 0].set_ylabel(r\"$|\\mathbf{B}| ~ [\\mathrm{km} / \\mathrm{s}]$\")\n", + " axs[n, 1].set_ylabel(r\"$\\ell ~ [\\mathrm{deg}]$\")\n", + " 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", + "\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", + "\n", + " fig.tight_layout(rect=[0, 0, 0.95, 0.95])\n", + " fig.savefig(f\"../../plots/bulkflow_CMB.pdf\", dpi=450)\n", + " fig.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 8. Full vs Delta comparison" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "catalogue = \"CF4_TFR_i\"\n", + "simname = \"csiborg2X\"\n", + "zcmb_max=0.05\n", + "sample_beta = True\n", + "sample_alpha = True\n", + "\n", + "fname_bayes = paths.flow_validation(\n", + " fdir, simname, catalogue, inference_method=\"bayes\",\n", + " sample_alpha=sample_alpha, sample_beta=sample_beta,\n", + " zcmb_max=zcmb_max)\n", + "\n", + "fname_mike = paths.flow_validation(\n", + " fdir, simname, catalogue, inference_method=\"mike\",\n", + " sample_alpha=sample_alpha, sample_beta=sample_beta,\n", + " zcmb_max=zcmb_max)\n", + "\n", + "\n", + "X = []\n", + "labels = [\"Full posterior\", \"Delta posterior\"]\n", + "for i, fname in enumerate([fname_bayes, fname_mike]):\n", + " samples = get_samples(fname)\n", + " if i == 1:\n", + " print(samples.keys())\n", + "\n", + " X.append(samples_to_getdist(samples, labels[i]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "params = [f\"a_{catalogue}\", f\"b_{catalogue}\", f\"c_{catalogue}\", f\"e_mu_{catalogue}\",\n", + " \"Vmag\", \"l\", \"b\", \"sigma_v\", \"beta\", f\"alpha_{catalogue}\"]\n", + "# params = [\"beta\", f\"a_{catalogue}\", f\"b_{catalogue}\", f\"e_mu_{catalogue}\"]\n", + "# params = [\"Vmag\", \"l\", \"b\", \"sigma_v\", \"beta\", f\"mag_cal_{catalogue}\", f\"alpha_cal_{catalogue}\", f\"beta_cal_{catalogue}\", f\"e_mu_{catalogue}\"]\n", + "\n", + "with plt.style.context('science'):\n", + " plt.rcParams.update({'font.size': 11})\n", + " g = plots.get_subplot_plotter()\n", + " g.settings.figure_legend_frame = False\n", + " g.settings.alpha_filled_add = 0.75\n", + " g.settings.fontsize = 12\n", + "\n", + " g.triangle_plot(X, params=params, filled=True, legend_loc='upper right')\n", + " # plt.gcf().suptitle(catalogue_to_pretty(catalogue), y=1.025)\n", + " plt.gcf().tight_layout()\n", + " plt.gcf().savefig(f\"../../plots/method_comparison_{simname}_{catalogue}.pdf\", dpi=300, bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## All possible things" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Dipole magnitude" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cats = [\"2MTF\", \"SFI_gals\", \"CF4_TFR_i\", \"CF4_TFR_w1\"]\n", + "sim = \"IndranilVoid_gauss\"\n", + "\n", + "X = []\n", + "for cat in cats:\n", + " fname = paths.flow_validation(\n", + " fdir, sim, cat, inference_method=\"mike\",\n", + " sample_mag_dipole=False,\n", + " sample_alpha=False, zcmb_max=0.05)\n", + " \n", + " if not exists(fname):\n", + " raise FileNotFoundError(fname)\n", + "\n", + " samples = get_samples(fname, convert_Vext_to_galactic=False)\n", + "\n", + " # keys = list(samples.keys())\n", + " # for key in keys:\n", + " # if cat in key:\n", + " # value = samples.pop(key)\n", + " # samples[key.replace(f\"_{cat}\",'')] = value\n", + " \n", + " samples = samples_to_getdist(samples, catalogue_to_pretty(cat))\n", + " X.append(samples)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# params = [\"Vmag\", \"l\", \"b\", \"a_dipole_mag\", \"a_dipole_l\", \"a_dipole_b\"]\n", + "params = [\"Vx\", \"Vy\", \"Vz\"]\n", + "# params = [\"Vmag\", \"l\", \"b\"]\n", + "\n", + "with plt.style.context('science'):\n", + " g = plots.get_subplot_plotter()\n", + " g.settings.figure_legend_frame = False\n", + " g.settings.alpha_filled_add = 0.75\n", + "\n", + " g.triangle_plot(X, params=params, filled=True, legend_loc='upper right')\n", + " # plt.gcf().suptitle(catalogue_to_pretty(cat), y=1.025)\n", + " plt.gcf().tight_layout()\n", + " plt.gcf().savefig(f\"../../plots/vext_{sim}.png\", dpi=500, bbox_inches='tight')" ] }, { @@ -497,7 +1137,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -514,20 +1154,9 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "scales = [0, 4, 8, 16, 32]\n", "\n", @@ -556,37 +1185,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Removed no burn in\n", - "Removed no burn in\n", - "Removed no burn in\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_3872503/2011775450.py:22: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", - " plt.gcf().tight_layout()\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "sim = \"Carrick2015\"\n", "catalogue = \"Pantheon+\"\n", @@ -613,12 +1214,90 @@ "plt.gcf().savefig(f\"../../plots/calibration_{catalogue}.png\", dpi=500, bbox_inches='tight')" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Indranil's void" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Evidence comparison" + ] + }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "zcmb_max = 0.05\n", + "\n", + "sims = [\"no_field\", \"IndranilVoid_exp\"]\n", + "cats = [\"LOSS\", \"Foundation\", \"2MTF\", \"SFI_gals\", \"CF4_TFR_i\", \"CF4_TFR_w1\"]\n", + "\n", + "neglnZ = {}\n", + "for sim in sims:\n", + " for cat in cats:\n", + " sample_alpha = sim not in [\"IndranilVoid_exp\", \"no_field\"]\n", + " fname = paths.flow_validation(\n", + " fdir, sim, cat, inference_method=\"mike\",\n", + " sample_alpha=sample_alpha, zcmb_max=zcmb_max)\n", + "\n", + " neglnZ[f\"{sim}_{cat}\"] = get_gof(\"neg_lnZ_harmonic\", fname)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "simA = sims[0]\n", + "simB = sims[1]\n", + "\n", + "print(f\"lnZ_({simA}) - lnZ_({simB})\\n\")\n", + "for cat in cats:\n", + " lnZ_A = - neglnZ[f\"{simA}_{cat}\"]\n", + " lnZ_B = - neglnZ[f\"{simB}_{cat}\"]\n", + " print(f\"{cat:15s} {lnZ_A - lnZ_B:.1f}\")\n", + "\n", + "\n", + "print(f\"\\n(Positive -> preference for {simA})\")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "data = np.loadtxt(\"/mnt/extraspace/rstiskalek/catalogs/v_pec_EXP_IndranilVoid.dat\")\n", + "\n", + "r = np.arange(0, 251)\n", + "phi = np.arange(0, 181)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure()\n", + "plt.plot(phi, data[:, 100])\n", + "plt.xlabel(r\"$\\phi ~ [\\mathrm{deg}]$\")\n", + "plt.ylabel(r\"$V ~ [\\mathrm{km} / \\mathrm{s}]$\")\n", + "\n", + "plt.xlim(0, 180)\n", + "plt.tight_layout()\n", + "plt.savefig(\"../../plots/profile.png\", dpi=450)\n", + "\n", + "plt.show()" + ] }, { "cell_type": "code", diff --git a/notebooks/flow/reconstruction_comparison.py b/notebooks/flow/reconstruction_comparison.py index 3883e93..6f97181 100644 --- a/notebooks/flow/reconstruction_comparison.py +++ b/notebooks/flow/reconstruction_comparison.py @@ -13,8 +13,7 @@ # 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 +from copy import copy, deepcopy import numpy as np from jax import numpy as jnp @@ -41,25 +40,6 @@ def cartesian_to_radec(x, y, z): 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 # ############################################################################### @@ -69,30 +49,96 @@ 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", + "Vmag": "V_{\\rm ext} ~ [\\mathrm{km} / \\mathrm{s}]", + "Vx": "V_x ~ [\\mathrm{km} / \\mathrm{s}]", + "Vy": "V_y ~ [\\mathrm{km} / \\mathrm{s}]", + "Vz": "V_z ~ [\\mathrm{km} / \\mathrm{s}]", + "sigma_v": "\\sigma_v ~ [\\mathrm{km} / \\mathrm{s}]", "alpha_cal": "\\mathcal{A}", "beta_cal": "\\mathcal{B}", "mag_cal": "\\mathcal{M}", - "e_mu": "\\sigma_\\mu", - "aTF": "a_{\\rm TF}", - "bTF": "b_{\\rm TF}", + "l": "\\ell ~ [\\mathrm{deg}]", + "b": "b ~ [\\mathrm{deg}]", } 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}}$", + "l": r"$\ell$", + "b": r"$b$", "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}$", } + names = copy(names) + for i, name in enumerate(names): + if "SFI_gals" in name: + names[i] = names[i].replace("SFI_gals", "SFI") + + if "CF4_GroupAll" in name: + names[i] = names[i].replace("CF4_GroupAll", "CF4Group") + + if "CF4_TFR_i" in name: + names[i] = names[i].replace("CF4_TFR_i", "CF4,TFR") + + for cat in ["2MTF", "SFI", "CF4,TFR"]: + ltx[f"a_{cat}"] = f"a_{{\\rm TF}}^{{\\rm {cat}}}" + ltx[f"b_{cat}"] = f"b_{{\\rm TF}}^{{\\rm {cat}}}" + ltx[f"c_{cat}"] = f"c_{{\\rm TF}}^{{\\rm {cat}}}" + ltx[f"corr_mag_eta_{cat}"] = f"\\rho_{{m,\\eta}}^{{\\rm {cat}}}" + ltx[f"eta_mean_{cat}"] = f"\\widehat{{\\eta}}^{{\\rm {cat}}}" + ltx[f"eta_std_{cat}"] = f"\\widehat{{\\sigma}}_\\eta^{{\\rm {cat}}}" + ltx[f"mag_mean_{cat}"] = f"\\widehat{{m}}^{{\\rm {cat}}}" + ltx[f"mag_std_{cat}"] = f"\\widehat{{\\sigma}}_m^{{\\rm {cat}}}" + + ltx_corner[f"a_{cat}"] = rf"$a_{{\rm TF}}^{{\rm {cat}}}$" + ltx_corner[f"b_{cat}"] = rf"$b_{{\rm TF}}^{{\rm {cat}}}$" + ltx_corner[f"c_{cat}"] = rf"$c_{{\rm TF}}^{{\rm {cat}}}$" + ltx_corner[f"corr_mag_eta_{cat}"] = rf"$\rho_{{m,\eta}}^{{\rm {cat}}}$" + ltx_corner[f"eta_mean_{cat}"] = rf"$\widehat{{\eta}}^{{\rm {cat}}}$" + ltx_corner[f"eta_std_{cat}"] = rf"$\widehat{{\sigma}}_\eta^{{\rm {cat}}}$" # noqa + ltx_corner[f"mag_mean_{cat}"] = rf"$\widehat{{m}}^{{\rm {cat}}}$" + ltx_corner[f"mag_std_{cat}"] = rf"$\widehat{{\sigma}}_m^{{\rm {cat}}}$" + + for cat in ["2MTF", "SFI", "Foundation", "LOSS", "CF4Group", "CF4,TFR"]: + ltx[f"alpha_{cat}"] = f"\\alpha^{{\\rm {cat}}}" + ltx[f"e_mu_{cat}"] = f"\\sigma_{{\\mu}}^{{\\rm {cat}}}" + ltx[f"a_dipole_mag_{cat}"] = f"\\epsilon_{{\\rm mag}}^{{\\rm {cat}}}" + ltx[f"a_dipole_l_{cat}"] = f"\\epsilon_{{\\ell}}^{{\\rm {cat}}} ~ [\\mathrm{{deg}}]" # noqa + ltx[f"a_dipole_b_{cat}"] = f"\\epsilon_{{b}}^{{\\rm {cat}}} ~ [\\mathrm{{deg}}]" # noqa + + ltx["a_dipole_mag"] = "\\epsilon_{{\\rm mag}}" + ltx["a_dipole_l"] = "\\epsilon_{{\\ell}} ~ [\\mathrm{{deg}}]" + ltx["a_dipole_b"] = "\\epsilon_{{b}} ~ [\\mathrm{{deg}}]" + + ltx_corner[f"alpha_{cat}"] = rf"$\alpha^{{\rm {cat}}}$" + ltx_corner[f"e_mu_{cat}"] = rf"$\sigma_{{\mu}}^{{\rm {cat}}}$" + ltx_corner[f"a_dipole_mag_{cat}"] = rf"$\epsilon_{{\rm mag}}^{{\rm {cat}}}$" # noqa + ltx_corner[f"a_dipole_l_{cat}"] = rf"$\epsilon_{{\ell}}^{{\rm {cat}}}$" + ltx_corner[f"a_dipole_b_{cat}"] = rf"$\epsilon_{{b}}^{{\rm {cat}}}$" + + for cat in ["Foundation", "LOSS"]: + ltx[f"alpha_cal_{cat}"] = f"\\mathcal{{A}}^{{\\rm {cat}}}" + ltx[f"beta_cal_{cat}"] = f"\\mathcal{{B}}^{{\\rm {cat}}}" + ltx[f"mag_cal_{cat}"] = f"\\mathcal{{M}}^{{\\rm {cat}}}" + + ltx_corner[f"alpha_cal_{cat}"] = rf"$\mathcal{{A}}^{{\rm {cat}}}$" + ltx_corner[f"beta_cal_{cat}"] = rf"$\mathcal{{B}}^{{\rm {cat}}}$" + ltx_corner[f"mag_cal_{cat}"] = rf"$\mathcal{{M}}^{{\rm {cat}}}$" + + for cat in ["CF4Group"]: + ltx[f"dmu_{cat}"] = f"\\Delta\\mu^{{\\rm {cat}}}" + ltx[f"dmu_dipole_mag_{cat}"] = f"\\epsilon_\\mu_{{\\rm mag}}^{{\\rm {cat}}}" # noqa + ltx[f"dmu_dipole_l_{cat}"] = f"\\epsilon_\\mu_{{\\ell}}^{{\\rm {cat}}} ~ [\\mathrm{{deg}}]" # noqa + ltx[f"dmu_dipole_b_{cat}"] = f"\\epsilon_\\mu_{{b}}^{{\\rm {cat}}} ~ [\\mathrm{{deg}}]" # noqa + + ltx_corner[f"dmu_{cat}"] = rf"$\Delta\mu_{{0}}^{{\rm {cat}}}$" + ltx_corner[f"dmu_dipole_mag_{cat}"] = rf"$\epsilon_{{\rm mag}}^{{\rm {cat}}}$" # noqa + ltx_corner[f"dmu_dipole_l_{cat}"] = rf"$\epsilon_{{\ell}}^{{\rm {cat}}}$" # noqa + ltx_corner[f"dmu_dipole_b_{cat}"] = rf"$\epsilon_{{b}}^{{\rm {cat}}}$" # noqa + labels = copy(names) for i, label in enumerate(names): if for_corner: @@ -113,21 +159,35 @@ def simname_to_pretty(simname): } if isinstance(simname, list): - return [ltx[s] if s in ltx else s for s in simname] + names = [ltx[s] if s in ltx else s for s in simname] + return "".join([f"{n}, " for n in names]).rstrip(", ") return ltx[simname] if simname in ltx else simname +def catalogue_to_pretty(catalogue): + ltx = {"SFI_gals": "SFI", + "CF4_TFR_not2MTForSFI_i": r"CF4 $i$-band", + "CF4_TFR_i": r"CF4 TFR $i$", + "CF4_TFR_w1": r"CF4 TFR W1", + } + + if isinstance(catalogue, list): + names = [ltx[s] if s in ltx else s for s in catalogue] + return "".join([f"{n}, " for n in names]).rstrip(", ") + + return ltx[catalogue] if catalogue in ltx else catalogue + + ############################################################################### # Read in goodness-of-fit # ############################################################################### -def get_gof(kind, simname, catalogue, ksmooth=0, nsim=None, sample_beta=True): +def get_gof(kind, fname): """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'") + if kind not in ["BIC", "AIC", "neg_lnZ_harmonic"]: + raise ValueError("`kind` must be one of 'BIC', 'AIC', 'neg_lnZ_harmonic'.") # noqa - fname = get_fname(simname, catalogue, ksmooth, nsim, sample_beta) with File(fname, 'r') as f: return f[f"gof/{kind}"][()] @@ -136,29 +196,48 @@ def get_gof(kind, simname, catalogue, ksmooth=0, nsim=None, sample_beta=True): # Read in samples # ############################################################################### -def get_samples(simname, catalogue, ksmooth=0, nsim=None, sample_beta=True, - convert_Vext_to_galactic=True): +def get_samples(fname, 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]) + else: + Vext = samples.pop("Vext") + samples["Vx"] = Vext[:, 0] + samples["Vy"] = Vext[:, 1] + samples["Vz"] = Vext[:, 2] + + keys = list(samples.keys()) + for key in keys: + + if "dmu_dipole_" in key: + dmu = samples.pop(key) + + dmu = csiborgtools.cartesian_to_radec(dmu) + dmu_mag = dmu[:, 0] + l, b = csiborgtools.radec_to_galactic(dmu[:, 1], dmu[:, 2]) + + samples[key.replace("dmu_dipole_", "dmu_dipole_mag_")] = dmu_mag + samples[key.replace("dmu_dipole_", "dmu_dipole_l_")] = l + samples[key.replace("dmu_dipole_", "dmu_dipole_b_")] = b + + if "a_dipole" in key: + adipole = samples.pop(key) + adipole = csiborgtools.cartesian_to_radec(adipole) + adipole_mag = adipole[:, 0] + l, b = csiborgtools.radec_to_galactic(adipole[:, 1], adipole[:, 2]) + samples[key.replace("a_dipole", "a_dipole_mag")] = adipole_mag + samples[key.replace("a_dipole", "a_dipole_l")] = l + samples[key.replace("a_dipole", "a_dipole_b")] = b return samples @@ -180,12 +259,20 @@ def get_bulkflow_simulation(simname, convert_to_galactic=True): return r, B -def get_bulkflow(simname, catalogue, ksmooth=0, nsim=None, sample_beta=True, - convert_to_galactic=True, weight_simulations=True, - downsample=1, Rmax=125): +def get_bulkflow(fname, simname, convert_to_galactic=True, downsample=1, + Rmax=125): + # Read in the samples + with File(fname, "r") as f: + Vext = f["samples/Vext"][...] + try: + beta = f["samples/beta"][...] + except KeyError: + beta = jnp.ones(len(Vext)) + # Read in the bulk flow f = np.load(f"/mnt/extraspace/rstiskalek/csiborg_postprocessing/field_shells/enclosed_mass_{simname}.npz") # noqa r = f["distances"] + # Shape of B_i is (nsims, nradial) Bx, By, Bz = (f["cumulative_velocity"][..., i] for i in range(3)) @@ -197,38 +284,18 @@ def get_bulkflow(simname, catalogue, ksmooth=0, nsim=None, sample_beta=True, By = By[:, mask] Bz = Bz[:, mask] - # Read in the samples - fname_samples = get_fname(simname, catalogue, ksmooth, nsim, sample_beta) - with File(fname_samples, 'r') as f: - # Shape of Vext_i is (nsamples,) - Vext_x, Vext_y, Vext_z = (f["samples/Vext"][...][::downsample, i] for i in range(3)) # noqa - nsamples = len(Vext_x) + Vext = Vext[::downsample] + beta = beta[::downsample] - if weight_simulations: - simulation_weights = jnp.exp(f["simulation_weights"][...])[::downsample] # noqa - else: - nsims = len(Bx) - simulation_weights = jnp.ones((nsamples, nsims)) / nsims - - if sample_beta: - beta = f["samples/beta"][...][::downsample] - else: - beta = jnp.ones(nsamples) - - # Multiply the simulation velocities by beta + # Multiply the simulation velocities by beta. Bx = Bx[..., None] * beta By = By[..., None] * beta Bz = Bz[..., None] * beta - # Shape of B_i is (nsims, nradial, nsamples) - Bx = Bx + Vext_x - By = By + Vext_y - Bz = Bz + Vext_z - - simulation_weights = simulation_weights.T[:, None, :] - Bx = jnp.sum(Bx * simulation_weights, axis=0) - By = jnp.sum(By * simulation_weights, axis=0) - Bz = jnp.sum(Bz * simulation_weights, axis=0) + # Add V_ext, shape of B_i is `(nsims, nradial, nsamples)`` + Bx = Bx + Vext[:, 0] + By = By + Vext[:, 1] + Bz = Bz + Vext[:, 2] if convert_to_galactic: Bmag, Bl, Bb = cartesian_to_radec(Bx, By, Bz) @@ -237,6 +304,8 @@ def get_bulkflow(simname, catalogue, ksmooth=0, nsim=None, sample_beta=True, else: B = np.stack([Bx, By, Bz], axis=-1) + # Stack over the simulations + B = np.hstack([B[i] for i in range(len(B))]) return r, B ############################################################################### @@ -245,25 +314,30 @@ def get_bulkflow(simname, catalogue, ksmooth=0, nsim=None, sample_beta=True, def samples_for_corner(samples): + samples = deepcopy(samples) + + # Remove the true parameters of each galaxy. + keys = list(samples.keys()) + for key in keys: + # Generally don't want to plot the true latent parameters.. + if "x_TFR" in key or "_true_" in key: + samples.pop(key) + + keys = list(samples.keys()) + 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 + return data, labels, keys -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 +def samples_to_getdist(samples, label): + data, __, keys = samples_for_corner(samples) return MCSamples( - samples=data, names=names, - labels=names_to_latex(names, for_corner=False), + samples=data, names=keys, + labels=names_to_latex(keys, for_corner=False), label=label) diff --git a/notebooks/flow/reconstruction_slice.ipynb b/notebooks/flow/reconstruction_slice.ipynb new file mode 100644 index 0000000..d73d1f0 --- /dev/null +++ b/notebooks/flow/reconstruction_slice.ipynb @@ -0,0 +1,506 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 8, + "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", + "from os.path import join\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from astropy.io import fits\n", + "from tqdm import tqdm\n", + "from scipy.ndimage import gaussian_filter\n", + "import scienceplots\n", + "import seaborn as sns\n", + "from warnings import warn\n", + "from astropy.cosmology import FlatLambdaCDM\n", + "from mpl_toolkits.axes_grid1 import make_axes_locatable\n", + "\n", + "import csiborgtools\n", + "\n", + "from reconstruction_comparison import simname_to_pretty\n", + "\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "%matplotlib inline\n", + "\n", + "paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring)\n", + "fdir = \"/mnt/extraspace/rstiskalek/csiborg_postprocessing/peculiar_velocity\"\n", + "\n", + "CLUSTERS = {\n", + " \"Shapley\": (-116.37827331, 69.68752732, -14.90318191),\n", + " \"Virgo\": (-3.48, 14.86, -2.21),\n", + " \"Norma\": (-50.26, -7.06, 6.44),\n", + " \"Coma\": (0.48, 72.79, 10.59),\n", + " \"Perseus\": (49.94, -10.73, -12.98),\n", + " \"Centaurus\": (-34.25, 14.93, -7.56)\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 258, + "metadata": {}, + "outputs": [], + "source": [ + "# from astropy.coordinates import SkyCoord\n", + "# from astropy.coordinates import Supergalactic\n", + "# from astropy.units import deg, Mpc\n", + "# from astropy.cosmology import FlatLambdaCDM\n", + "\n", + "# SPEED_OF_LIGHT = 299_792.458 \n", + "\n", + "\n", + "# cosmo = FlatLambdaCDM(H0=100, Om0=0.3)\n", + "\n", + "# RA = 196.490821\n", + "# dec = -33.067461\n", + "# dist = cosmo.comoving_distance(0.048)\n", + "\n", + "# c = SkyCoord(ra= RA * deg, dec= dec * deg, distance=dist)\n", + "# c = c.transform_to(Supergalactic)\n", + "# c.cartesian" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def get_field(simname, nsim, kind, MAS, grid):\n", + " # Open the field reader.\n", + " if simname == \"csiborg1\":\n", + " field_reader = csiborgtools.read.CSiBORG1Field(nsim)\n", + " elif \"csiborg2_\" in simname:\n", + " simkind = simname.split(\"_\")[-1]\n", + " field_reader = csiborgtools.read.CSiBORG2Field(nsim, simkind)\n", + " elif simname == \"csiborg2X\":\n", + " field_reader = csiborgtools.read.CSiBORG2XField(nsim)\n", + " elif simname == \"Carrick2015\":\n", + " folder = \"/mnt/extraspace/rstiskalek/catalogs\"\n", + " warn(f\"Using local paths from `{folder}`.\", RuntimeWarning)\n", + " if kind == \"density\":\n", + " fpath = join(folder, \"twompp_density_carrick2015.npy\")\n", + " return np.load(fpath).astype(np.float32)\n", + " elif kind == \"velocity\":\n", + " fpath = join(folder, \"twompp_velocity_carrick2015.npy\")\n", + " field = np.load(fpath).astype(np.float32)\n", + "\n", + " # Because the Carrick+2015 data is in the following form:\n", + " # \"The velocities are predicted peculiar velocities in the CMB\n", + " # frame in Galactic Cartesian coordinates, generated from the\n", + " # \\(\\delta_g^*\\) field with \\(\\beta^* = 0.43\\) and an external\n", + " # dipole \\(V_\\mathrm{ext} = [89,-131,17]\\) (Carrick et al Table 3)\n", + " # has already been added.\"\"\n", + " field[0] -= 89\n", + " field[1] -= -131\n", + " field[2] -= 17\n", + " field /= 0.43\n", + "\n", + " return field\n", + " else:\n", + " raise ValueError(f\"Unknown field kind: `{kind}`.\")\n", + " elif simname == \"CF4\":\n", + " folder = \"/mnt/extraspace/rstiskalek/catalogs/CF4\"\n", + " warn(f\"Using local paths from `{folder}`.\", RuntimeWarning)\n", + "\n", + " if kind == \"density\":\n", + " fpath = join(folder, f\"CF4_new_128-z008_realization{nsim}_delta.fits\") # noqa\n", + " elif kind == \"velocity\":\n", + " fpath = join(folder, f\"CF4_new_128-z008_realization{nsim}_velocity.fits\") # noqa\n", + " else:\n", + " raise ValueError(f\"Unknown field kind: `{kind}`.\")\n", + "\n", + " field = fits.open(fpath)[0].data\n", + "\n", + " # https://projets.ip2i.in2p3.fr//cosmicflows/ says to multiply by 52\n", + " if kind == \"velocity\":\n", + " field *= 52\n", + "\n", + " return field.astype(np.float32)\n", + " elif simname == \"Lilow2024\":\n", + " folder = \"/mnt/extraspace/rstiskalek/catalogs\"\n", + " warn(f\"Using local paths from `{folder}`.\", RuntimeWarning)\n", + "\n", + " if kind == \"density\":\n", + " fpath = join(folder, \"Lilow2024_density.npy\")\n", + " field = np.load(fpath)\n", + " elif kind == \"velocity\":\n", + " field = []\n", + " for p in [\"x\", \"y\", \"z\"]:\n", + " fpath = join(folder, f\"Lilow2024_{p}Velocity.npy\")\n", + " field.append(np.load(fpath).astype(np.float32))\n", + " field = np.stack(field)\n", + "\n", + " return field.astype(np.float32)\n", + " else:\n", + " raise ValueError(f\"Unknown simulation name: `{simname}`.\")\n", + "\n", + " # Read in the field.\n", + " if kind == \"density\":\n", + " field = field_reader.density_field(MAS=MAS, grid=grid)\n", + " elif kind == \"velocity\":\n", + " field = field_reader.velocity_field(MAS=MAS, grid=grid)\n", + " else:\n", + " raise ValueError(f\"Unknown field kind: `{kind}`.\")\n", + " \n", + " # NOTE added here \n", + " if kind == \"density\" and \"csiborg\" in simname:\n", + " Om0 = csiborgtools.simname2Omega_m(simname)\n", + " cosmo = FlatLambdaCDM(H0=100, Om0=Om0)\n", + " mean_rho_matter = cosmo.critical_density0.to(\"Msun/kpc^3\").value\n", + " mean_rho_matter *= Om0\n", + " field /= mean_rho_matter\n", + "\n", + " return field" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def make_slice(simname, xmin, xmax, ngrid):\n", + " boxsize = csiborgtools.simname2boxsize(simname)\n", + "\n", + " paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring)\n", + " nsims = paths.get_ics(simname)\n", + " print(nsims)\n", + "\n", + " if simname in [\"Carrick2015\", \"Lilow2024\"]:\n", + " frame = \"galactic\"\n", + " elif simname == \"CF4\":\n", + " frame = \"supergalactic\"\n", + " elif \"csiborg\" in simname:\n", + " frame = \"icrs\"\n", + " else:\n", + " raise ValueError(f\"Unknown frame for simulation: `{simname}`.\")\n", + "\n", + " out = np.full((len(nsims), ngrid, ngrid), np.nan)\n", + "\n", + " \n", + " for i, k in enumerate(tqdm(nsims, desc=simname)):\n", + " field = get_field(simname, k, \"density\", \"SPH\", 1024)\n", + " slice_values = csiborgtools.field.xy_supergalactic_slice(\n", + " field, boxsize, xmin, xmax, ngrid, frame)\n", + "\n", + " if simname == \"Lilow2024\":\n", + " slice_values[np.isnan(slice_values)] = 1\n", + "\n", + " out[i] = slice_values\n", + "\n", + " return out\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "load_from_disk = True\n", + "fname = \"/mnt/extraspace/rstiskalek/dump/XY_slices.npz\"\n", + "\n", + "xmin = -155\n", + "xmax = 155\n", + "ngrid = 500\n", + "\n", + "if not load_from_disk:\n", + " xy_carrick = make_slice(\"Carrick2015\", xmin, xmax, ngrid)\n", + " xy_lilow = make_slice(\"Lilow2024\", xmin, xmax, ngrid)\n", + " xy_CF4 = make_slice(\"CF4\", xmin, xmax, ngrid)\n", + " xy_CB2 = make_slice(\"csiborg2_main\", xmin, xmax, ngrid)\n", + " xy_CB2X = make_slice(\"csiborg2X\", xmin, xmax, ngrid)\n", + "\n", + " np.savez(fname, carrick=xy_carrick, lilow=xy_lilow,\n", + " CF4=xy_CF4, CB2=xy_CB2, CB2X=xy_CB2X)\n", + "else:\n", + " data = np.load(fname)\n", + " xy_carrick = data[\"carrick\"]\n", + " xy_lilow = data[\"lilow\"]\n", + " xy_CF4 = data[\"CF4\"]\n", + " xy_CB2 = data[\"CB2\"]\n", + " xy_CB2X = data[\"CB2X\"]\n", + " data.close()\n", + "\n", + "\n", + "xy_carrick += 1\n", + "\n", + "rsmooth = None\n", + "if rsmooth is not None:\n", + " sigma = rsmooth / ((xmax - xmin) / ngrid)\n", + " print(f\"Smoothing with sigma={sigma}\")\n", + "\n", + " for field in [xy_carrick, xy_CF4, xy_CB2, xy_CB2X]:\n", + " for i in range(len(field)):\n", + " field[i] = gaussian_filter(field[i], sigma=sigma)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Individual plots" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "\n", + "img = np.mean(xy_CB2X, axis=0)\n", + "img = np.clip(img, None, np.percentile(img.ravel(), 99.75))\n", + "img = np.log10(img)\n", + "\n", + "plt.imshow(img, origin=\"lower\", cmap=\"gray_r\", extent=[xmin, xmax, xmin, xmax])\n", + "\n", + "kwargs = {\"marker\": \"x\", \"s\": 15}\n", + "for name, coords in CLUSTERS.items():\n", + " plt.scatter(*coords[:2], label=name, **kwargs)\n", + "\n", + "plt.scatter(0, 0, label=\"Local Group\", **kwargs)\n", + "\n", + "plt.xlabel(r\"$\\mathrm{SGX} ~ [\\mathrm{Mpc} / h]$\")\n", + "plt.ylabel(r\"$\\mathrm{SGY} ~ [\\mathrm{Mpc} / h]$\")\n", + "\n", + "plt.legend(loc='lower center', bbox_to_anchor=(0.5, 1.025),\n", + " ncol=4, fontsize=\"small\", frameon=False,\n", + " handletextpad=0.1, # Reduce space between marker and text\n", + " borderpad=0.1, # Reduce padding between legend and border\n", + " columnspacing=0.1) # Reduce space between columns\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig(\"../../plots/slice_test.png\", dpi=450, bbox_inches=\"tight\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### CF4 data check" + ] + }, + { + "cell_type": "code", + "execution_count": 227, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "with plt.style.context(\"science\"):\n", + " fig, axs = plt.subplots(1, 2, figsize=(8.3, 8.3 * 0.75), sharex=True, sharey=True)\n", + "\n", + " kwargs = {\n", + " \"origin\": \"lower\", \"cmap\": \"viridis\", \"extent\": [xmin, xmax, xmin, xmax]}\n", + " im0 = axs[0].imshow(xy_CF4[0], **kwargs)\n", + " im1 = axs[1].imshow(xy_CF4[0] - xy_CF4[15], **kwargs)\n", + "\n", + " axs[0].set_title(\"Random sample\")\n", + " axs[1].set_title(\"Difference of two random samples\")\n", + "\n", + " # Adjust colorbars to be the same height as the plots using make_axes_locatable\n", + " labels = [r\"$\\delta$\", r\"$\\Delta \\delta$\"]\n", + " for i, im in enumerate([im0, im1]):\n", + " divider = make_axes_locatable(axs[i])\n", + " cax = divider.append_axes(\"right\", size=\"5%\", pad=0.1) # Create colorbar axis\n", + " fig.colorbar(im, label=labels[i], cax=cax, orientation=\"vertical\")\n", + "\n", + " for i in range(2):\n", + " axs[i].set_ylabel(r\"$\\mathrm{SGY} ~ [\\mathrm{Mpc / h}]$\")\n", + " axs[i].set_xlabel(r\"$\\mathrm{SGX} ~ [\\mathrm{Mpc / h}]$\")\n", + "\n", + " fig.tight_layout()\n", + " fig.savefig(\"../../plots/CF4_test.png\", dpi=450)\n", + " fig.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Paper plots" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1. Comparison of fields" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "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", + "\n", + " imshow_kwargs = {\"origin\": \"lower\", \"cmap\": \"gray_r\",\n", + " \"extent\": [xmin, xmax, xmin, xmax]}\n", + "\n", + " figwidth = 8.3\n", + " fig, axs = plt.subplots(2, 3, figsize=(figwidth, 0.67 * figwidth),\n", + " sharex=\"col\", sharey=True)\n", + " fig.subplots_adjust(wspace=0, hspace=0)\n", + "\n", + " # Carrick 2015\n", + " img = np.mean(xy_carrick, axis=0)\n", + " img = np.clip(img, None, np.percentile(img.ravel(), 99.75))\n", + " axs[0, 0].imshow(img, **imshow_kwargs)\n", + " axs[0, 0].text(\n", + " 0.05, 0.05, simname_to_pretty(\"Carrick2015\"), transform=axs[0, 0].transAxes,\n", + " bbox=dict(facecolor='white', alpha=0.75))\n", + "\n", + " # Lilow 2024\n", + " img = np.mean(xy_lilow, axis=0)\n", + " img = np.clip(img, None, np.percentile(img.ravel(), 99.75))\n", + " axs[0, 1].imshow(img, **imshow_kwargs)\n", + " axs[0, 1].text(\n", + " 0.05, 0.05, simname_to_pretty(\"Lilow2024\"), transform=axs[0, 1].transAxes,\n", + " bbox=dict(facecolor='white', alpha=0.75))\n", + "\n", + " # CF4\n", + " img = np.mean(xy_CF4, axis=0)\n", + " img = np.clip(img, None, np.percentile(img.ravel(), 99.9))\n", + " axs[0, 2].imshow(img, **imshow_kwargs)\n", + " axs[0, 2].text(\n", + " 0.05, 0.05, simname_to_pretty(\"CF4\"), transform=axs[0, 2].transAxes,\n", + " bbox=dict(facecolor='white', alpha=0.75))\n", + "\n", + " # csiborg2_main \n", + " img = np.mean(xy_CB2, axis=0)\n", + " img = np.clip(img, None, np.percentile(img.ravel(), 99.9))\n", + " img = np.log10(img)\n", + " axs[1, 0].imshow(img, **imshow_kwargs)\n", + " axs[1, 0].text(\n", + " 0.05, 0.05, simname_to_pretty(\"csiborg2_main\"), transform=axs[1, 0].transAxes,\n", + " bbox=dict(facecolor='white', alpha=0.75))\n", + "\n", + " # Manticore\n", + " img = np.mean(xy_CB2X, axis=0)\n", + " img = np.clip(img, None, np.percentile(img.ravel(), 99.9))\n", + " img = np.log10(img)\n", + " axs[1, 1].imshow(img, **imshow_kwargs)\n", + " axs[1, 1].text(\n", + " 0.05, 0.05, simname_to_pretty(\"csiborg2X\"), transform=axs[1, 1].transAxes,\n", + " bbox=dict(facecolor='white', alpha=0.75))\n", + "\n", + " # Jenny's field\n", + " img = np.zeros_like(xy_CB2X[0])\n", + " axs[1, 2].imshow(img, **imshow_kwargs)\n", + " axs[1, 2].text(\n", + " 0.05, 0.05, simname_to_pretty(\"Sorce+\"), transform=axs[1, 2].transAxes,\n", + " bbox=dict(facecolor='white', alpha=0.75))\n", + "\n", + " \n", + " for i in range(2):\n", + " axs[i, 0].set_ylabel(r\"$\\mathrm{SGY} ~ [\\mathrm{Mpc} / h]$\")\n", + "\n", + " for i in range(3):\n", + " axs[-1, i].set_xlabel(r\"$\\mathrm{SGX} ~ [\\mathrm{Mpc} / h]$\")\n", + " \n", + " for i in range(2):\n", + " for j in range(3):\n", + " axs[i, j].scatter(0, 0, marker=\"x\", s=15, color=\"firebrick\")\n", + "\n", + " fig.tight_layout()\n", + " fig.savefig(\"../../plots/XY_slices.pdf\", dpi=450)\n", + " fig.show()" + ] + }, + { + "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 +} diff --git a/notebooks/flow/selection.ipynb b/notebooks/flow/selection.ipynb new file mode 100644 index 0000000..86b746d --- /dev/null +++ b/notebooks/flow/selection.ipynb @@ -0,0 +1,586 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Selection fitting " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from tqdm import trange\n", + "from h5py import File\n", + "from jax.random import PRNGKey\n", + "from numpyro.infer import MCMC, NUTS, init_to_median\n", + "from astropy.cosmology import FlatLambdaCDM \n", + "from corner import corner\n", + "\n", + "import csiborgtools\n", + "\n", + "%matplotlib inline\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "Om0 = 0.3\n", + "H0 = 100\n", + "cosmo = FlatLambdaCDM(H0=H0, Om0=Om0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fit parameters of the toy selection model\n", + "\n", + "Choose either CF4 TFR or SFI." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# with File(\"/mnt/extraspace/rstiskalek/catalogs/PV_compilation.hdf5\", 'r') as f:\n", + "# grp = f[\"SFI_gals\"]\n", + "# # # print(grp.keys())\n", + "# mag = grp[\"mag\"][...]\n", + "\n", + "\n", + "# with File(\"/mnt/extraspace/rstiskalek/catalogs/PV/CF4/CF4_TF-distances.hdf5\", 'r') as f:\n", + " # mag = f[\"w1\"][...]\n", + "# mag = mag[mag > 3]\n", + "\n", + "model = csiborgtools.flow.ToyMagnitudeSelection()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "nuts_kernel = NUTS(model, init_strategy=init_to_median(num_samples=5000))\n", + "mcmc = MCMC(nuts_kernel, num_warmup=15_000, num_samples=15_000)\n", + "mcmc.run(PRNGKey(42), extra_fields=(\"potential_energy\",), mag=mag)\n", + "samples = mcmc.get_samples()\n", + "\n", + "mcmc.print_summary()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "keys = [\"alpha\", \"a\", \"m1\", \"m2\"]\n", + "data = np.vstack([samples[key] for key in keys]).T\n", + "labels = [r\"$\\alpha$\", r\"$a$\", r\"$m_1$\", r\"$m_2$\"]\n", + "\n", + "fig = corner(data, labels=labels, show_titles=True, smooth=True)\n", + "# fig.savefig(\"../../plots/selection_corner_CF4.png\", dpi=450)\n", + "\n", + "fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for key in keys:\n", + " print(f\"{key}: {np.mean(samples[key]):.3f} +/- {np.std(samples[key]):.3f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mrange = np.linspace(mag.min(), mag.max(), 1000)\n", + "nsamples = len(samples[\"m1\"])\n", + "\n", + "indx = np.random.choice(nsamples, 500)\n", + "\n", + "y = [model.log_observed_pdf(mrange, samples[\"alpha\"][i], samples[\"m1\"][i], samples[\"m2\"][i], samples[\"a\"][i]) for i in indx]\n", + "y = np.asarray(y)\n", + "y = 10**y" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure()\n", + "plt.hist(mag, bins=\"auto\", density=True, histtype=\"step\", color=\"blue\",\n", + " label=\"Data\", zorder=1)\n", + "\n", + "for i in range(100):\n", + " plt.plot(mrange, y[i], color=\"black\", alpha=0.25, lw=0.25)\n", + "\n", + "plt.xlabel(r\"$m$\")\n", + "plt.ylabel(r\"$p(m)$\")\n", + "plt.tight_layout()\n", + "\n", + "plt.savefig(\"../../plots/CF4_selection.png\", dpi=450)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Hubble \n", + "\n", + "$p(m) \\propto 10^{0.6 m}$ ?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.integrate import quad\n", + "from scipy.interpolate import interp1d\n", + "\n", + "zmin=0.00001\n", + "zmax=5\n", + "z_range = np.linspace(zmin, zmax, 100000)\n", + "r_range = cosmo.comoving_distance(z_range).value\n", + "distmod_range = cosmo.distmod(z_range).value\n", + "r2mu = interp1d(r_range, distmod_range, kind=\"cubic\")\n", + "\n", + "\n", + "def schechter_LF(M, M0=-20.83, alpha=-1):\n", + " return 10**(0.4 * (M0 - M) * (alpha + 1)) * np.exp(-10**(0.4 * (M0 - M)))\n", + "\n", + "\n", + "def sample_schechter_LF(M0=-20.83, alpha=-1, Mfaint=-16, Mbright=-30, npoints=1):\n", + " norm = quad(schechter_LF, Mbright, Mfaint, args=(M0, alpha))[0]\n", + "\n", + " samples = np.full(npoints, np.nan)\n", + " for i in trange(npoints):\n", + " while np.isnan(samples[i]):\n", + " M = np.random.uniform(Mbright, Mfaint)\n", + " if np.random.uniform(0, 1) < schechter_LF(M, M0, alpha) / norm:\n", + " samples[i] = M\n", + "\n", + " return samples\n", + "\n", + "\n", + "def sample_radial_distance(rmax, npoints):\n", + " return rmax * np.random.rand(npoints)**(1/3)\n", + "\n", + "\n", + "# z = np.linspace(0.001, 0.15, 100000)\n", + "# r = cosmo.comoving_distance(z).value\n", + "# mu = cosmo.distmod(z).value\n", + "# \n", + "# \n", + "# drdmu = np.gradient(r, mu)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "rmax = 300\n", + "npoints = 5000\n", + "\n", + "r_150 = sample_radial_distance(100, npoints)\n", + "r_300 = sample_radial_distance(300, npoints)\n", + "r_1000 = sample_radial_distance(5000, npoints)\n", + "\n", + "mu_150 = r2mu(r_150)\n", + "mu_300 = r2mu(r_300)\n", + "mu_1000 = r2mu(r_1000)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def p_hubble(m, a, b):\n", + " norm = np.log10(- 5 / np.log(1000) * (10**(3 / 5 * a) - 10**(3 / 5 * b)))\n", + " return 10**(0.6 * m - norm)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "M_LF = sample_schechter_LF(npoints=npoints)\n", + "\n", + "M_LF2 = sample_schechter_LF(npoints=npoints, M0=-20.83, alpha=-1.5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure()\n", + "M = -20.3\n", + "\n", + "# m = mu + M\n", + "# x = np.linspace(11, m.max(), 1000)\n", + "# plt.plot(x, p_hubble(x, m.min(), m.max()) * 5.5, color=\"black\")\n", + "\n", + "# plt.hist(m, bins=\"auto\", density=True, histtype=\"step\", color=\"blue\",)\n", + "\n", + "\n", + "cols = [\"red\", \"green\", \"blue\"]\n", + "rmax = [150, 300, 1000]\n", + "# for i, mu in enumerate([mu_150, mu_300, mu_1000]):\n", + "for i, mu in enumerate([mu_150, mu_300, mu_1000]):\n", + " plt.hist(mu + M_LF, bins=\"auto\", density=True,\n", + " histtype=\"step\", color=cols[i], label=rmax[i])\n", + "\n", + " plt.hist(mu + M_LF2, bins=\"auto\", density=True,\n", + " histtype=\"step\", color=cols[i], label=rmax[i], ls=\"--\")\n", + "\n", + "\n", + "plt.hist(mag, bins=\"auto\", density=True, histtype=\"step\", color=\"black\", label=\"Data\")\n", + "\n", + "plt.yscale(\"log\")\n", + "# plt.axvline(r2mu(rmax) + M, c=\"red\")\n", + "plt.legend()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "M = sample_schechter_LF(npoints=10000)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure()\n", + "plt.hist(x, bins=\"auto\", density=True, histtype=\"step\", color=\"blue\",)\n", + "# plt.yscale(\"log\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "yeuclidean = 10**(0.6 * mu)\n", + "ycomoving = r**2 * drdmu\n", + "\n", + "\n", + "\n", + "k = np.argmin(np.abs(mu - 35)) \n", + "\n", + "yeuclidean /= yeuclidean[k]\n", + "ycomoving /= ycomoving[k]\n", + "\n", + "\n", + "\n", + "plt.figure()\n", + "plt.plot(z, yeuclidean, label=\"Euclidean\")\n", + "plt.plot(z, ycomoving, label=\"Comoving\")\n", + "\n", + "# plt.yscale('log')\n", + "plt.xlabel(r\"$z$\")\n", + "plt.ylabel(r\"$p(\\mu)$\")\n", + "\n", + "plt.legend()\n", + "plt.tight_layout()\n", + "plt.savefig(\"../../plots/pmu_comoving_vs_euclidean.png\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.interpolate import interp1d\n", + "from scipy.integrate import quad\n", + "from scipy.stats import norm\n", + "\n", + "z = np.linspace(0.001, 0.1, 100000)\n", + "r = cosmo.comoving_distance(z).value\n", + "mu = cosmo.distmod(z).value\n", + "\n", + "\n", + "drdmu = np.gradient(r, mu)\n", + "\n", + "\n", + "\n", + "mu2drdmu = interp1d(mu, drdmu, kind='cubic')\n", + "mu2r = interp1d(mu, r, kind='cubic')\n", + "\n", + "\n", + "\n", + "def schechter_LF(M):\n", + " M0 = -20.83\n", + " alpha = -1\n", + " return 10**(0.4 * (M0 - M) * (alpha + 1)) * np.exp(-10**(0.4 * (M0 - M)))\n", + " \n", + "\n", + "\n", + "\n", + "def phi(M):\n", + " # return 1\n", + " # return schechter_LF(M)# * norm.pdf(M, loc=-22, scale=1)\n", + " loc = -22\n", + " std = 0.1\n", + "\n", + " return norm.pdf(M, loc=loc, scale=std)\n", + "\n", + " # if -22 < M < -21:\n", + " # return 1\n", + " # else:\n", + " # return 0\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "xrange = np.linspace(-24, -18, 1000)\n", + "\n", + "plt.figure()\n", + "plt.plot(xrange, schechter_LF(xrange))\n", + "# plt.yscale(\"log\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mu_min = mu.min()\n", + "mu_max = mu.max()\n", + "\n", + "\n", + "m = 12\n", + "\n", + "\n", + "m_range = np.linspace(10, 16, 100)\n", + "y = np.full_like(m_range, np.nan)\n", + "for i in trange(len(m_range)):\n", + " m = m_range[i]\n", + " # y[i] = quad(lambda x: mu2drdmu(x) * mu2r(x)**2 * phi(m - x), mu_min, mu_max)[0]\n", + " y[i] = quad(lambda x: 10**(0.6 * x) * phi(m - x), mu_min, mu_max)[0]\n", + "\n", + "\n", + "\n", + "y_hubble = 10**(0.6 * m_range)\n", + "ycomoving = r**2 * drdmu\n", + "\n", + "\n", + "k = np.argmin(np.abs(m_range - 12))\n", + "\n", + "y_hubble /= y_hubble[k]\n", + "y /= y[k]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mu_max - 18" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure()\n", + "plt.plot(m_range, y, label=\"Numerical\")\n", + "plt.plot(m_range, y_hubble, label=\"Hubble\")\n", + "# plt.plot(mu, ycomoving, label=\"Comoving\")\n", + "\n", + "plt.xlabel(r\"$m$\")\n", + "plt.ylabel(r\"$p(m)$\")\n", + "plt.legend()\n", + "\n", + "# plt.yscale(\"log\")\n", + "plt.tight_layout()\n", + "# plt.xlim(10, 14)\n", + "\n", + "plt.savefig(\"../../plots/pm.png\", dpi=450)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Simple simulation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "npoints = 10000\n", + "rmax = 30000\n", + "\n", + "# pos = np.random.uniform(-boxsize, boxsize, (npoints, 3))\n", + "\n", + "\n", + "r = rmax * np.random.rand(npoints)**(1/3)\n", + "\n", + "mu = 5 * np.log10(r) + 25\n", + "\n", + "# M = np.ones(npoints) * -22\n", + "# M = np.random.normal(-22, 100, npoints)\n", + "M = np.random.uniform(-24, -18, npoints)\n", + "\n", + "\n", + "m = mu + M" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def f(m, a, b):\n", + " norm = np.log10(- 5 / np.log(1000) * (10**(3 / 5 * a) - 10**(3 / 5 * b)))\n", + " return 10**(0.6 * m - norm)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure()\n", + "plt.hist(m, bins=\"auto\", density=True, histtype=\"step\")\n", + "m_range = np.linspace(m.min(), m.max(), 100)\n", + "# plt.plot(m_range, f(m_range, m.min(), m.max()))\n", + "# plt.yscale(\"log\")\n", + "plt.show()" + ] + }, + { + "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 +} diff --git a/scripts/field_prop/clear.sh b/scripts/field_prop/clear.sh new file mode 100755 index 0000000..bc0d2e7 --- /dev/null +++ b/scripts/field_prop/clear.sh @@ -0,0 +1,2 @@ +cm="rm *.out" +$cm \ No newline at end of file diff --git a/scripts/field_prop/field_los.py b/scripts/field_prop/field_los.py index 9096113..d2e7075 100644 --- a/scripts/field_prop/field_los.py +++ b/scripts/field_prop/field_los.py @@ -396,10 +396,17 @@ if __name__ == "__main__": parser.add_argument("--grid", type=int, help="Grid resolution.") args = parser.parse_args() - rmax = 300 - dr = 0.5 + rmax = 200 + if args.catalogue == "CF4_GroupAll": + dr = 1 + else: + dr = 0.75 + + # smooth_scales = [0, 2, 4, 6, 8] smooth_scales = [0] + print(f"Running catalogue {args.catalogue} for simulation {args.simname}.") + comm = MPI.COMM_WORLD paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring) nsims = get_nsims(args, paths) diff --git a/scripts/field_prop/field_los.sh b/scripts/field_prop/field_los.sh index 8ec545b..03ad644 100755 --- a/scripts/field_prop/field_los.sh +++ b/scripts/field_prop/field_los.sh @@ -1,17 +1,26 @@ nthreads=1 memory=64 -on_login=1 +on_login=${1} queue="berg" env="/mnt/users/rstiskalek/csiborgtools/venv_csiborg/bin/python" file="field_los.py" nsims="-1" +# These are only for CB MAS="SPH" grid=1024 -for simname in "Lilow2024"; do - for catalogue in "CF4_TFR"; do +if [ "$on_login" != "1" ] && [ "$on_login" != "0" ] +then + echo "'on_login' (1) must be either 0 or 1." + exit 1 +fi + + +# for simname in "csiborg1" "csiborg2_main" "csiborg2X" "Lilow2024" "Carrick2015" "CF4"; do +for simname in "csiborg2_main"; do + for catalogue in "2MTF" "SFI_gals" "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 new file mode 100644 index 0000000..a312d86 --- /dev/null +++ b/scripts/field_prop/field_los_indranil_void.py @@ -0,0 +1,95 @@ +# 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. +""" +MPI script to interpolate the density and velocity fields along the line of +sight. +""" +from os.path import join + +import csiborgtools +import numpy as np +from astropy.coordinates import SkyCoord, angular_separation +from h5py import File +from mpi4py import MPI +from scipy.interpolate import RegularGridInterpolator + +from field_los import get_los + + +def interpolate_indranil_void(kind, RA, dec, rmax, dr, dump_folder, catalogue): + fdir = "/mnt/extraspace/rstiskalek/catalogs" + if kind == "exp": + fname = join(fdir, "v_pec_EXP_IndranilVoid.dat") + elif kind == "gauss": + fname = join(fdir, "v_pec_GAUSS_IndranilVoid.dat") + else: + raise ValueError("Invalid void kind.") + + # These are only velocities. + data = np.loadtxt(fname) + fname_out = join(dump_folder, f"los_{catalogue}_IndranilVoid_{kind}.hdf5") + + r_grid = np.arange(0, 251) + phi_grid = np.arange(0, 181) + r_eval = np.arange(0, rmax, dr).astype(float) / 0.674 + + model_axis = SkyCoord(l=117, b=4, frame='galactic', unit='deg').icrs + coords = SkyCoord(ra=RA, dec=dec, unit='deg').icrs + + # Get angular separation in degrees + phi = angular_separation(coords.ra.rad, coords.dec.rad, + model_axis.ra.rad, model_axis.dec.rad) + phi *= 180 / np.pi + + # Get the interpolator + f = RegularGridInterpolator((r_grid, phi_grid), data.T) + # Get the dummy x-values to evaluate for each LOS + x_dummy = np.ones((len(r_eval), 2)) + x_dummy[:, 0] = r_eval + + result = np.full((len(RA), len(r_eval)), np.nan) + for i in range(len(RA)): + x_dummy[:, 1] = phi[i] + result[i] = f(x_dummy) + + # Write the output, homogenous density. + density = np.ones_like(result) + print(f"Writing to `{fname_out}`.") + with File(fname_out, 'w') as f_out: + f_out.create_dataset("rdist_0", data=r_eval * 0.674) + f_out.create_dataset("density_0", data=density) + f_out.create_dataset("velocity_0", data=result) + + +############################################################################### +# Command line interface # +############################################################################### + + +if __name__ == "__main__": + kind = "exp" + rmax = 165 + dr = 1 + + comm = MPI.COMM_WORLD + paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring) + + out_folder = "/mnt/extraspace/rstiskalek/csiborg_postprocessing/field_los" + + for catalogue in ["LOSS", "Foundation", "2MTF", "SFI_gals", "CF4_TFR", "CF4_GroupAll"]: # noqa + print(f"Running kind `{kind}` for catalogue `{catalogue}`.") + + RA, dec = get_los(catalogue, "", comm).T + interpolate_indranil_void( + kind, RA, dec, rmax, dr, out_folder, catalogue) diff --git a/scripts/flow/clear.sh b/scripts/flow/clear.sh new file mode 100755 index 0000000..bc0d2e7 --- /dev/null +++ b/scripts/flow/clear.sh @@ -0,0 +1,2 @@ +cm="rm *.out" +$cm \ No newline at end of file diff --git a/scripts/flow/flow_validation.py b/scripts/flow/flow_validation.py index ec49a1f..c7ccc35 100644 --- a/scripts/flow/flow_validation.py +++ b/scripts/flow/flow_validation.py @@ -34,7 +34,7 @@ def parse_args(): help="Simulation name.") parser.add_argument("--catalogue", type=str, required=True, help="PV catalogues.") - parser.add_argument("--ksmooth", type=int, default=1, + parser.add_argument("--ksmooth", type=int, default=0, help="Smoothing index.") parser.add_argument("--ksim", type=none_or_int, default=None, help="IC iteration number. If 'None', all IC realizations are used.") # noqa @@ -61,6 +61,7 @@ import sys from os.path import join # noqa import csiborgtools # noqa +from csiborgtools import fprint # noqa import jax # noqa from h5py import File # noqa from numpyro.infer import MCMC, NUTS, init_to_median # noqa @@ -72,7 +73,7 @@ def print_variables(names, variables): print(flush=True) -def get_models(get_model_kwargs, toy_selection, verbose=True): +def get_models(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/" @@ -111,7 +112,7 @@ def get_models(get_model_kwargs, toy_selection, verbose=True): cat, fpath, paths, ksmooth=ARGS.ksmooth) models[i] = csiborgtools.flow.get_model( - loader, toy_selection=toy_selection[i], **get_model_kwargs) + loader, mag_selection=mag_selection[i], **get_model_kwargs) print(f"\n{'Num. radial steps':<20} {len(loader.rdist)}\n", flush=True) return models @@ -127,9 +128,15 @@ def get_harmonic_evidence(samples, log_posterior, nchains_harmonic, epoch_num): data, log_posterior, return_flow_samples=False, epochs_num=epoch_num) -def run_model(model, nsteps, nburn, model_kwargs, out_folder, sample_beta, - calculate_harmonic, nchains_harmonic, epoch_num, kwargs_print): +def run_model(model, nsteps, nburn, model_kwargs, out_folder, + calculate_harmonic, nchains_harmonic, epoch_num, kwargs_print, + fname_kwargs): """Run the NumPyro model and save output to a file.""" + paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring) + + fname = paths.flow_validation(out_folder, ARGS.simname, ARGS.catalogue, + **fname_kwargs) + try: ndata = sum(model.ndata for model in model_kwargs["models"]) except AttributeError as e: @@ -159,13 +166,6 @@ def run_model(model, nsteps, nburn, model_kwargs, out_folder, sample_beta, neg_ln_evidence = jax.numpy.nan neg_ln_evidence_err = (jax.numpy.nan, jax.numpy.nan) - fname = f"samples_{ARGS.simname}_{'+'.join(ARGS.catalogue)}_ksmooth{ARGS.ksmooth}.hdf5" # noqa - if ARGS.ksim is not None: - fname = fname.replace(".hdf5", f"_nsim{ARGS.ksim}.hdf5") - - if sample_beta: - fname = fname.replace(".hdf5", "_sample_beta.hdf5") - fname = join(out_folder, fname) print(f"Saving results to `{fname}`.") with File(fname, "w") as f: @@ -209,7 +209,7 @@ def run_model(model, nsteps, nburn, model_kwargs, out_folder, sample_beta, def get_distmod_hyperparams(catalogue, sample_alpha, sample_mag_dipole): alpha_min = -1.0 - alpha_max = 3.0 + alpha_max = 10.0 if catalogue in ["LOSS", "Foundation", "Pantheon+", "Pantheon+_groups", "Pantheon+_zSN"]: # noqa return {"e_mu_min": 0.001, "e_mu_max": 1.0, @@ -224,7 +224,6 @@ def get_distmod_hyperparams(catalogue, sample_alpha, sample_mag_dipole): "a_mean": -21., "a_std": 5.0, "b_mean": -5.95, "b_std": 4.0, "c_mean": 0., "c_std": 20.0, - "sample_curvature": False, "a_dipole_mean": 0., "a_dipole_std": 1.0, "sample_a_dipole": sample_mag_dipole, "alpha_min": alpha_min, "alpha_max": alpha_max, @@ -242,14 +241,27 @@ def get_distmod_hyperparams(catalogue, sample_alpha, sample_mag_dipole): raise ValueError(f"Unsupported catalogue: `{ARGS.catalogue}`.") -def get_toy_selection(toy_selection, catalogue): - if not toy_selection: +def get_toy_selection(catalogue): + """Toy magnitude selection coefficients.""" + if catalogue == "SFI_gals": + kind = "soft" + # m1, m2, a + coeffs = [11.467, 12.906, -0.231] + elif "CF4_TFR" in catalogue and "_i" in catalogue: + kind = "soft" + coeffs = [13.043, 14.423, -0.129] + elif "CF4_TFR" in catalogue and "w1" in catalogue: + kind = "soft" + coeffs = [11.731, 14.189, -0.118] + elif catalogue == "2MTF": + kind = "hard" + coeffs = 11.25 + else: + fprint(f"found no selection coefficients for {catalogue}.") return None - if catalogue == "SFI_gals": - return [1.221e+01, 1.297e+01, -2.708e-01] - else: - raise ValueError(f"Unsupported catalogue: `{ARGS.catalogue}`.") + return {"kind": kind, + "coeffs": coeffs} if __name__ == "__main__": @@ -262,43 +274,63 @@ if __name__ == "__main__": # Fixed user parameters # ########################################################################### - nsteps = 1000 - nburn = 500 - zcmb_min = 0 + # `None` means default behaviour + nsteps = 10_000 + nburn = 2_000 + zcmb_min = None zcmb_max = 0.05 nchains_harmonic = 10 num_epochs = 50 - inference_method = "bayes" - calculate_harmonic = True if inference_method == "mike" else False - maxmag_selection = None - sample_alpha = False - sample_beta = True + inference_method = "mike" + mag_selection = None + sample_alpha = True + sample_beta = None sample_Vmono = False sample_mag_dipole = False - toy_selection = True + calculate_harmonic = False if inference_method == "bayes" else True - if toy_selection and inference_method == "mike": - raise ValueError("Toy selection is not supported with `mike` inference.") # noqa - - if nsteps % nchains_harmonic != 0: - raise ValueError( - "The number of steps must be divisible by the number of chains.") + fname_kwargs = {"inference_method": inference_method, + "smooth": ARGS.ksmooth, + "nsim": ARGS.ksim, + "zcmb_min": zcmb_min, + "zcmb_max": zcmb_max, + "mag_selection": mag_selection, + "sample_alpha": sample_alpha, + "sample_beta": sample_beta, + "sample_Vmono": sample_Vmono, + "sample_mag_dipole": sample_mag_dipole, + } main_params = {"nsteps": nsteps, "nburn": nburn, "zcmb_min": zcmb_min, "zcmb_max": zcmb_max, - "maxmag_selection": maxmag_selection, + "mag_selection": mag_selection, "calculate_harmonic": calculate_harmonic, "nchains_harmonic": nchains_harmonic, "num_epochs": num_epochs, "inference_method": inference_method, "sample_mag_dipole": sample_mag_dipole, - "toy_selection": toy_selection} + } print_variables(main_params.keys(), main_params.values()) - calibration_hyperparams = {"Vext_min": -1000, "Vext_max": 1000, + if sample_beta is None: + sample_beta = ARGS.simname == "Carrick2015" + + if mag_selection and inference_method != "bayes": + raise ValueError("Magnitude selection is only supported with `bayes` inference.") # noqa + + if inference_method != "bayes": + mag_selection = [None] * len(ARGS.catalogue) + elif mag_selection is None or mag_selection: + mag_selection = [get_toy_selection(cat) for cat in ARGS.catalogue] + + if nsteps % nchains_harmonic != 0: + raise ValueError( + "The number of steps must be divisible by the number of chains.") + + calibration_hyperparams = {"Vext_min": -3000, "Vext_max": 3000, "Vmono_min": -1000, "Vmono_max": 1000, - "beta_min": -1.0, "beta_max": 3.0, + "beta_min": -10.0, "beta_max": 10.0, "sigma_v_min": 1.0, "sigma_v_max": 750., "sample_Vmono": sample_Vmono, "sample_beta": sample_beta, @@ -315,15 +347,11 @@ if __name__ == "__main__": kwargs_print = (main_params, calibration_hyperparams, *distmod_hyperparams_per_catalogue) + ########################################################################### - get_model_kwargs = {"zcmb_min": zcmb_min, "zcmb_max": zcmb_max, - "maxmag_selection": maxmag_selection} - - toy_selection = [get_toy_selection(toy_selection, cat) - for cat in ARGS.catalogue] - - models = get_models(get_model_kwargs, toy_selection) + 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, @@ -334,5 +362,5 @@ if __name__ == "__main__": model = csiborgtools.flow.PV_validation_model run_model(model, nsteps, nburn, model_kwargs, out_folder, - calibration_hyperparams["sample_beta"], calculate_harmonic, - nchains_harmonic, num_epochs, kwargs_print) + 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 50f7b16..e93ed1f 100755 --- a/scripts/flow/flow_validation.sh +++ b/scripts/flow/flow_validation.sh @@ -1,5 +1,5 @@ #!/bin/bash -memory=7 +memory=14 on_login=${1} queue=${2} ndevice=1 @@ -37,12 +37,19 @@ else fi -# for simname in "Lilow2024" "CF4" "CF4gp" "csiborg1" "csiborg2_main" "csiborg2X"; do -for simname in "Carrick2015"; do - for catalogue in "SFI_gals"; do - # for catalogue in "CF4_TFR_i"; do - # for ksim in 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do +for simname in "Carrick2015" "csiborg2_main"; do +# for simname in "csiborg2_main" "csiborg2X" ; do +# for simname in "Carrick2015" "Lilow2024" "csiborg2_main" "csiborg2X" "CF4"; 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 "2MTF" "SFI_gals" "CF4_TFR_i"; 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 ksim in "none"; do + for ksmooth in 1 2 3 4; do pythoncm="$env $file --catalogue $catalogue --simname $simname --ksim $ksim --ksmooth $ksmooth --ndevice $ndevice --device $device" if [ "$on_login" == "1" ]; then @@ -65,3 +72,5 @@ for simname in "Carrick2015"; do done done done + +done \ No newline at end of file diff --git a/scripts/flow/test_harmonic.py b/scripts/flow/test_harmonic.py index 69c6a4f..6e831f5 100644 --- a/scripts/flow/test_harmonic.py +++ b/scripts/flow/test_harmonic.py @@ -1,4 +1,4 @@ -from argparse import ArgumentParser, ArgumentTypeError +from argparse import ArgumentParser def parse_args(): @@ -10,7 +10,7 @@ def parse_args(): ARGS = parse_args() # This must be done before we import JAX etc. -from numpyro import set_host_device_count, set_platform # noqa +from numpyro import set_platform # noqa set_platform(ARGS.device) # noqa @@ -30,8 +30,8 @@ def get_harmonic_evidence(samples, log_posterior, nchains_harmonic, epoch_num): data, log_posterior, return_flow_samples=False, epochs_num=epoch_num) -ndim = 250 -nsamples = 100_000 +ndim = 150 +nsamples = 50_000 nchains_split = 10 loc = jnp.zeros(ndim) cov = jnp.eye(ndim) @@ -42,10 +42,6 @@ X = gen.multivariate_normal(loc, cov, size=nsamples) samples = {f"x_{i}": X[:, i] for i in range(ndim)} logprob = multivariate_normal(loc, cov).logpdf(X) -neg_lnZ_laplace, neg_lnZ_laplace_error = csiborgtools.laplace_evidence( - samples, logprob, nchains_split) -print(f"neg_lnZ_laplace: {neg_lnZ_laplace} +/- {neg_lnZ_laplace_error}") - neg_lnZ_harmonic, neg_lnZ_harmonic_error = get_harmonic_evidence( samples, logprob, nchains_split, epoch_num=30)