capytaine 2.2__cp310-cp310-win_amd64.whl → 2.3__cp310-cp310-win_amd64.whl

capytaine/bem/solver.py

@@ -9,21 +9,24 @@
 
 """
 
+import os
 import logging
 
 import numpy as np
+import pandas as pd
 
 from datetime import datetime
 
 from rich.progress import track
 
-from capytaine.bem.problems_and_results import LinearPotentialFlowProblem
+from capytaine.bem.problems_and_results import LinearPotentialFlowProblem, DiffractionProblem
 from capytaine.green_functions.delhommeau import Delhommeau
 from capytaine.bem.engines import BasicMatrixEngine
 from capytaine.io.xarray import problems_from_dataset, assemble_dataset, kochin_data_array
 from capytaine.tools.optional_imports import silently_import_optional_dependency
 from capytaine.tools.lists_of_points import _normalize_points, _normalize_free_surface_points
 from capytaine.tools.symbolic_multiplication import supporting_symbolic_multiplication
+from capytaine.tools.timer import Timer
 
 LOG = logging.getLogger(__name__)
 
@@ -39,24 +42,39 @@ class BEMSolver:
     engine: MatrixEngine, optional
         Object handling the building of matrices and the resolution of linear systems with these matrices.
         (default: :class:`~capytaine.bem.engines.BasicMatrixEngine`)
+    method: string, optional
+        select boundary integral equation used to solve the problems.
+        Accepted values: "indirect" (as in e.g. Nemoh), "direct" (as in e.g. WAMIT)
+        Default value: "indirect"
 
     Attributes
     ----------
+    timer: dict[str, Timer]
+        Storing the time spent on each subtasks of the resolution
     exportable_settings : dict
         Settings of the solver that can be saved to reinit the same solver later.
     """
 
-    def __init__(self, *, green_function=None, engine=None):
+    def __init__(self, *, green_function=None, engine=None, method="indirect"):
         self.green_function = Delhommeau() if green_function is None else green_function
         self.engine = BasicMatrixEngine() if engine is None else engine
 
+        if method.lower() not in {"direct", "indirect"}:
+            raise ValueError(f"Unrecognized method when initializing solver: {repr(method)}. Expected \"direct\" or \"indirect\".")
+        self.method = method.lower()
+
+        self.timer = {"Solve total": Timer(), "  Green function": Timer(), "  Linear solver": Timer()}
+
+        self.solve = self.timer["Solve total"].wraps_function(self.solve)
+
         try:
             self.exportable_settings = {
                 **self.green_function.exportable_settings,
-                **self.engine.exportable_settings
+                **self.engine.exportable_settings,
+                "method": self.method,
             }
         except AttributeError:
-            pass
+            self.exportable_settings = {}
 
     def __str__(self):
         return f"BEMSolver(engine={self.engine}, green_function={self.green_function})"
@@ -64,6 +82,15 @@ class BEMSolver:
     def __repr__(self):
         return self.__str__()
 
+    def timer_summary(self):
+        return pd.DataFrame([
+            {
+                "task": name,
+                "total": self.timer[name].total,
+                "nb_calls": self.timer[name].nb_timings,
+                "mean": self.timer[name].mean
+            } for name in self.timer]).set_index("task")
+
     def _repr_pretty_(self, p, cycle):
         p.text(self.__str__())
 
@@ -71,7 +98,7 @@ class BEMSolver:
     def from_exported_settings(settings):
         raise NotImplementedError
 
