Aquila-Consortium/csiborgtools
0
0
Fork 0
mirror of https://github.com/Richard-Sti/csiborgtools.git synced 2024-12-22 18:08:03 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add Quijote (#61)

Browse source 
* Rename paths object

* Remove redshift calculation

* Explicit keywrod arg

* Rename box units

* Basic renaming

* Little docs

* Rename paths

* add imports

* Sort imports

* Add Quijote cat

* Split boxes

* add Quijote path

* Add origin argument

* Update nbs
This commit is contained in:
Richard Stiskalek 2023-05-13 17:37:34 +01:00 committed by GitHub
parent b3fd14b81f
commit 1d847cbd06
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
34 changed files with 1401 additions and 292 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
csiborgtools/__init__.py
View file

@ -14,7 +14,8 @@
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
from csiborgtools import clustering, field, fits, match, read # noqa
# Arguments to csiborgtools.read.CSiBORGPaths.
# Arguments to csiborgtools.read.Paths.
paths_glamdring = {"srcdir": "/mnt/extraspace/hdesmond/",
"postdir": "/mnt/extraspace/rstiskalek/CSiBORG/",
"quijote_dir": "/mnt/extraspace/rstiskalek/Quijote",
}

10
csiborgtools/field/density.py
View file

@ -52,7 +52,7 @@ class BaseField(ABC):
Returns
-------
box : :py:class:`csiborgtools.units.BoxUnits`
box : :py:class:`csiborgtools.units.CSiBORGBox`
"""
return self._box
@ -94,7 +94,7 @@ class DensityField(BaseField):
Parameters
----------
box : :py:class:`csiborgtools.read.BoxUnits`
box : :py:class:`csiborgtools.read.CSiBORGBox`
The simulation box information and transformations.
MAS : str
Mass assignment scheme. Options are Options are: 'NGP' (nearest grid
@ -204,7 +204,7 @@ class VelocityField(BaseField):
Parameters
----------
box : :py:class:`csiborgtools.read.BoxUnits`
box : :py:class:`csiborgtools.read.CSiBORGBox`
The simulation box information and transformations.
MAS : str
Mass assignment scheme. Options are Options are: 'NGP' (nearest grid
@ -295,7 +295,7 @@ class PotentialField(BaseField):
Parameters
----------
box : :py:class:`csiborgtools.read.BoxUnits`
box : :py:class:`csiborgtools.read.CSiBORGBox`
The simulation box information and transformations.
MAS : str
Mass assignment scheme. Options are Options are: 'NGP' (nearest grid
@ -334,7 +334,7 @@ class TidalTensorField(BaseField):
Parameters
----------
box : :py:class:`csiborgtools.read.BoxUnits`
box : :py:class:`csiborgtools.read.CSiBORGBox`
The simulation box information and transformations.
MAS : str
Mass assignment scheme. Options are Options are: 'NGP' (nearest grid

2
csiborgtools/field/interp.py
View file

@ -67,7 +67,7 @@ def evaluate_sky(*fields, pos, box, isdeg=True):
pos : 2-dimensional array of shape `(n_samples, 3)`
Spherical coordinates to evaluate the field. Columns are distance,
right ascension, declination, respectively.
box : :py:class:`csiborgtools.read.BoxUnits`
box : :py:class:`csiborgtools.read.CSiBORGBox`
The simulation box information and transformations.
isdeg : bool, optional
Whether `ra` and `dec` are in degres. By default `True`.

6
csiborgtools/fits/halo.py
View file

@ -67,7 +67,7 @@ class BaseStructure(ABC):
Returns
-------
box : :py:class:`csiborgtools.units.BoxUnits`
box : :py:class:`csiborgtools.units.CSiBORGBox`
"""
return self._box
@ -280,7 +280,7 @@ class Clump(BaseStructure):
Particle array. Must contain `['x', 'y', 'z', 'vx', 'vy', 'vz', 'M']`.
info : structured array
Array containing information from the clump finder.
box : :py:class:`csiborgtools.read.BoxUnits`
box : :py:class:`csiborgtools.read.CSiBORGBox`
Box units object.
"""
@ -301,7 +301,7 @@ class Halo(BaseStructure):
Particle array. Must contain `['x', 'y', 'z', 'vx', 'vy', 'vz', 'M']`.
info : structured array
Array containing information from the clump finder.
box : :py:class:`csiborgtools.read.BoxUnits`
box : :py:class:`csiborgtools.read.CSiBORGBox`
Box units object.
"""

6
csiborgtools/read/__init__.py
View file

@ -12,14 +12,14 @@
# 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.
from .box_units import BoxUnits # noqa
from .halo_cat import ClumpsCatalogue, HaloCatalogue # noqa
from .box_units import CSiBORGBox, QuijoteBox # noqa
from .halo_cat import ClumpsCatalogue, HaloCatalogue, QuijoteHaloCatalogue # noqa
from .knn_summary import kNNCDFReader # noqa
from .obs import (SDSS, MCXCClusters, PlanckClusters, TwoMPPGalaxies, # noqa
TwoMPPGroups)
from .overlap_summary import (NPairsOverlap, PairOverlap, # noqa
binned_resample_mean)
from .paths import CSiBORGPaths # noqa
from .paths import Paths # noqa
from .pk_summary import PKReader # noqa
from .readsim import (MmainReader, ParticleReader, halfwidth_mask, # noqa
load_clump_particles, load_parent_particles, read_initcm)

221
csiborgtools/read/box_units.py
View file

