fiesta-pkg 1.0.2__py3-none-any.whl

docs/source/conf.py

@@ -0,0 +1,56 @@
+# Configuration file for the Sphinx documentation builder.
+import os
+import sys
+
+sys.path.insert(0, os.path.abspath("../.."))
+
+import vinfo
+
+# -- Project information
+
+project = "FIESTA"
+copyright = "2021-2026, Krishna Naidoo"
+author = "Krishna Naidoo"
+
+version = vinfo.vstr
+
+# -- General configuration
+
+extensions = [
+    "sphinx.ext.duration",
+    "sphinx.ext.doctest",
+    "sphinx.ext.autodoc",
+    "sphinx.ext.autosummary",
+    "sphinx.ext.intersphinx",
+    "sphinx.ext.napoleon",
+    "sphinx.ext.mathjax",
+    "sphinx_simplepdf",
+]
+
+source_suffix = [".rst", ".md"]
+
+# Napoleon settings
+napoleon_numpy_docstring = True
+
+intersphinx_mapping = {
+    "python": ("https://docs.python.org/3/", None),
+    "sphinx": ("https://www.sphinx-doc.org/en/master/", None),
+}
+intersphinx_disabled_domains = ["std"]
+
+templates_path = ["_templates"]
+
+
+# -- Options for HTML output
+
+# html_theme = 'sphinx_rtd_theme'
+html_theme = "furo"
+
+html_static_path = ["_static"]
+html_theme_options = {
+    "light_logo": "FiEsta_logo_small_white.jpg",
+    "dark_logo": "FiEsta_logo_small_black.jpg",
+}
+
+# -- Options for EPUB output
+epub_show_urls = "footnote"

fiesta/__init__.py

@@ -0,0 +1,12 @@
+from . import boundary
+from . import coords
+from . import dtfe
+from . import maths
+from . import p2g
+from . import interp
+from . import kdtree
+from . import randoms
+from . import sph
+from . import src
+from . import utils
+from . import gridsph

fiesta/boundary/__init__.py

@@ -0,0 +1,18 @@
+from .periodic import buffer_periodic
+from .periodic import subbox_buffer_periodic
+from .periodic import buffer_periodic_2D
+from .periodic import subbox_buffer_periodic_2D
+from .periodic import buffer_periodic_3D
+from .periodic import subbox_buffer_periodic_3D
+
+from .randoms import buffer_random_2D
+from .randoms import buffer_random_3D
+
+from .mpi_periodic import mpi_buffer_internal_2D
+from .mpi_periodic import mpi_buffer_internal_3D
+from .mpi_periodic import mpi_buffer_periodic_2D
+from .mpi_periodic import mpi_buffer_periodic_3D
+
+from .mpi_randoms import mpi_buffer_random_2D
+from .mpi_randoms import mpi_buffer_random_3D
+from .mpi_randoms import mpi_buffer_random_utils

fiesta/boundary/mpi_periodic.py