-    def solve(self, problem, method='indirect', keep_details=True, _check_wavelength=True):
+    def solve(self, problem, method=None, keep_details=True, _check_wavelength=True):
         """Solve the linear potential flow problem.
 
         Parameters
@@ -79,12 +106,15 @@ class BEMSolver:
         problem: LinearPotentialFlowProblem
             the problem to be solved
         method: string, optional
-            select boundary integral approach indirect (i.e.Nemoh)/direct (i.e.WAMIT) (default: indirect)
+            select boundary integral equation used to solve the problem.
+            It is recommended to set the method more globally when initializing the solver.
+            If provided here, the value in argument of `solve` overrides the global one.
         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
         -------
@@ -97,33 +127,54 @@ class BEMSolver:
             self._check_wavelength_and_mesh_resolution([problem])
             self._check_wavelength_and_irregular_frequencies([problem])
 
+        if isinstance(problem, DiffractionProblem) and float(problem.encounter_omega) in {0.0, np.inf}:
+            raise ValueError("Diffraction problems at zero or infinite frequency are not defined")
+            # This error used to be raised when initializing the problem.
+            # It is now raised here, in order to be catchable by
+            # _solve_and_catch_errors, such that batch resolution
+            # can include this kind of problems without the full batch
+            # failing.
+            # Note that if this error was not raised here, the resolution
+            # would still fail with a less explicit error message.
+
         if problem.forward_speed != 0.0:
             omega, wavenumber = problem.encounter_omega, problem.encounter_wavenumber
         else:
             omega, wavenumber = problem.omega, problem.wavenumber
 
         linear_solver = supporting_symbolic_multiplication(self.engine.linear_solver)
+        method = method if method is not None else self.method
         if (method == 'direct'):
             if problem.forward_speed != 0.0:
                 raise NotImplementedError("Direct solver is not able to solve problems with forward speed.")
 
-            S, D = self.engine.build_matrices(
-                    problem.body.mesh_including_lid, problem.body.mesh_including_lid,
-                    problem.free_surface, problem.water_depth, wavenumber,
-                    self.green_function, adjoint_double_layer=False
-                    )
-
-            potential = linear_solver(D, S @ problem.boundary_condition)
+            with self.timer["  Green function"]:
+                S, D = self.engine.build_matrices(
+                        problem.body.mesh_including_lid, problem.body.mesh_including_lid,
+                        problem.free_surface, problem.water_depth, wavenumber,
+                        self.green_function, adjoint_double_layer=False
+                        )
+            rhs = S @ problem.boundary_condition
+            with self.timer["  Linear solver"]:
+                potential = linear_solver(D, rhs)
+            if not potential.shape == problem.boundary_condition.shape:
+                raise ValueError(f"Error in linear solver of {self.engine}: the shape of the output ({potential.shape}) "
+                                 f"does not match the expected shape ({problem.boundary_condition.shape})")
             pressure = 1j * omega * problem.rho * potential
             sources = None
         else:
-            S, K = self.engine.build_matrices(
-                    problem.body.mesh_including_lid, problem.body.mesh_including_lid,
-                    problem.free_surface, problem.water_depth, wavenumber,
-                    self.green_function, adjoint_double_layer=True
-                    )
+            with self.timer["  Green function"]:
+                S, K = self.engine.build_matrices(
+                        problem.body.mesh_including_lid, problem.body.mesh_including_lid,
+                        problem.free_surface, problem.water_depth, wavenumber,
+                        self.green_function, adjoint_double_layer=True
+                        )
 
-            sources = linear_solver(K, problem.boundary_condition)
+            with self.timer["  Linear solver"]:
+                sources = linear_solver(K, problem.boundary_condition)
+            if not sources.shape == problem.boundary_condition.shape:
+                raise ValueError(f"Error in linear solver of {self.engine}: the shape of the output ({sources.shape}) "
+                                 f"does not match the expected shape ({problem.boundary_condition.shape})")
             potential = S @ sources
             pressure = 1j * omega * problem.rho * potential
             if problem.forward_speed != 0.0:
@@ -144,7 +195,17 @@ class BEMSolver:
 
         return result
 
-    def solve_all(self, problems, *, method='indirect', n_jobs=1, progress_bar=True, _check_wavelength=True, **kwargs):
+    def _solve_and_catch_errors(self, problem, *args, **kwargs):
+        """Same as BEMSolver.solve() but returns a
+        FailedLinearPotentialFlowResult when the resolution failed."""
+        try:
+            res = self.solve(problem, *args, **kwargs)
+        except Exception as e:
+            LOG.info(f"Skipped {problem}\nbecause of {repr(e)}")
+            res = problem.make_failed_results_container(e)
+        return res
+
+    def solve_all(self, problems, *, method=None, n_jobs=1, progress_bar=None, _check_wavelength=True, **kwargs):
         """Solve several problems.
         Optional keyword arguments are passed to `BEMSolver.solve`.
 
@@ -153,12 +214,20 @@ class BEMSolver:
         problems: list of LinearPotentialFlowProblem
             several problems to be solved
         method: string, optional
-            select boundary integral approach indirect (i.e.Nemoh)/direct (i.e.WAMIT) (default: indirect)
+            select boundary integral equation used to solve the problems.
+            It is recommended to set the method more globally when initializing the solver.
+            If provided here, the value in argument of `solve_all` overrides the global one.
         n_jobs: int, optional (default: 1)
             the number of jobs to run in parallel using the optional dependency `joblib`
             By defaults: do not use joblib and solve sequentially.
-        progress_bar: bool, optional (default: True)
-            Display a progress bar while solving
+        progress_bar: bool, optional
+            Display a progress bar while solving.
+            If no value is provided to this method directly,
+            check whether the environment variable `CAPYTAINE_PROGRESS_BAR` is defined
+            and otherwise default to True.
+        _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
         -------
@@ -169,11 +238,23 @@ class BEMSolver:
             self._check_wavelength_and_mesh_resolution(problems)
             self._check_wavelength_and_irregular_frequencies(problems)
 
+        if progress_bar is None:
+            if "CAPYTAINE_PROGRESS_BAR" in os.environ:
+                env_var = os.environ["CAPYTAINE_PROGRESS_BAR"].lower()
+                if env_var in {'true', '1', 't'}:
+                    progress_bar = True
+                elif env_var in {'false', '0', 'f'}:
+                    progress_bar = False
+                else:
+                    raise ValueError("Invalid value '{}' for the environment variable CAPYTAINE_PROGRESS_BAR.".format(os.environ["CAPYTAINE_PROGRESS_BAR"]))
+            else:
+                progress_bar = True
+
         if n_jobs == 1:  # force sequential resolution
             problems = sorted(problems)
             if progress_bar:
                 problems = track(problems, total=len(problems), description="Solving BEM problems")
-            return [self.solve(pb, method=method, _check_wavelength=False, **kwargs) for pb in problems]
+            results = [self._solve_and_catch_errors(pb, method=method, _check_wavelength=False, **kwargs) for pb in problems]
         else:
             joblib = silently_import_optional_dependency("joblib")
             if joblib is None:
@@ -186,12 +267,14 @@ class BEMSolver:
                                           total=len(groups_of_problems),
                                           description=f"Solving BEM problems with {n_jobs} threads:")
             results = [res for grp in groups_of_results for res in grp]  # flatten the nested list
-            return results
+        LOG.info("Solver timer summary:\n%s", self.timer_summary())
+        return results
 
     @staticmethod
     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 +301,10 @@ 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.free_surface != np.inf and
+                          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 +329,7 @@ class BEMSolver:
                             + recommendation
                             )
 
