capytaine 2.2__cp38-cp38-macosx_11_0_arm64.whl

capytaine/tools/cache_on_disk.py

@@ -0,0 +1,26 @@
+"""
+Adapted from https://github.com/platformdirs/platformdirs (MIT Licensed)
+"""
+import os
+import sys
+from pathlib import Path
+
+from capytaine import __version__
+
+
+def cache_directory():
+    if "CAPYTAINE_CACHE_DIR" in os.environ:
+        path = os.path.join(os.environ["CAPYTAINE_CACHE_DIR"], __version__)
+    elif sys.platform == "win32":  # Windows
+        path = os.path.normpath(os.environ.get("LOCALAPPDATA"))
+        path = os.path.join(path, "capytaine", "Cache", __version__)
+    elif sys.platform == "darwin":  # MacOS
+        path = os.path.expanduser("~/Library/Caches")
+        path = os.path.join(path, "capytaine", __version__)
+    else:
+        path = os.environ.get("XDG_CACHE_HOME", "")
+        if path.strip() == "":
+            path = os.path.expanduser("~/.cache")
+        path = os.path.join(path, "capytaine", __version__)
+    Path(path).mkdir(parents=True, exist_ok=True)
+    return path

capytaine/tools/deprecation_handling.py

@@ -0,0 +1,18 @@
+import logging
+
+import numpy as np
+
+LOG = logging.getLogger(__name__)
+
+def _get_water_depth(free_surface, water_depth, sea_bottom, default_water_depth=np.inf):
+    if water_depth is None and sea_bottom is None:
+        return default_water_depth
+    elif water_depth is not None and sea_bottom is None:
+        if water_depth <= 0.0:
+            raise ValueError(f"`water_depth` should be strictly positive. Received value: {water_depth}")
+        return float(water_depth)
+    elif water_depth is None and sea_bottom is not None:
+        LOG.warning("To uniformize notations througouth Capytaine, setting `water_depth` is preferred to `sea_bottom` since version 2.0.")
+        return float(free_surface - sea_bottom)
+    else:
+        raise ValueError("Cannot give both a `water_depth` and a `sea_bottom`.")

capytaine/tools/lists_of_points.py

@@ -0,0 +1,52 @@
+import numpy as np
+from capytaine.bodies import FloatingBody
+from capytaine.post_pro.free_surfaces import FreeSurface
+from capytaine.meshes import Mesh, CollectionOfMeshes
+
+
+def _normalize_points(points, keep_mesh=False):
+    if isinstance(points, (FloatingBody, FreeSurface)):
+        if keep_mesh:
+            return points.mesh, (points.mesh.nb_faces,)
+        else:
+            return points.mesh.faces_centers, (points.mesh.nb_faces,)
+
+    if isinstance(points, (Mesh, CollectionOfMeshes)):
+        if keep_mesh:
+            return points, (points.nb_faces,)
+        else:
+            return points.faces_centers, (points.nb_faces,)
+
+    points = np.asarray(points)
+
+    if points.ndim == 1:  # A single point has been provided
+        output_shape = (1,)
+        points = points.reshape((1, points.shape[0]))
+
+    elif points.ndim == 2:
+        output_shape = (points.shape[0],)
+
+    elif points.ndim > 2:
+        # `points` is expected to be the results of a meshgrid. Points has shape (d, nx, ny, ...)
+        output_shape = points.shape[1:]
+        points = points.reshape(points.shape[0], -1).transpose()
+        # points is now a (nx*ny*... , d) array
+
+    else:
+        raise ValueError(f"Expected a list of points or a mesh, but got instead: {points}")
+
+    return points, output_shape
+
+def _normalize_free_surface_points(points, keep_mesh=False):
+    if keep_mesh and isinstance(points, (FloatingBody, FreeSurface)):
+        return points.mesh, (points.mesh.nb_faces,)
+
+    if keep_mesh and isinstance(points, (Mesh, CollectionOfMeshes)):
+        return points, (points.nb_faces,)
+
+    points, output_shape = _normalize_points(points, keep_mesh)
+
+    if points.ndim == 2 and points.shape[1] == 2:  # Only x and y have been provided
+        points = np.concatenate([points, np.zeros((points.shape[0], 1))], axis=1)
+
+    return points, output_shape

capytaine/tools/lru_cache.py

