diff --git a/csiborgtools/params.py b/csiborgtools/params.py index 2442473..4de3c5e 100644 --- a/csiborgtools/params.py +++ b/csiborgtools/params.py @@ -92,6 +92,7 @@ def simname2boxsize(simname): "csiborg2_random": 676.6, "borg1": 677.7, "borg2": 676.6, + "borg2_all": 676.6, "quijote": 1000., "TNG300-1": 205., "Carrick2015": 400., @@ -123,6 +124,8 @@ def simname2Omega_m(simname): "csiborg2_random": 0.3111, "csiborg2_varysmall": 0.3111, "borg1": 0.307, + "borg2": 0.3111, + "borg2_all": 0.3111, "Carrick2015": 0.3, } @@ -144,6 +147,7 @@ paths_glamdring = { "borg1_dir": "/mnt/users/hdesmond/BORG_final", "borg2_dir": "/mnt/extraspace/rstiskalek/BORG_STOPYRA_2023", "tng300_1_dir": "/mnt/extraspace/rstiskalek/TNG300-1/", + "aux_cat_dir": "/mnt/extraspace/rstiskalek/catalogs", } diff --git a/csiborgtools/read/__init__.py b/csiborgtools/read/__init__.py index 3480929..2fe8ec7 100644 --- a/csiborgtools/read/__init__.py +++ b/csiborgtools/read/__init__.py @@ -14,7 +14,8 @@ # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. from .catalogue import (CSiBORG1Catalogue, CSiBORG2Catalogue, # noqa CSiBORG2SUBFINDCatalogue, # noqa - CSiBORG2MergerTreeReader, QuijoteCatalogue) # noqa + CSiBORG2MergerTreeReader, QuijoteCatalogue, # noqa + MDPL2Catalogue) # noqa from .snapshot import (CSiBORG1Snapshot, CSiBORG2Snapshot, QuijoteSnapshot, # noqa CSiBORG1Field, CSiBORG2Field, QuijoteField, BORG2Field, # noqa BORG1Field, TNG300_1Field) # noqa diff --git a/csiborgtools/read/catalogue.py b/csiborgtools/read/catalogue.py index 6490fda..a3c7f41 100644 --- a/csiborgtools/read/catalogue.py +++ b/csiborgtools/read/catalogue.py @@ -582,6 +582,29 @@ class BaseCatalogue(ABC): """ return self._properties + self._custom_keys + def pick_fiducial_observer(self, n, rmax): + r""" + Select a new fiducial observer in the box. + + Parameters + ---------- + n : int + Fiducial observer index. + rmax : float + Max. distance from the fiducial obs. in :math:`\mathrm{cMpc} / h`. + """ + self.clear_cache() + print(fiducial_observers(self.boxsize, rmax)) + self.observer_location = fiducial_observers(self.boxsize, rmax)[n] + self.observer_velocity = None + + if self._bounds is None: + bounds = {"dist": (0, rmax)} + else: + bounds = {**self._bounds, "dist": (0, rmax)} + + self._make_mask(bounds) + def __getitem__(self, key): # For internal calls we don't want to load the filtered data and use # the __ prefixed keys. The internal calls are not being cached. @@ -1366,27 +1389,83 @@ class QuijoteCatalogue(BaseCatalogue): fpath = self.paths.initial_lagpatch(self.nsim, self.simname) return numpy.load(fpath)["lagpatch_size"] - def pick_fiducial_observer(self, n, rmax): - r""" - Select a new fiducial observer in the box. - Parameters - ---------- - n : int - Fiducial observer index. - rmax : float - Max. distance from the fiducial obs. in :math:`\mathrm{cMpc} / h`. - """ - self.clear_cache() - self.observer_location = fiducial_observers(self.box.boxsize, rmax)[n] - self.observer_velocity = None +############################################################################### +# External halo catalogues # +############################################################################### - if self._bounds is None: - bounds = {"dist": (0, rmax)} - else: - bounds = {**self._bounds, "dist": (0, rmax)} +class MDPL2Catalogue(BaseCatalogue): + r""" + XXX - self._make_mask(bounds) + Parameters + ---------- + nsim : int + IC realisation index. + paths : py:class`csiborgtools.read.Paths`, optional + Paths object. + snapshot : subclass of py:class:`BaseSnapshot`, optional + Snapshot object corresponding to the catalogue. + bounds : dict + Parameter bounds; keys as parameter names, values as (min, max) + tuples. Use `dist` for radial distance, `None` for no bound. + observer_velocity : array, optional + Observer's velocity in :math:`\mathrm{km} / \mathrm{s}`. + cache_maxsize : int, optional + Maximum number of cached arrays. + """ + def __init__(self, paths=None, bounds=None, cache_maxsize=64): + boxsize = 1000. + super().__init__() + x0 = boxsize / 2 + super().init_with_snapshot( + "MDPL2", 0, 125, paths, None, bounds, boxsize, [x0, x0, x0], None, + False, cache_maxsize) + + self._custom_keys = [] + self._bounds = bounds + + def _read_fof_catalogue(self, kind): + fpath = self.paths.external_halo_catalogue(self.simname) + + with File(fpath, 'r') as f: + if kind == "index": + return numpy.arange(len(f["x"])) + + if kind not in f.keys(): + raise ValueError(f"FoF catalogue key '{kind}' not available. Available keys are: {list(f.keys())}") # noqa + out = f[kind][...] + return out + + @property + def coordinates(self): + return numpy.vstack( + [self._read_fof_catalogue(key) for key in ["x", "y", "z"]]).T + + @property + def velocities(self): + return numpy.vstack( + [self._read_fof_catalogue(key) for key in ["vx", "vy", "vz"]]).T + + @property + def totmass(self): + return self._read_fof_catalogue("mass") + + @property + def npart(self): + raise RuntimeError("Number of particles is not available.") + + @property + def index(self): + return self._read_fof_catalogue("index") + + @property + def lagpatch_coordinates(self): + raise RuntimeError("Lagrangian patch information is not available") + + @property + def lagpatch_radius(self): + raise RuntimeError("Lagrangian patch information is not available") ############################################################################### diff --git a/csiborgtools/read/paths.py b/csiborgtools/read/paths.py index bf4a8cc..281a999 100644 --- a/csiborgtools/read/paths.py +++ b/csiborgtools/read/paths.py @@ -59,6 +59,8 @@ class Paths: Path to the BORG2 simulation directory. tng300_1_dir : str Path to the TNG300-1 simulation directory. + aux_cat_dir : str + Path to the directory containing auxiliary catalogues. """ def __init__(self, csiborg1_srcdir, @@ -69,7 +71,8 @@ class Paths: quijote_dir, borg1_dir, borg2_dir, - tng300_1_dir + tng300_1_dir, + aux_cat_dir ): self.csiborg1_srcdir = csiborg1_srcdir self.csiborg2_main_srcdir = csiborg2_main_srcdir @@ -80,6 +83,7 @@ class Paths: self.borg2_dir = borg2_dir self.tng300_1_dir = tng300_1_dir self.postdir = postdir + self.aux_cat_dir = aux_cat_dir def get_ics(self, simname): """ @@ -100,6 +104,9 @@ class Paths: elif simname == "csiborg2_main" or simname == "borg2": files = glob(join(self.csiborg2_main_srcdir, "chain_*")) files = [int(search(r'chain_(\d+)', f).group(1)) for f in files] + elif simname == "borg2_all": + files = glob(join(self.borg2_dir, "mcmc_*")) + files = [int(search(r'mcmc_(\d+)', f).group(1)) for f in files] elif simname == "csiborg2_random": files = glob(join(self.csiborg2_random_srcdir, "chain_*")) files = [int(search(r'chain_(\d+)', f).group(1)) for f in files] @@ -246,6 +253,24 @@ class Paths: else: raise ValueError(f"Unknown simulation name `{simname}`.") + def external_halo_catalogue(self, name): + """ + Path to an external halo catalogue. + + Parameters + ---------- + name : str + Catalogue name. + + Returns + ------- + str + """ + if name == "MDPL2": + return join(self.aux_cat_dir, "MDPL2_FOF_125.hdf5") + else: + raise ValueError(f"Unknown external FOF catalogue `{name}`.") + def initial_lagpatch(self, nsim, simname): """ Path to the Lagrangain patch information of a simulation for halos diff --git a/csiborgtools/read/snapshot.py b/csiborgtools/read/snapshot.py index 07687c4..a2a4ffa 100644 --- a/csiborgtools/read/snapshot.py +++ b/csiborgtools/read/snapshot.py @@ -969,7 +969,7 @@ class BORG2Field(BaseField): rho_mean = omega0 * 277.53662724583074 # h^2 Msun / kpc^3 field += 1 field *= rho_mean - # return field + return field def velocity_field(self, MAS, grid): raise RuntimeError("The velocity field is not available.") diff --git a/csiborgtools/utils.py b/csiborgtools/utils.py index 157991a..f960150 100644 --- a/csiborgtools/utils.py +++ b/csiborgtools/utils.py @@ -35,6 +35,19 @@ def center_of_mass(particle_positions, particles_mass, boxsize): """ Calculate the center of mass of a halo while assuming periodic boundary conditions of a cubical box. + + Parameters + ---------- + particle_positions : 2-dimensional array of shape `(nparticles, 3)` + Particle positions in the box. + particles_mass : 1-dimensional array of shape `(nparticles,)` + Particle masses. + boxsize : float + Box size. + + Returns + ------- + 1-dimensional array of shape `(3,)` """ cm = np.zeros(3, dtype=particle_positions.dtype) totmass = sum(particles_mass) @@ -60,28 +73,46 @@ def periodic_distance(points, reference_point, boxsize): """ Compute the 3D distance between multiple points and a reference point using periodic boundary conditions. + + Parameters + ---------- + points : 2-dimensional array of shape `(npoints, 3)` + Points to calculate the distance from. + reference_point : 1-dimensional array of shape `(3,)` + Reference point. + boxsize : float + Box size. + + Returns + ------- + 1-dimensional array of shape `(npoints,)` """ npoints = len(points) - half_box = boxsize / 2 dist = np.zeros(npoints, dtype=points.dtype) for i in range(npoints): - for j in range(3): - dist_1d = abs(points[i, j] - reference_point[j]) - - if dist_1d > (half_box): - dist_1d = boxsize - dist_1d - - dist[i] += dist_1d**2 - - dist[i] = dist[i]**0.5 + dist[i] = periodic_distance_two_points( + points[i], reference_point, boxsize) return dist @jit(nopython=True, fastmath=True, boundscheck=False) def periodic_distance_two_points(p1, p2, boxsize): - """Compute the 3D distance between two points in a periodic box.""" + """ + Compute the 3D distance between two points in a periodic box. + + Parameters + ---------- + p1, p2 : 1-dimensional array of shape `(3,)` + Points to calculate the distance between. + boxsize : float + Box size. + + Returns + ------- + float + """ half_box = boxsize / 2 dist = 0 @@ -98,7 +129,20 @@ def periodic_distance_two_points(p1, p2, boxsize): @jit(nopython=True, boundscheck=False) def periodic_wrap_grid(pos, boxsize=1): - """Wrap positions in a periodic box.""" + """ + Wrap positions in a periodic box. Overwrites the input array. + + Parameters + ---------- + pos : 2-dimensional array of shape `(npoints, 3)` + Positions to wrap. + boxsize : float, optional + Box size. + + Returns + ------- + 2-dimensional array of shape `(npoints, 3)` + """ for n in range(pos.shape[0]): for i in range(3): if pos[n, i] > boxsize: @@ -113,6 +157,15 @@ def periodic_wrap_grid(pos, boxsize=1): def delta2ncells(field): """ Calculate the number of cells in `field` that are non-zero. + + Parameters + ---------- + field : 3-dimensional array of shape `(nx, ny, nz)` + Field to calculate the number of non-zero cells. + + Returns + ------- + int """ tot = 0 imax, jmax, kmax = field.shape @@ -124,19 +177,43 @@ def delta2ncells(field): return tot -def cartesian_to_radec(X): +def cartesian_to_radec(X, return_degrees=True, origin=[0., 0., 0.]): """ Calculate the radial distance, RA [0, 360) deg and dec [-90, 90] deg. + + Parameters + ---------- + X : 2-dimensional array of shape `(npoints, 3)` + Cartesian coordinates. + return_degrees : bool, optional + Whether to return the angles in degrees. + origin : 1-dimensional array of shape `(3,)`, optional + Origin of the coordinate system. + + Returns + ------- + out : 2-dimensional array of shape `(npoints, 3)` + Spherical coordinates: distance, RA and dec. """ x, y, z = X[:, 0], X[:, 1], X[:, 2] + x -= origin[0] + y -= origin[1] + z -= origin[2] + dist = np.linalg.norm(X, axis=1) dec = np.arcsin(z / dist) ra = np.arctan2(y, x) ra[ra < 0] += 2 * np.pi - ra *= 180 / np.pi - dec *= 180 / np.pi + if return_degrees: + ra *= 180 / np.pi + dec *= 180 / np.pi + + # Place the origin back + x += origin[0] + y += origin[1] + z += origin[2] return np.vstack([dist, ra, dec]).T @@ -145,6 +222,15 @@ def radec_to_cartesian(X): """ Calculate Cartesian coordinates from radial distance, RA [0, 360) deg and dec [-90, 90] deg. + + Parameters + ---------- + X : 2-dimensional array of shape `(npoints, 3)` + Spherical coordinates: distance, RA and dec. + + Returns + ------- + 2-dimensional array of shape `(npoints, 3)` """ dist, ra, dec = X[:, 0], X[:, 1], X[:, 2] @@ -175,23 +261,43 @@ def radec_to_galactic(ra, dec): @jit(nopython=True, fastmath=True, boundscheck=False) -def great_circle_distance(x1, x2): +def great_circle_distance(x1, x2, in_degrees=True): """ Great circle distance between two points on a sphere, defined by RA and dec, both in degrees. + + Parameters + ---------- + x1, x2 : 1-dimensional arrays of shape `(2,)` + RA and dec in degrees. + in_degrees : bool, optional + Whether the input is in degrees. + + Returns + ------- + float """ ra1, dec1 = x1 ra2, dec2 = x2 - ra1 *= np.pi / 180 - dec1 *= np.pi / 180 - ra2 *= np.pi / 180 - dec2 *= np.pi / 180 + if in_degrees: + ra1 *= np.pi / 180 + dec1 *= np.pi / 180 + ra2 *= np.pi / 180 + dec2 *= np.pi / 180 - return 180 / np.pi * np.arccos( - np.sin(dec1) * np.sin(dec2) - + np.cos(dec1) * np.cos(dec2) * np.cos(ra1 - ra2) - ) + dist = np.arccos(np.sin(dec1) * np.sin(dec2) + + np.cos(dec1) * np.cos(dec2) * np.cos(ra1 - ra2)) + + # Convert to degrees and ensure the inputs are unchanged. + if in_degrees: + dist *= 180 / np.pi + ra1 *= 180 / np.pi + dec1 *= 180 / np.pi + ra2 *= 180 / np.pi + dec2 *= 180 / np.pi + + return dist def cosine_similarity(x, y): @@ -316,6 +422,17 @@ def real2redshift(pos, vel, observer_location, observer_velocity, boxsize, def number_counts(x, bin_edges): """ Calculate counts of samples in bins. + + Parameters + ---------- + x : 1-dimensional array + Samples to bin. + bin_edges : 1-dimensional array + Bin edges. + + Returns + ------- + 1-dimensional array """ out = np.full(bin_edges.size - 1, np.nan, dtype=np.float32) for i in range(bin_edges.size - 1): @@ -326,6 +443,21 @@ def number_counts(x, bin_edges): def binned_statistic(x, y, left_edges, bin_width, statistic): """ Calculate a binned statistic. + + Parameters + ---------- + x, y : 1-dimensional arrays + Values by which to bin and calculate the statistic on, respectively. + left_edges : 1-dimensional array + Left edges of the bins. + bin_width : float + Width of the bins. + statistic : callable + Function to calculate the statistic, must be `f(x)`. + + Returns + ------- + 1-dimensional array """ out = np.full(left_edges.size, np.nan, dtype=x.dtype) diff --git a/notebooks/flow/flow_bulk.ipynb b/notebooks/flow/flow_bulk.ipynb index 0d17532..a42f56d 100644 --- a/notebooks/flow/flow_bulk.ipynb +++ b/notebooks/flow/flow_bulk.ipynb @@ -9,18 +9,9 @@ }, { "cell_type": "code", - "execution_count": 95, + "execution_count": 1, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], + "outputs": [], "source": [ "# Copyright (C) 2024 Richard Stiskalek\n", "# This program is free software; you can redistribute it and/or modify it\n", @@ -39,7 +30,6 @@ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", - "import csiborgtools\n", "\n", "from flow_bulk import *\n", "\n", @@ -186,6 +176,100 @@ "fig.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Enclosed overdensity $\\texttt{BORG2}$ all" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring)\n", + "nsims = paths.get_ics(\"borg2_all\")\n", + "\n", + "r, overdensity = read_enclosed_density(\"borg2_all\")\n", + "overdensity_A = overdensity[:80]\n", + "overdensity_B = overdensity[80:][::30]" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 7500, 7600, 7700, 7800, 7900, 8000, 8100, 8200, 8300,\n", + " 8400, 8500, 8600, 8700, 8800, 8900, 9000, 9100, 9200,\n", + " 9300, 9400, 9500, 9600, 9700, 9800, 9900, 10000, 10100,\n", + " 10200, 10300, 10400, 10500, 10600, 10700, 10800, 10900, 11000,\n", + " 11100, 11200, 11300, 11400, 11500, 11600, 11700, 11800, 11900,\n", + " 12000, 12100, 12200, 12300, 12400, 12500, 12600, 12700, 12800,\n", + " 12900, 13000, 13100, 13200, 13300, 13400, 13500, 13600, 13700,\n", + " 13800, 13900, 14000, 14100, 14200, 14300, 14400, 14500, 14600,\n", + " 14700, 14800, 14900, 15000, 15100, 15200, 15300, 15400])" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nsims[:80]" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "cols = plt.rcParamsDefault['axes.prop_cycle'].by_key()['color']\n", + "\n", + "# r, overdensity = read_enclosed_density(\"csiborg1\")\n", + "c = cols[0]\n", + "for i in range(len(overdensity_A)):\n", + " plt.plot(r, overdensity_A[i], c=c, lw=0.2, zorder=0, ls=\"dotted\")\n", + "plt.plot(r, np.median(overdensity_A, axis=0), c=c, lw=2, label=r\"Chain index: $7500$ to $15000$\")\n", + "\n", + "c = cols[1]\n", + "for i in range(len(overdensity_B)):\n", + " plt.plot(r, overdensity_B[i], c=c, lw=0.2, zorder=0, ls=\"dotted\")\n", + "plt.plot(r, np.median(overdensity_B, axis=0), c=c, lw=2, label=r\"Chain index: $15000$ to $17000$\")\n", + "\n", + "\n", + "\n", + "plt.xlabel(r\"$R ~ [\\mathrm{Mpc} / h]$\")\n", + "plt.ylabel(r\"$\\delta_{\\rm enc} (r \\leq R)$\")\n", + "plt.legend()\n", + "\n", + "plt.xlim(0, r.max())\n", + "plt.ylim(-0.14, -0.005)\n", + "plt.axhline(0, c='k', ls='--', lw=1)\n", + "plt.tight_layout()\n", + "plt.savefig(\"../../plots/enclosed_density_BORG2.png\", dpi=450)\n", + "plt.show()" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/scripts/field_bulk.py b/scripts/field_bulk.py index 4ccf2c0..4aa5b09 100644 --- a/scripts/field_bulk.py +++ b/scripts/field_bulk.py @@ -148,7 +148,7 @@ def main_borg(args, folder): if args.simname == "borg1": reader = csiborgtools.read.BORG1Field(nsim) field = reader.density_field() - elif args.simname == "borg2": + elif args.simname == "borg2" or args.simname == "borg2_all": reader = csiborgtools.read.BORG2Field(nsim) field = reader.density_field() else: @@ -204,7 +204,7 @@ def main_csiborg(args, folder): if __name__ == "__main__": parser = ArgumentParser() parser.add_argument("--simname", type=str, help="Simulation name.", - choices=["csiborg1", "csiborg2_main", "csiborg2_varysmall", "csiborg2_random", "borg1", "borg2"]) # noqa + choices=["csiborg1", "csiborg2_main", "csiborg2_varysmall", "csiborg2_random", "borg1", "borg2", "borg2_all"]) # noqa args = parser.parse_args() folder = "/mnt/extraspace/rstiskalek/csiborg_postprocessing/field_shells" diff --git a/scripts/field_bulk.sh b/scripts/field_bulk.sh index 34a82bf..d938ab5 100755 --- a/scripts/field_bulk.sh +++ b/scripts/field_bulk.sh @@ -1,9 +1,9 @@ nthreads=1 -memory=40 +memory=12 on_login=0 -queue="cmb" +queue="berg" env="/mnt/zfsusers/rstiskalek/csiborgtools/venv_csiborg/bin/python" -file="mass_enclosed.py" +file="field_bulk.py" simname=${1}