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

capytaine/io/mesh_loaders.py

@@ -11,7 +11,7 @@ import numpy as np
 from capytaine.meshes.meshes import Mesh
 from capytaine.meshes.symmetric import ReflectionSymmetricMesh
 from capytaine.meshes.geometry import xOz_Plane, yOz_Plane
-from capytaine.tools.optional_imports import import_optional_dependency
+from capytaine.tools.optional_imports import import_optional_dependency, silently_import_optional_dependency
 
 LOG = logging.getLogger(__name__)
 
@@ -24,14 +24,15 @@ def _check_file(filename, name=None):
     return
 
 
-def load_mesh(filename, file_format=None, name=None):
+def load_mesh(mesh, file_format=None, name=None):
     """Driver function that loads every mesh file format known by meshmagick.
     Dispatch to one of the other function depending on file_format.
 
     Parameters
     ----------
-    filename: str
-        name of the mesh file on disk
+    mesh: str or meshio object
+        Either the path to the mesh on disk
+        or a meshio object to be loaded with the dedicated method
     file_format: str, optional
         format of the mesh defined in the extension_dict dictionary
     name: str, optional
@@ -42,6 +43,13 @@ def load_mesh(filename, file_format=None, name=None):
     Mesh or SymmetricMesh
         the loaded mesh
     """
+    meshio = silently_import_optional_dependency("meshio")
+    if meshio is not None and isinstance(mesh, meshio._mesh.Mesh):
+        from capytaine.io.meshio import load_from_meshio
+        return load_from_meshio(mesh, name=name)
+
+    filename = mesh
+
     _check_file(filename)
 
     if file_format is None:
@@ -53,7 +61,8 @@ def load_mesh(filename, file_format=None, name=None):
 
     loader = extension_dict[file_format]
 
-    if name is None: name = filename
+    if name is None:
+        name = filename
 
     return loader(filename, name)
 
@@ -712,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)
 
@@ -810,31 +820,46 @@ def load_MSH(filename, name=None):
 
     _check_file(filename)
 
-    with open(filename, 'r') as file:
-        data = file.read()
+    try:
+        meshio = import_optional_dependency("meshio")
+    except:
+        with open(filename, 'r') as file:
+            data = file.read()
+        version = float(re.search(r'\$MeshFormat\n(\d.\d).*\n\$EndMeshFormat', data, re.DOTALL).groups()[0])
+
+        if 4 <= version < 5:
+            message = (
+                f"Meshio is required to read MSH file format version 4. "
+                f"Use pip or conda to install Meshio."
+            )
+            raise ImportError(message) from None
+        else:
+            nb_nodes, nodes_data = re.search(r'\$Nodes\n(\d+)\n(.+)\$EndNodes', data, re.DOTALL).groups()
+            nb_elts, elts_data = re.search(r'\$Elements\n(\d+)\n(.+)\$EndElements', data, re.DOTALL).groups()
 
-    nb_nodes, nodes_data = re.search(r'\$Nodes\n(\d+)\n(.+)\$EndNodes', data, re.DOTALL).groups()
-    nb_elts, elts_data = re.search(r'\$Elements\n(\d+)\n(.+)\$EndElements', data, re.DOTALL).groups()
+            vertices = np.asarray(list(map(float, nodes_data.split())), dtype=float).reshape((-1, 4))[:, 1:]
+            vertices = np.ascontiguousarray(vertices)
+            faces = []
 
-    vertices = np.asarray(list(map(float, nodes_data.split())), dtype=float).reshape((-1, 4))[:, 1:]
-    vertices = np.ascontiguousarray(vertices)
-    faces = []
+            # Triangles
+            for tri_elt in re.findall(r'(^\d+\s2(?:\s\d+)+?$)', elts_data, re.MULTILINE):
+                tri_elt = list(map(int, tri_elt.split()))
+                triangle = tri_elt[-3:]
+                triangle.append(triangle[0])
+                faces.append(triangle)
 