@@ -0,0 +1,216 @@
+import numpy as np
+
+from . import periodic
+
+from typing import Union, List
+
+
+def mpi_buffer_internal_2D(
+    data: np.ndarray,
+    boxsize: float,
+    buffer_length: float,
+    MPI: object,
+    origin: float = 0.0,
+) -> np.ndarray:
+    """
+    Internal buffer particles between partitions are moved up and down.
+
+    Parameters
+    ----------
+    data : array
+        Where columns 0 and 1 correspond to the x and y coordinates.
+    xboxsize : float
+        Boxsize along x-axis.
+    buffer_length : float
+        Length of the buffer region.
+    MPI : class object
+        MPIutils MPI class object.
+    origin : float, optional
+        Origin point.
+
+    Returns
+    -------
+    datap : array
+        Periodic data values.
+    """
+    if np.isscalar(origin):
+        xorigin = origin
+    else:
+        xorigin = origin[0]
+    if np.isscalar(boxsize):
+        xboxsize = boxsize
+    else:
+        xboxsize = boxsize[0]
+    cond = np.where(data[:, 0] <= xorigin + buffer_length)[0]
+    data_send_down = MPI.send_down(data[cond])
+    cond = np.where(data[:, 0] >= xorigin + xboxsize - buffer_length)[0]
+    data_send_up = MPI.send_up(data[cond])
+    if MPI.rank == 0:
+        # data_send_up[:,0] -= xboxsize
+        datap = np.vstack([data, data_send_down])
+    elif MPI.rank == MPI.size - 1:
+        # data_send_down[:,0] += xboxsize
+        datap = np.vstack([data, data_send_up])
+    else:
+        datap = np.vstack([data, data_send_down, data_send_up])
+    return datap
+
+
+def mpi_buffer_periodic_2D(
+    data: np.ndarray,
+    boxsize: Union[float, List[float]],
+    buffer_length: float,
+    MPI: object,
+    origin: Union[float, List[float]] = 0.0,
+    include_internal: bool = True,
+) -> np.ndarray:
+    """
+    Generates random buffer particles around a 2D box.
+
+    Parameters
+    ----------
+    data : array
+        Where columns 0 and 1 are x and y.
+    boxsize : float or list
+        Boxsize.
+    buffer_length : float
+        Length of the buffer region.
+    MPI : class object
+        MPIutils MPI class object.
+    origin : float or list, optional
+        Origin point.
+    include_internal : bool, optional
+        Whether to include internal buffer particles.
+
+    Returns
+    -------
+    datap : array
+        Periodic data values.
+    """
+    if np.isscalar(origin):
+        xorigin, yorigin = origin, origin
+    else:
+        xorigin, yorigin = origin[0], origin[1]
+    if np.isscalar(boxsize):
+        xboxsize, yboxsize = boxsize, boxsize
+    else:
+        xboxsize, yboxsize = boxsize[0], boxsize[1]
+    datap = periodic.buffer_periodic(data, 1, yboxsize, buffer_length, origin=yorigin)
+    cond = np.where(datap[:, 0] <= xorigin + buffer_length)[0]
+    data_send_down = MPI.send_down(datap[cond])
+    cond = np.where(datap[:, 0] >= xorigin + xboxsize - buffer_length)[0]
+    data_send_up = MPI.send_up(datap[cond])
+    if MPI.rank == 0:
+        data_send_up[:, 0] -= xboxsize
+    elif MPI.rank == MPI.size - 1:
+        data_send_down[:, 0] += xboxsize
+    datap = np.vstack([datap, data_send_down, data_send_up])
+    if include_internal:
+        datap = mpi_buffer_internal_2D(datap, boxsize, buffer_length, MPI, origin)
+    return datap
+
+
+def mpi_buffer_internal_3D(
+    data: np.ndarray,
+    boxsize: float,
+    buffer_length: float,
+    MPI: object,
+    origin: float = 0.0,
+) -> np.ndarray:
+    """
+    Internal buffer particles between partitions are moved up and down.
+
+    Parameters
+    ----------
+    data : array
+        Where columns 0, 1 and 2 correspond to the x, y and z coordinates.
+    xboxsize : float
+        Boxsize along x-axis.
+    buffer_length : float
+        Length of the buffer region.
+    MPI : class object
+        MPIutils MPI class object.
+    origin : float, optional
+        Origin point.
+
+    Returns
+    -------
+    datap : array
+        Periodic data values.
+    """
+    if np.isscalar(origin):
+        xorigin = origin
+    else:
+        xorigin = origin[0]
+    if np.isscalar(boxsize):
+        xboxsize = boxsize
+    else:
+        xboxsize = boxsize[0]
+    cond = np.where(data[:, 0] <= xorigin + buffer_length)[0]
+    data_send_down = MPI.send_down(data[cond])
+    cond = np.where(data[:, 0] >= xorigin + xboxsize - buffer_length)[0]
+    data_send_up = MPI.send_up(data[cond])
+    if MPI.rank == 0:
+        # data_send_up[:,0] -= xboxsize
+        datap = np.vstack([data, data_send_down])
+    elif MPI.rank == MPI.size - 1:
+        # data_send_down[:,0] += xboxsize
+        datap = np.vstack([data, data_send_up])
+    else:
+        datap = np.vstack([data, data_send_down, data_send_up])
+    return datap
+
+
+def mpi_buffer_periodic_3D(
+    data: np.ndarray,
+    boxsize: Union[float, List[float]],
+    buffer_length: float,
+    MPI: object,
+    origin: Union[float, List[float]] = 0.0,
+    include_internal: bool = True,
+) -> np.ndarray:
+    """
+    Generates random buffer particles around a 3D box.
+
+    Parameters
+    ----------
+    data : array
+        Where columns 0, 1 and 2 correspond to the x, y and z coordinates.
+    xboxsize : float or list
+        Boxsize along x-axis.
+    buffer_length : float
+        Length of the buffer region.
+    MPI : class object
+        MPIutils MPI class object.
+    origin : float or list, optional
+        Origin point.
+    include_internal : bool, optional
+        Whether to include internal buffer particles.
+
+    Returns
+    -------
+    datap : array
+        Periodic data values.
+    """
+    if np.isscalar(origin):
+        xorigin, yorigin, zorigin = origin, origin, origin
+    else:
+        xorigin, yorigin, zorigin = origin[0], origin[1], origin[2]
+    if np.isscalar(boxsize):
+        xboxsize, yboxsize, zboxsize = boxsize, boxsize, boxsize
+    else:
+        xboxsize, yboxsize, zboxsize = boxsize[0], boxsize[1], boxsize[2]
+    datap = periodic.buffer_periodic(data, 1, yboxsize, buffer_length, origin=yorigin)
+    datap = periodic.buffer_periodic(datap, 2, zboxsize, buffer_length, origin=zorigin)
+    cond = np.where(datap[:, 0] <= xorigin + buffer_length)[0]
+    data_send_down = MPI.send_down(datap[cond])
+    cond = np.where(datap[:, 0] >= xorigin + xboxsize - buffer_length)[0]
+    data_send_up = MPI.send_up(datap[cond])
+    if MPI.rank == 0:
+        data_send_up[:, 0] -= xboxsize
+    elif MPI.rank == MPI.size - 1:
+        data_send_down[:, 0] += xboxsize
+    datap = np.vstack([datap, data_send_down, data_send_up])
+    if include_internal:
+        datap = mpi_buffer_internal_3D(datap, boxsize, buffer_length, MPI, origin)
+    return datap

fiesta/boundary/mpi_randoms.py

@@ -0,0 +1,215 @@
+import numpy as np
+
+from .. import randoms
+
+
+from typing import List, Tuple, Union
+
+
+def mpi_buffer_random_2D(
+    npart: int,
+    boxsize: Union[float, List[float]],
+    limits: List[float],
+    buffer_length: float,
+    MPI: object,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Generates random buffer particles around a 2D box.
+
+    Parameters
+    ----------
+    npart : int
+        Number of particles in the 2D box.
+    boxsize : float or list
+        Box size.
+    limits : list
+        Ranges for each coordinate axis [xmin, xmax, ymin, ymax].
+    buffer_length : float
+        Length of the buffer region.
+    MPI : class object
+        MPIutils MPI class object.
+
+    Returns
+    -------
+    x : array
+        Random x-values.
+    y : array
+        Random y-values.
+    """
+    if np.isscalar(boxsize):
+        xboxsize, yboxsize = boxsize, boxsize
+    else:
+        xboxsize, yboxsize = boxsize[0], boxsize[1]
+    # Determine number of particles needed in the padded region to maintain
+    # the average density.
+    part_dens = npart / (xboxsize * yboxsize)
+    # box edge 1
+    _xmin = limits[0] - buffer_length
+    _xmax = limits[1] + buffer_length
+    _ymin = limits[2] - buffer_length
+    _ymax = limits[2]
+    size1 = int(part_dens * (_xmax - _xmin) * (_ymax - _ymin))
+    x1, y1 = randoms.random_box(size1, _xmin, _xmax, _ymin, _ymax)
+    # box edge 2
+    _xmin = limits[0] - buffer_length
+    _xmax = limits[1] + buffer_length
+    _ymin = limits[3]
+    _ymax = limits[3] + buffer_length
+    size2 = int(part_dens * (_xmax - _xmin) * (_ymax - _ymin))
+    x2, y2 = randoms.random_box(size2, _xmin, _xmax, _ymin, _ymax)
+    x = np.concatenate([x1, x2])
+    y = np.concatenate([y1, y2])
+    if MPI.rank == 0:
+        _xmin = limits[0] - buffer_length
+        _xmax = limits[0]
+        _ymin = limits[2]
+        _ymax = limits[3]
+        size = int(part_dens * (_xmax - _xmin) * (_ymax - _ymin))
+        _x, _y = randoms.random_box(size, _xmin, _xmax, _ymin, _ymax)
+        x = np.concatenate([x, _x])
+        y = np.concatenate([y, _y])
+    if MPI.rank == MPI.size - 1:
+        _xmin = limits[1]
+        _xmax = limits[1] + buffer_length
+        _ymin = limits[2]
+        _ymax = limits[3]
+        size = int(part_dens * (_xmax - _xmin) * (_ymax - _ymin))
+        _x, _y = randoms.random_box(size, _xmin, _xmax, _ymin, _ymax)
+        x = np.concatenate([x, _x])
+        y = np.concatenate([y, _y])
+    return x, y
+
+
+def mpi_buffer_random_3D(
+    npart: int,
+    boxsize: Union[float, List[float]],
+    limits: List[float],
+    buffer_length: float,
+    MPI: object,
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Generates random buffer particles around a 3D box.
+
+    Parameters
+    ----------
+    npart : int
+        Number of particles in the 3D box.
+    boxsize : float or list
+        Box size.
+    limits : list
+        Ranges for each coordinate axis [xmin, xmax, ymin, ymax, zmin, zmax].
+    buffer_length : float
+        Length of the buffer region.
+    MPI : class object
+        MPIutils MPI class object.
+
+    Returns
+    -------
+    x : array
+        Random x-values.
+    y : array
+        Random y-values.
+    z : array
+        Random z-values.
+    """
+    if np.isscalar(boxsize):
+        xboxsize, yboxsize, zboxsize = boxsize, boxsize, boxsize
+    else:
+        xboxsize, yboxsize, zboxsize = boxsize[0], boxsize[1], boxsize[2]
+    box_vol = xboxsize * yboxsize * zboxsize
+    part_dens = npart / box_vol
+    # Divide into three regions along z-axis
+    # Region 1: zrange = [-buffer_length, 0.]
+    # Region 2: zrange = [0., boxsize]
+    # Region 3: zrange = [boxsize, boxsize+buffer_length]
+    # Splitting region 2, into four regions.
+    # Subregion 21: xrange = [-buffer_length, boxsize], yrange = [-buffer_length, 0]
+    # Subregion 22: xrange = [boxsize, boxsize+buffer_length], yrange =[-buffer_length, boxsize]
+    # Subregion 23: xrange = [0, boxsize+buffer_length], yrange=[boxsize, boxsize+buffer_length]
+    # Subregion 24: xrange = [-buffer_length, 0], yrange = [0, boxsize+buffer_length]
+    # Region 1
+    xmin, xmax = limits[0] - buffer_length, limits[1] + buffer_length
+    ymin, ymax = limits[2] - buffer_length, limits[3] + buffer_length
+    zmin, zmax = limits[4] - buffer_length, limits[4]
+    npart1 = int(part_dens * (xmax - xmin) * (ymax - ymin) * (zmax - zmin))
+    x1, y1, z1 = randoms.random_cube(npart1, xmin, xmax, ymin, ymax, zmin, zmax)
+    # Region 3
+    xmin, xmax = limits[0] - buffer_length, limits[1] + buffer_length
+    ymin, ymax = limits[2] - buffer_length, limits[3] + buffer_length
+    zmin, zmax = limits[5], limits[5] + buffer_length
+    npart3 = int(part_dens * (xmax - xmin) * (ymax - ymin) * (zmax - zmin))
+    x3, y3, z3 = randoms.random_cube(npart3, xmin, xmax, ymin, ymax, zmin, zmax)
+    # x = np.concatenate([x1, x3])
+    # y = np.concatenate([y1, y3])
+    # z = np.concatenate([z1, z3])
+    # Subregion 21
+    xmin, xmax = limits[0] - buffer_length, limits[1] + buffer_length
+    ymin, ymax = limits[2] - buffer_length, limits[2]
+    zmin, zmax = limits[4], limits[5]
+    npart21 = int(part_dens * (xmax - xmin) * (ymax - ymin) * (zmax - zmin))
+    x21, y21, z21 = randoms.random_cube(npart21, xmin, xmax, ymin, ymax, zmin, zmax)
+    # Subregion 22
+    xmin, xmax = limits[0] - buffer_length, limits[1] + buffer_length
+    ymin, ymax = limits[3], limits[3] + buffer_length
+    zmin, zmax = limits[4], limits[5]
+    npart22 = int(part_dens * (xmax - xmin) * (ymax - ymin) * (zmax - zmin))
+    x22, y22, z22 = randoms.random_cube(npart22, xmin, xmax, ymin, ymax, zmin, zmax)
+    x = np.concatenate([x1, x21, x22, x3])
+    y = np.concatenate([y1, y21, y22, y3])
+    z = np.concatenate([z1, z21, z22, z3])
+    if MPI.rank == 0:
+        # Subregion 23
+        xmin, xmax = limits[0] - buffer_length, limits[0]
+        ymin, ymax = limits[2], limits[3]
+        zmin, zmax = limits[4], limits[5]
+        npart23 = int(part_dens * (xmax - xmin) * (ymax - ymin) * (zmax - zmin))
+        x23, y23, z23 = randoms.random_cube(npart23, xmin, xmax, ymin, ymax, zmin, zmax)
+        x = np.concatenate([x, x23])
+        y = np.concatenate([y, y23])
+        z = np.concatenate([z, z23])
+    elif MPI.rank == MPI.size - 1:
+        # Subregion 24
+        xmin, xmax = limits[1], limits[1] + buffer_length
+        ymin, ymax = limits[2], limits[3]
+        zmin, zmax = limits[4], limits[5]
+        npart24 = int(part_dens * (xmax - xmin) * (ymax - ymin) * (zmax - zmin))
+        x24, y24, z24 = randoms.random_cube(npart24, xmin, xmax, ymin, ymax, zmin, zmax)
+        x = np.concatenate([x, x24])
+        y = np.concatenate([y, y24])
+        z = np.concatenate([z, z24])
+    return x, y, z
+
+
+def mpi_buffer_random_utils(
+    data: np.ndarray, limits: List[float], buffer_length: float, MPI: object
+) -> np.ndarray:
+    """
+    Generates random buffer particles around a 2D box.
+
+    Parameters
+    ----------
+    data : array
+        Where columns 0 and 1 are x and y.
+    limits : list
+        Ranges for each coordinate axis [xmin, xmax, ymin, ymax].
+    buffer_length : float
+        Length of the buffer region.
+    MPI : class object
+        MPIutils MPI class object.
+
+    Returns
+    -------
+    datap : array
+        Periodic data values.
+    """
+    cond = np.where(data[:, 0] <= limits[0] + buffer_length)[0]
+    data_send_down = MPI.send_down(data[cond])
+    cond = np.where(data[:, 0] >= limits[1] - buffer_length)[0]
+    data_send_up = MPI.send_up(data[cond])
+    if MPI.rank == 0:
+        datap = np.vstack([data, data_send_down])
+    elif MPI.rank == MPI.size - 1:
+        datap = np.vstack([data, data_send_up])
+    else:
+        datap = np.vstack([data, data_send_down, data_send_up])
+    return datap