-    def fill_dataset(self, dataset, bodies, *, method='indirect', n_jobs=1, **kwargs):
+    def fill_dataset(self, dataset, bodies, *, method=None, n_jobs=1, _check_wavelength=True, progress_bar=None, **kwargs):
         """Solve a set of problems defined by the coordinates of an xarray dataset.
 
         Parameters
@@ -255,12 +340,20 @@ class BEMSolver:
             The body or bodies involved in the problems
             They should all have different names.
         method: string, optional
-            select boundary integral approach indirect (i.e.Nemoh)/direct (i.e.WAMIT) (default: indirect)
+            select boundary integral equation used to solve the problems.
+            It is recommended to set the method more globally when initializing the solver.
+            If provided here, the value in argument of `fill_dataset` overrides the global one.
         n_jobs: int, optional (default: 1)
             the number of jobs to run in parallel using the optional dependency `joblib`
             By defaults: do not use joblib and solve sequentially.
-        progress_bar: bool, optional (default: True)
-            Display a progress bar while solving
+        progress_bar: bool, optional
+            Display a progress bar while solving.
+            If no value is provided to this method directly,
+            check whether the environment variable `CAPYTAINE_PROGRESS_BAR` is defined
+            and otherwise default to True.
+        _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
         -------
@@ -268,14 +361,16 @@ class BEMSolver:
         """
         attrs = {'start_of_computation': datetime.now().isoformat(),
                  **self.exportable_settings}
+        if method is not None:  # Overrides the method in self.exportable_settings
+            attrs["method"] = method
         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, progress_bar=progress_bar)
             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, progress_bar=progress_bar)
             dataset = assemble_dataset(results, attrs=attrs, **kwargs)
         return dataset
 
@@ -285,7 +380,7 @@ class BEMSolver:
 
         Parameters
         ----------
-        points: array of shape (3,) or (N, 3), or 3-ple of arrays returned by meshgrid, or cpt.Mesh or cpt.CollectionOfMeshes object
+        points: array of shape (3,) or (N, 3), or 3-ple of arrays returned by meshgrid, or MeshLike object
             Coordinates of the point(s) at which the potential should be computed
         result: LinearPotentialFlowResult
             The return of the BEM solver
@@ -305,7 +400,8 @@ class BEMSolver:
             They probably have not been stored by the solver because the option keep_details=True have not been set or the direct method has been used.
             Please re-run the resolution with the indirect method and keep_details=True.""")
 
-        S, _ = self.green_function.evaluate(points, result.body.mesh_including_lid, result.free_surface, result.water_depth, result.encounter_wavenumber)
+        with self.timer["  Green function"]:
+            S, _ = self.green_function.evaluate(points, result.body.mesh_including_lid, result.free_surface, result.water_depth, result.encounter_wavenumber)
         potential = S @ result.sources  # Sum the contributions of all panels in the mesh
         return potential.reshape(output_shape)
 
@@ -317,7 +413,8 @@ class BEMSolver:
             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.""")
 
-        _, gradG = self.green_function.evaluate(points, result.body.mesh_including_lid, result.free_surface, result.water_depth, result.encounter_wavenumber,
+        with self.timer["  Green function"]:
+            _, gradG = self.green_function.evaluate(points, result.body.mesh_including_lid, result.free_surface, result.water_depth, result.encounter_wavenumber,
                                                 early_dot_product=False)
         velocities = np.einsum('ijk,j->ik', gradG, result.sources)  # Sum the contributions of all panels in the mesh
         return velocities.reshape((*output_shape, 3))
@@ -327,7 +424,7 @@ class BEMSolver:
 
         Parameters
         ----------
-        points: array of shape (3,) or (N, 3), or 3-ple of arrays returned by meshgrid, or cpt.Mesh or cpt.CollectionOfMeshes object
+        points: array of shape (3,) or (N, 3), or 3-ple of arrays returned by meshgrid, or MeshLike object
             Coordinates of the point(s) at which the velocity should be computed
         result: LinearPotentialFlowResult
             The return of the BEM solver
@@ -351,7 +448,7 @@ class BEMSolver:
 
         Parameters
         ----------
-        points: array of shape (3,) or (N, 3), or 3-ple of arrays returned by meshgrid, or cpt.Mesh or cpt.CollectionOfMeshes object
+        points: array of shape (3,) or (N, 3), or 3-ple of arrays returned by meshgrid, or MeshLike object
             Coordinates of the point(s) at which the pressure should be computed
         result: LinearPotentialFlowResult
             The return of the BEM solver
@@ -379,7 +476,7 @@ class BEMSolver:
 
         Parameters
         ----------
-        points: array of shape (2,) or (N, 2), or 2-ple of arrays returned by meshgrid, or cpt.Mesh or cpt.CollectionOfMeshes object
+        points: array of shape (2,) or (N, 2), or 2-ple of arrays returned by meshgrid, or MeshLike object
             Coordinates of the point(s) at which the free surface elevation should be computed
         result: LinearPotentialFlowResult
             The return of the BEM solver
@@ -418,7 +515,7 @@ class BEMSolver:
         ----------
         result : LinearPotentialFlowResult
             the return of the BEM solver
-        mesh : Mesh or CollectionOfMeshes
+        mesh : MeshLike
             a mesh
         chunk_size: int, optional
             Number of lines to compute in the matrix.

capytaine/bodies/bodies.py

@@ -5,11 +5,12 @@
 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
 
+from capytaine.meshes.mesh_like_protocol import MeshLike
 from capytaine.meshes.collections import CollectionOfMeshes
 from capytaine.meshes.geometry import Abstract3DObject, ClippableMixin, Plane, inplace_transformation
 from capytaine.meshes.properties import connected_components, connected_components_of_waterline
@@ -39,10 +40,10 @@ class FloatingBody(ClippableMixin, Abstract3DObject):
 
     Parameters
     ----------
-    mesh : Mesh or CollectionOfMeshes, optional
+    mesh : MeshLike, optional
         the mesh describing the geometry of the hull of the floating body.
         If none is given, a empty one is created.
-    lid_mesh : Mesh or CollectionOfMeshes or None, optional
+    lid_mesh : MeshLike or None, optional
         a mesh of an internal lid for irregular frequencies removal.
         Unlike the mesh of the hull, no dof is defined on the lid_mesh.
         If none is given, none is used when solving the Boundary Integral Equation.
@@ -69,21 +70,28 @@ class FloatingBody(ClippableMixin, Abstract3DObject):
             from capytaine.io.meshio import load_from_meshio
             self.mesh = load_from_meshio(mesh)
 
-        elif isinstance(mesh, Mesh) or isinstance(mesh, CollectionOfMeshes):
+        elif isinstance(mesh, MeshLike):
             self.mesh = mesh
 
         else:
             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
 
         if name is None and mesh is None:
             self.name = "dummy_body"
         elif name is None:
-            self.name = self.mesh.name
+            if hasattr(self.mesh, "name"):
+                self.name = self.mesh.name
+            else:
+                self.name = "anonymous_body"
         else:
             self.name = name
 
@@ -93,7 +101,7 @@ class FloatingBody(ClippableMixin, Abstract3DObject):
         else:
             self.center_of_mass = None
 
-        if self.mesh.nb_vertices > 0 and self.mesh.nb_faces > 0:
+        if hasattr(self.mesh, "heal_mesh") and self.mesh.nb_vertices > 0 and self.mesh.nb_faces > 0:
             self.mesh.heal_mesh()
 
         if dofs is None:
@@ -108,6 +116,8 @@ class FloatingBody(ClippableMixin, Abstract3DObject):
 
         LOG.info(f"New floating body: {self.__str__()}.")
 
+        self._check_dofs_shape_consistency()
+
     @staticmethod
     def from_meshio(mesh, name=None) -> 'FloatingBody':
         """Create a FloatingBody from a meshio mesh object.
@@ -131,7 +141,7 @@ class FloatingBody(ClippableMixin, Abstract3DObject):
     @cached_property
     def mesh_including_lid(self):
         if self.lid_mesh is not None:
-            return CollectionOfMeshes([self.mesh, self.lid_mesh])
+            return self.mesh.join_meshes(self.lid_mesh)
         else:
             return self.mesh
 
@@ -260,6 +270,14 @@ class FloatingBody(ClippableMixin, Abstract3DObject):
                             coords={'influenced_dof': list(self.dofs), 'radiating_dof': list(self.dofs)},
                             )
 
+    def _check_dofs_shape_consistency(self):
+        for dof_name, dof in self.dofs.items():
+            if np.array(dof).shape != (self.mesh.nb_faces, 3):
+                raise ValueError(f"The array defining the dof {dof_name} of body {self.name} does not have the expected shape.\n"
+                                 f"Expected shape: ({self.mesh.nb_faces}, 3)\n"
+                                 f"  Actual shape: {dof.shape}")
+
+
     ###################
     # Hydrostatics #
     ###################
@@ -752,14 +770,14 @@ respective inertia coefficients are assigned as NaN.")
         if name is None:
             name = "+".join(body.name for body in bodies)
         meshes = CollectionOfMeshes(
-                [body.mesh for body in bodies],
+                [body.mesh.copy() for body in bodies],
                 name=f"{name}_mesh"
                 )
         if all(body.lid_mesh is None for body in bodies):
             lid_meshes = None
         else:
             lid_meshes = CollectionOfMeshes(
-                    [body.lid_mesh for body in bodies if body.lid_mesh is not None],
+                    [body.lid_mesh.copy() for body in bodies if body.lid_mesh is not None],
                     name=f"{name}_lid_mesh"
                     )
         dofs = FloatingBody.combine_dofs(bodies)
@@ -792,6 +810,8 @@ respective inertia coefficients are assigned as NaN.")
     @staticmethod
     def combine_dofs(bodies) -> dict:
         """Combine the degrees of freedom of several bodies."""
+        for body in bodies:
+            body._check_dofs_shape_consistency()
         dofs = {}
         cum_nb_faces = accumulate(chain([0], (body.mesh.nb_faces for body in bodies)))
         total_nb_faces = sum(body.mesh.nb_faces for body in bodies)
@@ -819,6 +839,8 @@ respective inertia coefficients are assigned as NaN.")
         name : str, optional
             a name for the new copy
         """
+        self._check_dofs_shape_consistency()
+
         new_body = copy.deepcopy(self)
         if name is None:
             new_body.name = f"copy_of_{self.name}"
@@ -874,9 +896,9 @@ respective inertia coefficients are assigned as NaN.")
             raise NotImplementedError  # TODO
 
         if return_index:
-            new_mesh, id_v = Mesh.extract_faces(self.mesh, id_faces_to_extract, return_index)
+            new_mesh, id_v = self.mesh.extract_faces(id_faces_to_extract, return_index)
         else:
-            new_mesh = Mesh.extract_faces(self.mesh, id_faces_to_extract, return_index)
+            new_mesh = self.mesh.extract_faces(id_faces_to_extract, return_index)
         new_body = FloatingBody(new_mesh)
         LOG.info(f"Extract floating body from {self.name}.")
 
@@ -991,11 +1013,16 @@ respective inertia coefficients are assigned as NaN.")
 
     @inplace_transformation
     def clip(self, plane):
+        self._check_dofs_shape_consistency()
+
         # Clip mesh
         LOG.info(f"Clipping {self.name} with respect to {plane}")
         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 +1127,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/bodies/predefined/rectangles.py

@@ -101,6 +101,8 @@ class RectangularParallelepiped(FloatingBody):
                 translation_symmetry=translational_symmetry, reflection_symmetry=reflection_symmetry,
                 name=f"{name}_mesh")
 
+        self.geometric_center = np.asarray(center, dtype=float)
+
         FloatingBody.__init__(self, mesh=mesh, name=name)
 
 class OpenRectangularParallelepiped(RectangularParallelepiped):

capytaine/green_functions/FinGreen3D/.gitignore

@@ -0,0 +1 @@
+build/