capytaine 2.1__cp311-cp311-macosx_10_9_x86_64.whl → 2.2__cp311-cp311-macosx_10_9_x86_64.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.1"
+__version__ = "2.2"
 
 __author__ = "Matthieu Ancellin"
 __uri__ = "https://github.com/capytaine/capytaine"

capytaine/bem/problems_and_results.py

@@ -193,7 +193,7 @@ class LinearPotentialFlowProblem:
                     or len(self.body.mesh.faces) == 0):
                 raise ValueError(f"The mesh of the body {self.body.__short_str__()} is empty.")
 
-            panels_above_fs = self.body.mesh.faces_centers[:, 2] >= self.free_surface
+            panels_above_fs = self.body.mesh.faces_centers[:, 2] >= self.free_surface + 1e-8
             panels_below_sb = self.body.mesh.faces_centers[:, 2] <= -self.water_depth
             if (any(panels_above_fs) or any(panels_below_sb)):
 
@@ -218,7 +218,7 @@ class LinearPotentialFlowProblem:
             if len(self.boundary_condition.shape) != 1:
                 raise ValueError(f"Expected a 1-dimensional array as boundary_condition. Provided boundary condition's shape: {self.boundary_condition.shape}.")
 
-            if self.boundary_condition.shape[0] != self.body.mesh.nb_faces:
+            if self.boundary_condition.shape[0] != self.body.mesh_including_lid.nb_faces:
                 raise ValueError(
                     f"The shape of the boundary condition ({self.boundary_condition.shape})"
                     f"does not match the number of faces of the mesh ({self.body.mesh.nb_faces})."
@@ -256,7 +256,7 @@ class LinearPotentialFlowProblem:
     def __str__(self):
         """Do not display default values in str(problem)."""
         parameters = [f"body={self.body.__short_str__() if self.body is not None else None}",
-                      f"{self.provided_freq_type}={self.__getattribute__(self.provided_freq_type):.3f}",
+                      f"{self.provided_freq_type}={float(self.__getattribute__(self.provided_freq_type)):.3f}",
                       f"water_depth={self.water_depth}"]
 
         if not self.forward_speed == _default_parameters['forward_speed']:
@@ -345,7 +345,7 @@ class DiffractionProblem(LinearPotentialFlowProblem):
                          forward_speed=forward_speed, rho=rho, g=g)
 
         if float(self.omega) in {0.0, np.inf}:
-            raise NotImplementedError(f"DiffractionProblem does not support zero or infinite frequency.")
+            raise NotImplementedError("DiffractionProblem does not support zero or infinite frequency.")
 
         if self.body is not None:
 
@@ -356,6 +356,9 @@ class DiffractionProblem(LinearPotentialFlowProblem):
             # Note that even with forward speed, this is computed based on the
             # frequency and not the encounter frequency.
 
+            if self.body.lid_mesh is not None:
+                self.boundary_condition = np.concatenate([self.boundary_condition, np.zeros(self.body.lid_mesh.nb_faces)])
+
             if len(self.body.dofs) == 0:
                 LOG.warning(f"The body {self.body.name} used in diffraction problem has no dofs!")
 
@@ -398,10 +401,9 @@ class RadiationProblem(LinearPotentialFlowProblem):
                 self.radiating_dof = next(iter(self.body.dofs))
 
             if self.radiating_dof not in self.body.dofs:
-                LOG.error(f"In {self}: the radiating degree of freedom {self.radiating_dof} is not one of"
-                          f"the degrees of freedom of the body.\n"
-                          f"The dofs of the body are {list(self.body.dofs.keys())}")
-                raise ValueError("Unrecognized degree of freedom name.")
+                raise ValueError(f"In {self}:\n"
+                                 f"the radiating dof {repr(self.radiating_dof)} is not one of the degrees of freedom of the body.\n"
+                                 f"The dofs of the body are {list(self.body.dofs.keys())}")
 
             dof = self.body.dofs[self.radiating_dof]
 
