capytaine 2.3__cp312-cp312-win_amd64.whl → 3.0.0a1__cp312-cp312-win_amd64.whl

capytaine/meshes/visualization.py

@@ -0,0 +1,353 @@
+# Copyright 2025 Mews Labs
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import importlib
+from typing import Optional, List
+
+import numpy as np
+
+from capytaine import __version__
+from capytaine.tools.optional_imports import import_optional_dependency
+
+
+def show_3d(mesh, *, backend=None, **kwargs):
+    """Dispatch the 3D viewing to one of the available backends below."""
+    backends_functions = {
+            "pyvista": show_pyvista,
+            "matplotlib": show_matplotlib,
+            }
+    if backend is not None:
+        if backend in backends_functions:
+            return backends_functions[backend](mesh, **kwargs)
+        else:
+            raise NotImplementedError(f"Backend '{backend}' is not implemented.")
+    else:
+        for backend in backends_functions:
+            try:
+                return backends_functions[backend](mesh, **kwargs)
+            except (NotImplementedError, ImportError):
+                pass
+            raise NotImplementedError(f"No compatible backend found to show the mesh {mesh}"
+                                      "Consider installing `matplotlib` or `pyvista`.")
+
+
+def show_pyvista(
+    mesh,
+    *,
+    ghost_meshes=None,
+    plotter=None,
+    normal_vectors=False,
+    display_free_surface=True,
+    water_depth=np.inf,
+    color_field=None,
+    cbar_label="",
+    **kwargs
+) -> Optional["pv.Plotter"]:  # noqa: F821
+    """
+    Visualize the mesh using PyVista.
+
+    PyVista default keyboards controls: https://docs.pyvista.org/api/plotting/plotting
+
+    Parameters
+    ----------
+    mesh : Mesh
+        The mesh object to visualize.
+    ghost_meshes: List[Mesh], optional
+        Additional meshes, shown in transparency
+    plotter: pv.Plotter, optional
+        If provided, use this PyVista plotter and return it at the end.
+        Otherwise a new one is created and the 3D view is displayed at the end.
+    normal_vectors: bool, optional
+        If True, display normal vector (default: True)
+    display_free_surface: bool, optional
+        If True, display free surface and if `water_depth` is finite display the sea bottom.
+        (default: True)
+    water_depth: float, optional
+        Where to display the sea bottom if `display_free_surface` is True
+    color_field: array of shape (nb_faces, ), optional
+        Scalar field to be plot on the mesh.
+    cmap: matplotlib colormap, optional
+        Colormap to use for scalar field plotting.
+    cbar_label: string, optional
+        Label for colorbar show color field scale
+    kwargs : additional optional arguments
+        Additional arguments passed to PyVista's add_mesh methods for customization (e.g. mesh color).
+    """
+    pv = import_optional_dependency("pyvista")
+
+    all_meshes_in_scene: List[Mesh] = [mesh] if ghost_meshes is None else [mesh, *ghost_meshes]
+    pv_meshes = [m.export_to_pyvista() for m in all_meshes_in_scene]
+
+    if color_field is not None and isinstance(color_field, np.ndarray):
+        acc_faces = 0
+        # Split the content of color_fields into the meshes in the scene
+        for m in pv_meshes:
+            m.cell_data["color_field"] = color_field[acc_faces:acc_faces+m.n_cells]
+            acc_faces = acc_faces + m.n_cells
+
+    if plotter is None:
+        default_plotter = True
+        plotter = pv.Plotter()
+    else:
+        default_plotter = False
+
+    if color_field is not None:
+        kwargs.setdefault("scalars", "color_field")
+    kwargs.setdefault("scalar_bar_args", {"title": cbar_label})
+    plotter.add_mesh(pv_meshes[0], name="hull", show_edges=True, **kwargs)
+
+    for i_ghost, g_mesh in enumerate(pv_meshes[1:]):
+        plotter.add_mesh(
+                g_mesh,
+                name=f"symmetric_hull_{i_ghost}",
+                opacity=0.4,
+                show_edges=False,
+                **kwargs
+                )
+
+    # NORMALS
+    def show_normals():
+        mini = mesh.vertices.min()
+        maxi = mesh.vertices.max()
+        plotter.add_arrows(
+            mesh.faces_centers,
+            mesh.faces_normals,
+            name="normals",
+            mag=0.04*(maxi-mini),
+            show_scalar_bar=False
+        )
+
+    def toggle_normals():
+        nonlocal normal_vectors
+        if normal_vectors:
+            normal_vectors = False
+            plotter.remove_actor('normals')
+        else:
+            normal_vectors = True
+            show_normals()
+
+    if normal_vectors:
+        show_normals()
+    plotter.add_key_event("n", lambda : toggle_normals())
+
+    scene_min = np.min([m.vertices[:, :].min(axis=0) for m in all_meshes_in_scene], axis=0)
+    scene_max = np.max([m.vertices[:, :].max(axis=0) for m in all_meshes_in_scene], axis=0)
+
+    # FREE SURFACE
+    def show_free_surface():
+        center = (scene_min[:2] + scene_max[:2]) / 2
+        diam = 1.1*(scene_max[:2] - scene_min[:2])
+        plane = pv.Plane(center=(*center, 0), direction=(0, 0, 1), i_size=diam[0], j_size=diam[1])
+        plotter.add_mesh(plane, color="blue", opacity=0.5, name="display_free_surface")
+        if water_depth != np.inf:
+            plane = pv.Plane(center=(*center, -water_depth), direction=(0, 0, 1), i_size=diam[0], j_size=diam[1])
+            plotter.add_mesh(plane, color="brown", opacity=0.5, name="display_sea_bottom")
+
+
+    def toggle_free_surface():
+        nonlocal display_free_surface
+        if display_free_surface:
+            display_free_surface = False
+            plotter.remove_actor('display_free_surface')
+            if water_depth != np.inf:
+                plotter.remove_actor('display_sea_bottom')
+        else:
+            display_free_surface = True
+            show_free_surface()
+
+    if display_free_surface:
+        show_free_surface()
+
+    plotter.add_key_event("h", lambda : toggle_free_surface())
+
+    # BOUNDS
+    def show_bounds():
+        plotter.show_bounds(grid='back', location='outer', n_xlabels=2, n_ylabels=2, n_zlabels=2)
+
+    bounds = True
+    show_bounds()
+    def toggle_bounds():
+        nonlocal bounds
+        if bounds:
+            plotter.remove_bounds_axes()
+            bounds = False
+        else:
+            show_bounds()
+            plotter.update()
+            bounds = True
+
+
+    plotter.add_key_event("b", lambda: toggle_bounds())
+
+    plotter.add_key_event("T", lambda : plotter.view_xy())
+    plotter.add_key_event("B", lambda : plotter.view_xy(negative=True))
+    plotter.add_key_event("S", lambda : plotter.view_xz())
+    plotter.add_key_event("P", lambda : plotter.view_xz(negative=True))
+    plotter.add_key_event("F", lambda : plotter.view_yz())
+    plotter.add_key_event("R", lambda : plotter.view_yz(negative=True))
+
+    view_clipping = {'x': 0, 'y': 0}  # 0 = no clipping, +1 clipping one side, -1 clipping other side
+    def clipped_mesh():
+        nonlocal view_clipping
+        clipped_pv_mesh = pv_meshes[0]
+        for dir in ['x', 'y']:
+            if view_clipping[dir] == 1:
+                clipped_pv_mesh = clipped_pv_mesh.clip(dir)
+            elif view_clipping[dir] == -1:
+                clipped_pv_mesh = clipped_pv_mesh.clip("-" + dir)
+        return clipped_pv_mesh
+
+    def toggle_view_clipping(dir):
+        nonlocal view_clipping
+        if view_clipping[dir] == 0:
+            view_clipping[dir] = +1
+        elif view_clipping[dir] == +1:
+            view_clipping[dir] = -1
+        else:
+            view_clipping[dir] = 0
+        plotter.add_mesh(clipped_mesh(), name="hull", show_edges=True, **kwargs)
+
+    plotter.add_key_event("X", lambda : toggle_view_clipping("x"))
+    plotter.add_key_event("Y", lambda : toggle_view_clipping("y"))
+
+    plotter.add_text(
+        f"Capytaine version {__version__}\n\n"
+        """Keyboard controls:
+        b: toggle scale and bounding box
+        h: toggle free surface (and sea bottom if water depth was given)
+        n: toggle normal vectors
+        T,B,P,S,F,R: view [T]op, [B]ottom, [P]ort, [S]tarboard, [F]ront, [R]ear
+        X, Y: toggle displaying clipped mesh in x or y direction
+        q: exit
+        """,
+        position="upper_left",
+        font_size=10
+    )
+    plotter.show_axes()  # xyz in bottom left corner
+
+    if default_plotter:
+        plotter.show()
+    else:
+        return plotter
+
+
+def show_matplotlib(
+    mesh,
+    *,
+    ghost_meshes=None,
+    ax=None,
+    bounding_box=None,
+    normal_vectors=False,
+    scale_normal_vector=None,
+    color_field=None,
+    cmap=None,
+    cbar_label=None,
+    **kwargs
+):
+    """
+    Visualize the mesh using Matplotlib.
+
+    Parameters
+    ----------
+    mesh : Mesh
+        The mesh object to visualize.
+    ghost_meshes: List[Mesh], optional
+        Additional meshes. In the matplotlib viewer, they are just merged with the main mesh.
+    ax: matplotlib axis
+        The 3d axis in which to plot the mesh. If not provided, create a new one.
+    bounding_box: tuple[tuple[int]], optional
+        Min and max coordinates values to display in each three dimensions.
+    normal_vectors: bool, optional
+        If True, display normal vector.
+    scale_normal_vector: array of shape (nb_faces, ), optional
+        Scale separately each of the normal vectors.
+    color_field: array of shape (nb_faces, ), optional
+        Scalar field to be plot on the mesh (optional).
+    cmap: matplotlib colormap, optional
+        Colormap to use for scalar field plotting.
+    cbar_label: string, optional
+        Label for colorbar show color field scale
+
+    Other parameters are passed to Poly3DCollection.
+    """
+    matplotlib = import_optional_dependency("matplotlib")
+    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
+
+    default_axis = ax is None
+    if default_axis:
+        fig = plt.figure(layout="constrained")
+        ax = fig.add_subplot(111, projection="3d")
+        ax.set_box_aspect([1, 1, 1])  # Equal aspect ratio
+
+    all_meshes_in_scene: List[Mesh] = [mesh] if ghost_meshes is None else [mesh, *ghost_meshes]
+
+    faces = []
+    for m in all_meshes_in_scene:
+        for face in m.faces:
+            vertices = [m.vertices[int(index_vertex), :] for index_vertex in face]
+            faces.append(vertices)
+
+    if color_field is None:
+        if 'facecolors' not in kwargs:
+            kwargs['facecolors'] = "yellow"
+    else:
+        if cmap is None:
+            cmap = matplotlib.colormaps['coolwarm']
+        m = cm.ScalarMappable(cmap=cmap)
+        m.set_array([min(color_field), max(color_field)])
+        m.set_clim(vmin=min(color_field), vmax=max(color_field))
+        colors = m.to_rgba(color_field)
+        kwargs['facecolors'] = colors
+    kwargs.setdefault("edgecolor", "k")
+
+    ax.add_collection3d(Poly3DCollection(faces, **kwargs))
+
+    if color_field is not None:
+        cbar = plt.colorbar(m, ax=ax)
+        if cbar_label is not None:
+            cbar.set_label(cbar_label)
+
+    # Plot normal vectors.
+    if normal_vectors:
+        if scale_normal_vector is not None:
+            vectors = (scale_normal_vector * mesh.faces_normals.T).T
+        else:
+            vectors = mesh.faces_normals
+        ax.quiver(*zip(*mesh.faces_centers), *zip(*vectors), length=0.2)
+
+    ax.set_xlabel("x")
+    ax.set_ylabel("y")
+    ax.set_zlabel("z")
+
+    if bounding_box is None:
+        # auto cube around mesh
+        mini = mesh.vertices.min(axis=0)
+        maxi = mesh.vertices.max(axis=0)
+        center = (mini + maxi) / 2
+        radius = (maxi - mini).max() / 2
+        ax.set_xlim(center[0] - radius, center[0] + radius)
+        ax.set_ylim(center[1] - radius, center[1] + radius)
+        ax.set_zlim(center[2] - radius, center[2] + radius)
+    else:
+        (xmin, xmax), (ymin, ymax), (zmin, zmax) = bounding_box
+        ax.set_xlim(xmin, xmax)
+        ax.set_ylim(ymin, ymax)
+        ax.set_zlim(zmin, zmax)
+
+    if default_axis:
+        plt.show()