-    # Triangles
-    for tri_elt in re.findall(r'(^\d+\s2(?:\s\d+)+?$)', elts_data, re.MULTILINE):
-        tri_elt = list(map(int, tri_elt.split()))
-        triangle = tri_elt[-3:]
-        triangle.append(triangle[0])
-        faces.append(triangle)
+            for quad_elt in re.findall(r'(^\d+\s3(?:\s\d+)+?$)', elts_data, re.MULTILINE):
+                quad_elt = list(map(int, quad_elt.split()))
+                quadrangle = quad_elt[-4:]
+                faces.append(quadrangle)
 
-    for quad_elt in re.findall(r'(^\d+\s3(?:\s\d+)+?$)', elts_data, re.MULTILINE):
-        quad_elt = list(map(int, quad_elt.split()))
-        quadrangle = quad_elt[-4:]
-        faces.append(quadrangle)
+            faces = np.asarray(faces, dtype=int) - 1
 
-    faces = np.asarray(faces, dtype=int) - 1
+            return Mesh(vertices, faces, name)
 
-    return Mesh(vertices, faces, name)
+    msh_mesh = meshio.read(filename)
+    from capytaine.io.meshio import load_from_meshio
+    return load_from_meshio(msh_mesh, name)
 
 
 def load_MED(filename, name=None):

capytaine/io/meshio.py

@@ -32,4 +32,7 @@ def load_from_meshio(mesh, name=None):
     if name is None:
         name = f'mesh_from_meshio_{next(Mesh._ids)}'
 
-    return Mesh(vertices=mesh.points, faces=all_faces_as_quads(mesh.cells_dict), name=name)
+    mesh = Mesh(vertices=mesh.points, faces=all_faces_as_quads(mesh.cells_dict), name=name)
+    mesh.heal_mesh()
+
+    return mesh

capytaine/io/xarray.py