@@ -422,6 +424,9 @@ class RadiationProblem(LinearPotentialFlowProblem):
                             )
                 self.boundary_condition += self.forward_speed * ddofdx_dot_n
 
+            if self.body.lid_mesh is not None:
+                self.boundary_condition = np.concatenate([self.boundary_condition, np.zeros(self.body.lid_mesh.nb_faces)])
+
 
     def _astuple(self):
         return super()._astuple() + (self.radiating_dof,)

capytaine/bem/solver.py

@@ -1,5 +1,5 @@
-# Copyright (C) 2017-2019 Matthieu Ancellin
-# See LICENSE file at <https://github.com/mancellin/capytaine>
+# Copyright (C) 2017-2024 Matthieu Ancellin
+# See LICENSE file at <https://github.com/capytaine/capytaine>
 """Solver for the BEM problem.
 
 .. code-block:: python
@@ -93,7 +93,9 @@ class BEMSolver:
         """
         LOG.info("Solve %s.", problem)
 
-        if _check_wavelength: self._check_wavelength([problem])
+        if _check_wavelength:
+            self._check_wavelength_and_mesh_resolution([problem])
+            self._check_wavelength_and_irregular_frequencies([problem])
 
         if problem.forward_speed != 0.0:
             omega, wavenumber = problem.encounter_omega, problem.encounter_wavenumber
@@ -106,7 +108,7 @@ class BEMSolver:
                 raise NotImplementedError("Direct solver is not able to solve problems with forward speed.")
 
             S, D = self.engine.build_matrices(
-                    problem.body.mesh, problem.body.mesh,
+                    problem.body.mesh_including_lid, problem.body.mesh_including_lid,
                     problem.free_surface, problem.water_depth, wavenumber,
                     self.green_function, adjoint_double_layer=False
                     )
@@ -116,7 +118,7 @@ class BEMSolver:
             sources = None
         else:
             S, K = self.engine.build_matrices(
-                    problem.body.mesh, problem.body.mesh,
+                    problem.body.mesh_including_lid, problem.body.mesh_including_lid,
                     problem.free_surface, problem.water_depth, wavenumber,
                     self.green_function, adjoint_double_layer=True
                     )
@@ -127,10 +129,11 @@ class BEMSolver:
             if problem.forward_speed != 0.0:
                 result = problem.make_results_container(sources=sources)
                 # Temporary result object to compute the ∇Φ term
-                nabla_phi = self._compute_potential_gradient(problem.body.mesh, result)
+                nabla_phi = self._compute_potential_gradient(problem.body.mesh_including_lid, result)
                 pressure += problem.rho * problem.forward_speed * nabla_phi[:, 0]
 
-        forces = problem.body.integrate_pressure(pressure)
+        pressure_on_hull = pressure[:problem.body.mesh.nb_faces]  # Discards pressure on lid if any
+        forces = problem.body.integrate_pressure(pressure_on_hull)
 
         if not keep_details:
             result = problem.make_results_container(forces)