@ -15,14 +15,15 @@
"""
Simulation box unit transformations.
"""
from abc import ABC
import numpy
from astropy import constants, units
from astropy.cosmology import LambdaCDM
from scipy.interpolate import interp1d
from .readsim import ParticleReader
# Map of unit conversions
# Map of CSiBORG unit conversions
CONV_NAME = {
"length": ["x", "y", "z", "peak_x", "peak_y", "peak_z", "Rs", "rmin",
"rmax", "r200c", "r500c", "r200m", "x0", "y0", "z0",
@ -33,53 +34,18 @@ CONV_NAME = {
"density": ["rho0"]}
class BoxUnits:
r"""
Box units class for converting between box and physical units.
###############################################################################
# Base box #
###############################################################################
Paramaters
----------
nsnap : int
Snapshot index.
nsim : int
IC realisation index.
paths : py:class`csiborgtools.read.CSiBORGPaths`
CSiBORG paths object.
class BaseBox(ABC):
"""
Base class for box units.
"""
_name = "box_units"
_cosmo = None
def __init__(self, nsnap, nsim, paths):
"""
Read in the snapshot info file and set the units from it.
"""
partreader = ParticleReader(paths)
info = partreader.read_info(nsnap, nsim)
pars = [
"boxlen",
"time",
"aexp",
"H0",
"omega_m",
"omega_l",
"omega_k",
"omega_b",
"unit_l",
"unit_d",
"unit_t",
]
for par in pars:
setattr(self, "_" + par, float(info[par]))
self._cosmo = LambdaCDM(
H0=self._H0,
Om0=self._omega_m,
Ode0=self._omega_l,
Tcmb0=2.725 * units.K,
Ob0=self._omega_b,
)
self._Msuncgs = constants.M_sun.cgs.value # Solar mass in grams
@property
def cosmo(self):
"""
@ -89,6 +55,8 @@ class BoxUnits:
-------
cosmo : `astropy.cosmology.LambdaCDM`
"""
if self._cosmo is None:
raise ValueError("Cosmology not set.")
return self._cosmo
@property
@ -101,7 +69,7 @@ class BoxUnits:
-------
H0 : float
"""
return self._H0
return self.cosmo.H0.value
@property
def h(self):
@ -112,7 +80,54 @@ class BoxUnits:
-------
h : float
"""
return self._H0 / 100
return self.H0 / 100
@property
def Om0(self):
r"""
The matter density parameter.
Returns
-------
Om0 : float
"""
return self.cosmo.Om0
###############################################################################
# CSiBORG box #
###############################################################################
class CSiBORGBox(BaseBox):
r"""
CSiBORG box units class for converting between box and physical units.
Paramaters
----------
nsnap : int
Snapshot index.
nsim : int
IC realisation index.
paths : py:class`csiborgtools.read.Paths`
CSiBORG paths object.
"""
def __init__(self, nsnap, nsim, paths):
"""
Read in the snapshot info file and set the units from it.
"""
partreader = ParticleReader(paths)
info = partreader.read_info(nsnap, nsim)
pars = ["boxlen", "time", "aexp", "H0", "omega_m", "omega_l",
"omega_k", "omega_b", "unit_l", "unit_d", "unit_t"]
for par in pars:
setattr(self, "_" + par, float(info[par]))
self._cosmo = LambdaCDM(H0=self._H0, Om0=self._omega_m,
Ode0=self._omega_l, Tcmb0=2.725 * units.K,
Ob0=self._omega_b)
self._Msuncgs = constants.M_sun.cgs.value # Solar mass in grams
@property
def box_G(self):
@ -157,7 +172,6 @@ class BoxUnits:
-------
rhoc : float
"""
return 3 * self.box_H0**2 / (8 * numpy.pi * self.box_G)
def box2kpc(self, length):
@ -244,83 +258,6 @@ class BoxUnits:
"""
return vel * (1e-2 * self._unit_l / self._unit_t / self._aexp) * 1e-3
def box2cosmoredshift(self, dist):
r"""
Convert the box comoving distance to cosmological redshift.
NOTE: this likely is already the observed redshift.
Parameters
----------
dist : float
Distance in box units.
Returns
-------
cosmo_redshift : foat
Cosmological redshift.
"""
x = numpy.linspace(0.0, 1.0, 5001)
y = self.cosmo.comoving_distance(x)
return interp1d(y, x)(self.box2mpc(dist))
def box2pecredshift(self, vx, vy, vz, px, py, pz, p0x=0, p0y=0, p0z=0):
"""
Convert the box phase-space information to a peculiar redshift.
NOTE: there is some confusion about this.
Parameters
----------
vx, vy, vz : 1-dimensional arrays
Cartesian velocity components.
px, py, pz : 1-dimensional arrays
Cartesian position vectors components.
p0x, p0y, p0z : floats
Centre of the box coordinates. By default 0, in which it is assumed
that the coordinates are already centred.
Returns
-------
pec_redshift : 1-dimensional array
Peculiar redshift.
"""
# Peculiar velocity along the radial distance
r = numpy.vstack([px - p0x, py - p0y, pz - p0z]).T
norm = numpy.sum(r**2, axis=1) ** 0.5
v = numpy.vstack([vx, vy, vz]).T
vpec = numpy.sum(r * v, axis=1) / norm
# Ratio between the peculiar velocity and speed of light
x = self.box2vel(vpec) / constants.c.value
# Doppler shift
return numpy.sqrt((1 + x) / (1 - x)) - 1
def box2obsredshift(self, vx, vy, vz, px, py, pz, p0x=0, p0y=0, p0z=0):
"""
Convert the box phase-space information to an 'observed' redshift.
NOTE: there is some confusion about this.
Parameters
----------
vx, vy, vz : 1-dimensional arrays
Cartesian velocity components.
px, py, pz : 1-dimensional arrays
Cartesian position vectors components.
p0x, p0y, p0z : floats
Centre of the box coordinates. By default 0, in which it is assumed
that the coordinates are already centred.
Returns
-------
obs_redshift : 1-dimensional array
Observed redshift.
"""
r = numpy.vstack([px - p0x, py - p0y, pz - p0z]).T
zcosmo = self.box2cosmoredshift(numpy.sum(r**2, axis=1) ** 0.5)
zpec = self.box2pecredshift(vx, vy, vz, px, py, pz, p0x, p0y, p0z)
return (1 + zpec) * (1 + zcosmo) - 1
def solarmass2box(self, mass):
r"""
Convert mass from :math:`M_\odot` (with :math:`h=0.705`) to box units.
@ -391,7 +328,7 @@ class BoxUnits:
return (density / self._unit_d * self._Msuncgs
/ (units.Mpc.to(units.cm)) ** 3)
def convert_from_boxunits(self, data, names):
def convert_from_box(self, data, names):
r"""
Convert columns named `names` in array `data` from box units to
physical units, such that
@ -421,13 +358,12 @@ class BoxUnits:
transforms = {"length": self.box2mpc,
"mass": self.box2solarmass,
"velocity": self.box2vel,
"density": self.box2dens,
}
"density": self.box2dens}
for name in names:
# Check that the name is even in the array
if name not in data.dtype.names:
raise ValueError("Name `{}` not in `data` array.".format(name))
raise ValueError(f"Name `{name}` not in `data` array.")
# Convert
found = False
@ -439,11 +375,36 @@ class BoxUnits:
# If nothing found
if not found:
raise NotImplementedError(
"Conversion of `{}` is not defined.".format(name)
)
f"Conversion of `{name}` is not defined.")
# Center at the observer
if name in ["peak_x", "peak_y", "peak_z", "x0", "y0", "z0"]:
data[name] -= transforms["length"](0.5)
return data
###############################################################################
# Quijote fiducial cosmology box #
###############################################################################
class QuijoteBox(BaseBox):
"""
Quijote fiducial cosmology box.
Parameters
----------
nsnap : int
Snapshot number.
**kwargs : dict
Empty keyword arguments. For backwards compatibility.
"""
def __init__(self, nsnap, **kwargs):
zdict = {4: 0.0, 3: 0.5, 2: 1.0, 1: 2.0, 0: 3.0}
assert nsnap in zdict.keys(), f"`nsnap` must be in {zdict.keys()}."
self._aexp = 1 / (1 + zdict[nsnap])
self._cosmo = LambdaCDM(H0=67.11, Om0=0.3175, Ode0=0.6825,
Tcmb0=2.725 * units.K, Ob0=0.049)

250
csiborgtools/read/halo_cat.py
View file

@ -12,24 +12,29 @@
# 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.
"""CSiBORG halo and clumps catalogues."""
from abc import ABC
"""
Simulation catalogues:
- CSiBORG: halo and clump catalogue.
- Quijote: halo catalogue.
"""
from abc import ABC, abstractproperty
from os.path import join
import numpy
from readfof import FoF_catalog
from sklearn.neighbors import NearestNeighbors
from .box_units import BoxUnits
from .paths import CSiBORGPaths
from .box_units import CSiBORGBox, QuijoteBox
from .paths import Paths
from .readsim import ParticleReader
from .utils import (add_columns, cartesian_to_radec, flip_cols,
radec_to_cartesian, real2redshift)
from .utils import (add_columns, cartesian_to_radec, cols_to_structured,
flip_cols, radec_to_cartesian, real2redshift)
class BaseCatalogue(ABC):
"""
Base (sub)halo catalogue.
"""
_data = None
_paths = None
_nsim = None
@ -51,14 +56,25 @@ class BaseCatalogue(ABC):
def nsim(self, nsim):
self._nsim = nsim
@property
def paths(self):
@abstractproperty
def nsnap(self):
"""
CSiBORG paths manager.
Catalogue's snapshot index.
Returns
-------
paths : :py:class:`csiborgtools.read.CSiBORGPaths`
nsnap : int
"""
pass
@property
def paths(self):
"""
Paths manager.
Returns
-------
paths : :py:class:`csiborgtools.read.Paths`
"""
if self._paths is None:
raise RuntimeError("`paths` is not set!")
@ -66,7 +82,7 @@ class BaseCatalogue(ABC):
@paths.setter
def paths(self, paths):
assert isinstance(paths, CSiBORGPaths)
assert isinstance(paths, Paths)
self._paths = paths
@property
@ -82,36 +98,16 @@ class BaseCatalogue(ABC):
raise RuntimeError("Catalogue data not loaded!")
return self._data
@property
def nsnap(self):
"""
Catalogue's snapshot index corresponding to the maximum simulation
snapshot index.
Returns
-------
nsnap : int
"""
return max(self.paths.get_snapshots(self.nsim))
@property
@abstractproperty
def box(self):
"""
CSiBORG box object handling unit conversion.
Box object.
Returns
-------
box : :py:class:`csiborgtools.units.BoxUnits`
box : instance of :py:class:`csiborgtools.units.BoxUnits`
"""
return BoxUnits(self.nsnap, self.nsim, self.paths)
@box.setter
def box(self, box):
try:
assert box._name == "box_units"
self._box = box
except AttributeError as err:
raise TypeError from err
pass
def position(self, in_initial=False, cartesian=True):
r"""
@ -143,8 +139,8 @@ class BaseCatalogue(ABC):
return pos
def velocity(self):
"""
Cartesian velocity components in box units.
r"""
Cartesian velocity components in :math:`\mathrm{km} / \mathrm{s}`.
Returns
-------
@ -204,7 +200,7 @@ class BaseCatalogue(ABC):
knn : :py:class:`sklearn.neighbors.NearestNeighbors`
"""
knn = NearestNeighbors()
return knn.fit(self.position(in_initial))
return knn.fit(self.position(in_initial=in_initial))
def radius_neigbours(self, X, radius, in_initial):
r"""
@ -299,20 +295,56 @@ class BaseCatalogue(ABC):
@property
def keys(self):
"""Catalogue keys."""
"""
Catalogue keys.
Returns
-------
keys : list of strings
"""
return self.data.dtype.names
def __getitem__(self, key):
initpars = ["x0", "y0", "z0"]
if key in initpars and key not in self.keys:
raise RuntimeError("Initial positions are not set!")
if key not in self.keys:
raise KeyError(f"Key '{key}' not in catalogue.")
return self.data[key]
def __len__(self):
return self.data.size
class ClumpsCatalogue(BaseCatalogue):
###############################################################################
# CSiBORG base catalogue #
###############################################################################
class BaseCSiBORG(BaseCatalogue):
"""
Base CSiBORG catalogue class.
"""
@property
def nsnap(self):
return max(self.paths.get_snapshots(self.nsim))
@property
def box(self):
"""
CSiBORG box object handling unit conversion.
Returns
-------
box : instance of :py:class:`csiborgtools.units.BaseBox`
"""
return CSiBORGBox(self.nsnap, self.nsim, self.paths)
###############################################################################
# CSiBORG clumps catalogue #
###############################################################################
class ClumpsCatalogue(BaseCSiBORG):
r"""
Clumps catalogue, defined in the final snapshot.
@ -320,8 +352,8 @@ class ClumpsCatalogue(BaseCatalogue):
----------
sim : int
IC realisation index.
paths : py:class`csiborgtools.read.CSiBORGPaths`
CSiBORG paths object.
paths : py:class`csiborgtools.read.Paths`
Paths object.
maxdist : float, optional
The maximum comoving distance of a halo. By default
:math:`155.5 / 0.705 ~ \mathrm{Mpc}` with assumed :math:`h = 0.705`,
@ -363,7 +395,7 @@ class ClumpsCatalogue(BaseCatalogue):
names = ["x", "y", "z", "mass_cl", "totpartmass", "rho0", "r200c",
"r500c", "m200c", "m500c", "r200m", "m200m",
"vx", "vy", "vz"]
self._data = self.box.convert_from_boxunits(self._data, names)
self._data = self.box.convert_from_box(self._data, names)
if maxdist is not None:
dist = numpy.sqrt(self._data["x"]**2 + self._data["y"]**2
+ self._data["z"]**2)
@ -383,7 +415,12 @@ class ClumpsCatalogue(BaseCatalogue):
return self["index"] == self["parent"]
class HaloCatalogue(BaseCatalogue):
###############################################################################
# CSiBORG halo catalogue #
###############################################################################
class HaloCatalogue(BaseCSiBORG):
r"""
Halo catalogue, i.e. parent halos with summed substructure, defined in the
final snapshot.
@ -392,8 +429,8 @@ class HaloCatalogue(BaseCatalogue):
----------
nsim : int
IC realisation index.
paths : py:class`csiborgtools.read.CSiBORGPaths`
CSiBORG paths object.
paths : py:class`csiborgtools.read.Paths`
Paths object.
maxdist : float, optional
The maximum comoving distance of a halo. By default
:math:`155.5 / 0.705 ~ \mathrm{Mpc}` with assumed :math:`h = 0.705`,
@ -455,11 +492,11 @@ class HaloCatalogue(BaseCatalogue):
names = ["x", "y", "z", "M", "totpartmass", "rho0", "r200c",
"r500c", "m200c", "m500c", "r200m", "m200m",
"vx", "vy", "vz"]
self._data = self.box.convert_from_boxunits(self._data, names)
self._data = self.box.convert_from_box(self._data, names)
if load_initial:
names = ["x0", "y0", "z0", "lagpatch"]
self._data = self.box.convert_from_boxunits(self._data, names)
self._data = self.box.convert_from_box(self._data, names)
if maxdist is not None:
dist = numpy.sqrt(self._data["x"]**2 + self._data["y"]**2
@ -480,3 +517,112 @@ class HaloCatalogue(BaseCatalogue):
if self._clumps_cat is None:
raise ValueError("`clumps_cat` is not loaded.")
return self._clumps_cat
###############################################################################
# Quijote halo catalogue #
###############################################################################
class QuijoteHaloCatalogue(BaseCatalogue):
"""
Quijote halo catalogue.
Parameters
----------
nsim : int
IC realisation index.
paths : py:class`csiborgtools.read.Paths`
Paths object.
nsnap : int
Snapshot index.
origin : len-3 tuple, optional
Where to place the origin of the box. By default the centre of the box.
In units of :math:`cMpc`.
maxdist : float, optional
The maximum comoving distance of a halo in the new reference frame, in
units of :math:`cMpc`.
minmass : len-2 tuple
Minimum mass. The first element is the catalogue key and the second is
the value.
rawdata : bool, optional
Whether to return the raw data. In this case applies no cuts and
transformations.
**kwargs : dict
Keyword arguments for backward compatibility.
"""
_nsnap = None
def __init__(self, nsim, paths, nsnap,
origin=[500 / 0.6711, 500 / 0.6711, 500 / 0.6711],
maxdist=None, minmass=("group_mass", 1e12), rawdata=False,
**kwargs):
self.paths = paths
self.nsnap = nsnap
fpath = join(self.paths.quijote_dir, "halos", str(nsim))
fof = FoF_catalog(fpath, self.nsnap, long_ids=False, swap=False,
SFR=False, read_IDs=False)
cols = [("x", numpy.float32), ("y", numpy.float32),
("z", numpy.float32), ("vx", numpy.float32),
("vy", numpy.float32), ("vz", numpy.float32),
("group_mass", numpy.float32), ("npart", numpy.int32)]
data = cols_to_structured(fof.GroupLen.size, cols)
pos = fof.GroupPos / 1e3 / self.box.h
for i in range(3):
pos -= origin[i]
vel = fof.GroupVel * (1 + self.redshift)
for i, p in enumerate(["x", "y", "z"]):
data[p] = pos[:, i]
data["v" + p] = vel[:, i]
data["group_mass"] = fof.GroupMass * 1e10 / self.box.h
data["npart"] = fof.GroupLen
if not rawdata:
if maxdist is not None:
pos = numpy.vstack([data["x"], data["y"], data["z"]]).T
data = data[numpy.linalg.norm(pos, axis=1) < maxdist]
if minmass is not None:
data = data[data[minmass[0]] > minmass[1]]
self._data = data
@property
def nsnap(self):
"""
Snapshot number.
Returns
-------
nsnap : int
"""
return self._nsnap
@nsnap.setter
def nsnap(self, nsnap):
assert nsnap in [0, 1, 2, 3, 4]
self._nsnap = nsnap
@property
def redshift(self):
"""
Redshift of the snapshot.
Returns
-------
redshift : float
"""
z_dict = {4: 0.0, 3: 0.5, 2: 1.0, 1: 2.0, 0: 3.0}
return z_dict[self.nsnap]
@property
def box(self):
"""
Quijote box object.
Returns
-------
box : instance of :py:class:`csiborgtools.units.BaseBox`
"""
return QuijoteBox(self.nsnap)

5
csiborgtools/read/knn_summary.py
View file

@ -24,7 +24,7 @@ class kNNCDFReader:
Parameters
----------
paths : py:class`csiborgtools.read.CSiBORGPaths`
paths : py:class`csiborgtools.read.Paths`
"""
_paths = None
@ -38,13 +38,12 @@ class kNNCDFReader:
Parameters
----------
paths : py:class`csiborgtools.read.CSiBORGPaths`
paths : py:class`csiborgtools.read.Paths`
"""
return self._paths
@paths.setter
def paths(self, paths):
# assert isinstance(paths, CSiBORGPaths) # REMOVE
self._paths = paths
def read(self, run, kind, rmin=None, rmax=None, to_clip=True):

10
csiborgtools/read/overlap_summary.py
View file

@ -36,7 +36,7 @@ class PairOverlap:
Halo catalogue corresponding to the reference simulation.
catx : :py:class:`csiborgtools.read.HaloCatalogue`
Halo catalogue corresponding to the cross simulation.
paths : py:class`csiborgtools.read.CSiBORGPaths`
paths : py:class`csiborgtools.read.Paths`
CSiBORG paths object.
"""
_cat0 = None
@ -59,7 +59,7 @@ class PairOverlap:
Halo catalogue corresponding to the reference simulation.
catx : :py:class:`csiborgtools.read.HaloCatalogue`
Halo catalogue corresponding to the cross simulation.
paths : py:class`csiborgtools.read.CSiBORGPaths`
paths : py:class`csiborgtools.read.Paths`
CSiBORG paths object.
Returns
@ -268,8 +268,8 @@ class PairOverlap:
assert (norm_kind is None
or norm_kind in ("r200c", "ref_patch", "sum_patch"))
# Get positions either in the initial or final snapshot
pos0 = self.cat0().position(in_initial)
posx = self.catx().position(in_initial)
pos0 = self.cat0().position(in_initial=in_initial)
posx = self.catx().position(in_initial=in_initial)
# Get the normalisation array if applicable
if norm_kind == "r200c":
@ -474,7 +474,7 @@ class NPairsOverlap:
Single reference simulation halo catalogue.
catxs : list of :py:class:`csiborgtools.read.HaloCatalogue`
List of cross simulation halo catalogues.
paths : py:class`csiborgtools.read.CSiBORGPaths`
paths : py:class`csiborgtools.read.Paths`
CSiBORG paths object.
verbose : bool, optional
Verbosity flag for loading the overlap objects.

45
csiborgtools/read/paths.py
View file

@ -21,29 +21,32 @@ from warnings import warn
import numpy
class CSiBORGPaths:
class Paths:
"""
Paths manager for CSiBORG IC realisations.
Paths manager for CSiBORG and Quijote simulations.
Parameters
----------
srcdir : str
Path to the folder where the RAMSES outputs are stored.
postdir: str
Path to the folder where post-processed files are stored.
Parameters
----------
srcdir : str, optional
Path to the folder where the RAMSES outputs are stored.
postdir: str, optional
Path to the folder where post-processed files are stored.
quiote_dir : str, optional
Path to the folder where Quijote simulations are stored.
"""
_srcdir = None
_postdir = None
_quijote_dir = None
def __init__(self, srcdir=None, postdir=None):
def __init__(self, srcdir=None, postdir=None, quijote_dir=None):
self.srcdir = srcdir
self.postdir = postdir
self.quijote_dir = quijote_dir
@staticmethod
def _check_directory(path):
if not isdir(path):
raise IOError("Invalid directory `{}`!".format(path))
raise IOError(f"Invalid directory `{path}`!")
@property
def srcdir(self):
@ -65,6 +68,26 @@ class CSiBORGPaths:
self._check_directory(path)
self._srcdir = path
@property
def quijote_dir(self):
"""
Path to the folder where Quijote simulations are stored.
Returns
-------
path : str
"""
if self._quijote_dir is None:
raise ValueError("`quijote_dir` is not set!")
return self._quijote_dir
@quijote_dir.setter
def quijote_dir(self, path):
if path is None:
return
self._check_directory(path)
self._quijote_dir = path
@property
def postdir(self):
"""

14
csiborgtools/read/readsim.py
View file

@ -22,7 +22,7 @@ import numpy
from scipy.io import FortranFile
from tqdm import tqdm, trange
from .paths import CSiBORGPaths
from .paths import Paths
from .utils import cols_to_structured
###############################################################################
@ -36,7 +36,7 @@ class ParticleReader:
Parameters
----------
paths : py:class`csiborgtools.read.CSiBORGPaths`
paths : py:class`csiborgtools.read.Paths`
"""
_paths = None
@ -50,13 +50,13 @@ class ParticleReader:
Parameters
----------
paths : py:class`csiborgtools.read.CSiBORGPaths`
paths : py:class`csiborgtools.read.Paths`
"""
return self._paths
@paths.setter
def paths(self, paths):
assert isinstance(paths, CSiBORGPaths)
assert isinstance(paths, Paths)
self._paths = paths
def read_info(self, nsnap, nsim):
@ -396,17 +396,17 @@ class ParticleReader:
class MmainReader:
"""
Object to generate the summed substructure catalogue.
Object to generate the summed substructure CSiBORG PHEW catalogue.
Parameters
----------
paths : :py:class:`csiborgtools.read.CSiBORGPaths`
paths : :py:class:`csiborgtools.read.Paths`
Paths objects.
"""
_paths = None
def __init__(self, paths):
assert isinstance(paths, CSiBORGPaths)
assert isinstance(paths, Paths)
self._paths = paths
@property

8
csiborgtools/read/tpcf_summary.py
View file

@ -16,7 +16,7 @@
import joblib
import numpy
from .paths import CSiBORGPaths
from .paths import Paths
class TPCFReader:
@ -25,7 +25,7 @@ class TPCFReader:
Parameters
----------
paths : py:class`csiborgtools.read.CSiBORGPaths`
paths : py:class`csiborgtools.read.Paths`
"""
_paths = None
@ -39,13 +39,13 @@ class TPCFReader:
Parameters
----------
paths : py:class`csiborgtools.read.CSiBORGPaths`
paths : py:class`csiborgtools.read.Paths`
"""
return self._paths
@paths.setter
def paths(self, paths):
assert isinstance(paths, CSiBORGPaths)
assert isinstance(paths, Paths)
self._paths = paths
def read(self, run):

2
csiborgtools/read/utils.py
View file

@ -93,7 +93,7 @@ def real2redshift(pos, vel, origin, box, in_box_units, periodic_wrap=True,
Cartesian velocity components.
origin : 1-dimensional array `(3,)`
Origin of the coordinate system in the `pos` reference frame.
box : py:class:`csiborg.read.BoxUnits`
box : py:class:`csiborg.read.CSiBORGBox`
Box units.
in_box_units: bool
Whether `pos` and `vel` are in box units. If not, position is assumed

550
notebooks/fits.ipynb
View file

File diff suppressed because one or more lines are too long

500
notebooks/matching.ipynb
View file

File diff suppressed because one or more lines are too long

2
notebooks/perseus.ipynb
View file

@ -50,7 +50,7 @@
"metadata": {},
"outputs": [],
"source": [
"paths = csiborgtools.read.CSiBORGPaths(**csiborgtools.paths_glamdring)\n",
"paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring)\n",
"nsims = paths.get_ics(False)"
]
},

4
notebooks/playground_field.ipynb
View file

@ -97,9 +97,9 @@
"source": [
"grid = 256\n",
"length = 677.05\n",
"paths = csiborgtools.read.CSiBORGPaths()\n",
"paths = csiborgtools.read.Paths()\n",
"paths.set_info(7444, paths.get_maximum_snapshot(7444))\n",
"box = csiborgtools.units.BoxUnits(paths)\n",
"box = csiborgtools.units.CSiBORGBox(paths)\n",
"MAS = \"CIC\"\n",
"field = csiborgtools.field.DensityField(particles, length, box, MAS)"
]

4
notebooks/plot_correlation.ipynb
View file

@ -52,7 +52,7 @@
},
"outputs": [],
"source": [
"paths = csiborgtools.read.CSiBORGPaths()\n",
"paths = csiborgtools.read.Paths()\n",
"hw = 0.05\n",
"darkskyps = np.genfromtxt(\"../plots/darksky.csv\", delimiter=\", \")\n",
"\n",
@ -3699,7 +3699,7 @@
},
"outputs": [],
"source": [
"paths = csiborgtools.read.CSiBORGPaths()\n",
"paths = csiborgtools.read.Paths()\n",
"cat = csiborgtools.read.CombinedCatalogue(paths, min_m500=1e13, max_dist=210)"
]
},

8
notebooks/plot_mass_function.ipynb
View file

@ -55,7 +55,7 @@
"\n",
"data = data[(data[\"npart\"] > 100) & np.isfinite(data[\"m200\"])]\n",
"\n",
"boxunits = csiborgtools.units.BoxUnits(Nsnap, simpath)"
"CSiBORGBox = csiborgtools.units.CSiBORGBox(Nsnap, simpath)"
]
},
{
@ -96,7 +96,7 @@
}
],
"source": [
"boxunits.box2kpc(0.21) * 1e-3"
"CSiBORGBox.box2kpc(0.21) * 1e-3"
]
},
{
@ -1120,7 +1120,7 @@
}
],
"source": [
"mass = boxunits.box2solarmass(data[\"m200\"])\n",
"mass = CSiBORGBox.box2solarmass(data[\"m200\"])\n",
"\n"
]
},
@ -1220,7 +1220,7 @@
"source": [
"# n = 584\n",
"# xs = csiborgtools.fits.pick_single_clump(n, parts, part_clumps, clumps)\n",
"# halo = csiborgtools.fits.Clump.from_arrays(*xs, rhoc=boxunits.box_rhoc)\n",
"# halo = csiborgtools.fits.Clump.from_arrays(*xs, rhoc=CSiBORGBox.box_rhoc)\n",
"# print(halo.Npart)"
]
},

