capytaine 2.2__cp311-cp311-win_amd64.whl → 2.2.1__cp311-cp311-win_amd64.whl

capytaine/__about__.py

@@ -5,7 +5,7 @@ __all__ = ["__title__", "__description__", "__version__", "__author__", "__uri__
 __title__ = "capytaine"
 __description__ = """Python BEM solver for linear potential flow, based on Nemoh"""
 
-__version__ = "2.2"
+__version__ = "2.2.1"
 
 __author__ = "Matthieu Ancellin"
 __uri__ = "https://github.com/capytaine/capytaine"

capytaine/__init__.py

@@ -3,15 +3,14 @@
 
 
 # start delvewheel patch
-def _delvewheel_patch_1_7_1():
+def _delvewheel_patch_1_9_0():
     import os
-    libs_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'capytaine.libs'))
-    if os.path.isdir(libs_dir):
+    if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'capytaine.libs'))):
         os.add_dll_directory(libs_dir)
 
 
-_delvewheel_patch_1_7_1()
-del _delvewheel_patch_1_7_1
+_delvewheel_patch_1_9_0()
+del _delvewheel_patch_1_9_0
 # end delvewheel patch
 
 from .__about__ import (

capytaine/bem/engines.py

@@ -123,10 +123,10 @@ class BasicMatrixEngine(MatrixEngine):
 
             S_a, V_a = self.build_matrices(
                 mesh1[0], mesh2[0], free_surface, water_depth, wavenumber,
-                green_function)
+                green_function, adjoint_double_layer=adjoint_double_layer)
             S_b, V_b = self.build_matrices(
                 mesh1[0], mesh2[1], free_surface, water_depth, wavenumber,
-                green_function)
+                green_function, adjoint_double_layer=adjoint_double_layer)
 
             return BlockSymmetricToeplitzMatrix([[S_a, S_b]]), BlockSymmetricToeplitzMatrix([[V_a, V_b]])
 

capytaine/bem/problems_and_results.py

@@ -529,7 +529,10 @@ class RadiationResult(LinearPotentialFlowResult):
 
     @property
     def radiation_damping(self):
-        return {dof: float(np.imag(force)/self.encounter_omega) for (dof, force) in self.forces.items()}
+        if float(self.encounter_omega) in {0.0, np.inf} and self.forward_speed == 0.0:
+            return {dof: 0.0 for dof in self.forces.keys()}
+        else:
+            return {dof: float(np.imag(force)/self.encounter_omega) for (dof, force) in self.forces.items()}
 
     # Aliases for backward compatibility
     added_masses = added_mass

capytaine/bem/solver.py

@@ -83,8 +83,9 @@ class BEMSolver:
         keep_details: bool, optional
             if True, store the sources and the potential on the floating body in the output object
             (default: True)
-        _check_wavelength: bool, optional
-            if True, check the mesh resolution with respect to the wavelength
+        _check_wavelength: bool, optional (default: True)
+            If True, the frequencies are compared to the mesh resolution and
+            the estimated first irregular frequency to warn the user.
 
         Returns
         -------
@@ -159,6 +160,9 @@ class BEMSolver:
             By defaults: do not use joblib and solve sequentially.
         progress_bar: bool, optional (default: True)
             Display a progress bar while solving
+        _check_wavelength: bool, optional (default: True)
+            If True, the frequencies are compared to the mesh resolution and
+            the estimated first irregular frequency to warn the user.
 
         Returns
         -------
@@ -192,6 +196,7 @@ class BEMSolver:
     def _check_wavelength_and_mesh_resolution(problems):
         """Display a warning if some of the problems have a mesh resolution
         that might not be sufficient for the given wavelength."""
+        LOG.debug("Check wavelength with mesh resolution.")
         risky_problems = [pb for pb in problems
                           if 0.0 < pb.wavelength < pb.body.minimal_computable_wavelength]
         nb_risky_problems = len(risky_problems)
@@ -218,8 +223,9 @@ class BEMSolver:
     @staticmethod
     def _check_wavelength_and_irregular_frequencies(problems):
         """Display a warning if some of the problems might encounter irregular frequencies."""