@@ -162,7 +165,9 @@ class BEMSolver:
         list of LinearPotentialFlowResult
             the solved problems
         """
-        if _check_wavelength: self._check_wavelength(problems)
+        if _check_wavelength:
+            self._check_wavelength_and_mesh_resolution(problems)
+            self._check_wavelength_and_irregular_frequencies(problems)
 
         if n_jobs == 1:  # force sequential resolution
             problems = sorted(problems)
@@ -184,31 +189,60 @@ class BEMSolver:
             return results
 
     @staticmethod
-    def _check_wavelength(problems):
+    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."""
         risky_problems = [pb for pb in problems
-                          if pb.wavelength < pb.body.minimal_computable_wavelength]
+                          if 0.0 < pb.wavelength < pb.body.minimal_computable_wavelength]
         nb_risky_problems = len(risky_problems)
         if nb_risky_problems == 1:
             pb = risky_problems[0]
             freq_type = risky_problems[0].provided_freq_type
             freq = pb.__getattribute__(freq_type)
             LOG.warning(f"Mesh resolution for {pb}:\n"
-                    f"The resolution of the mesh of the body {pb.body.__short_str__()} might "
-                    f"be insufficient for {freq_type}={freq}.\n"
-                     "This warning appears because the largest panel of this mesh "
-                    f"has radius {pb.body.mesh.faces_radiuses.max():.3f} > wavelength/8."
-                    )
+                        f"The resolution of the mesh of the body {pb.body.__short_str__()} might "
+                        f"be insufficient for {freq_type}={freq}.\n"
+                        "This warning appears because the largest panel of this mesh "
+                        f"has radius {pb.body.mesh.faces_radiuses.max():.3f} > wavelength/8."
+                        )
         elif nb_risky_problems > 1:
             freq_type = risky_problems[0].provided_freq_type
             freqs = np.array([float(pb.__getattribute__(freq_type)) for pb in risky_problems])
             LOG.warning(f"Mesh resolution for {nb_risky_problems} problems:\n"
-                         "The resolution of the mesh might be insufficient "
+                        "The resolution of the mesh might be insufficient "
                         f"for {freq_type} ranging from {freqs.min():.3f} to {freqs.max():.3f}.\n"
-                         "This warning appears when the largest panel of this mesh "
-                         "has radius > wavelength/8."
-                    )
+                        "This warning appears when the largest panel of this mesh "
+                        "has radius > wavelength/8."
+                        )
+
+    @staticmethod
+    def _check_wavelength_and_irregular_frequencies(problems):
+        """Display a warning if some of the problems might encounter irregular frequencies."""
+        risky_problems = [pb for pb in problems
+                          if pb.body.first_irregular_frequency_estimate() < 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):
+                recommendation = "Setting a lid for the floating body is recommended."
+            else:
+                recommendation = "The lid might need to be closer to the free surface."
+            if nb_risky_problems == 1:
+                pb = risky_problems[0]
+                freq_type = risky_problems[0].provided_freq_type
+                freq = pb.__getattribute__(freq_type)
+                LOG.warning(f"Irregular frequencies for {pb}:\n"
+                            f"The body {pb.body.__short_str__()} might display irregular frequencies "
+                            f"for {freq_type}={freq}.\n"
+                            + recommendation
+                            )
+            elif nb_risky_problems > 1:
+                freq_type = risky_problems[0].provided_freq_type
+                freqs = np.array([float(pb.__getattribute__(freq_type)) for pb in risky_problems])
+                LOG.warning(f"Irregular frequencies for {nb_risky_problems} problems:\n"
+                            "Irregular frequencies might be encountered "
+                            f"for {freq_type} ranging from {freqs.min():.3f} to {freqs.max():.3f}.\n"
+                            + recommendation
+                            )
 
     def fill_dataset(self, dataset, bodies, *, method='indirect', n_jobs=1, **kwargs):
         """Solve a set of problems defined by the coordinates of an xarray dataset.
@@ -271,7 +305,7 @@ 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, result.free_surface, result.water_depth, result.encounter_wavenumber)
+        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)
 
@@ -283,7 +317,7 @@ 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, result.free_surface, result.water_depth, result.encounter_wavenumber,
+        _, 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))
@@ -409,7 +443,7 @@ class BEMSolver:
         if chunk_size > mesh.nb_faces:
             S = self.engine.build_S_matrix(
                 mesh,
-                result.body.mesh,
+                result.body.mesh_including_lid,
                 result.free_surface, result.water_depth, result.wavenumber,
                 self.green_function
             )
@@ -421,7 +455,7 @@ class BEMSolver:
                 faces_to_extract = list(range(i, min(i+chunk_size, mesh.nb_faces)))
                 S = self.engine.build_S_matrix(
                     mesh.extract_faces(faces_to_extract),
-                    result.body.mesh,
+                    result.body.mesh_including_lid,
                     result.free_surface, result.water_depth, result.wavenumber,
                     self.green_function
                 )

capytaine/bodies/bodies.py

@@ -1,23 +1,25 @@
 """Floating bodies to be used in radiation-diffraction problems."""
-# Copyright (C) 2017-2019 Matthieu Ancellin
-# See LICENSE file at <https://github.com/mancellin/capytaine>
+# Copyright (C) 2017-2024 Matthieu Ancellin
+# See LICENSE file at <https://github.com/capytaine/capytaine>
 
 import logging
 import copy
 from itertools import chain, accumulate, zip_longest
+from functools import cached_property
 
 import numpy as np
 import xarray as xr
 
-from capytaine.tools.optional_imports import silently_import_optional_dependency
-meshio = silently_import_optional_dependency("meshio")
-
+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
 from capytaine.meshes.meshes import Mesh
 from capytaine.meshes.symmetric import build_regular_array_of_meshes
-from capytaine.meshes.collections import CollectionOfMeshes
 from capytaine.bodies.dofs import RigidBodyDofsPlaceholder
 
+from capytaine.tools.optional_imports import silently_import_optional_dependency
+meshio = silently_import_optional_dependency("meshio")
+
 LOG = logging.getLogger(__name__)
 
 TRANSLATION_DOFS_DIRECTIONS = {"surge": (1, 0, 0), "sway": (0, 1, 0), "heave": (0, 0, 1)}
@@ -38,8 +40,12 @@ class FloatingBody(ClippableMixin, Abstract3DObject):
     Parameters
     ----------
     mesh : Mesh or CollectionOfMeshes, optional
-        the mesh describing the geometry of the floating body.
+        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
+        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.
     dofs : dict, optional
         the degrees of freedom of the body.
         If none is given, a empty dictionary is initialized.
@@ -55,7 +61,7 @@ class FloatingBody(ClippableMixin, Abstract3DObject):
         If none is given, the one of the mesh is used.
     """
 