capytaine/post_pro/free_surfaces.py

@@ -48,10 +48,7 @@ class FreeSurface():
         self.y_range = y_range
         self.ny = ny
 
-        if name is None:
-            self.name = f"free_surface_{next(Mesh._ids)}"
-        else:
-            self.name = name
+        self.name = name
 
         self.mesh = self._generate_mesh()
 

capytaine/post_pro/kochin.py

@@ -36,19 +36,19 @@ def compute_kochin(result, theta, ref_point=(0.0, 0.0)):
     k = result.wavenumber
     h = result.water_depth
 
-    # omega_bar.shape = (nb_faces, 2) @ (2, nb_theta)
-    omega_bar = (result.body.mesh.faces_centers[:, 0:2] - ref_point) @ (np.cos(theta), np.sin(theta))
+    # omega_bar.shape = (nb_faces_including_lid, 2) @ (2, nb_theta)
+    omega_bar = (result.body.mesh_including_lid.faces_centers[:, 0:2] - ref_point) @ (np.cos(theta), np.sin(theta))
 
     if 0 <= k*h < 20:
-        cih = np.cosh(k*(result.body.mesh.faces_centers[:, 2]+h))/np.cosh(k*h)
+        cih = np.cosh(k*(result.body.mesh_including_lid.faces_centers[:, 2]+h))/np.cosh(k*h)
     else:
-        cih = np.exp(k*result.body.mesh.faces_centers[:, 2])
+        cih = np.exp(k*result.body.mesh_including_lid.faces_centers[:, 2])
 
-    # cih.shape = (nb_faces,)
-    # omega_bar.T.shape = (nb_theta, nb_faces)
-    # result.body.mesh.faces_areas.shape = (nb_faces,)
-    zs = cih * np.exp(-1j * k * omega_bar.T) * result.body.mesh.faces_areas
+    # cih.shape = (nb_faces_including_lid,)
+    # omega_bar.T.shape = (nb_theta, nb_faces_including_lid)
+    # result.body.mesh.faces_areas.shape = (nb_faces_including_lid,)
+    zs = cih * np.exp(-1j * k * omega_bar.T) * result.body.mesh_including_lid.faces_areas
 
-    # zs.shape = (nb_theta, nb_faces)
-    # result.sources.shape = (nb_faces,)
+    # zs.shape = (nb_theta, nb_faces_including_lid)
+    # result.sources.shape = (nb_faces_including_lid,)
     return zs @ result.sources/(4*np.pi)

capytaine/tools/block_circulant_matrices.py

@@ -0,0 +1,275 @@
+"""Implementation of block circulant matrices to be used for optimizing resolution with symmetries."""
+# Copyright (C) 2025 Capytaine developers
+# See LICENSE file at <https://github.com/capytaine/capytaine>
+
+import logging
+import numpy as np
+from typing import List, Union, Sequence
+from numpy.typing import NDArray, ArrayLike
+import scipy.linalg as sl
+
+LOG = logging.getLogger(__name__)
+
+
+def circular_permutation(l: List, i: int) -> List:
+    return l[-i:] + l[:-i]
+
+
+def leading_dimensions_at_the_end(a):
+    """Transform an array of shape (n, m, ...) into (..., n, m).
+    Invert of `leading_dimensions_at_the_end`"""
+    return np.moveaxis(a, [0, 1], [-2, -1])
+
+
+def ending_dimensions_at_the_beginning(a):
+    """Transform an array of shape (..., n, m) into (n, m, ...).
+    Invert of `leading_dimensions_at_the_end`"""
+    return np.moveaxis(a, [-2, -1], [0, 1])
+
+
+class BlockCirculantMatrix:
+    """Data-sparse representation of a block matrix of the following form
+
+        ( a  d  c  b )
+        ( b  a  d  c )
+        ( c  b  a  d )
+        ( d  c  b  a )
+
+    where a, b, c and d are matrices of the same shape.
+
+    Parameters
+    ----------
+    blocks: Sequence of matrix-like, can be also a ndarray of shape (nb_blocks, n, n, ...)
+        The **first column** of blocks [a, b, c, d, ...]
+        Each block should have the same shape.
+    """
+    def __init__(self, blocks: Sequence[ArrayLike]):
+        self.blocks = blocks
+        self.nb_blocks = len(blocks)
+        assert all(self.blocks[0].shape == b.shape for b in self.blocks[1:])
+        assert all(self.blocks[0].dtype == b.dtype for b in self.blocks[1:])
+        self.shape = (
+            self.nb_blocks*self.blocks[0].shape[0],
+            self.nb_blocks*self.blocks[0].shape[1],
+            *self.blocks[0].shape[2:]
+        )
+        self.ndim = len(self.shape)
+        self.dtype = self.blocks[0].dtype
+
+    def __array__(self, dtype=None, copy=True):
+        if not copy:
+            raise NotImplementedError
+        if dtype is None:
+            dtype = self.dtype
+        full_blocks = [np.asarray(b) for b in self.blocks]  # Transform all blocks to numpy arrays
+        first_row = [full_blocks[0], *(full_blocks[1:][::-1])]
+        if self.ndim >= 3:
+            first_row = [leading_dimensions_at_the_end(b) for b in first_row]
+            # Need to permute_dims to conform to `block` usage when the array is more than 2D
+        full_matrix = np.block([[b for b in circular_permutation(first_row, i)]
+                         for i in range(self.nb_blocks)]).astype(dtype)
+        if self.ndim >= 3:
+            full_matrix = ending_dimensions_at_the_beginning(full_matrix)
+        return full_matrix
+
+    def __add__(self, other):
+        if isinstance(other, BlockCirculantMatrix) and self.shape == other.shape:
+            return BlockCirculantMatrix([a + b for (a, b) in zip(self.blocks, other.blocks)])
+        else:
+            return NotImplemented
+
+    def __sub__(self, other):
+        if isinstance(other, BlockCirculantMatrix) and self.shape == other.shape:
+            return BlockCirculantMatrix([a - b for (a, b) in zip(self.blocks, other.blocks)])
+        else:
+            return NotImplemented
+
+    def __matmul__(self, other):
+        if self.nb_blocks == 2 and isinstance(other, np.ndarray) and other.ndim == 1:
+            a, b = self.blocks
+            x1, x2 = other[:len(other)//2], other[len(other)//2:]
+            y = np.concatenate([a @ x1 + b @ x2, b @ x1 + a @ x2], axis=0)
+            return y
+        elif self.nb_blocks == 3 and isinstance(other, np.ndarray) and other.ndim == 1:
+            a, b, c = self.blocks
+            n = len(other)
+            x1, x2, x3 = other[:n//3], other[n//3:2*n//3], other[2*n//3:]
+            y = np.concatenate([
+                a @ x1 + c @ x2 + b @ x3,
+                b @ x1 + a @ x2 + c @ x3,
+                c @ x1 + b @ x2 + a @ x3,
+            ], axis=0)
+            return y
+        elif isinstance(other, np.ndarray) and other.ndim == 1:
+            self.blocks
+            y = np.zeros(other.shape, dtype=np.result_type(self.dtype, other.dtype))
+            blocks_indices = list(range(self.nb_blocks))
+            for i, x_i in enumerate(np.split(other, self.nb_blocks)):
+                y += np.concatenate([self.blocks[j] @ x_i for j in circular_permutation(blocks_indices, i)])
+            return y
+        else:
+            return NotImplemented
+
+    def matvec(self, other):
+        return self.__matmul__(other)
+
+    def block_diagonalize(self) -> "BlockDiagonalMatrix":
+        if self.ndim == 2 and self.nb_blocks == 2:
+            a, b = self.blocks
+            return BlockDiagonalMatrix([a + b, a - b])
+        elif self.ndim == 2 and self.nb_blocks == 3:
+            a, b, c = self.blocks
+            return BlockDiagonalMatrix([
+                a + b + c,
+                a + np.exp(-2j*np.pi/3, dtype=self.dtype) * b + np.exp(2j*np.pi/3, dtype=self.dtype) * c,
+                a + np.exp(2j*np.pi/3, dtype=self.dtype) * b + np.exp(-2j*np.pi/3, dtype=self.dtype) * c,
+            ])
+        elif self.ndim == 2 and self.nb_blocks == 4:
+            a, b, c, d = self.blocks
+            return BlockDiagonalMatrix([
+                a + b + c + d,
+                a - 1j*b - c + 1j*d,
+                a - b + c - d,
+                a + 1j*b - c - 1j*d,
+            ])
+        elif self.ndim == 2 and all(isinstance(b, np.ndarray) for b in self.blocks):
+            return BlockDiagonalMatrix(np.fft.fft(np.asarray(self.blocks), axis=0))
+        else:
+            raise NotImplementedError()
+
+    def solve(self, b: np.ndarray) -> np.ndarray:
+        LOG.debug("Called solve on %s of shape %s",
+                  self.__class__.__name__, self.shape)
+        n = self.nb_blocks
+        b_fft = np.fft.fft(b.reshape((n, b.shape[0]//n)), axis=0).reshape(b.shape)
+        res_fft = self.block_diagonalize().solve(b_fft)
+        res = np.fft.ifft(res_fft.reshape((n, b.shape[0]//n)), axis=0).reshape(b.shape)
+        LOG.debug("Done")
+        return res
+
+
+class BlockDiagonalMatrix:
+    """Data-sparse representation of a block matrix of the following form
+
+        ( a  0  0  0 )
+        ( 0  b  0  0 )
+        ( 0  0  c  0 )
+        ( 0  0  0  d )
+
+    where a, b, c and d are matrices of the same shape.
+
+    Parameters
+    ----------
+    blocks: iterable of matrix-like
+        The blocks [a, b, c, d, ...]
+    """
+    def __init__(self, blocks: Sequence[ArrayLike]):
+        self.blocks = blocks
+        self.nb_blocks = len(blocks)
+        assert all(blocks[0].shape == b.shape for b in blocks[1:])
+        self.shape = (
+                sum(bl.shape[0] for bl in blocks),
+                sum(bl.shape[1] for bl in blocks)
+                )
+        assert all(blocks[0].dtype == b.dtype for b in blocks[1:])
+        self.dtype = blocks[0].dtype
+
+    def __array__(self, dtype=None, copy=True):
+        if not copy:
+            raise NotImplementedError
+        if dtype is None:
+            dtype = self.dtype
+        full_blocks = [np.asarray(b) for b in self.blocks]  # Transform all blocks to numpy arrays
+        if self.ndim >= 3:
+            full_blocks = [leading_dimensions_at_the_end(b) for b in full_blocks]
+        full_matrix = np.block([
+            [full_blocks[i] if i == j else np.zeros(full_blocks[i].shape)
+             for j in range(self.nb_blocks)]
+            for i in range(self.nb_blocks)])
+        if self.ndim >= 3:
+            full_matrix = ending_dimensions_at_the_beginning(full_matrix)
+        return full_matrix
+
+    def solve(self, b: np.ndarray) -> np.ndarray:
+        LOG.debug("Called solve on %s of shape %s",
+                  self.__class__.__name__, self.shape)
+        n = self.nb_blocks
+        rhs = np.split(b, n)
+        res = [np.linalg.solve(Ai, bi) if isinstance(Ai, np.ndarray) else Ai.solve(bi)
+               for (Ai, bi) in zip(self.blocks, rhs)]
+        LOG.debug("Done")
+        return np.hstack(res)
+
+
+MatrixLike = Union[np.ndarray, BlockDiagonalMatrix, BlockCirculantMatrix]
+
+
+def lu_decompose(A: MatrixLike, *, overwrite_a : bool = False):
+    if isinstance(A, np.ndarray):
+        return LUDecomposedMatrix(A, overwrite_a=overwrite_a)
+    elif isinstance(A, BlockDiagonalMatrix):
+        return LUDecomposedBlockDiagonalMatrix(A, overwrite_a=overwrite_a)
+    elif isinstance(A, BlockCirculantMatrix):
+        return LUDecomposedBlockCirculantMatrix(A, overwrite_a=overwrite_a)
+    else:
+        raise NotImplementedError()
+
+
+class LUDecomposedMatrix:
+    def __init__(self, A: NDArray, *, overwrite_a : bool = False):
+        LOG.debug("LU decomp of %s of shape %s",
+                  A.__class__.__name__, A.shape)
+        self._lu_decomp = sl.lu_factor(A, overwrite_a=overwrite_a)
+        self.shape = A.shape
+        self.dtype = A.dtype
+
+    def solve(self, b: np.ndarray) -> np.ndarray:
+        LOG.debug("Called solve on %s of shape %s",
+                  self.__class__.__name__, self.shape)
+        return sl.lu_solve(self._lu_decomp, b)
+
+
+class LUDecomposedBlockDiagonalMatrix:
+    """LU decomposition of a BlockDiagonalMatrix,
+    stored as the LU decomposition of each block."""
+    def __init__(self, bdm: BlockDiagonalMatrix, *, overwrite_a : bool = False):
+        LOG.debug("LU decomp of %s of shape %s",
+                  bdm.__class__.__name__, bdm.shape)
+        self._lu_decomp = [lu_decompose(bl, overwrite_a=overwrite_a) for bl in bdm.blocks]
+        self.shape = bdm.shape
+        self.nb_blocks = bdm.nb_blocks
+        self.dtype = bdm.dtype
+
+    def solve(self, b: np.ndarray) -> np.ndarray:
+        LOG.debug("Called solve on %s of shape %s",
+                  self.__class__.__name__, self.shape)
+        rhs = np.split(b, self.nb_blocks)
+        res = [Ai.solve(bi) for (Ai, bi) in zip(self._lu_decomp, rhs)]
+        return np.hstack(res)
+
+
+class LUDecomposedBlockCirculantMatrix:
+    def __init__(self, bcm: BlockCirculantMatrix, *, overwrite_a : bool = False):
+        LOG.debug("LU decomp of %s of shape %s",
+                  bcm.__class__.__name__, bcm.shape)
+        self._lu_decomp = lu_decompose(bcm.block_diagonalize(), overwrite_a=overwrite_a)
+        self.shape = bcm.shape
+        self.nb_blocks = bcm.nb_blocks
+        self.dtype = bcm.dtype
+
+    def solve(self, b: np.ndarray) -> np.ndarray:
+        LOG.debug("Called solve on %s of shape %s",
+                  self.__class__.__name__, self.shape)
+        n = self.nb_blocks
+        b_fft = np.fft.fft(b.reshape((n, b.shape[0]//n)), axis=0).reshape(b.shape)
+        res_fft = self._lu_decomp.solve(b_fft)
+        res = np.fft.ifft(res_fft.reshape((n, b.shape[0]//n)), axis=0).reshape(b.shape)
+        return res
+
+
+LUDecomposedMatrixLike = Union[LUDecomposedMatrix, LUDecomposedBlockDiagonalMatrix, LUDecomposedBlockCirculantMatrix]
+
+
+def has_been_lu_decomposed(A):
+    # Python 3.8 does not support isinstance(A, LUDecomposedMatrixLike)
+    return isinstance(A, (LUDecomposedMatrix, LUDecomposedBlockDiagonalMatrix, LUDecomposedBlockCirculantMatrix))

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.mesh_like_protocol import MeshLike
+from capytaine.meshes.abstract_meshes import AbstractMesh
 
 
 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, MeshLike):
+    if isinstance(points, AbstractMesh):
         if keep_mesh:
             return points, (points.nb_faces,)
         else: