capytaine 2.2.1__cp39-cp39-win_amd64.whl → 2.3.1__cp39-cp39-win_amd64.whl

capytaine/meshes/meshes.py

@@ -644,9 +644,18 @@ class Mesh(ClippableMixin, SurfaceIntegralsMixin, Abstract3DObject):
     #  Combine meshes  #
     ####################
 
-    def join_meshes(*meshes, name=None):
+    def join_meshes(*meshes, name=None, return_masks=False):
         from capytaine.meshes.collections import CollectionOfMeshes
-        return CollectionOfMeshes(meshes, name=name).merged()
+        coll = CollectionOfMeshes(meshes, name=name)
+        if return_masks:
+            masks = []
+            for i_mesh in range(len(meshes)):
+                mask = np.full((coll.nb_faces,), False)
+                mask[coll.indices_of_mesh(i_mesh)] = True
+                masks.append(mask)
+            return coll.merged(), masks
+        else:
+            return coll.merged()
 
     def __add__(self, mesh_to_add) -> 'Mesh':
         return self.join_meshes(mesh_to_add)
@@ -761,17 +770,19 @@ class Mesh(ClippableMixin, SurfaceIntegralsMixin, Abstract3DObject):
                 z_lid = min(z_lid, z_lid_comp)
         return 0.9*z_lid  # Add a small safety margin
 
-    def generate_lid(self, z=0.0, faces_max_radius=None):
+    def generate_lid(self, z=0.0, faces_max_radius=None, name=None):
         """
         Return a mesh of the internal free surface of the body.
 
         Parameters
         ----------
-        z: float
+        z: float, optional
             Vertical position of the lid. Default: 0.0
-        faces_max_radius: float
+        faces_max_radius: float, optional
             resolution of the mesh of the lid.
             Default: mean of hull mesh resolution.
+        name: str, optional
+            A name for the new mesh
 
         Returns
         -------
@@ -795,8 +806,14 @@ class Mesh(ClippableMixin, SurfaceIntegralsMixin, Abstract3DObject):
         if faces_max_radius is None:
             faces_max_radius = np.mean(clipped_hull_mesh.faces_radiuses)
 
+        candidate_lid_size = (
+                    max(faces_max_radius/2, 1.1*x_span),
+                    max(faces_max_radius/2, 1.1*y_span),
+                )
+        # The size of the lid is at least the characteristic length of a face
+
         candidate_lid_mesh = mesh_rectangle(
-                size=(1.1*y_span, 1.1*x_span),  # TODO Fix mesh_rectangle
+                size=(candidate_lid_size[1], candidate_lid_size[0]),  # TODO Fix: Exchange x and y in mesh_rectangle
                 faces_max_radius=faces_max_radius,
                 center=(x_mean, y_mean, z),
                 normal=(0.0, 0.0, -1.0),
@@ -825,10 +842,13 @@ class Mesh(ClippableMixin, SurfaceIntegralsMixin, Abstract3DObject):
 
         lid_faces = candidate_lid_mesh.faces[np.all(np.isin(candidate_lid_mesh.faces, needs_lid), axis=-1), :]
 
+        if name is None:
+            name = "lid for {}".format(self.name)
+
         if len(lid_faces) == 0:
-            return Mesh(None, None, name="lid for {}".format(self.name))
+            return Mesh(None, None, name=name)
 
-        lid_mesh = Mesh(candidate_lid_mesh.vertices, lid_faces, name="lid for {}".format(self.name))
+        lid_mesh = Mesh(candidate_lid_mesh.vertices, lid_faces, name=name)
         lid_mesh.heal_mesh()
 
         return lid_mesh

capytaine/meshes/symmetric.py

@@ -10,7 +10,7 @@ import numpy as np
 
 from capytaine.meshes.meshes import Mesh
 from capytaine.meshes.collections import CollectionOfMeshes
-from capytaine.meshes.geometry import Axis, Plane, Oz_axis, inplace_transformation
+from capytaine.meshes.geometry import Axis, Plane, xOy_Plane, Oz_axis, inplace_transformation
 
 LOG = logging.getLogger(__name__)
 
@@ -84,13 +84,27 @@ class ReflectionSymmetricMesh(SymmetricMesh):
     def __deepcopy__(self, *args):
         return ReflectionSymmetricMesh(self.half.copy(), self.plane, name=self.name)
 
-    def join_meshes(*meshes, name=None):
+    def join_meshes(*meshes, name=None, return_masks=False):
         assert all(isinstance(mesh, ReflectionSymmetricMesh) for mesh in meshes), \
             "Only meshes with the same symmetry can be joined together."
         assert all(meshes[0].plane == mesh.plane for mesh in meshes), \
             "Only reflection symmetric meshes with the same reflection plane can be joined together."
-        half_mesh = CollectionOfMeshes([mesh.half for mesh in meshes], name=f"half_of_{name}" if name is not None else None)
-        return ReflectionSymmetricMesh(half_mesh, plane=meshes[0].plane, name=name)
+        if not return_masks:
+            name = name=f"half_of_{name}" if name is not None else None
+            half_mesh = meshes[0].half.join_meshes(
+                *(mesh.half for mesh in meshes[1:]),
+                name=name, return_masks=False
+            )
+            return ReflectionSymmetricMesh(half_mesh, plane=meshes[0].plane, name=name)
+        else:
+            name = name=f"half_of_{name}" if name is not None else None
+            half_mesh, half_masks = meshes[0].half.join_meshes(
+                *(mesh.half for mesh in meshes[1:]),
+                name=name, return_masks=True
+            )
+            masks = [np.concatenate([half_mask, half_mask]) for half_mask in half_masks]
+            joined = ReflectionSymmetricMesh(half_mesh, plane=meshes[0].plane, name=name)
+            return joined, masks
 
     @inplace_transformation
     def translate(self, vector):
@@ -110,6 +124,15 @@ class ReflectionSymmetricMesh(SymmetricMesh):
         CollectionOfMeshes.mirror(self, plane)
         return self
 
+    def generate_lid(self, z=0.0, faces_max_radius=None, name=None):
+        if name is None:
+            name = "lid for {}".format(self.name)
+        return ReflectionSymmetricMesh(self.half.generate_lid(z, faces_max_radius), self.plane, name=name)
+
+    def extract_lid(self, plane=xOy_Plane):
+        hull, lid = self.half.extract_lid(plane)
+        return ReflectionSymmetricMesh(hull, self.plane), ReflectionSymmetricMesh(lid, self.plane)
+
 
 class TranslationalSymmetricMesh(SymmetricMesh):
     """A mesh with a repeating pattern by translation.
@@ -194,15 +217,43 @@ class TranslationalSymmetricMesh(SymmetricMesh):
         CollectionOfMeshes.mirror(self, plane)
         return self
 
-    def join_meshes(*meshes, name=None):
+    def join_meshes(*meshes, name=None, return_masks=False):
         assert all(isinstance(mesh, TranslationalSymmetricMesh) for mesh in meshes), \
             "Only meshes with the same symmetry can be joined together."
         assert all(np.allclose(meshes[0].translation, mesh.translation) for mesh in meshes), \
             "Only translation symmetric meshes with the same translation vector can be joined together."
         assert all(len(meshes[0]) == len(mesh) for mesh in meshes), \
             "Only symmetric meshes with the same number of elements can be joined together."
-        mesh_strip = CollectionOfMeshes([mesh.first_slice for mesh in meshes], name=f"strip_of_{name}" if name is not None else None)
-        return TranslationalSymmetricMesh(mesh_strip, translation=meshes[0].translation, nb_repetitions=len(meshes[0]) - 1, name=name)
+        if not return_masks:
+            strip_name = f"strip_of_{name}" if name is not None else None
+            mesh_strip = meshes[0].first_slice.join_meshes(
+                *(mesh.first_slice for mesh in meshes[1:]),
+                name=strip_name,
+                return_masks=False
+            )
+            return TranslationalSymmetricMesh(
+                mesh_strip,
+                translation=meshes[0].translation,
+                nb_repetitions=len(meshes[0]) - 1,
+                name=name
+            )
+        else:
+            strip_name = f"strip_of_{name}" if name is not None else None
+            mesh_strip, strip_masks = meshes[0].first_slice.join_meshes(
+                *(mesh.first_slice for mesh in meshes[1:]),
+                name=strip_name,
+                return_masks=True
+            )
+            joined = TranslationalSymmetricMesh(
+                mesh_strip,
+                translation=meshes[0].translation,
+                nb_repetitions=len(meshes[0]) - 1,
+                name=name
+            )
+            masks = [np.concatenate([
+                strip_mask for _ in range(len(meshes[0]))
+            ]) for strip_mask in strip_masks]
+            return joined, masks
 
 
 def build_regular_array_of_meshes(base_mesh, distance, nb_bodies):
@@ -354,15 +405,43 @@ class AxialSymmetricMesh(SymmetricMesh):
     def __deepcopy__(self, *args):
         return AxialSymmetricMesh(self.first_slice.copy(), axis=self.axis.copy(), nb_repetitions=len(self) - 1, name=self.name)
 