-    def __init__(self, mesh=None, dofs=None, mass=None, center_of_mass=None, name=None):
+    def __init__(self, mesh=None, dofs=None, mass=None, center_of_mass=None, name=None, *, lid_mesh=None):
         if mesh is None:
             self.mesh = Mesh(name="dummy_mesh")
 
@@ -69,6 +75,11 @@ class FloatingBody(ClippableMixin, Abstract3DObject):
         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)
+        else:
+            self.lid_mesh = None
+
         if name is None and mesh is None:
             self.name = "dummy_body"
         elif name is None:
@@ -99,13 +110,15 @@ class FloatingBody(ClippableMixin, Abstract3DObject):
 
     @staticmethod
     def from_meshio(mesh, name=None) -> 'FloatingBody':
-        """Create a FloatingBody from a meshio mesh object."""
+        """Create a FloatingBody from a meshio mesh object.
+        Kinda deprecated, use cpt.load_mesh instead."""
         from capytaine.io.meshio import load_from_meshio
         return FloatingBody(mesh=load_from_meshio(mesh, name), name=name)
 
     @staticmethod
     def from_file(filename: str, file_format=None, name=None) -> 'FloatingBody':
-        """Create a FloatingBody from a mesh file using meshmagick."""
+        """Create a FloatingBody from a mesh file using meshmagick.
+        Kinda deprecated, use cpt.load_mesh instead."""
         from capytaine.io.mesh_loaders import load_mesh
         if name is None: name = filename
         mesh = load_mesh(filename, file_format, name=f"{name}_mesh")
@@ -115,6 +128,13 @@ class FloatingBody(ClippableMixin, Abstract3DObject):
         """Arbitrary order. The point is to sort together the problems involving the same body."""
         return self.name < other.name
 
+    @cached_property
+    def mesh_including_lid(self):
+        if self.lid_mesh is not None:
+            return CollectionOfMeshes([self.mesh, self.lid_mesh])
+        else:
+            return self.mesh
+
     ##########
     #  Dofs  #
     ##########