2
notebooks/test_mmain.ipynb
View file

@ -69,7 +69,7 @@
"metadata": {},
"outputs": [],
"source": [
"paths = csiborgtools.read.CSiBORGPaths(**csiborgtools.paths_glamdring)\n",
"paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring)\n",
"# cat = csiborgtools.read.ClumpsCatalogue(7444, paths)"
]
},

4
scripts/cluster_crosspk.py
View file

@ -48,8 +48,8 @@ rank = comm.Get_rank()
nproc = comm.Get_size()
MAS = "CIC" # mass asignment scheme
paths = csiborgtools.read.CSiBORGPaths(**csiborgtools.paths_glamdring)
box = csiborgtools.read.BoxUnits(paths)
paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring)
box = csiborgtools.read.CSiBORGBox(paths)
reader = csiborgtools.read.ParticleReader(paths)
ics = paths.get_ics()
nsims = len(ics)

2
scripts/cluster_knn_auto.py
View file

@ -49,7 +49,7 @@ with open("../scripts/knn_auto.yml", "r") as file:
Rmax = 155 / 0.705 # Mpc (h = 0.705) high resolution region radius
totvol = 4 * numpy.pi * Rmax**3 / 3
paths = csiborgtools.read.CSiBORGPaths(**csiborgtools.paths_glamdring)
paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring)
ics = paths.get_ics()
knncdf = csiborgtools.clustering.kNN_CDF()

