capytaine 2.2__cp39-cp39-win_amd64.whl → 2.3__cp39-cp39-win_amd64.whl

capytaine/meshes/meshes.py

@@ -470,8 +470,9 @@ class Mesh(ClippableMixin, SurfaceIntegralsMixin, Abstract3DObject):
         Other parameters are passed to Poly3DCollection.
         """
         matplotlib = import_optional_dependency("matplotlib")
-        plt = matplotlib.pyplot
-        cm = matplotlib.cm
+        import importlib
+        plt = importlib.import_module("matplotlib.pyplot")
+        cm = importlib.import_module("matplotlib.cm")
 
         mpl_toolkits = import_optional_dependency("mpl_toolkits", package_name="matplotlib")
         Poly3DCollection = mpl_toolkits.mplot3d.art3d.Poly3DCollection
@@ -760,17 +761,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
         -------
@@ -794,8 +797,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),
@@ -808,7 +817,8 @@ class Mesh(ClippableMixin, SurfaceIntegralsMixin, Abstract3DObject):
         # edges_of_hull_faces.shape = (nb_full_faces, 4, 2)
         lid_points_in_local_coords = candidate_lid_points[:, np.newaxis, np.newaxis, :] - hull_faces[:, :, :]
         # lid_points_in_local_coords.shape = (nb_candidate_lid_points, nb_full_faces, 4, 2)
-        side_of_hull_edges = np.cross(lid_points_in_local_coords, edges_of_hull_faces)
+        side_of_hull_edges = (lid_points_in_local_coords[..., 0] * edges_of_hull_faces[..., 1]
+                             - lid_points_in_local_coords[..., 1] * edges_of_hull_faces[..., 0])
         # side_of_hull_edges.shape = (nb_candidate_lid_points, nb_full_faces, 4)
         point_is_above_panel = np.all(side_of_hull_edges <= 0, axis=-1) | np.all(side_of_hull_edges >= 0, axis=-1)
         # point_is_above_panel.shape = (nb_candidate_lid_points, nb_full_faces)
@@ -823,10 +833,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/properties.py

@@ -4,7 +4,11 @@ Based on meshmagick <https://github.com/LHEEA/meshmagick> by François Rongère.
 # Copyright (C) 2017-2019 Matthieu Ancellin, based on the work of François Rongère
 # See LICENSE file at <https://github.com/mancellin/capytaine>
 
+from functools import reduce
+from itertools import chain
 import numpy as np
+from typing import List
+from numpy.typing import NDArray
 
 
 def compute_faces_properties(mesh):
@@ -198,37 +202,67 @@ def compute_connectivity(mesh):
             'f_f': f_f,
             'boundaries': boundaries}
 
+def faces_in_group(faces: NDArray[np.integer], group: NDArray[np.integer]) -> NDArray[np.bool_]:
+    """Identification of faces with vertices within group.
 
-def connected_components(mesh):
-    """Returns a list of meshes that each corresponds to the a connected component in the original mesh.
-    Assumes the mesh is mostly conformal without duplicate vertices.
+    Parameters
+    ----------
+    faces : NDArray[np.integer]
+        Mesh faces. Expecting a numpy array of shape N_faces x N_vertices_per_face.
+    group : NDArray[np.integer]
+        Group of connected vertices
+
+    Returns
+    -------
+    NDArray[np.bool]
+        Mask of faces containing vertices from the group
     """
-    from typing import Set, FrozenSet, List
+    return np.any(np.isin(faces, group), axis=1)
 
-    vertices_components: Set[FrozenSet[int]] = set()
-    for set_of_v_in_face in map(frozenset, mesh.faces):
-        intersecting_components = [c for c in vertices_components if len(c.intersection(set_of_v_in_face)) > 0]
-        if len(intersecting_components) == 0:
-            vertices_components.add(set_of_v_in_face)
+def clustering(faces: NDArray[np.integer]) -> List[NDArray[np.integer]]:
+    """Clustering of vertices per connected faces.
+
+    Parameters
+    ----------
+    faces : NDArray[np.integer]
+        Mesh faces. Expecting a numpy array of shape N_faces x N_vertices_per_face.
+
+    Returns
+    -------
+    list[NDArray[np.integer]]
+        Groups of connected vertices.
+    """
+    vert_groups: list[NDArray[np.integer]] = []
+    mask = np.ones(faces.shape[0], dtype=bool)
+    while np.any(mask):
+        # Consider faces whose vertices are not already identified in a group.
+        # Start new group by considering first face
+        remaining_faces = faces[mask]
+        group = remaining_faces[0]
+        rem_mask = np.ones(remaining_faces.shape[0], dtype=bool)
+        # Iterative update of vertices group. Output final result to frozenset
+        while not np.allclose(new:=faces_in_group(remaining_faces, group), rem_mask):
+            group = np.unique(remaining_faces[new])
+            rem_mask = new
         else:
-            for c in intersecting_components:
-                vertices_components.remove(c)
-            vertices_components.add(frozenset.union(set_of_v_in_face, *intersecting_components))
+            group = np.unique(remaining_faces[new])
+        vert_groups.append(group)
+        # Identify faces that have no vertices in current groups
+        mask = ~reduce(np.logical_or, [faces_in_group(faces, group) for group in vert_groups])
+    return vert_groups
 
-    # Verification
-    for component in vertices_components:
-        assert all(len(component.intersection(c)) == 0 for c in vertices_components if c != component)
 
+def connected_components(mesh):
+    """Returns a list of meshes that each corresponds to the a connected component in the original mesh.
+    Assumes the mesh is mostly conformal without duplicate vertices.
+    """
+    # Get connected vertices
+    vertices_components = clustering(mesh.faces)
+    # Verification
+    if sum(len(group) for group in vertices_components) != len(set(chain.from_iterable(vertices_components))):
+        raise ValueError("Error in connected components clustering. Some elements are duplicated")
     # The components are found. The rest is just about retrieving the faces in each components.
-    vertices_components: List[FrozenSet[int]] = list(vertices_components)
-    faces_components: List[List[int]] = [[] for _ in vertices_components]
-    for i_face, v_in_face in enumerate(mesh.faces):
-        for i_component, v_c in enumerate(vertices_components):
-            if any(v in v_c for v in v_in_face):
-                assert all(v in v_c for v in v_in_face)
-                faces_components[i_component].append(i_face)
-                break
-
+    faces_components = [np.argwhere(faces_in_group(mesh.faces, group)) for group in vertices_components]
     components = [mesh.extract_faces(f) for f in faces_components]
     return components
 

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__)
 
@@ -89,7 +89,7 @@ class ReflectionSymmetricMesh(SymmetricMesh):
             "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)
+        half_mesh = meshes[0].half.join_meshes(*(mesh.half for mesh in meshes[1:]), name=f"half_of_{name}" if name is not None else None)
         return ReflectionSymmetricMesh(half_mesh, plane=meshes[0].plane, name=name)
 
     @inplace_transformation
@@ -110,6 +110,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.

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

@@ -1,3 +1,13 @@
+"""This module is used for the handling of zero and infinite frequencies.
+In this cases, the magnitudes that the solver has to manipulate are in the form of ω times a non-zero term.
+Instead of evaluating this multiplication as zero of infinity, we keep it symbolic using the class defined here.
+
+The frequency can be provided to the solver as something like
+`SymbolicMultiplication("0", 1.0)` (that is zero) and the solver will return an
+output of the form `SymbolicMultiplication("0", np.array(...))`
+(that is also actually zero, except we may be intested in the non-zero array).
+"""
+
 import numpy as np
 from functools import wraps, total_ordering
 
@@ -6,6 +16,8 @@ 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)}"
@@ -30,6 +42,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)
 
@@ -87,17 +102,30 @@ class SymbolicMultiplication:
 
     def __float__(self):
         if self.symbol == "0":
-            return 0.0
+            return 0.0 * float(self.value)
         elif self.symbol == "∞":
-            return np.inf
+            return np.inf * float(self.value)
         else:
             raise NotImplementedError
 
     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):
+    """
+    When this decorator is applied to a function, this function can now take
+    as input a `SymbolicMultiplication` object. The function is applied on the
+    `value` part of the `SymbolicMultiplication` without modifying the
+    `symbol`.
+    """
     @wraps(f)
     def wrapped_f(a, x):
         if hasattr(x, 'symbol'):

capytaine/tools/timer.py

@@ -0,0 +1,64 @@
+"""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.dist-info/DELVEWHEEL

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