pyramis 0.1.0__tar.gz

pyramis-0.1.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: pyramis
+Version: 0.1.0
+Summary: A python-based ramses analyzer for minimalist
+Author-email: San Han <san.han@iap.fr>
+License: MIT
+Project-URL: Repository, https://github.com/sanhan/pyramis
+Keywords: ramses
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: h5py>=3.12.1
+Requires-Dist: numpy>=1.26.4
+
+# PYthon-based Ramses Analyzer MInimaliSt
+A minimalist version of [Ramses Univsersal Reader](https://github.com/sanhancluster/pyramis.git), to provide key essential features for management and analysis of the [RAMSES](https://github.com/ramses-organisation/ramses) simulation data.
+
+## Installing
+### Using pip
+```bash
+git clone https://github.com/sanhancluster/pyramis.git
+cd pyramis
+pip install -e .
+```
+### Using conda
+```bash
+conda 
+```

pyramis-0.1.0/README.md

@@ -0,0 +1,14 @@
+# PYthon-based Ramses Analyzer MInimaliSt
+A minimalist version of [Ramses Univsersal Reader](https://github.com/sanhancluster/pyramis.git), to provide key essential features for management and analysis of the [RAMSES](https://github.com/ramses-organisation/ramses) simulation data.
+
+## Installing
+### Using pip
+```bash
+git clone https://github.com/sanhancluster/pyramis.git
+cd pyramis
+pip install -e .
+```
+### Using conda
+```bash
+conda 
+```

pyramis-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyramis"
+version = "0.1.0"
+description = "A python-based ramses analyzer for minimalist"
+authors = [
+  {name="San Han", email="san.han@iap.fr"}
+]
+requires-python = ">=3.11"
+license = {text = "MIT"}
+dependencies = [
+    "h5py>=3.12.1",
+    "numpy>=1.26.4"
+]
+readme = "README.md"
+keywords = ["ramses"]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[project.urls]
+Repository = "https://github.com/sanhan/pyramis"

pyramis-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyramis-0.1.0/src/pyramis/__init__.py

@@ -0,0 +1,6 @@
+from .config_module import load_config
+config = load_config()
+
+from .basic import *
+
+__all__ = ["config"]

pyramis-0.1.0/src/pyramis/basic.py

@@ -0,0 +1,96 @@
+import numpy as np
+from . import config
+from scipy.integrate import cumulative_trapezoid
+from types import SimpleNamespace
+
+DIM_KEYS = config['DIM_KEYS']
+
+cgs_unit = SimpleNamespace(**config['CGS_UNIT'])
+
+def get_vector(data: np.ndarray, name_format: str='{axis}', axis=-1) -> np.ndarray:
+    return np.stack([data[f'{name_format.format(axis=axis)}'] for axis in DIM_KEYS], axis=axis)
+
+
+def get_position(data: np.ndarray, axis=-1) -> np.ndarray:
+    return get_vector(data, name_format='{axis}', axis=axis)
+
+
+def get_velocity(data: np.ndarray, axis=-1) -> np.ndarray:
+    return get_vector(data, name_format='v{axis}', axis=axis)
+
+
+def get_cosmo_table(H0: float, omega_m: float, omega_l: float, omega_k=None, omega_r=None, nbins=5000, aexp_min=1E-4, aexp_max=10.0) -> np.ndarray:
+    """
+    Build a conversion table for aexp, ttilde, and age of the universe.
+    ttilde refers `conformal time (super-comoving time)` scale that is used in cosmological simulation in ramses.
+    
+    Parameters
+    ----------
+    H0 : float
+        Hubble constant at z=0 in km/s/Mpc.
+    omega_m : float
+        Matter density parameter at z=0.
+    omega_l : float
+        Dark energy density parameter at z=0.
+    nbins : int, optional
+        Number of bins in the table, by default 5000.
+    """
+    def E(aexp):
+        return np.sqrt(omega_m * aexp ** -3 + omega_l)
+    
+    if omega_r is None:
+        omega_r = 0.0
+    
+    if omega_k is None:
+        omega_k = 1.0 - omega_m - omega_l - omega_r
+
+    x = np.linspace(np.log(aexp_min), np.log(aexp_max), nbins)
+    aexp = np.exp(x)
+    E = np.sqrt(omega_m * aexp**-3 + omega_l + omega_k * aexp**-2 + omega_r * aexp**-4)
+
+    dtsc_over_dx = np.exp(-x) / E
+    tsc = cumulative_trapezoid(dtsc_over_dx, x, initial=0.0)
+    tsc = tsc - np.interp(1.0, aexp, tsc)
+
+    dt_over_dx = 1. / (H0 * cgs_unit.km / cgs_unit.Mpc * E * cgs_unit.Gyr)
+    age = cumulative_trapezoid(dt_over_dx, x, initial=0.0)
+    z = 1.0 / aexp - 1.0
+    table = np.rec.fromarrays([aexp, tsc, age, z], dtype=[('aexp', 'f8'), ('t_sc', 'f8'), ('age', 'f8'), ('z', 'f8')])
+
+    return table
+
+
+def cosmo_convert(table, x, xname, yname):
+    x_arr = table[xname]
+    y_arr = table[yname]
+
+    if np.any(x < x_arr[0]) or np.any(x > x_arr[-1]):
+        raise ValueError(f"{xname} out of bounds: valid range [{x_arr[0]}, {x_arr[-1]}]")
+
+    y = np.interp(x, x_arr, y_arr)
+    return y
+
+
+def uniform_digitize(values, lim, nbins):
+    """
+    A faster version of np.digitize that works with uniform bins.
+    The result may vary from np.digitize near the bin edges.
+
+    Parameters
+    ----------
+    values : array-like
+        The input values to digitize.
+    lim : array-like
+        The limits for the bins.
+    nbins : int
+        The number of bins.
+
+    Returns
+    -------
+    array-like
+        The digitized indices of the input values.
+    """
+    values_idx = (values - lim[..., 0]) / (lim[..., 1] - lim[..., 0]) * nbins + 1
+    values_idx = values_idx.astype(int)
+    values_idx = np.clip(values_idx, 0, nbins+1)
+    return values_idx

pyramis-0.1.0/src/pyramis/config_module.py

@@ -0,0 +1,21 @@
+import tomllib
+from pathlib import Path
+import multiprocessing as mp
+
+CONFIG_PATH = Path(__file__).parent / "config.toml"
+BASE_CONFIG_PATH = Path(__file__).parent / "config_base.toml"
+
+def load_config(path: str | Path = CONFIG_PATH) -> dict:
+    """Load configuration from a TOML file."""
+    base_path = BASE_CONFIG_PATH
+    path = Path(path)
+
+    if not path.exists():
+        path = BASE_CONFIG_PATH
+    
+    with base_path.open("rb") as f:
+        config = tomllib.load(f)
+
+    with path.open("rb") as f:
+        config.update(tomllib.load(f))
+        return config

pyramis-0.1.0/src/pyramis/core.py

@@ -0,0 +1,99 @@
+from typing import Union
+import numpy as np
+
+from .geometry import DIM_KEYS, Box, Region
+from .utils import hilbert3d
+from . import config
+
+DEFAULT_LEVEL_SUBDIVIDE = config['DEFAULT_LEVEL_SUBDIVIDE']
+
+def domain_slice(data, domain_list, bounds):
+    """
+    Returns a merged array of sliced portion from data based on domain_list and bounds.
+
+    Parameters:
+    data (array-like): The data to be sliced.
+    domain_list (array-like): List of domain indices willing to be sliced.
+    bounds (array-like): Array contains domain boundaries.
+    """
+    starts, ends = bounds[domain_list], bounds[domain_list+1]
+    merged = np.concatenate([data[start:end] for start, end in zip(starts, ends)])
+    return merged
+
+
+def compute_chunk_list_from_hilbert(region: Union[Region, np.ndarray, list], hilbert_boundary, level_hilbert, boxlen: float=1.0, level_divide=None, level_subdivide: int=DEFAULT_LEVEL_SUBDIVIDE, ndim: int=3) -> np.ndarray:
+    """
+    Computes the list of chunk indices that intersect with the given region based on 3-dimensional Hilbert curve partitioning.
+
+    Parameters
+    ----------
+    region : Region or np.ndarray
+        The spatial region of interest, either as a Region instance or a (2, 3) ndarray representing a bounding box.
+    hilbert_boundary : np.ndarray
+        Array of Hilbert boundary keys defining the chunk partitions.
+    level_hilbert : int
+        The Hilbert curve level used for partitioning.
+    boxsize : float
+        The size of the entire box in which the Hilbert curve is defined.
+    level_divide : int, optional
+        The level at which to divide the Hilbert curve for chunking. If None, it is computed based on the region size.
+    level_subdivide : int
+        Additional subdivision level to refine the chunking.
+    """
+    assert_ascending(hilbert_boundary)
+    if isinstance(region, Region):
+        bounding_box = region.bounding_box.box
+    elif (isinstance(region, np.ndarray) or isinstance(region, list)) and np.shape(region) == (ndim, 2):
+        bounding_box = region
+        region = Box(bounding_box)
+    else:
+        raise ValueError("region must be either a Region instance or a (ndim, 2) ndarray representing a bounding box.")
+    
+    if level_divide is None:
+        level_divide = -int(np.floor(np.log2(np.min(bounding_box[:, 1] - bounding_box[:, 0]) / boxlen))) + level_subdivide
+    level_divide = np.minimum(level_divide, level_hilbert)
+    grid_size = boxlen * np.exp2(-level_divide)
+    
+    min_idx = np.floor(bounding_box[:, 0] / grid_size).astype(np.int64)
+    max_idx = np.ceil(bounding_box[:, 1] / grid_size).astype(np.int64)
+    
+    grid_x, grid_y, grid_z = np.meshgrid(
+        np.arange(min_idx[0], max_idx[0]),
+        np.arange(min_idx[1], max_idx[1]),
+        np.arange(min_idx[2], max_idx[2]),
+    )
+    grid_points = np.stack([grid_x.ravel(), grid_y.ravel(), grid_z.ravel()], axis=-1)
+
+    if not isinstance(region, Box):
+        grid_points = grid_points[region.contains((grid_points + 0.5) * grid_size, size=grid_size/2)]
+    hilbert_keys_min = hilbert3d(grid_points, bit_length=level_divide) * np.exp2(ndim * (level_hilbert - level_divide))
+    hilbert_keys_max = (hilbert3d(grid_points, bit_length=level_divide) + 1) * np.exp2(ndim * (level_hilbert - level_divide))
+    chunk_indices_min = np.searchsorted(hilbert_boundary, hilbert_keys_min, side='right') - 1
+    chunk_indices_max = np.searchsorted(hilbert_boundary, hilbert_keys_max, side='left') - 1
+
+    chunk_indices = np.unique(np.concatenate([np.arange(start, end + 1) for start, end in zip(chunk_indices_min, chunk_indices_max)]))
+    return np.sort(chunk_indices)
+
+
+def assert_ascending(arr, msg="Array is not sorted in ascending order."):
+    if not np.all(arr[:-1] <= arr[1:]):
+        raise ValueError(msg)
+
+
+def str_to_tuple(input_data):
+    return tuple(map(int, input_data.split(',')))
+
+
+def quad_to_f16(by):
+    # receives byte array with format of IEEE 754 quadruple float and converts to numpy.float128 array
+    # because quadruple float is not supported in numpy
+    # source: https://stackoverflow.com/questions/52568037/reading-16-byte-fortran-floats-into-python-from-a-file
+    out = []
+    asint = []
+    for raw in np.reshape(by, (-1, 16)):
+        asint.append(int.from_bytes(raw, byteorder='little'))
+    asint = np.array(asint)
+    sign = (np.float128(-1.0)) ** np.float128(asint >> 127)
+    exponent = ((asint >> 112) & 0x7FFF) - 16383
+    significand = np.float128((asint & ((1 << 112) - 1)) | (1 << 112))
+    return sign * significand * 2.0 ** np.float128(exponent - 112)

pyramis-0.1.0/src/pyramis/geometry.py

@@ -0,0 +1,139 @@
+import numpy as np
+from . import config
+
+DIM_KEYS = config['DIM_KEYS']
+
+class Region():
+    def evaluate(self, data):
+        if (isinstance(data, np.ndarray) and data.shape[-1] == 3):
+            return self.contains(data)
+
+    def contains(self, points, size=0):
+        raise NotImplementedError()
+    
+    def contains_data(self, data, size=0):
+        raise NotImplementedError()
+
+    @property
+    def center(self):
+        raise NotImplementedError()
+
+    @property
+    def bounding_box(self):
+        raise NotImplementedError()
+
+    __call__ = evaluate
+
+
+class Box(Region):
+    def __init__(self, box):
+        self.box = np.asarray(box)
+
+    def set_center(self, center, extent=None):
+        center = np.asarray(center)
+        if extent is None:
+            extent = self.extent
+        extent = np.asarray(extent)
+        self.box = np.stack([center - extent / 2, center + extent / 2], axis=-1)
+
+    @property
+    def extent(self) -> np.ndarray:
+        return self.box[:, 1] - self.box[:, 0]
+
+    @property
+    def center(self) -> np.ndarray:
+        return np.mean(self.box, axis=-1)
+
+    @property
+    def bounding_box(self) -> "Box":
+        return self
+
+    def contains(self, points, size=0):
+        box = self.box
+        half_size = np.asarray(size / 2)[..., np.newaxis]
+
+        mask = np.all(
+            (box[:, 0] <= points + half_size) &
+            (points - half_size <= box[:, 1]),
+            axis=-1
+        )
+        return mask
+    
+    def contains_data(self, data, size=0):
+        box = self.box
+        half_size = np.asarray(size / 2)
+
+        mask = np.ones(len(data), dtype=bool)
+        for i, key in enumerate(DIM_KEYS):
+            mask &= (box[i, 0] <= data[key] + half_size) & (data[key] - half_size <= box[i, 1])
+        return mask
+
+
+    def __getitem__(self, key):
+        return self.box[key]
+
+
+class Sphere(Region):
+    def __init__(self, center, radius: float):
+        self._center = np.asarray(center)
+        self.radius = radius
+    
+    @property
+    def center(self) -> np.ndarray:
+        return self._center
+
+    @property
+    def bounding_box(self) -> "Box":
+        box = Box(None)
+        box.set_center(self.center, self.radius * 2)
+        return box
+
+    def contains(self, points, size=0):
+        center = self.center
+        radius = self.radius
+        return np.linalg.norm(points - center, axis=-1) <= radius - size
+    
+    def contains_data(self, data, size=0):
+        center = self.center
+        radius = self.radius
+
+        dist2 = np.zeros(len(data), dtype=float)
+        for i, key in enumerate(DIM_KEYS):
+            dist2 += (data[key] - center[i])**2
+        mask = np.sqrt(dist2) <= radius - size
+        return mask
+
+
+class Spheroid(Region):
+    def __init__(self, center, radii: np.ndarray):
+        self._center = np.asarray(center)
+        self.radii = np.asarray(radii)
+
+    @property
+    def center(self) -> np.ndarray:
+        return self._center
+
+    @property
+    def bounding_box(self) -> "Box":
+        box = Box(None)
+        box.set_center(self.center, self.radii * 2)
+        return box
+
+    def contains(self, points, size=0):
+        center = self.center
+        radii = self.radii
+        normed = (points - center) / (radii - size)
+        dist = np.linalg.norm(normed, axis=-1)
+        mask = dist <= 1
+        return mask
+    
+    def contains_data(self, data, size=0):
+        center = self.center
+        radii = self.radii
+        
+        dist2 = np.zeros(len(data), dtype=float)
+        for i, key in enumerate(DIM_KEYS):
+            normed = (data[key] - center[i]) / (radii[i] - size)
+            dist2 += normed**2
+        mask = dist2 <= 1
+        return mask