@@ -173,7 +193,7 @@ class FloatingBody(ClippableMixin, Abstract3DObject):
                     if hasattr(self, point_attr) and getattr(self, point_attr) is not None:
                         axis_point = getattr(self, point_attr)
                         LOG.info(f"The rotation dof {name} has been initialized around the point: "
-                                 f"FloatingBody(..., name={self.name}).{point_attr} = {getattr(self, point_attr)}")
+                                 f"{self.__short_str__()}.{point_attr} = {getattr(self, point_attr)}")
                         break
                 else:
                     axis_point = np.array([0, 0, 0])
@@ -267,7 +287,7 @@ class FloatingBody(ClippableMixin, Abstract3DObject):
         """Returns volume of the FloatingBody."""
         return self.mesh.volume
 
-    def disp_mass(self, *, rho=1000):
+    def disp_mass(self, *, rho=1000.0):
         return self.mesh.disp_mass(rho=rho)
 
     @property
@@ -512,7 +532,9 @@ class FloatingBody(ClippableMixin, Abstract3DObject):
             raise AttributeError("Cannot compute hydrostatics stiffness on {} since no dof has been defined.".format(self.name))
 
         def divergence_dof(influenced_dof):
-            if divergence is None:
+            if influenced_dof.lower() in [*TRANSLATION_DOFS_DIRECTIONS, *ROTATION_DOFS_AXIS]:
+                return 0.0  # Dummy value that is not actually used afterwards.
+            elif divergence is None:
                 return 0.0
             elif isinstance(divergence, dict) and influenced_dof in divergence.keys():
                 return divergence[influenced_dof]
@@ -536,7 +558,7 @@ class FloatingBody(ClippableMixin, Abstract3DObject):
         K = hs_set.hydrostatic_stiffness.sel(influenced_dof=list(self.dofs.keys()), radiating_dof=list(self.dofs.keys()))
         return K
 
-    def compute_rigid_body_inertia(self, *, rho=1000, output_type="body_dofs"):
+    def compute_rigid_body_inertia(self, *, rho=1000.0, output_type="body_dofs"):
         """
         Inertia Mass matrix of the body for 6 rigid DOFs.
 
@@ -626,8 +648,8 @@ class FloatingBody(ClippableMixin, Abstract3DObject):
 
         if output_type == "body_dofs":
             if len(non_rigid_dofs) > 0:
-                LOG.warning(f"Non-rigid dofs: {non_rigid_dofs} are detected and \
-respective inertia coefficients are assigned as NaN.")
+                LOG.warning(f"Non-rigid dofs {non_rigid_dofs} detected: their \
+inertia coefficients are assigned as NaN.")
 
             inertia_matrix_xr = total_mass_xr.sel(influenced_dof=body_dof_names,
                                                   radiating_dof=body_dof_names)
@@ -729,7 +751,17 @@ respective inertia coefficients are assigned as NaN.")
     def join_bodies(*bodies, name=None) -> 'FloatingBody':
         if name is None:
             name = "+".join(body.name for body in bodies)
-        meshes = CollectionOfMeshes([body.mesh for body in bodies], name=f"{name}_mesh")
+        meshes = CollectionOfMeshes(
+                [body.mesh 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],
+                    name=f"{name}_lid_mesh"
+                    )
         dofs = FloatingBody.combine_dofs(bodies)
 
         if all(body.mass is not None for body in bodies):
@@ -744,7 +776,8 @@ respective inertia coefficients are assigned as NaN.")
             new_cog = None
 
         joined_bodies = FloatingBody(
-            mesh=meshes, dofs=dofs, mass=new_mass, center_of_mass=new_cog, name=name
+            mesh=meshes, lid_mesh=lid_meshes, dofs=dofs,
+            mass=new_mass, center_of_mass=new_cog, name=name
             )
 
         for matrix_name in ["inertia_matrix", "hydrostatic_stiffness"]:
@@ -820,7 +853,6 @@ respective inertia coefficients are assigned as NaN.")
         if not isinstance(locations, np.ndarray):
             raise TypeError('locations must be of type np.ndarray')
         assert locations.shape[1] == 2, 'locations must be of shape nx2, received {:}'.format(locations.shape)
-        n = locations.shape[0]
 
         fb_list = []
         for idx, li in enumerate(locations):
@@ -836,6 +868,7 @@ respective inertia coefficients are assigned as NaN.")
     def extract_faces(self, id_faces_to_extract, return_index=False):
         """Create a new FloatingBody by extracting some faces from the mesh.
         The dofs evolve accordingly.
+        The lid_mesh, center_of_mass, mass and hydrostatics data are discarded.
         """
         if isinstance(self.mesh, CollectionOfMeshes):
             raise NotImplementedError  # TODO
@@ -857,7 +890,12 @@ respective inertia coefficients are assigned as NaN.")
             return new_body
 
     def sliced_by_plane(self, plane):
-        return FloatingBody(mesh=self.mesh.sliced_by_plane(plane), dofs=self.dofs, name=self.name)
+        """Return the same body, but replace the mesh by a set of two meshes
+        corresponding to each sides of the plane."""
+        return FloatingBody(mesh=self.mesh.sliced_by_plane(plane),
+                            lid_mesh=self.lid_mesh.sliced_by_plane(plane)
+                                        if self.lid_mesh is not None else None,
+                            dofs=self.dofs, name=self.name)
 
     def minced(self, nb_slices=(8, 8, 4)):
         """Experimental method decomposing the mesh as a hierarchical structure.
@@ -918,6 +956,8 @@ respective inertia coefficients are assigned as NaN.")
     @inplace_transformation
     def mirror(self, plane):
         self.mesh.mirror(plane)
+        if self.lid_mesh is not None:
+            self.lid_mesh.mirror(plane)
         for dof in self.dofs:
             self.dofs[dof] -= 2 * np.outer(np.dot(self.dofs[dof], plane.normal), plane.normal)
         for point_attr in ('geometric_center', 'rotation_center', 'center_of_mass'):
@@ -930,6 +970,8 @@ respective inertia coefficients are assigned as NaN.")
     @inplace_transformation
     def translate(self, vector, *args, **kwargs):
         self.mesh.translate(vector, *args, **kwargs)
+        if self.lid_mesh is not None:
+            self.lid_mesh.translate(vector, *args, **kwargs)
         for point_attr in ('geometric_center', 'rotation_center', 'center_of_mass'):
             if point_attr in self.__dict__ and self.__dict__[point_attr] is not None:
                 self.__dict__[point_attr] = np.array(self.__dict__[point_attr]) + vector
@@ -938,6 +980,8 @@ respective inertia coefficients are assigned as NaN.")
     @inplace_transformation
     def rotate(self, axis, angle):
         self.mesh.rotate(axis, angle)
+        if self.lid_mesh is not None:
+            self.lid_mesh.rotate(axis, angle)
         for point_attr in ('geometric_center', 'rotation_center', 'center_of_mass'):
             if point_attr in self.__dict__ and self.__dict__[point_attr] is not None:
                 self.__dict__[point_attr] = axis.rotate_points([self.__dict__[point_attr]], angle)[0, :]
@@ -950,6 +994,8 @@ respective inertia coefficients are assigned as NaN.")
         # 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)
 
         # Clip dofs
         ids = self.mesh._clipping_data['faces_ids']
@@ -976,11 +1022,25 @@ respective inertia coefficients are assigned as NaN.")
 
     def __str__(self):
         short_dofs = '{' + ', '.join('"{}": ...'.format(d) for d in self.dofs) + '}'