+        LOG.debug("Check wavelength with estimated irregular frequency.")
         risky_problems = [pb for pb in problems
-                          if pb.body.first_irregular_frequency_estimate() < pb.omega < np.inf]
+                          if pb.body.first_irregular_frequency_estimate(g=pb.g) < pb.omega < np.inf]
         nb_risky_problems = len(risky_problems)
         if nb_risky_problems >= 1:
             if any(pb.body.lid_mesh is None for pb in problems):
@@ -244,7 +250,7 @@ class BEMSolver:
                             + recommendation
                             )
 
-    def fill_dataset(self, dataset, bodies, *, method='indirect', n_jobs=1, **kwargs):
+    def fill_dataset(self, dataset, bodies, *, method='indirect', n_jobs=1, _check_wavelength=True, **kwargs):
         """Solve a set of problems defined by the coordinates of an xarray dataset.
 
         Parameters
@@ -261,6 +267,9 @@ class BEMSolver:
             By defaults: do not use joblib and solve sequentially.
         progress_bar: bool, optional (default: True)
             Display a progress bar while solving
+        _check_wavelength: bool, optional (default: True)
+            If True, the frequencies are compared to the mesh resolution and
+            the estimated first irregular frequency to warn the user.
 
         Returns
         -------
@@ -270,12 +279,12 @@ class BEMSolver:
                  **self.exportable_settings}
         problems = problems_from_dataset(dataset, bodies)
         if 'theta' in dataset.coords:
-            results = self.solve_all(problems, keep_details=True, method=method, n_jobs=n_jobs)
+            results = self.solve_all(problems, keep_details=True, method=method, n_jobs=n_jobs, _check_wavelength=_check_wavelength)
             kochin = kochin_data_array(results, dataset.coords['theta'])
             dataset = assemble_dataset(results, attrs=attrs, **kwargs)
             dataset.update(kochin)
         else:
-            results = self.solve_all(problems, keep_details=False, method=method, n_jobs=n_jobs)
+            results = self.solve_all(problems, keep_details=False, method=method, n_jobs=n_jobs, _check_wavelength=_check_wavelength)
             dataset = assemble_dataset(results, attrs=attrs, **kwargs)
         return dataset
 

capytaine/bodies/bodies.py

@@ -5,7 +5,7 @@
 import logging
 import copy
 from itertools import chain, accumulate, zip_longest
-from functools import cached_property
+from functools import cached_property, lru_cache
 
 import numpy as np
 import xarray as xr
@@ -76,7 +76,11 @@ class FloatingBody(ClippableMixin, Abstract3DObject):
             raise TypeError("Unrecognized `mesh` object passed to the FloatingBody constructor.")
 
         if lid_mesh is not None:
-            self.lid_mesh = lid_mesh.with_normal_vector_going_down(inplace=False)
+            if lid_mesh.nb_faces == 0:
+                LOG.warning("Lid mesh %s provided for body initialization is empty. The lid mesh is ignored.", lid_mesh)
+                self.lid_mesh = None
+            else:
+                self.lid_mesh = lid_mesh.with_normal_vector_going_down(inplace=False)
         else:
             self.lid_mesh = None
 
@@ -996,6 +1000,9 @@ respective inertia coefficients are assigned as NaN.")
         self.mesh.clip(plane)
         if self.lid_mesh is not None:
             self.lid_mesh.clip(plane)
+            if self.lid_mesh.nb_faces == 0:
+                LOG.warning("Lid mesh %s is empty after clipping. The lid mesh is removed.", self.lid_mesh)
+                self.lid_mesh = None
 
         # Clip dofs
         ids = self.mesh._clipping_data['faces_ids']
@@ -1100,6 +1107,7 @@ respective inertia coefficients are assigned as NaN.")
         else:
             return 8*self.mesh.faces_radiuses.max()
 
+    @lru_cache
     def first_irregular_frequency_estimate(self, *, g=9.81):
         r"""Estimates the angular frequency of the lowest irregular
         frequency.

capytaine/io/mesh_loaders.py

@@ -721,6 +721,7 @@ def load_GDF(filename, name=None):
         npan = int(gdf_file.readline().split()[0])
         faces_vertices = np.genfromtxt(gdf_file)
 