2
scripts/cluster_knn_cross.py
View file

@ -48,7 +48,7 @@ with open("../scripts/knn_cross.yml", "r") as file:
config = yaml.safe_load(file)
Rmax = 155 / 0.705 # Mpc (h = 0.705) high resolution region radius
paths = csiborgtools.read.CSiBORGPaths(**csiborgtools.paths_glamdring)
paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring)
ics = paths.get_ics()
knncdf = csiborgtools.clustering.kNN_CDF()

2
scripts/cluster_tcpf_auto.py
View file

@ -47,7 +47,7 @@ with open("../scripts/tpcf_auto.yml", "r") as file:
config = yaml.safe_load(file)
Rmax = 155 / 0.705 # Mpc (h = 0.705) high resolution region radius
paths = csiborgtools.read.CSiBORGPaths()
paths = csiborgtools.read.Paths()
ics = paths.get_ics()
tpcf = csiborgtools.clustering.Mock2PCF()

4
scripts/field_derived.py
View file

@ -45,7 +45,7 @@ parser.add_argument("--grid", type=int, help="Grid resolution.")
parser.add_argument("--in_rsp", type=lambda x: bool(strtobool(x)),
help="Calculate from the RSP density field?")
args = parser.parse_args()
paths = csiborgtools.read.CSiBORGPaths(**csiborgtools.paths_glamdring)
paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring)
if args.ics is None or args.ics[0] == -1:
ics = paths.get_ics()
@ -59,7 +59,7 @@ for i in csiborgtools.fits.split_jobs(len(ics), nproc)[rank]:
print(f"{datetime.now()}: rank {rank} working on simulation {nsim}.",
flush=True)
nsnap = max(paths.get_snapshots(nsim))
box = csiborgtools.read.BoxUnits(nsnap, nsim, paths)
box = csiborgtools.read.CSiBORGBox(nsnap, nsim, paths)
density_gen = csiborgtools.field.DensityField(box, args.MAS)
rho = numpy.load(paths.field_path("density", args.MAS, args.grid, nsim,

4
scripts/field_fromparts.py
View file

@ -46,7 +46,7 @@ parser.add_argument("--grid", type=int, help="Grid resolution.")
parser.add_argument("--in_rsp", type=lambda x: bool(strtobool(x)),
help="Calculate the density field in redshift space?")
args = parser.parse_args()
paths = csiborgtools.read.CSiBORGPaths(**csiborgtools.paths_glamdring)
paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring)
mpart = 1.1641532e-10 # Particle mass in CSiBORG simulations.
if args.ics is None or args.ics[0] == -1:
@ -61,7 +61,7 @@ for i in csiborgtools.fits.split_jobs(len(ics), nproc)[rank]:
flush=True)
nsnap = max(paths.get_snapshots(nsim))
box = csiborgtools.read.BoxUnits(nsnap, nsim, paths)
box = csiborgtools.read.CSiBORGBox(nsnap, nsim, paths)
parts = csiborgtools.read.read_h5(paths.particles_path(nsim))["particles"]
if args.kind == "density":