-    def join_meshes(*meshes, name=None):
+    def join_meshes(*meshes, name=None, return_masks=False):
         assert all(isinstance(mesh, AxialSymmetricMesh) for mesh in meshes), \
             "Only meshes with the same symmetry can be joined together."
         assert all(meshes[0].axis == mesh.axis for mesh in meshes), \
             "Only axisymmetric meshes with the same symmetry axis can be joined together."
         assert all(len(meshes[0]) == len(mesh) for mesh in meshes), \
             "Only axisymmetric meshes with the same number of elements can be joined together."
-        mesh_slice = CollectionOfMeshes([mesh.first_slice for mesh in meshes], name=f"slice_of_{name}" if name is not None else None)
-        return AxialSymmetricMesh(mesh_slice, axis=meshes[0].axis, nb_repetitions=len(meshes[0]) - 1, name=name)
+        if not return_masks:
+            slice_name = f"slice_of_{name}" if name is not None else None
+            mesh_slice = meshes[0].first_slice.join_meshes(
+                *(mesh.first_slice for mesh in meshes[1:]),
+                name=slice_name,
+                return_masks=False
+            )
+            return AxialSymmetricMesh(
+                mesh_slice,
+                axis=meshes[0].axis,
+                nb_repetitions=len(meshes[0]) - 1,
+                name=name
+            )
+        else:
+            slice_name = f"slice_of_{name}" if name is not None else None
+            mesh_slice, slice_masks = meshes[0].first_slice.join_meshes(
+                *(mesh.first_slice for mesh in meshes[1:]),
+                name=slice_name,
+                return_masks=True
+            )
+            joined = AxialSymmetricMesh(
+                mesh_slice,
+                axis=meshes[0].axis,
+                nb_repetitions=len(meshes[0]) - 1,
+                name=name
+            )
+            masks = [np.concatenate([
+                slice_mask for _ in range(len(meshes[0]))
+            ]) for slice_mask in slice_masks]
+            return joined, masks
 
     @inplace_transformation
     def translate(self, vector):

capytaine/post_pro/kochin.py

@@ -1,6 +1,6 @@
 """Computation of the Kochin function."""
 # Copyright (C) 2017-2019 Matthieu Ancellin
-# See LICENSE file at <https://github.com/mancellin/capytaine>
+# See LICENSE file at <https://github.com/capytaine/capytaine>
 
 import logging
 import numpy as np
@@ -29,9 +29,9 @@ def compute_kochin(result, theta, ref_point=(0.0, 0.0)):
         LOG.warning("Kochin functions with forward speed have never been validated.")
 
     if result.sources is None:
-        raise Exception(f"""The values of the sources of {result} cannot been found.
-        They probably have not been stored by the solver because the option keep_details=True have not been set.
-        Please re-run the resolution with this option.""")
+        raise ValueError(f"""The values of the sources of {result} cannot been found.
+        They have not been stored by the solver either because the direct method has been used or the option keep_details=True have not been set.
+        Please re-run the resolution with `method='indirect'` and `keep_details=True`.""")
 
     k = result.wavenumber
     h = result.water_depth

capytaine/tools/lists_of_points.py

@@ -1,7 +1,7 @@
 import numpy as np
 from capytaine.bodies import FloatingBody
 from capytaine.post_pro.free_surfaces import FreeSurface
-from capytaine.meshes import Mesh, CollectionOfMeshes
+from capytaine.meshes.mesh_like_protocol import MeshLike
 
 
 def _normalize_points(points, keep_mesh=False):
@@ -11,7 +11,7 @@ def _normalize_points(points, keep_mesh=False):
         else:
             return points.mesh.faces_centers, (points.mesh.nb_faces,)
 
-    if isinstance(points, (Mesh, CollectionOfMeshes)):
+    if isinstance(points, MeshLike):
         if keep_mesh:
             return points, (points.nb_faces,)
         else:
@@ -41,7 +41,7 @@ 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)):
+    if keep_mesh and isinstance(points, MeshLike):
         return points, (points.nb_faces,)
 
     points, output_shape = _normalize_points(points, keep_mesh)

capytaine/tools/prony_decomposition.py