+    faces_vertices = faces_vertices.reshape(-1, 3)
     vertices, indices = np.unique(faces_vertices, axis=0, return_inverse=True)
     faces = indices.reshape(-1, 4)
 

capytaine/io/xarray.py

@@ -112,11 +112,19 @@ def problems_from_dataset(dataset: xr.Dataset,
     if wave_direction_range is not None:
         for freq, wave_direction, water_depth, body_name, forward_speed, rho, g \
                 in product(freq_range, wave_direction_range, water_depth_range, body_range, forward_speed_range, rho_range, g_range):
-            problems.append(
-                DiffractionProblem(body=body_range[body_name], **{freq_type: freq},
-                                   wave_direction=wave_direction, water_depth=water_depth,
-                                   forward_speed=forward_speed, rho=rho, g=g)
-            )
+            if freq not in {0.0, np.inf}:
+                problems.append(
+                    DiffractionProblem(body=body_range[body_name], **{freq_type: freq},
+                                       wave_direction=wave_direction, water_depth=water_depth,
+                                       forward_speed=forward_speed, rho=rho, g=g)
+                )
+            elif freq in {0.0, np.inf} and radiating_dofs is not None:
+                # Diffraction problems are not defined for 0 and infinite frequency.
+                # But we don't want the whole batch to fail, as these frequencies are there for the radiation problems.
+                # The excitation force will be NaN for these frequencies in the resulting dataset.
+                pass
+            else:
+                raise ValueError("Zero and infinite frequencies are not defined when solving only diffraction problems.")
 
     if radiating_dofs is not None:
         for freq, radiating_dof, water_depth, body_name, forward_speed, rho, g \

capytaine/matrices/block.py

@@ -185,7 +185,9 @@ class BlockMatrix:
         self._put_in_full_matrix(full_matrix)
         return full_matrix
 
-    def __array__(self, dtype=None):
+    def __array__(self, dtype=None, copy=True):
+        if not copy:
+            raise ValueError("Making an ndarray out of a BlockMatrix requires copy")
         return self.full_matrix(dtype=dtype)
 
     def no_toeplitz(self):
@@ -587,4 +589,4 @@ class BlockMatrix:
         this_block = self
         for index in path:
             this_block = this_block.all_blocks[index, index]
-        return this_block
+        return this_block

capytaine/matrices/low_rank.py

@@ -318,7 +318,9 @@ class LowRankMatrix:
         else:
             return self.left_matrix @ self.right_matrix
 
-    def __array__(self, dtype=None):
+    def __array__(self, dtype=None, copy=True):
+        if not copy:
+            raise ValueError("Making an ndarray out of a BlockMatrix requires copy")
         return self.full_matrix(dtype=dtype)
 
     @property

capytaine/meshes/clipper.py

@@ -30,14 +30,14 @@ def clip(source_mesh: Mesh, plane: Plane, vicinity_tol=1e-12, name=None):
     """
     vertices_data = _vertices_positions_wrt_plane(source_mesh, plane, vicinity_tol)
 
-    nb_vertices_above_or_on_plane = np.count_nonzero(
-        vertices_data['vertices_above_mask'] | vertices_data['vertices_on_mask']
+    nb_vertices_strictly_above_plane = np.count_nonzero(
+        vertices_data['vertices_above_mask']
     )
     nb_vertices_below_or_on_plane = np.count_nonzero(
         vertices_data['vertices_below_mask'] | vertices_data['vertices_on_mask']
     )
 
-    if nb_vertices_above_or_on_plane == source_mesh.nb_vertices:
+    if nb_vertices_strictly_above_plane == source_mesh.nb_vertices:
         LOG.warning(f"Clipping {source_mesh.name} by {plane}: all vertices are removed.")
         clipped_mesh = Mesh(None, None)
         clipped_mesh._clipping_data = dict(faces_ids=[])

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
@@ -808,7 +809,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)

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/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
 
@@ -87,9 +97,9 @@ 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
 
@@ -98,6 +108,12 @@ class SymbolicMultiplication:
 
 
 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-2.2.1.dist-info/DELVEWHEEL

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