4
scripts/fit_halos.py
View file

@ -42,7 +42,7 @@ parser.add_argument("--kind", type=str, choices=["halos", "clumps"])
parser.add_argument("--ics", type=int, nargs="+", default=None,
help="IC realisations. If `-1` processes all simulations.")
args = parser.parse_args()
paths = csiborgtools.read.CSiBORGPaths(**csiborgtools.paths_glamdring)
paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring)
partreader = csiborgtools.read.ParticleReader(paths)
nfwpost = csiborgtools.fits.NFWPosterior()
@ -105,7 +105,7 @@ for nsim in [ics[i] for i in jobs]:
print(f"{datetime.now()}: rank {rank} calculating simulation `{nsim}`.",
flush=True)
nsnap = max(paths.get_snapshots(nsim))
box = csiborgtools.read.BoxUnits(nsnap, nsim, paths)
box = csiborgtools.read.CSiBORGBox(nsnap, nsim, paths)
# Particle archive
f = csiborgtools.read.read_h5(paths.particles_path(nsim))

3
scripts/fit_init.py
View file

@ -22,7 +22,6 @@ from datetime import datetime
import numpy
from mpi4py import MPI
from tqdm import tqdm
try:
@ -45,7 +44,7 @@ parser = ArgumentParser()
parser.add_argument("--ics", type=int, nargs="+", default=None,
help="IC realisations. If `-1` processes all simulations.")
args = parser.parse_args()
paths = csiborgtools.read.CSiBORGPaths(**csiborgtools.paths_glamdring)
paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring)
partreader = csiborgtools.read.ParticleReader(paths)
if args.ics is None or args.ics[0] == -1:

4
scripts/fit_profiles.py
View file

@ -45,7 +45,7 @@ nproc = comm.Get_size()
if nproc > 1:
raise NotImplementedError("MPI is not implemented implemented yet.")
paths = csiborgtools.read.CSiBORGPaths(**csiborgtools.paths_glamdring)
paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring)
cols_collect = [("r", numpy.float32), ("M", numpy.float32)]
if args.ics is None or args.ics == -1:
nsims = paths.get_ics()
@ -59,7 +59,7 @@ for i, nsim in enumerate(nsims):
now = datetime.now()
print(f"{now}: calculating {i}th simulation `{nsim}`.", flush=True)
nsnap = max(paths.get_snapshots(nsim))
box = csiborgtools.read.BoxUnits(nsnap, nsim, paths)
box = csiborgtools.read.CSiBORGBox(nsnap, nsim, paths)
f = csiborgtools.read.read_h5(paths.particles_path(nsim))
particles = f["particles"]

2
scripts/match_all.py
View file

@ -54,7 +54,7 @@ def get_combs():
Get the list of all pairs of simulations, then permute them with a known
seed to minimise loading the same files simultaneously.
"""
paths = csiborgtools.read.CSiBORGPaths(**csiborgtools.paths_glamdring)
paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring)
ics = paths.get_ics()
combs = list(combinations(ics, 2))
Random(42).shuffle(combs)

2
scripts/match_singlematch.py
View file

@ -32,7 +32,7 @@ except ModuleNotFoundError:
def pair_match(nsim0, nsimx, sigma, smoothen, verbose):
from csiborgtools.read import HaloCatalogue, read_h5
paths = csiborgtools.read.CSiBORGPaths(**csiborgtools.paths_glamdring)
paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring)
smooth_kwargs = {"sigma": sigma, "mode": "constant", "cval": 0.0}
overlapper = csiborgtools.match.ParticleOverlap()
matcher = csiborgtools.match.RealisationsMatcher()

2
scripts/pre_dumppart.py
View file

@ -49,7 +49,7 @@ parser.add_argument("--ics", type=int, nargs="+", default=None,
args = parser.parse_args()
verbose = nproc == 1
paths = csiborgtools.read.CSiBORGPaths(**csiborgtools.paths_glamdring)
paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring)
partreader = csiborgtools.read.ParticleReader(paths)
# Keep "ID" as the last column!
pars_extract = ['x', 'y', 'z', 'vx', 'vy', 'vz', 'M', "ID"]

2
scripts/pre_mmain.py
View file

@ -33,7 +33,7 @@ comm = MPI.COMM_WORLD
rank = comm.Get_rank()
nproc = comm.Get_size()
paths = csiborgtools.read.CSiBORGPaths(**csiborgtools.paths_glamdring)
paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring)
mmain_reader = csiborgtools.read.MmainReader(paths)

4
scripts/pre_sortinit.py
View file

@ -18,9 +18,9 @@ snapshot ordering, which is sorted by the clump IDs.
"""
from argparse import ArgumentParser
from datetime import datetime
from gc import collect
import h5py
from gc import collect
import numpy
from mpi4py import MPI
@ -44,7 +44,7 @@ parser = ArgumentParser()
parser.add_argument("--ics", type=int, nargs="+", default=None,
help="IC realisations. If `-1` processes all simulations.")
args = parser.parse_args()
paths = csiborgtools.read.CSiBORGPaths(**csiborgtools.paths_glamdring)
paths = csiborgtools.read.Paths(**csiborgtools.paths_glamdring)
partreader = csiborgtools.read.ParticleReader(paths)
# NOTE: ID has to be the last column.
pars_extract = ["x", "y", "z", "M", "ID"]