-        return (f"{self.__class__.__name__}(mesh={self.mesh.__short_str__()}, dofs={short_dofs}, {self._optional_params_str()}name=\"{self.name}\")")
+
+        if self.lid_mesh is not None:
+            lid_mesh_str = self.lid_mesh.__short_str__()
+        else:
+            lid_mesh_str = str(None)
+
+        return (f"{self.__class__.__name__}(mesh={self.mesh.__short_str__()}, lid_mesh={lid_mesh_str}, "
+                f"dofs={short_dofs}, {self._optional_params_str()}name=\"{self.name}\")")
 
     def __repr__(self):
         short_dofs = '{' + ', '.join('"{}": ...'.format(d) for d in self.dofs) + '}'
-        return (f"{self.__class__.__name__}(mesh={str(self.mesh)}, dofs={short_dofs}, {self._optional_params_str()}name=\"{self.name}\")")
+
+        if self.lid_mesh is not None:
+            lid_mesh_str = str(self.lid_mesh)
+        else:
+            lid_mesh_str = str(None)
+
+        return (f"{self.__class__.__name__}(mesh={str(self.mesh)}, lid_mesh={lid_mesh_str}, "
+                f"dofs={short_dofs}, {self._optional_params_str()}name=\"{self.name}\")")
 
     def _repr_pretty_(self, p, cycle):
         p.text(self.__str__())
@@ -990,6 +1050,7 @@ respective inertia coefficients are assigned as NaN.")
             def __repr__(self):
                 return '...'
         yield "mesh", self.mesh
+        yield "lid_mesh", self.lid_mesh
         yield "dofs", {d: DofWithShortRepr() for d in self.dofs}
         if self.mass is not None:
             yield "mass", self.mass, None
@@ -1034,7 +1095,47 @@ respective inertia coefficients are assigned as NaN.")
     @property
     def minimal_computable_wavelength(self):
         """For accuracy of the resolution, wavelength should not be smaller than this value."""
-        return 8*self.mesh.faces_radiuses.max()
+        if self.lid_mesh is not None:
+            return max(8*self.mesh.faces_radiuses.max(), 8*self.lid_mesh.faces_radiuses.max())
+        else:
+            return 8*self.mesh.faces_radiuses.max()
+
+    def first_irregular_frequency_estimate(self, *, g=9.81):
+        r"""Estimates the angular frequency of the lowest irregular
+        frequency.
+        This is based on the formula for the lowest irregular frequency of a
+        parallelepiped of size :math:`L \times B` and draft :math:`H`:
+
+        .. math::
+            \omega = \sqrt{
+                        \frac{\pi g \sqrt{\frac{1}{B^2} + \frac{1}{L^2}}}
+                             {\tanh\left(\pi H \sqrt{\frac{1}{B^2} + \frac{1}{L^2}} \right)}
+                     }
+
+        The formula is applied to all shapes to get an estimate that is usually
+        conservative.
+        The definition of a lid (supposed to be fully covering and horizontal)
+        is taken into account.
+        """
+        if self.lid_mesh is None:
+            draft = abs(self.mesh.vertices[:, 2].min())
+        else:
+            draft = abs(self.lid_mesh.vertices[:, 2].min())
+            if draft < 1e-6:
+                return np.inf
+
+        # Look for the x and y span of each components (e.g. for multibody) and
+        # keep the one causing the lowest irregular frequency.
+        # The draft is supposed to be same for all components.
+        omega = np.inf
+        for comp in connected_components(self.mesh):
+            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)
+                omega_comp = np.sqrt(np.pi*g*p/(np.tanh(np.pi*draft*p)))
+                omega = min(omega, omega_comp)
+        return omega
 
     def cluster_bodies(*bodies, name=None):
         """
@@ -1052,7 +1153,7 @@ respective inertia coefficients are assigned as NaN.")
         FloatingBody
             Array built from the provided bodies
         """
-        from scipy.cluster.hierarchy import linkage, dendrogram
+        from scipy.cluster.hierarchy import linkage
         nb_buoys = len(bodies)
 
         if any(body.center_of_buoyancy is None for body in bodies):