@@ -0,0 +1,49 @@
+# Copyright (C) 2017-2024 Matthieu Ancellin
+# See LICENSE file at <https://github.com/capytaine/capytaine>
+"""Tools for memoization of functions."""
+from collections import OrderedDict
+from functools import wraps
+
+import logging
+
+LOG = logging.getLogger(__name__)
+
+
+def lru_cache_with_strict_maxsize(maxsize=1):
+    """Behaves mostly like functools.lru_cache(), but the oldest data in the cache is
+    deleted *before* computing a new one, in order to *never* have more that
+    `maxsize` items in memory.
+    This is useful to limit RAM usage when stored objects are big, like the interaction
+    matrices of Capytaine."""
+
+    def decorator(f):
+        cache = OrderedDict()
+
+        @wraps(f)
+        def decorated_f(*args, **kwargs):
+            hashable_kwargs = tuple((k, v) for (k, v) in kwargs.items())
+            # Might miss a cache hit if the order of kwargs is changed.
+            # But at least unlike a previous version, should not return a wrong value.
+
+            if (args, hashable_kwargs) in cache:
+                # Get item in cache
+                LOG.debug("Get cached version of %s(%s, %s)", f.__name__, args, hashable_kwargs)
+                return cache[(args, hashable_kwargs)]
+
+            if len(cache) + 1 > maxsize:
+                # Drop oldest item in cache.
+                cache.popitem(last=False)
+
+            # Compute and store
+            LOG.debug("Computing %s(%s, %s)", f.__name__, args, hashable_kwargs)
+            result = f(*args, **kwargs)
+            cache[(args, hashable_kwargs)] = result
+
+            return result
+
+        return decorated_f
+
+    return decorator
+
+
+delete_first_lru_cache = lru_cache_with_strict_maxsize  # For backward compatibility...

capytaine/tools/optional_imports.py

@@ -0,0 +1,27 @@
+"""Tool to import optional dependencies. Inspired by similar code in pandas."""
+
+import importlib
+
+def import_optional_dependency(module_name: str, package_name: str = None):
+    try:
+        module = importlib.import_module(module_name)
+    except ImportError:
+        if package_name is None:
+            package_name = module_name
+
+        message = (
+            f"Missing optional dependency '{module_name}'. "
+            f"Use pip or conda to install {package_name}."
+        )
+        raise ImportError(message) from None
+
+    return module
+
+def silently_import_optional_dependency(module_name: str):
+    # Same as above, except it does not raise a exception when the module is not found.
+    # Instead, simply returns None.
+    try:
+        module = importlib.import_module(module_name)
+    except ImportError:
+        module = None
+    return module

capytaine/tools/prony_decomposition.py

@@ -0,0 +1,94 @@
+"""Prony decomposition: tool to approximate a function as a sum of exponentials.
+Used in particular in the finite depth Green function.
+"""
+# Copyright (C) 2017-2019 Matthieu Ancellin
+# See LICENSE file at <https://github.com/mancellin/capytaine>
+
+import logging
+
+import numpy as np
+from numpy.polynomial import polynomial
+from scipy.optimize import curve_fit
+from scipy.linalg import toeplitz
+
+LOG = logging.getLogger(__name__)
+
+
+def exponential_decomposition(X, F, m):
+    """Use Prony's method to approximate the sampled real function F=f(X) as a sum of m
+    exponential functions x → Σ a_i exp(lamda_i x).
+
+    Parameters
+    ----------
+    X: 1D array
+        sampling points.
+    F: 1D array (same size as X)
+        values of the function to approximate at the points of x.
+    m: integer
+        number of exponential functions
+
+    Return
+    ------
+    a: 1D array (size m)
+        coefficients of the exponentials
+    lamda: 1D array (size m)
+        growth rate of the exponentials
+    """
+    assert X.shape == F.shape
+
+    # Compute the coefficients of the polynomials of Prony's method
+    A = toeplitz(c=F[m-1:-1], r=F[:m][::-1])
+    P, *_ = np.linalg.lstsq(A, F[m:], rcond=None)
+
+    # Build and solve polynomial function
+    coeffs = np.ones(m+1)
+    # coeffs[:m] = -P[::-1]
+    for i in range(m):
+        coeffs[m-i-1] = -P[i]
+    roots = polynomial.polyroots(coeffs)
+
+    # Discard values where log is undefined
+    roots = roots[np.logical_or(np.imag(roots) != 0.0, np.real(roots) >= 0.0)]
+
+    # Deduce lamda and keep only interesting values
+    lamda = np.real(np.log(roots)/(X[1] - X[0]))
+    lamda = np.unique(lamda)
+    lamda = lamda[np.logical_and(-20.0 < lamda, lamda < 0.0)]
+
+    # Fit the values of 'a' on the curve
+    def f(x, *ar):
+        ar = np.asarray(ar)[:, np.newaxis]
+        la = lamda[:, np.newaxis]
+        return np.sum(ar * np.exp(la * x), axis=0)
+    a, *_ = curve_fit(f, X, F, p0=np.zeros(lamda.shape))
+
+    return a, lamda
+
+
+def error_exponential_decomposition(X, F, a, lamda):
+    """Compare exponential decomposition defined by the coefficients a and lamda to the reference
+    values in F.
+
+    Parameters
+    ----------
+    X: 1D array
+        sampling points
+    F: 1D array (same size as X)
+        reference values
+    a: 1D array
+        coefficients of the exponentials
+    lamda: 1D array (same size as a)
+        growth rate of the exponentials
+
+    Returns
+    -------
+    error: float
+        mean square error of the decomposition
+    """
+    a = np.asarray(a)[:, np.newaxis]
+    lamda = np.asarray(lamda)[:, np.newaxis]
+
+    def f(x):
+        return np.sum(a * np.exp(lamda*x), axis=0)
+
+    return np.square(f(X) - F).mean()

capytaine/tools/symbolic_multiplication.py

@@ -0,0 +1,107 @@
+import numpy as np
+from functools import wraps, total_ordering
+
+@total_ordering
+class SymbolicMultiplication:
+    def __init__(self, symbol, value=1.0):
+        self.symbol = symbol
+        self.value = value
+
+    def __format__(self, format_spec):
+        return f"{self.symbol}×{self.value.__format__(format_spec)}"
+
+    __array_priority__ = 1.0
+
+    def __array_function__(self, func, types, *args, **kwargs):
+        if func in {np.real, np.imag, np.sum}:
+            return SymbolicMultiplication(self.symbol, func(self.value))
+        else:
+            return NotImplemented
+
+    def __str__(self):
+        return f"{self.symbol}×{self.value}"
+
+    def __repr__(self):
+        return f"SymbolicMultiplication(\"{self.symbol}\", {repr(self.value)})"
+
+    def __add__(self, x):
+        return self._concretize() + x
+
+    def __radd__(self, x):
+        return x + self._concretize()
+
+    def __mul__(self, x):
+        return SymbolicMultiplication(self.symbol, self.value * x)
+
+    def __rmul__(self, x):
+        return SymbolicMultiplication(self.symbol, x * self.value)
+
+    def __pow__(self, n):
+        if n == 2:
+            return self * self
+        else:
+            raise NotImplementedError
+
+    def __truediv__(self, x):
+        if hasattr(x, 'symbol') and self.symbol == x.symbol:
+            return self.value / x.value
+        else:
+            return SymbolicMultiplication(self.symbol, self.value / x)
+
+    def __rtruediv__(self, x):
+        if hasattr(x, 'symbol') and self.symbol == x.symbol:
+            return x.value / self.value
+        elif self.symbol == "0":
+            return SymbolicMultiplication("∞", x/self.value)
+        elif self.symbol == "∞":
+            return SymbolicMultiplication("0", x/self.value)
+        else:
+            raise NotImplementedError
+
+    def __matmul__(self, x):
+        return SymbolicMultiplication(self.symbol, self.value @ x)
+
+    def __rmatmul__(self, x):
+        return SymbolicMultiplication(self.symbol, x @ self.value)
+
+    def __getitem__(self, item):
+        return SymbolicMultiplication(self.symbol, self.value[item])
+
+    def __eq__(self, x):
+        return float(self) == x
+
+    def __lt__(self, x):
+        return float(self) < x
+
+    def __hash__(self):
+        return hash((self.symbol, self.value))
+
+    def _concretize(self):
+        if isinstance(self.value, np.ndarray):
+            if self.symbol == "0":
+                return np.zeros_like(self.value)
+            elif self.symbol == "∞":
+                return np.full_like(self.value, np.inf)
+        else:
+            return float(self)
+
+    def __float__(self):
+        if self.symbol == "0":
+            return 0.0
+        elif self.symbol == "∞":
+            return np.inf
+        else:
+            raise NotImplementedError
+
+    def reshape(self, *args):
+        return SymbolicMultiplication(self.symbol, self.value.reshape(*args))
+
+
+def supporting_symbolic_multiplication(f):
+    @wraps(f)
+    def wrapped_f(a, x):
+        if hasattr(x, 'symbol'):
+            return SymbolicMultiplication(x.symbol, f(a, x.value))
+        else:
+            return f(a, x)
+    return wrapped_f

capytaine/ui/cli.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python
+# coding: utf-8
+"""Experimental command-line interface for Capytaine."""
+# Copyright (C) 2017-2023 Matthieu Ancellin
+# See LICENSE file at <https://github.com/capytaine/capytaine>
+
+import argparse
+
+import capytaine as cpt
+from capytaine.io.legacy import run_cal_file
+
+cpt.set_logging()
+
+parser = argparse.ArgumentParser(description="Command-line interface for Capytaine taking Nemoh.cal files as input and returning Tecplots files.")
+parser.add_argument('paramfiles',
+                    default=['./Nemoh.cal'],
+                    nargs='*',
+                    help='path of parameters files (default: ./Nemoh.cal)')
+
+
+def main():
+    args = parser.parse_args()
+    for paramfile in args.paramfiles:
+        run_cal_file(paramfile)
+
+
+if __name__ == '__main__':
+    main()

capytaine/ui/rich.py

@@ -0,0 +1,5 @@
+import logging
+from rich.logging import RichHandler
+
+def set_logging(level="INFO"):
+    logging.basicConfig(level=level, format="%(message)s", handlers=[RichHandler(level=level, log_time_format="[%X]", show_path=False)], force=True)

capytaine/ui/vtk/__init__.py

@@ -0,0 +1,3 @@
+from capytaine.ui.vtk.mesh_viewer import MeshViewer
+from capytaine.ui.vtk.body_viewer import FloatingBodyViewer
+from capytaine.ui.vtk.animation import Animation