@@ -1,8 +1,8 @@
 """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>
+# Copyright (C) 2017-2024 Matthieu Ancellin
+# See LICENSE file at <https://github.com/capytaine/capytaine>
 
 import logging
 
@@ -12,6 +12,7 @@ from scipy.optimize import curve_fit
 from scipy.linalg import toeplitz
 
 LOG = logging.getLogger(__name__)
+RNG = np.random.default_rng()
 
 
 def exponential_decomposition(X, F, m):
@@ -66,8 +67,8 @@ def exponential_decomposition(X, F, m):
 
 
 def error_exponential_decomposition(X, F, a, lamda):
-    """Compare exponential decomposition defined by the coefficients a and lamda to the reference
-    values in F.
+    """Mean square error of the exponential decomposition defined by the
+    coefficients a and lamda with respect to the reference values in F.
 
     Parameters
     ----------
@@ -92,3 +93,58 @@ def error_exponential_decomposition(X, F, a, lamda):
         return np.sum(a * np.exp(lamda*x), axis=0)
 
     return np.square(f(X) - F).mean()
+
+
+class PronyDecompositionFailure(Exception):
+    pass
+
+
+def find_best_exponential_decomposition(f, x_min, x_max, n_exp_range, *, tol=1e-4, noise_on_domain_points_std=0.01):
+    """Tries to construct an exponential decompositoin of the function f on the
+    domain [x_min, x_max] by testing the number of exponentials in n_exp_range.
+
+    Parameters
+    ----------
+    f: callable
+        The function ℝ→ℝ to be approximated.
+        Should support vectorized calls (that is passing a vector of inputs
+        and get the vector of corresponding outputs)
+    x_min, x_max: floats
+        The bounds of the domain of input in which f should be approximated
+    n_exp_range: iterable of ints
+        The decomposition sizes that will be tested
+    tol: float, optional
+        The target mean square error.
+    noise_on_domain_points_std: float, optional
+        Introduces some random variability on the points where the function is evaluated.
+        Set this parameter to zero to disable randomness.
+
+    """
+    # Try different range of evaluation points to construct the decomposition.
+    for n_exp in n_exp_range:
+
+        # f might be ill-defined at some single specific values
+        # (for the use-case of delhommeau.py, it is when x = kh exactly).
+        # Thus we slightly randomize the range of evaluation points for the Prony decomposition.
+        # This way, if one of the evaluation points hits the singular point, it will most likely not hit it again at the next iteration.
+        x_max_iter = (1 + noise_on_domain_points_std*RNG.uniform())*x_max
+
+        try:
+            # The coefficients are computed on a resolution of 4*n_exp+1 ...
+            X = np.linspace(x_min, x_max_iter, 4*n_exp+1)
+            a, lamda = exponential_decomposition(X, f(X), n_exp)
+
+            # ... and they are evaluated on a finer discretization.
+            X = np.linspace(x_min, x_max_iter, 8*n_exp+1)
+            if error_exponential_decomposition(X, f(X), a, lamda) < tol:
+                return a, lamda
+        except Exception:
+            # If something bad happened while computing the decomposition, try
+            # the next one.
+            continue
+
+    raise PronyDecompositionFailure(
+            "No suitable Prony decomposition has been found in "
+            f"[{x_min}, {x_max}] for tol={tol} "
+            f"using a number of terms in {n_exp_range}."
+            )

capytaine/tools/symbolic_multiplication.py

@@ -11,11 +11,12 @@ output of the form `SymbolicMultiplication("0", np.array(...))`
 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
+        if hasattr(value, "shape"):
+            self.shape = value.shape  # When wrapping Numpy arrays
 
     def __format__(self, format_spec):
         return f"{self.symbol}×{self.value.__format__(format_spec)}"
@@ -40,6 +41,9 @@ class SymbolicMultiplication:
     def __radd__(self, x):
         return x + self._concretize()
 
+    def __neg__(self):
+        return SymbolicMultiplication(self.symbol, -self.value)
+
     def __mul__(self, x):
         return SymbolicMultiplication(self.symbol, self.value * x)
 
@@ -77,11 +81,26 @@ class SymbolicMultiplication:
     def __getitem__(self, item):
         return SymbolicMultiplication(self.symbol, self.value[item])
 
-    def __eq__(self, x):
-        return float(self) == x
+    def __setitem__(self, item, val):
+        if isinstance(val, SymbolicMultiplication) and self.symbol == val.symbol:
+            self.value.__setitem__(item, val.value)
+        else:
+            raise NotImplementedError
 
     def __lt__(self, x):
-        return float(self) < x
+        return self._concretize() < x
+
+    def __le__(self, x):
+        return self._concretize() <= x
+
+    def __eq__(self, x):
+        return self._concretize() == x
+
+    def __ge__(self, x):
+        return self._concretize() >= x
+
+    def __gt__(self, x):
+        return self._concretize() > x
 
     def __hash__(self):
         return hash((self.symbol, self.value))
@@ -106,6 +125,13 @@ class SymbolicMultiplication:
     def reshape(self, *args):
         return SymbolicMultiplication(self.symbol, self.value.reshape(*args))
 
+    def sum(self, *args, **kwargs):
+        return SymbolicMultiplication(self.symbol, self.value.sum(*args, **kwargs))
+
+    @property
+    def T(self):
+        return SymbolicMultiplication(self.symbol, self.value.T)
+
 
 def supporting_symbolic_multiplication(f):
     """