@@ -57,6 +57,10 @@ def problems_from_dataset(dataset: xr.Dataset,
     if isinstance(bodies, FloatingBody):
         bodies = [bodies]
 
+    # Should be done before looking for `frequency_keys`, otherwise
+    # frequencies provided as a scalar dimension will be skipped.
+    dataset = _unsqueeze_dimensions(dataset)
+
     # SANITY CHECKS
     assert len(list(set(body.name for body in bodies))) == len(bodies), \
         "All bodies should have different names."
@@ -80,8 +84,6 @@ def problems_from_dataset(dataset: xr.Dataset,
                              "Received {}".format(frequency_keys))
     # END SANITY CHECKS
 
-    dataset = _unsqueeze_dimensions(dataset)
-
     if len(frequency_keys) == 0:
         freq_type = "omega"
         freq_range = [_default_parameters['omega']]
@@ -110,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/linear_solvers.py

@@ -3,14 +3,13 @@
 They are based on numpy solvers with a thin layer for the handling of Hierarchical Toeplitz matrices.
 """
 # 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
 from scipy import linalg as sl
 from scipy.sparse import linalg as ssl
-from itertools import accumulate, chain
 
 from capytaine.matrices.block import BlockMatrix
 from capytaine.matrices.block_toeplitz import BlockSymmetricToeplitzMatrix, BlockCirculantMatrix
@@ -27,7 +26,7 @@ def solve_directly(A, b):
         blocks_of_diagonalization = A.block_diagonalize()
         fft_of_rhs = np.fft.fft(np.reshape(b, (A.nb_blocks[0], A.block_shape[0])), axis=0)
         try:  # Try to run it as vectorized numpy arrays.
-            fft_of_result = np.linalg.solve(blocks_of_diagonalization, fft_of_rhs)
+            fft_of_result = np.linalg.solve(blocks_of_diagonalization, fft_of_rhs[..., np.newaxis])[..., 0]
         except np.linalg.LinAlgError:  # Or do the same thing with list comprehension.
             fft_of_result = np.array([solve_directly(block, vec) for block, vec in zip(blocks_of_diagonalization, fft_of_rhs)])
         result = np.fft.ifft(fft_of_result, axis=0).reshape((A.shape[1],))

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/collections.py

@@ -103,14 +103,14 @@ class CollectionOfMeshes(ClippableMixin, SurfaceIntegralsMixin, Abstract3DObject
 
     def path_to_leaf(self):
         """
-        Builds a list of lists of paths from the collection corresponding to the 
+        Builds a list of lists of paths from the collection corresponding to the
         root of the tree to the submeshes corresponding to the leaves
         """
         ptl = []
         for i, mesh in enumerate(self):
            for path in mesh.path_to_leaf():
                ptl.append([i] + path)
-        return ptl 
+        return ptl
 
     def copy(self, name=None):
         from copy import deepcopy
@@ -124,6 +124,11 @@ class CollectionOfMeshes(ClippableMixin, SurfaceIntegralsMixin, Abstract3DObject
         for mesh in self:
             mesh.heal_mesh(closed_mesh=closed_mesh)
 
+    @inplace_transformation
+    def with_normal_vector_going_down(self):
+        for mesh in self:
+            mesh.with_normal_vector_going_down()
+
     ##############
     # Properties #
     ##############
@@ -311,3 +316,9 @@ class CollectionOfMeshes(ClippableMixin, SurfaceIntegralsMixin, Abstract3DObject
 
     def show_matplotlib(self, *args, **kwargs):
         self.merged().show_matplotlib(*args, **kwargs)
+
+    def lowest_lid_position(self, *args, **kwargs):
+        return self.merged().lowest_lid_position(*args, **kwargs)
+
+    def generate_lid(self, *args, **kwargs):
+        return self.merged().generate_lid(*args, **kwargs)

capytaine/meshes/meshes.py

@@ -9,8 +9,8 @@ from itertools import count
 
 import numpy as np
 
-from capytaine.meshes.geometry import Abstract3DObject, ClippableMixin, Plane, inplace_transformation
-from capytaine.meshes.properties import compute_faces_properties
+from capytaine.meshes.geometry import Abstract3DObject, ClippableMixin, Plane, inplace_transformation, xOy_Plane
+from capytaine.meshes.properties import compute_faces_properties, connected_components, connected_components_of_waterline
 from capytaine.meshes.surface_integrals import SurfaceIntegralsMixin
 from capytaine.meshes.quality import (merge_duplicates, heal_normals, remove_unused_vertices,
                                       heal_triangles, remove_degenerated_faces)
@@ -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
@@ -744,3 +745,126 @@ class Mesh(ClippableMixin, SurfaceIntegralsMixin, Abstract3DObject):
         if closed_mesh:
             self.heal_normals()
         return self
+
+    ##########
+    #  Lids  #
+    ##########
+
+    def lowest_lid_position(self, omega_max, *, g=9.81):
+        z_lid = 0.0
+        for comp in connected_components(self):
+            for ccomp in connected_components_of_waterline(comp):
+                x_span = ccomp.vertices[:, 0].max() - ccomp.vertices[:, 0].min()
+                y_span = ccomp.vertices[:, 1].max() - ccomp.vertices[:, 1].min()
+                p = np.hypot(1/x_span, 1/y_span)
+                z_lid_comp = -np.arctanh(np.pi*g*p/omega_max**2) / (np.pi * p)
+                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):
+        """
+        Return a mesh of the internal free surface of the body.
+
+        Parameters
+        ----------
+        z: float
+            Vertical position of the lid. Default: 0.0
+        faces_max_radius: float
+            resolution of the mesh of the lid.
+            Default: mean of hull mesh resolution.
+
+        Returns
+        -------
+        Mesh
+            lid of internal surface
+        """
+        from capytaine.meshes.predefined.rectangles import mesh_rectangle
+
+        clipped_hull_mesh = self.clipped(Plane(normal=(0, 0, 1), point=(0, 0, z)))
+        # Alternatively: could keep only faces below z without proper clipping,
+        # and it would work similarly.
+
+        if clipped_hull_mesh.nb_faces == 0:
+            return Mesh(None, None, name="lid for {}".format(self.name))
+
+        x_span = clipped_hull_mesh.vertices[:, 0].max() - clipped_hull_mesh.vertices[:, 0].min()
+        y_span = clipped_hull_mesh.vertices[:, 1].max() - clipped_hull_mesh.vertices[:, 1].min()
+        x_mean = (clipped_hull_mesh.vertices[:, 0].max() + clipped_hull_mesh.vertices[:, 0].min())/2
+        y_mean = (clipped_hull_mesh.vertices[:, 1].max() + clipped_hull_mesh.vertices[:, 1].min())/2
+
+        if faces_max_radius is None:
+            faces_max_radius = np.mean(clipped_hull_mesh.faces_radiuses)
+
+        candidate_lid_mesh = mesh_rectangle(
+                size=(1.1*y_span, 1.1*x_span),  # TODO Fix mesh_rectangle
+                faces_max_radius=faces_max_radius,
+                center=(x_mean, y_mean, z),
+                normal=(0.0, 0.0, -1.0),
+                )
+
+        candidate_lid_points = candidate_lid_mesh.vertices[:, 0:2]
+
+        hull_faces = clipped_hull_mesh.vertices[clipped_hull_mesh.faces, 0:2]
+        edges_of_hull_faces = hull_faces[:, [1, 2, 3, 0], :] - hull_faces[:, :, :]  # Vectors between two consecutive points in a face
+        # 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 = (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)
+
+        # For all point in candidate_lid_points, and for all edges of all faces of
+        # the hull mesh, check on which side of the edge is the point by using a
+        # cross product.
+        # If a point on the same side of all edges of a face, then it is inside.
+
+        nb_panels_below_point = np.sum(point_is_above_panel, axis=-1)
+        needs_lid = (nb_panels_below_point % 2 == 1).nonzero()[0]
+
+        lid_faces = candidate_lid_mesh.faces[np.all(np.isin(candidate_lid_mesh.faces, needs_lid), axis=-1), :]
+
+        if len(lid_faces) == 0:
+            return Mesh(None, None, name="lid for {}".format(self.name))
+
+        lid_mesh = Mesh(candidate_lid_mesh.vertices, lid_faces, name="lid for {}".format(self.name))
+        lid_mesh.heal_mesh()
+
+        return lid_mesh
+
+    @inplace_transformation
+    def with_normal_vector_going_down(self):
+        # For lid meshes for irregular frequencies removal
+        if np.allclose(self.faces_normals[:, 2], np.ones((self.nb_faces,))):
+            # The mesh is horizontal with normal vectors going up
+            LOG.warning(f"Inverting the direction of the normal vectors of {self} to be downward.")
+            self.faces = self.faces[:, ::-1]
+        else:
+            return self
+
+    def _face_on_plane(self, i_face, plane):
+        return (
+                self.faces_centers[i_face, :] in plane
+                and plane.is_orthogonal_to(self.faces_normals[i_face, :])
+                )
+
+    def extract_lid(self, plane=xOy_Plane):
+        """
+        Split the mesh into a mesh of the hull and a mesh of the lid.
+        By default, the lid is composed of the horizontal faces on the z=0 plane.
+
+        Parameters
+        ----------
+        plane: Plane
+            The plane on which to look for lid faces.
+
+        Returns
+        -------
+        2-ple of Mesh
+            hull mesh and lid mesh
+        """
+        faces_on_plane = [i_face for i_face in range(self.nb_faces) if self._face_on_plane(i_face, plane)]
+        lid_mesh = self.extract_faces(faces_on_plane)
+        hull_mesh = self.extract_faces(list(set(range(self.nb_faces)) - set(faces_on_plane)))
+        return hull_mesh, lid_mesh

capytaine/meshes/predefined/cylinders.py

@@ -88,7 +88,7 @@ def mesh_disk(*, radius=1.0, center=(0, 0, 0), normal=(0, 0, 1),
     else:
         theta_range = np.linspace(0, _theta_max, ntheta+1)
         r_range = np.linspace(0.0, radius, nr+1)
-        nodes = np.array([(0, r*sin(t), r*cos(t)) for (r, t) in product(r_range, theta_range)])
+        nodes = np.array([(0, r*sin(t), -r*cos(t)) for (r, t) in product(r_range, theta_range)])
         panels = np.array([(j+i*(ntheta+1), j+1+i*(ntheta+1), j+1+(i+1)*(ntheta+1), j+(i+1)*(ntheta+1))
                                 for (i, j) in product(range(0, nr), range(0, ntheta))])
 
@@ -170,7 +170,7 @@ def mesh_vertical_cylinder(*, length=10.0, radius=1.0, center=(0, 0, 0),
                 resolution=(nr, ntheta//2, nz), reflection_symmetry=False, axial_symmetry=False,
                 name=f"half_{name}", _theta_max=_theta_max/2)
 
-        mesh = ReflectionSymmetricMesh(half_cylinder, plane=xOz_Plane, name=name)
+        mesh = ReflectionSymmetricMesh(half_cylinder, plane=yOz_Plane, name=name)
 
     elif axial_symmetry:
 

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):
@@ -197,3 +201,76 @@ def compute_connectivity(mesh):
             'v_f': v_f,
             '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.
+
+    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
+    """
+    return np.any(np.isin(faces, group), axis=1)
+
+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:
+            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
+
+
+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.
+    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
+
+
+def connected_components_of_waterline(mesh, z=0.0):
+    if np.any(mesh.vertices[:, 2] > z + 1e-8):
+        mesh = mesh.immersed_part(free_surface=z)
+    fs_vertices_indices = np.where(np.isclose(mesh.vertices[:, 2], z))[0]
+    fs_faces_indices = np.where(np.any(np.isin(mesh.faces, fs_vertices_indices), axis=1))[0]
+    crown_mesh = mesh.extract_faces(fs_faces_indices)
+    return connected_components(crown_mesh)

capytaine/post_pro/rao.py

@@ -55,6 +55,6 @@ def rao(dataset, wave_direction=None, dissipation=None, stiffness=None):
     # Solve and add coordinates
     rao_dims = [d for d in H.dims if d != 'influenced_dof']
     rao_coords = {c: H.coords[c] for c in H.coords if c != 'influenced_dof'}
-    rao = xr.DataArray(np.linalg.solve(H, fex), coords=rao_coords, dims=rao_dims)
+    rao = xr.DataArray(np.linalg.solve(H.values, fex.values[..., np.newaxis])[..., 0], coords=rao_coords, dims=rao_dims)
 
     return rao

capytaine/tools/cache_on_disk.py

@@ -9,7 +9,9 @@ from capytaine import __version__
 
 
 def cache_directory():
-    if sys.platform == "win32":  # Windows
+    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

capytaine/tools/symbolic_multiplication.py

@@ -1,7 +1,17 @@
+"""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
+from functools import wraps, total_ordering
 
-# @total_ordering
+@total_ordering
 class SymbolicMultiplication:
     def __init__(self, symbol, value=1.0):
         self.symbol = symbol
@@ -64,6 +74,9 @@ class SymbolicMultiplication:
     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
 
@@ -84,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
 
@@ -95,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/ui/vtk/body_viewer.py

@@ -15,6 +15,8 @@ class FloatingBodyViewer(MeshViewer):
 
     def add_body(self, body, **kwargs):
         self.add_mesh(body.mesh, **kwargs)
+        if body.lid_mesh is not None:
+            self.add_mesh(body.lid_mesh, **kwargs)
 
         for dof in body.dofs:
             vtk_data_array = vtk.vtkFloatArray()

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\\cp39-win_amd64\\build\\venv\\Scripts\\delvewheel', 'repair', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-qolinjw3\\cp39-win_amd64\\repaired_wheel', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-qolinjw3\\cp39-win_amd64\\built_wheel\\capytaine-2.2.1-cp39-cp39-win_amd64.whl', '--no-mangle-all']