turbocluster 0.1__tar.gz

turbocluster-0.1/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: turbocluster
+Version: 0.1
+Summary: A GPU-accelerated Python library for filtering turbulence in Arepo simulations
+Author-email: Lorenzo Maria Perrone <lorenzolmp@protonmail.com>, Thomas Berlok <tberlok@gmail.com>
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.14.0
+Description-Content-Type: text/markdown
+Requires-Dist: scipy>=1.7.3
+Requires-Dist: numpy<=2.4.6
+Requires-Dist: matplotlib
+Requires-Dist: h5py
+Requires-Dist: astropy>=4.3
+Requires-Dist: numba-cuda[cu13]
+Requires-Dist: paicos[dev]>=0.1.17
+Requires-Dist: cupy-cuda13x[ctk]
+Requires-Dist: nvtx
+
+[![Documentation Status](https://app.readthedocs.org/projects/turbocluster/badge/?version=latest)](https://turbocluster.readthedocs.io/en/latest/)
+[![flake8](https://github.com/LorenzoLMP/turbocluster/actions/workflows/flake8.yml/badge.svg)](
+https://github.com/LorenzoLMP/turbocluster/actions/workflows/flake8.yml)
+
+# turbocluster
+
+A GPU-accelerated Python library for filtering turbulence in Arepo simulations.
+
+<img src="images/turbocluster_banner.png" width="auto">
+
+**NOTE**: This project is in active development and not officially released publicly yet. Expect kinks and bugs. Refer to [this arXiv paper](https://arxiv.org/pdf/2601.06250) if you would like to know more about its use.
+
+A work-in-progress documentation can be found at [readthedocs](https://turbocluster.readthedocs.io/en/latest/).
+
+# TODO: 
+- double-check tests and examples
+- can cuda.jit() be replaced by jit() on non-cuda hardware?
+
+
+
+

turbocluster-0.1/README.md

@@ -0,0 +1,21 @@
+[![Documentation Status](https://app.readthedocs.org/projects/turbocluster/badge/?version=latest)](https://turbocluster.readthedocs.io/en/latest/)
+[![flake8](https://github.com/LorenzoLMP/turbocluster/actions/workflows/flake8.yml/badge.svg)](
+https://github.com/LorenzoLMP/turbocluster/actions/workflows/flake8.yml)
+
+# turbocluster
+
+A GPU-accelerated Python library for filtering turbulence in Arepo simulations.
+
+<img src="images/turbocluster_banner.png" width="auto">
+
+**NOTE**: This project is in active development and not officially released publicly yet. Expect kinks and bugs. Refer to [this arXiv paper](https://arxiv.org/pdf/2601.06250) if you would like to know more about its use.
+
+A work-in-progress documentation can be found at [readthedocs](https://turbocluster.readthedocs.io/en/latest/).
+
+# TODO: 
+- double-check tests and examples
+- can cuda.jit() be replaced by jit() on non-cuda hardware?
+
+
+
+

turbocluster-0.1/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "turbocluster"
+version = "0.1"
+authors = [
+    { name="Lorenzo Maria Perrone", email="lorenzolmp@protonmail.com" },
+    { name="Thomas Berlok", email="tberlok@gmail.com" },
+]
+description = "A GPU-accelerated Python library for filtering turbulence in Arepo simulations"
+readme = "README.md"
+requires-python = ">=3.14.0"
+classifiers = [
+    "Programming Language :: Python :: 3.14",
+]
+
+dynamic = ["dependencies"]
+
+[tool.setuptools.dynamic]
+dependencies = {file = ["requirements.txt"]}
+
+
+[tool.setuptools.packages.find]
+where = ["."]  # list of folders that contain the packages (["."] by default)
+include = ["turbocluster"]  # package names shbuld match these glob patterns (["*"] by default)
+exclude = []  # exclude packages matching these glob patterns (empty by default)
+namespaces = false  # to disable scanning PEP 420 namespaces (true by default)
+
+
+[tool.cibuildwheel]
+before-all = "uname -a"

turbocluster-0.1/requirements.txt

@@ -0,0 +1,9 @@
+scipy >= 1.7.3
+numpy <= 2.4.6
+matplotlib
+h5py
+astropy >= 4.3
+numba-cuda[cu13]
+paicos[dev] >= 0.1.17
+cupy-cuda13x[ctk]
+nvtx

turbocluster-0.1/setup.cfg

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

turbocluster-0.1/tests/test_cuda.py

@@ -0,0 +1,58 @@
+import cupy as cp
+from numba import cuda
+import numpy as np
+
+
+@cuda.jit()
+def check_particle(pos, hsml, center, widths, isParticleInDomain):
+    """ """
+    ip = cuda.grid(1)
+    # each thread is assigned to a particle
+    numParticles = pos.shape[0]
+    isParticleInDomainTmp = 0
+
+    if ip < numParticles:
+
+        xp, yp, zp = pos[ip]
+        xmin = center[0] - widths[0] / 2 - hsml[ip]
+        xmax = center[0] + widths[0] / 2 + hsml[ip]
+
+        ymin = center[1] - widths[1] / 2 - hsml[ip]
+        ymax = center[1] + widths[1] / 2 + hsml[ip]
+
+        zmin = center[2] - widths[2] / 2 - hsml[ip]
+        zmax = center[2] + widths[2] / 2 + hsml[ip]
+
+        if (xp > xmin) and (xp < xmax):
+            if (yp > ymin) and (yp < ymax):
+                if (zp > zmin) and (zp < zmax):
+                    isParticleInDomainTmp = 1
+
+        isParticleInDomain[ip] = isParticleInDomainTmp
+
+
+pos = cp.random.random((1000000, 3))
+isParticleInDomain = cp.zeros(pos.shape[0])
+hsml = cp.zeros(pos.shape[0])
+widths = cp.array([1, 1, 1])
+center = cp.array([0.5, 0.5, 0.5])
+
+
+Np = pos.shape[0]
+threadsperblock = 256
+blocks_1d = (Np + (threadsperblock - 1)) // threadsperblock
+
+if __name__ == "__main__":
+
+    try:
+        check_particle[blocks_1d, threadsperblock](
+            pos, hsml, center, widths, isParticleInDomain
+        )
+        success = np.array_equal(cp.asnumpy(isParticleInDomain), np.ones(pos.shape[0]))
+
+        if success:
+            print("The test worked")
+        else:
+            raise ValueError("The test failed.")
+    except Exception as e:
+        print(e)

turbocluster-0.1/turbocluster/__init__.py

@@ -0,0 +1,9 @@
+from .cartesian_tiling import CartesianTiling
+from .data_init import DataGpuInit
+
+from .SmoothingFilter.smoothing_filter import SmoothingFilter
+from .DepositToGrid.deposit_routines import DepositCartesianGrid
+from .PotentialEnergy.potential_energy import PotentialEnergy
+
+# from .helper_functions import *
+# from .utils.power_spectra_utils import *

turbocluster-0.1/turbocluster/cartesian_tiling.py

@@ -0,0 +1,247 @@
+import cupy as cp
+from numba import cuda
+import nvtx
+
+
+@cuda.jit(device=True, inline=True)
+def find_tile_single_dim(particle_pos, nx, tile_width):
+    """ """
+    tile_index = int(particle_pos / tile_width)
+    return tile_index
+
+
+@cuda.jit
+def find_tile_index(pos, npixs, tile_widths, tile_index):
+    """ """
+    ip = cuda.grid(1)
+
+    if ip < pos.shape[0]:
+        xp = pos[ip, 0]
+        yp = pos[ip, 1]
+        zp = pos[ip, 2]
+        ip_tile_x = find_tile_single_dim(xp, npixs[0], tile_widths[0])
+        ip_tile_y = find_tile_single_dim(yp, npixs[1], tile_widths[1])
+        ip_tile_z = find_tile_single_dim(zp, npixs[2], tile_widths[2])
+        tile_index[ip, 0] = ip_tile_x
+        tile_index[ip, 1] = ip_tile_y
+        tile_index[ip, 2] = ip_tile_z
+
+
+@cuda.jit
+def get_tile_information(tile_index, particles_per_tile, start_index_for_tile):
+    """
+    Need to do this on each block and then assemble
+    """
+    ip = cuda.grid(1)
+    if ip < tile_index.shape[0]:
+        ip_tile_x, ip_tile_y, ip_tile_z = tile_index[ip, :]
+        cuda.atomic.add(particles_per_tile, (ip_tile_x, ip_tile_y, ip_tile_z), 1)
+        cuda.atomic.min(start_index_for_tile, (ip_tile_x, ip_tile_y, ip_tile_z), ip)
+
+
+@cuda.jit
+def accumulate_quantity_per_tile(tile_index, quantity_per_tile, quantity):
+    """ """
+    ip = cuda.grid(1)
+    if ip < tile_index.shape[0]:
+        ip_tile_x, ip_tile_y, ip_tile_z = tile_index[ip, :]
+        cuda.atomic.add(
+            quantity_per_tile, (ip_tile_x, ip_tile_y, ip_tile_z), quantity[ip]
+        )
+
+
+@cuda.jit
+def findmax_quantity_per_tile(tile_index, quantity_per_tile, quantity):
+    """ """
+    ip = cuda.grid(1)
+    if ip < tile_index.shape[0]:
+        ip_tile_x, ip_tile_y, ip_tile_z = tile_index[ip, :]
+        cuda.atomic.max(
+            quantity_per_tile, (ip_tile_x, ip_tile_y, ip_tile_z), quantity[ip]
+        )
+
+
+@cuda.jit
+def compactify_kernel(
+    occupancy_arr,
+    cumulative_occupancy_flat,
+    npixs,
+    Nmax,
+    particles_per_tile,
+    start_index_for_tile,
+    numBlocksCompactGrid,
+    compactGrid,
+):
+    """ """
+    ip = cuda.grid(1)
+    numBlocksFullGrid = int(npixs[0] * npixs[1] * npixs[2])
+    if ip < numBlocksFullGrid:
+        newPos = int(cumulative_occupancy_flat[ip])
+        numBlocksNeeded = int(occupancy_arr[ip])
+        # we walk backwards like a shrimp
+        for i in range(numBlocksNeeded):
+            compactGrid[newPos - 1 - i, 0] = ip
+            compactGrid[newPos - 1 - i, 1] = (
+                start_index_for_tile[ip] + (numBlocksNeeded - 1 - i) * Nmax
+            )
+            if i > 0:
+                compactGrid[newPos - 1 - i, 2] = Nmax
+            else:
+                compactGrid[newPos - 1 - i, 2] = (
+                    particles_per_tile[ip] - (numBlocksNeeded - 1) * Nmax
+                )
+
+
+class CartesianTiling:
+    """ """
+
+    def __init__(
+        self,
+        positions,
+        center,
+        widths,
+        extra_layer_thickness,
+        npix=128,
+        threadsperblock=256,
+    ):
+
+        self.Np = Np = positions.shape[0]
+
+        self.blocks_1d = (Np + (threadsperblock - 1)) // threadsperblock
+        self.threadsperblock = threadsperblock
+
+        # Copy positions
+        self._pos = cp.array(positions)
+
+        self.tilebox_widths = widths + 2 * extra_layer_thickness
+
+        npix_x = npix
+        npix_y = int(self.tilebox_widths[1] / self.tilebox_widths[0] * npix)
+        npix_z = int(self.tilebox_widths[2] / self.tilebox_widths[0] * npix)
+
+        npix_y = max([npix_y, 1])
+        npix_z = max([npix_z, 1])
+
+        self.npixs = cp.array([npix_x, npix_y, npix_z])
+
+        self.off_sets = center - self.tilebox_widths / 2.0
+
+        self.tile_widths = self.tilebox_widths / self.npixs
+
+        self._pos -= self.off_sets[None, :]
+
+    def sort_particles_in_tiles(self):
+
+        npix_x, npix_y, npix_z = self.npixs
+
+        # tile_index tells us which tile does each particle belong to
+        self.tile_index = cp.zeros((self.Np, 3), dtype=int)
+
+        self.particles_per_tile = cp.zeros(self.npixs.tolist(), dtype=int)
+        # Initialize to value larger than the largest posssible tileindex
+        self.start_index_for_tile = (
+            cp.ones(self.npixs.tolist(), dtype=int) * self.Np + 1
+        )
+
+        # Get what tile does each particle belong to
+        rng = nvtx.start_range(message="find_tile_index")
+        find_tile_index[self.blocks_1d, self.threadsperblock](
+            self._pos, self.npixs, self.tile_widths, self.tile_index
+        )
+        nvtx.end_range(rng)
+
+        rng = nvtx.start_range(message="sort_index")
+        self.sort_index = cp.argsort(
+            self.tile_index[:, 2] * npix_x * npix_y
+            + self.tile_index[:, 1] * npix_x
+            + self.tile_index[:, 0]
+        )
+        nvtx.end_range(rng)
+
+        unsort_index = cp.zeros(self.Np, dtype=int)
+        unsort_index[self.sort_index] = cp.arange(self.Np)
+        self.unsort_index = unsort_index
+
+        self.tile_index = self.tile_index[self.sort_index, :]
+
+        rng = nvtx.start_range(message="get_tile_information")
+        get_tile_information[self.blocks_1d, self.threadsperblock](
+            self.tile_index, self.particles_per_tile, self.start_index_for_tile
+        )
+        nvtx.end_range(rng)
+
+    def accumulate_per_tile(self, quantity):
+        """
+        This function accumulates a variable per each tile
+        """
+
+        tile_index = self.tile_index
+
+        npix_x = int(self.npixs[0])
+        npix_y = int(self.npixs[1])
+        npix_z = int(self.npixs[2])
+
+        quantity_per_tile = cp.zeros((npix_x, npix_y, npix_z), dtype=cp.float64)
+
+        accumulate_quantity_per_tile[self.blocks_1d, self.threadsperblock](
+            tile_index, quantity_per_tile, quantity
+        )
+
+        return quantity_per_tile
+
+    def findmax_per_tile(self, quantity):
+        """
+        This function finds max of a variable per each tile
+        """
+
+        tile_index = self.tile_index
+
+        npix_x = int(self.npixs[0])
+        npix_y = int(self.npixs[1])
+        npix_z = int(self.npixs[2])
+
+        quantity_per_tile = cp.zeros((npix_x, npix_y, npix_z), dtype=cp.float64)
+
+        findmax_quantity_per_tile[self.blocks_1d, self.threadsperblock](
+            tile_index, quantity_per_tile, quantity
+        )
+
+        return quantity_per_tile
+
+    def compactify_grid(self, Nmax):
+        occupancy_arr = ((self.particles_per_tile + (Nmax - 1)) // Nmax).flatten()
+        cumulative_occupancy = cp.cumsum(occupancy_arr)
+        numBlocksCompactGrid = cumulative_occupancy[-1]
+        compactGrid = cp.zeros((int(numBlocksCompactGrid), 3), dtype=int)
+
+        threadsperblock = 256
+        numBlocksFullGrid = int(self.npixs[0] * self.npixs[1] * self.npixs[2])
+        blocks_1d = (numBlocksFullGrid + (threadsperblock - 1)) // threadsperblock
+        compactify_kernel[blocks_1d, threadsperblock](
+            occupancy_arr,
+            cumulative_occupancy,
+            self.npixs,
+            Nmax,
+            self.particles_per_tile.flatten(),
+            self.start_index_for_tile.flatten(),
+            numBlocksCompactGrid,
+            compactGrid,
+        )
+        # compactGrid is an array of 3-tuples numBlocksCompactGrid long.
+        # for each block in numBlocksCompactGrid the 3-tuples is as follows
+        # [id of the tile in the grid it refers to, id of first particle, num of particles it contains]
+
+        self.compactGrid = compactGrid
+
+    def release_gpu_memory(self):
+        # TODO: Add deletion of all GPU variables stored in self
+
+        if self.sort_index is not None:
+            del self.sort_index
+        del self.unsort_index
+        del self.start_index_for_tile
+        del self.particles_per_tile
+        del self.tile_index
+        del self._pos
+
+        # cp._default_memory_pool.free_all_blocks()

turbocluster-0.1/turbocluster/data_init.py

@@ -0,0 +1,163 @@
+import numpy as np
+import cupy as cp
+from numba import cuda
+import math
+import paicos as pa
+import nvtx
+
+
+from .cartesian_tiling import CartesianTiling
+
+
+class DataGpuInit:
+    """ """
+
+    def __init__(
+        self, snap, center, widths, orientation=None, threadsperblock=256, **kwargs
+    ):
+        """ """
+
+        # self.__dict__.update(kwargs)
+
+        self.snap = snap
+        self.cartesian = True
+        if pa.settings.use_units:
+            self.code_length = code_length = self.snap.length
+        # self.npix = npix
+        self.threadsperblock = threadsperblock
+
+        if hasattr(center, "unit"):
+            self.center = center.copy
+            assert center.unit == code_length.unit, "this restriction applies"
+        elif pa.settings.use_units:
+            self.center = np.array(center) * code_length
+        else:
+            self.center = np.array(center)
+
+        if hasattr(widths, "unit"):
+            self.widths = widths.copy
+            assert widths.unit == code_length.unit, "this restriction applies"
+        elif pa.settings.use_units:
+            self.widths = np.array(widths) * code_length
+        else:
+            self.widths = np.array(widths)
+
+        if orientation is None:
+            self.orientation = None
+        else:
+            self.orientation = orientation.copy
+
+        # self.pos = self.snap["0_Coordinates"]
+
+        self.gpu_variables = {}
+
+    def _do_region_selection(self, thickness, pos):
+
+        center = self.center
+        widths = self.widths
+        snap = self.snap
+
+        # Send subset of snapshot to GPU
+        # get the index of the region of projection
+        rng = nvtx.start_range(message="region_selection")
+        if self.orientation is None:
+            get_index = pa.util.get_index_of_cubic_region_plus_thin_layer
+            indices = get_index(pos, center, widths, thickness, snap.box)
+        else:
+            get_index = pa.util.get_index_of_rotated_cubic_region_plus_thin_layer
+            indices = get_index(
+                pos, center, widths, thickness, snap.box, self.orientation
+            )
+        nvtx.end_range(rng)
+
+        return indices
+
+    def _send_variable_to_gpu(self, variable, gpu_key="input_variable", sort=False):
+        if isinstance(variable, str):
+            # variable_str = str(variable)
+            # err_msg = 'filter only works on gas'
+            # assert int(variable[0]) == 0, err_msg
+            variable = self.snap[variable]
+        else:
+            # variable_str = gpu_key
+            if not isinstance(variable, np.ndarray):
+                raise RuntimeError("Unexpected type for variable")
+
+        variable_str = gpu_key
+        # select only region of interest
+        if variable.shape[0] == self.index.shape[0]:
+            variable = variable[self.index]
+
+        if variable_str in self.gpu_variables and variable_str != gpu_key:
+            pass
+        else:
+            # Send variable to gpu
+            if pa.settings.use_units:
+                self.gpu_variables[variable_str] = cp.array(variable.value)
+            else:
+                self.gpu_variables[variable_str] = cp.array(variable)
+
+        if sort:
+            try:
+                if (
+                    self.gpu_variables[variable_str].shape[0]
+                    == self.tile.sort_index.shape[0]
+                ):
+                    self.gpu_variables[variable_str] = self.gpu_variables[variable_str][
+                        self.tile.sort_index
+                    ]
+            except RuntimeError:
+                raise RuntimeError(
+                    "Sorted can be done only after creating a CartesianTiling"
+                )
+
+        if isinstance(variable, pa.units.PaicosQuantity):
+            unit_quantity = variable.unit_quantity
+        else:
+            unit_quantity = None
+
+        return variable_str, unit_quantity
+
+    def _rotate_coordinates(self):
+
+        if self.orientation is not None:
+            if "inverse_rotation_matrix" not in self.gpu_variables:
+                self.gpu_variables["inverse_rotation_matrix"] = cp.array(
+                    self.orientation.inverse_rotation_matrix
+                )
+
+                self.gpu_variables["pos"] = cp.matmul(
+                    self.gpu_variables["inverse_rotation_matrix"],
+                    self.gpu_variables["pos"],
+                    axes=[(-2, -1), (-1, -2), (-1, -2)],
+                )
+
+                self.gpu_variables["center"] = cp.matmul(
+                    self.gpu_variables["inverse_rotation_matrix"],
+                    self.gpu_variables["center"],
+                )
+
+    def __del__(self):
+        """
+        Clean up like this? Not sure it is needed...
+        """
+        self.release_gpu_memory()
+
+    def release_gpu_memory(self):
+        # TODO: Add deletion of all GPU variables stored in self
+        if hasattr(self, "gpu_variables"):
+            for key in list(self.gpu_variables):
+                del self.gpu_variables[key]
+            del self.gpu_variables
+        if hasattr(self, "tile"):
+            self.tile.release_gpu_memory()
+            del self.tile
+
+        # cp._default_memory_pool.free_all_blocks()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        print("bye")
+        self.__del__()

turbocluster-0.1/turbocluster/helper_functions.py

@@ -0,0 +1,67 @@
+import numpy as np
+import cupy as cp
+
+
+def volume_integral(snap, qt, indices):
+    if isinstance(qt, str):
+        qt = snap[qt]
+
+    # using paicos omp-vectorized routines
+    a = snap.get_sum_of_array((qt * snap["0_Volume"])[indices])
+
+    return a
+
+
+def volume_average(snap, qt, indices):
+    if isinstance(qt, str):
+        qt = snap[qt]
+
+    # using paicos omp-vectorized routines
+    a = snap.get_sum_of_array((qt * snap["0_Volume"])[indices])
+    vol = snap.get_sum_of_array((snap["0_Volume"])[indices])
+
+    return a / vol
+
+
+def extract_turbulent_var(
+    snap,
+    sf,
+    variable,
+    filter_length,
+    weight,
+    filter_type="gaussian",
+    iterative=False,
+    selection=None,
+):
+
+    filt_var = sf.filter_variable(
+        variable,
+        filter_length,
+        weight=weight,
+        filter_type=filter_type,
+        iterative=iterative,
+        selection=selection,
+    )
+
+    print(
+        "min/max/avg occupancy cartesian tiling %d / %d / %.2f"
+        % (
+            sf.tile.particles_per_tile.min(),
+            sf.tile.particles_per_tile.max(),
+            cp.sum(sf.tile.particles_per_tile)
+            / cp.prod(sf.tile.particles_per_tile.shape),
+        )
+    )
+    if isinstance(variable, str):
+        variable = snap[variable]
+
+    smoothVar = np.zeros_like(variable)
+    turbVar = np.zeros_like(variable)
+
+    smoothVar[sf.index] = filt_var
+    turbVar[sf.index] = variable[sf.index] - filt_var
+    turbVar[~sf.indicesFirstPass * sf.index] = (
+        0  # this is for the thin buffer, which we set to zero
+    )
+
+    return smoothVar, turbVar

turbocluster-0.1/turbocluster.egg-info/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: turbocluster
+Version: 0.1
+Summary: A GPU-accelerated Python library for filtering turbulence in Arepo simulations
+Author-email: Lorenzo Maria Perrone <lorenzolmp@protonmail.com>, Thomas Berlok <tberlok@gmail.com>
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.14.0
+Description-Content-Type: text/markdown
+Requires-Dist: scipy>=1.7.3
+Requires-Dist: numpy<=2.4.6
+Requires-Dist: matplotlib
+Requires-Dist: h5py
+Requires-Dist: astropy>=4.3
+Requires-Dist: numba-cuda[cu13]
+Requires-Dist: paicos[dev]>=0.1.17
+Requires-Dist: cupy-cuda13x[ctk]
+Requires-Dist: nvtx
+
+[![Documentation Status](https://app.readthedocs.org/projects/turbocluster/badge/?version=latest)](https://turbocluster.readthedocs.io/en/latest/)
+[![flake8](https://github.com/LorenzoLMP/turbocluster/actions/workflows/flake8.yml/badge.svg)](
+https://github.com/LorenzoLMP/turbocluster/actions/workflows/flake8.yml)
+
+# turbocluster
+
+A GPU-accelerated Python library for filtering turbulence in Arepo simulations.
+
+<img src="images/turbocluster_banner.png" width="auto">
+
+**NOTE**: This project is in active development and not officially released publicly yet. Expect kinks and bugs. Refer to [this arXiv paper](https://arxiv.org/pdf/2601.06250) if you would like to know more about its use.
+
+A work-in-progress documentation can be found at [readthedocs](https://turbocluster.readthedocs.io/en/latest/).
+
+# TODO: 
+- double-check tests and examples
+- can cuda.jit() be replaced by jit() on non-cuda hardware?
+
+
+
+

turbocluster-0.1/turbocluster.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+requirements.txt
+tests/test_cuda.py
+turbocluster/__init__.py
+turbocluster/cartesian_tiling.py
+turbocluster/data_init.py
+turbocluster/helper_functions.py
+turbocluster.egg-info/PKG-INFO
+turbocluster.egg-info/SOURCES.txt
+turbocluster.egg-info/dependency_links.txt
+turbocluster.egg-info/requires.txt
+turbocluster.egg-info/top_level.txt

turbocluster-0.1/turbocluster.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

turbocluster-0.1/turbocluster.egg-info/requires.txt

@@ -0,0 +1,9 @@
+scipy>=1.7.3
+numpy<=2.4.6
+matplotlib
+h5py
+astropy>=4.3
+numba-cuda[cu13]
+paicos[dev]>=0.1.17
+cupy-cuda13x[ctk]
+nvtx

turbocluster-0.1/turbocluster.egg-info/top_level.txt

@@ -0,0 +1 @@
+turbocluster