capytaine/tools/timer.py

@@ -0,0 +1,66 @@
+"""A simple timer class used to measure the time spent in various parts of the BEM solver."""
+
+from functools import wraps
+import time
+
+class Timer:
+    """A simple timer class that can be used as context manager or as decorator using `wraps_function` method
+
+    Example
+    -------
+    ::
+
+        timer = Timer()
+        with timer:
+            sleep(1.0)
+
+        print(timer.total)  # 1.0...
+
+        @timer.wraps_function
+        def my_function():
+            sleep(0.5)
+
+        my_function()
+        print(timer.total)  # 1.5...
+        my_function()
+        print(timer.total)  # 2.0...
+
+        print(timer.timings)  # [1.0, 0.5, 0.5]
+    """
+
+    def __init__(self, timings=None):
+        if timings is None:
+            self.timings = []
+        else:
+            self.timings = timings
+
+    def __repr__(self):
+        return f"Timer({self.timings})"
+
+    @property
+    def nb_timings(self):
+        return len(self.timings)
+
+    @property
+    def total(self):
+        return sum(self.timings)
+
+    @property
+    def mean(self):
+        if self.nb_timings == 0:
+            return float('nan')
+        else:
+            return self.total/self.nb_timings
+
+    def __enter__(self):
+        self.start_time = time.perf_counter()
+
+    def __exit__(self, *exc):
+        self.timings.append(time.perf_counter() - self.start_time)
+
+    def wraps_function(self, f):
+        @wraps(f)
+        def wrapped_f(*args, **kwargs):
+            with self:
+                return f(*args, **kwargs)
+        return wrapped_f

capytaine-2.3.1.dist-info/DELVEWHEEL

@@ -0,0 +1,2 @@
+Version: 1.11.2
+Arguments: ['C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-f4_ko6cf\\cp39-win_amd64\\build\\venv\\Scripts\\delvewheel', 'repair', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-f4_ko6cf\\cp39-win_amd64\\repaired_wheel', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-f4_ko6cf\\cp39-win_amd64\\built_wheel\\capytaine-2.3.1-cp39-cp39-win_amd64.whl', '--no-mangle-all']

{capytaine-2.2.1.dist-info → capytaine-2.3.1.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: capytaine
-Version: 2.2.1
+Version: 2.3.1
 Summary: Python BEM solver for linear potential flow, based on Nemoh
-Author-Email: Matthieu Ancellin <matthieu.ancellin@eurobios.com>
+Author-Email: Matthieu Ancellin <matthieu.ancellin@mews-labs.com>
 License:                     GNU GENERAL PUBLIC LICENSE
                                 Version 3, 29 June 2007
          
@@ -683,25 +683,21 @@ Classifier: Programming Language :: Fortran
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Topic :: Scientific/Engineering
+Project-URL: homepage, https://capytaine.org
 Project-URL: repository, https://github.com/capytaine/capytaine
 Requires-Python: >=3.8
 Requires-Dist: numpy>=1.20; python_version >= "3.9"
 Requires-Dist: numpy>=1.24; python_version == "3.8"
 Requires-Dist: scipy
-Requires-Dist: pandas>=1.3
+Requires-Dist: pandas<3,>=1.3
 Requires-Dist: xarray
 Requires-Dist: rich
 Provides-Extra: optional
 Requires-Dist: matplotlib; extra == "optional"
 Requires-Dist: joblib>=1.3; extra == "optional"
 Requires-Dist: meshio; extra == "optional"
-Provides-Extra: test
-Requires-Dist: pytest; extra == "test"
-Provides-Extra: docs
-Requires-Dist: sphinx; extra == "docs"
-Requires-Dist: sphinx-toolbox; extra == "docs"
-Requires-Dist: sphinxcontrib-proof; extra == "docs"
-Requires-Dist: sphinxcontrib-mermaid; extra == "docs"
+Requires-Dist: netcdf4; extra == "optional"
+Requires-Dist: vtk; extra == "optional"
 Description-Content-Type: text/markdown
 
 # Capytaine: a linear potential flow BEM solver with Python.