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

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, lru_cache
 
 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,15 @@ class FloatingBody(ClippableMixin, Abstract3DObject):
         else:
             raise TypeError("Unrecognized `mesh` object passed to the FloatingBody constructor.")
 
+        if lid_mesh is not None:
+            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:
@@ -99,13 +114,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 +132,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 +197,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 +291,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 +536,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 +562,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 +652,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 +755,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 +780,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 +857,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 +872,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 +894,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 +960,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 +974,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 +984,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 +998,11 @@ 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)
+            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']
@@ -976,11 +1029,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 +1057,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 +1102,48 @@ 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()
+
+    @lru_cache
+    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 +1161,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):

capytaine/green_functions/delhommeau.py

@@ -23,10 +23,11 @@ _default_parameters = dict(
     tabulation_rmax=100.0,
     tabulation_nz=372,
     tabulation_zmin=-251.0,
-    tabulation_nb_integration_points=1000,
-    tabulation_method="scaled_nemoh3",
+    tabulation_nb_integration_points=1001,
+    tabulation_grid_shape="scaled_nemoh3",
     finite_depth_prony_decomposition_method="fortran",
-    floating_point_precision="float64"
+    floating_point_precision="float64",
+    gf_singularities="low_freq",
 )
 
 
@@ -55,10 +56,16 @@ class Delhommeau(AbstractGreenFunction):
         Number of points for the numerical integration w.r.t. :math:`theta` of
         Delhommeau's integrals
         Default: 1000
-    tabulation_method: string, optional
+    tabulation_grid_shape: string, optional
         Either :code:`"legacy"` or :code:`"scaled_nemoh3"`, which are the two
         methods currently implemented.
         Default: :code:`"scaled_nemoh3"`
+    tabulation_cache_dir: str or None, optional
+        Directory in which to save the tabulation file(s).
+        If None, the tabulation is not saved on disk.
+        Default: calls capytaine.tools.cache_on_disk.cache_directory(), which
+        returns the value of the environment variable CAPYTAINE_CACHE_DIR if
+        set, or else the default cache directory on your system.
     finite_depth_prony_decomposition_method: string, optional
         The implementation of the Prony decomposition used to compute the
         finite water_depth Green function. Accepted values: :code:`'fortran'`
@@ -69,22 +76,26 @@ class Delhommeau(AbstractGreenFunction):
         Either :code:`'float32'` for single precision computations or
         :code:`'float64'` for double precision computations.
         Default: :code:`'float64'`.
+    gf_singularities: string, optional
+        Chose of the variant among the ways singularities can be extracted from
+        the Green function. Currently only affects the infinite depth Green
+        function.
+        Default: "low_freq".
 
     Attributes
     ----------
     fortran_core:
         Compiled Fortran module with functions used to compute the Green
         function.
-    tabulation_method_index: int
+    tabulation_grid_shape_index: int
         Integer passed to Fortran code to describe which method is used.
     tabulated_r_range: numpy.array of shape (tabulation_nr,) and type floating_point_precision
     tabulated_z_range: numpy.array of shape (tabulation_nz,) and type floating_point_precision
         Coordinates of the tabulation points.
-    tabulated_integrals: numpy.array of shape (tabulation_nr, tabulation_nz, 2, 2) and type floating_point_precision
+    tabulated_integrals: numpy.array of shape (tabulation_nr, tabulation_nz, nb_tabulated_values) and type floating_point_precision
         Tabulated Delhommeau integrals.
     """
 
-    fortran_core_basename = "Delhommeau"
 
 
     def __init__(self, *,
@@ -93,23 +104,43 @@ class Delhommeau(AbstractGreenFunction):
                  tabulation_nz=_default_parameters["tabulation_nz"],
                  tabulation_zmin=_default_parameters["tabulation_zmin"],
                  tabulation_nb_integration_points=_default_parameters["tabulation_nb_integration_points"],
-                 tabulation_method=_default_parameters["tabulation_method"],
+                 tabulation_grid_shape=_default_parameters["tabulation_grid_shape"],
+                 tabulation_cache_dir=cache_directory(),
                  finite_depth_prony_decomposition_method=_default_parameters["finite_depth_prony_decomposition_method"],
                  floating_point_precision=_default_parameters["floating_point_precision"],
+                 gf_singularities=_default_parameters["gf_singularities"],
                  ):
 
-        self.floating_point_precision = floating_point_precision
+        self.fortran_core = import_module(f"capytaine.green_functions.libs.Delhommeau_{floating_point_precision}")
 
-        self.fortran_core = import_module(f"capytaine.green_functions.libs.{self.fortran_core_basename}_{self.floating_point_precision}")
+        self.tabulation_grid_shape = tabulation_grid_shape
+        fortran_enum = {
+                'legacy': self.fortran_core.constants.legacy_grid,
+                'scaled_nemoh3': self.fortran_core.constants.scaled_nemoh3_grid,
+                              }
+        self.tabulation_grid_shape_index = fortran_enum[tabulation_grid_shape]
 
-        self.tabulation_method = tabulation_method
-        fortran_indices_for_methods = {
-                'legacy': self.fortran_core.delhommeau_integrals.legacy_method,
-                'scaled_nemoh3': self.fortran_core.delhommeau_integrals.scaled_nemoh3_method,
+        self.gf_singularities = gf_singularities
+        fortran_enum = {
+                'high_freq': self.fortran_core.constants.high_freq,
+                'low_freq': self.fortran_core.constants.low_freq,
+                'low_freq_with_rankine_part': self.fortran_core.constants.low_freq_with_rankine_part,
                               }
-        self.tabulation_method_index = fortran_indices_for_methods[tabulation_method]
+        self.gf_singularities_index = fortran_enum[gf_singularities]
+
+        self.floating_point_precision = floating_point_precision
+        self.tabulation_nb_integration_points = tabulation_nb_integration_points
 
-        self._create_or_load_tabulation(tabulation_nr, tabulation_rmax, tabulation_nz, tabulation_zmin, tabulation_nb_integration_points)
+        self.tabulation_cache_dir = tabulation_cache_dir
+        if tabulation_cache_dir is None:
+            self._create_tabulation(tabulation_nr, tabulation_rmax,
+                                    tabulation_nz, tabulation_zmin,
+                                    tabulation_nb_integration_points)
+        else:
+            self._create_or_load_tabulation(tabulation_nr, tabulation_rmax,
+                                            tabulation_nz, tabulation_zmin,
+                                            tabulation_nb_integration_points,
+                                            tabulation_cache_dir)
 
         self.finite_depth_prony_decomposition_method = finite_depth_prony_decomposition_method
 
@@ -120,9 +151,10 @@ class Delhommeau(AbstractGreenFunction):
             'tabulation_nz': tabulation_nz,
             'tabulation_zmin': tabulation_zmin,
             'tabulation_nb_integration_points': tabulation_nb_integration_points,
-            'tabulation_method': tabulation_method,
+            'tabulation_grid_shape': tabulation_grid_shape,
             'finite_depth_prony_decomposition_method': finite_depth_prony_decomposition_method,
             'floating_point_precision': floating_point_precision,
+            'gf_singularities': gf_singularities,
         }
 
         self._hash = hash(self.exportable_settings.values())
@@ -152,7 +184,8 @@ class Delhommeau(AbstractGreenFunction):
 
     def _create_or_load_tabulation(self, tabulation_nr, tabulation_rmax,
                                    tabulation_nz, tabulation_zmin,
-                                   tabulation_nb_integration_points):
+                                   tabulation_nb_integration_points,
+                                   tabulation_cache_dir):
         """This method either:
             - loads an existing tabulation saved on disk
             - generates a new tabulation with the data provided as argument and save it on disk.
@@ -162,13 +195,12 @@ class Delhommeau(AbstractGreenFunction):
         tabulation_rmax = float(tabulation_rmax)
         tabulation_zmin = float(tabulation_zmin)
 
-        filename = "tabulation_{}_{}_{}_{}_{}_{}_{}_{}.npz".format(
-            self.fortran_core_basename, self.floating_point_precision,
-            self.tabulation_method,
+        filename = "tabulation_{}_{}_{}_{}_{}_{}_{}.npz".format(
+            self.floating_point_precision, self.tabulation_grid_shape,
             tabulation_nr, tabulation_rmax, tabulation_nz, tabulation_zmin,
             tabulation_nb_integration_points
         )
-        filepath = os.path.join(cache_directory(), filename)
+        filepath = os.path.join(tabulation_cache_dir, filename)
 
         if os.path.exists(filepath):
             LOG.info("Loading tabulation from %s", filepath)
@@ -178,22 +210,29 @@ class Delhommeau(AbstractGreenFunction):
             self.tabulated_integrals = loaded_arrays["values"]
 
         else:
-            LOG.warning("Precomputing tabulation, it may take a few seconds.")
-            self.tabulated_r_range = self.fortran_core.delhommeau_integrals.default_r_spacing(
-                    tabulation_nr, tabulation_rmax, self.tabulation_method_index
-                    )
-            self.tabulated_z_range = self.fortran_core.delhommeau_integrals.default_z_spacing(
-                    tabulation_nz, tabulation_zmin, self.tabulation_method_index
-                    )
-            self.tabulated_integrals = self.fortran_core.delhommeau_integrals.construct_tabulation(
-                    self.tabulated_r_range, self.tabulated_z_range, tabulation_nb_integration_points
-                    )
+            self._create_tabulation(tabulation_nr, tabulation_rmax,
+                                    tabulation_nz, tabulation_zmin,
+                                    tabulation_nb_integration_points)
             LOG.debug("Saving tabulation in %s", filepath)
             np.savez_compressed(
                 filepath, r_range=self.tabulated_r_range, z_range=self.tabulated_z_range,
                 values=self.tabulated_integrals
             )
 
+    def _create_tabulation(self, tabulation_nr, tabulation_rmax,
+                                   tabulation_nz, tabulation_zmin,
+                                   tabulation_nb_integration_points):
+        LOG.warning("Precomputing tabulation, it may take a few seconds.")
+        self.tabulated_r_range = self.fortran_core.delhommeau_integrals.default_r_spacing(
+                tabulation_nr, tabulation_rmax, self.tabulation_grid_shape_index
+                )
+        self.tabulated_z_range = self.fortran_core.delhommeau_integrals.default_z_spacing(
+                tabulation_nz, tabulation_zmin, self.tabulation_grid_shape_index
+                )
+        self.tabulated_integrals = self.fortran_core.delhommeau_integrals.construct_tabulation(
+                self.tabulated_r_range, self.tabulated_z_range, tabulation_nb_integration_points,
+                )
+
     @lru_cache(maxsize=128)
     def find_best_exponential_decomposition(self, dimensionless_omega, dimensionless_wavenumber):
         """Compute the decomposition of a part of the finite water_depth Green function as a sum of exponential functions.
@@ -220,8 +259,8 @@ class Delhommeau(AbstractGreenFunction):
             the amplitude and growth rates of the exponentials
         """
 
-        LOG.debug(f"\tCompute Prony decomposition in finite water_depth Green function "
-                  f"for dimless_omega=%.2e and dimless_wavenumber=%.2e",
+        LOG.debug("\tCompute Prony decomposition in finite water_depth Green function "
+                  "for dimless_omega=%.2e and dimless_wavenumber=%.2e",
                   dimensionless_omega, dimensionless_wavenumber)
 
         if self.finite_depth_prony_decomposition_method.lower() == 'python':
@@ -307,7 +346,10 @@ class Delhommeau(AbstractGreenFunction):
             elif wavenumber == np.inf:
                 coeffs = np.array((1.0, -1.0, 0.0))
             else:
-                coeffs = np.array((1.0, 1.0, 1.0))
+                if self.gf_singularities == "high_freq":
+                    coeffs = np.array((1.0, -1.0, 1.0))
+                else:  # low_freq or low_freq_with_rankine_part
+                    coeffs = np.array((1.0, 1.0, 1.0))
 
         else:  # Finite water_depth
             if wavenumber == 0.0 or wavenumber == np.inf:
@@ -322,26 +364,37 @@ class Delhommeau(AbstractGreenFunction):
         if isinstance(mesh1, Mesh) or isinstance(mesh1, CollectionOfMeshes):
             collocation_points = mesh1.faces_centers
             nb_collocation_points = mesh1.nb_faces
-            if ( adjoint_double_layer == False ):
-                early_dot_product_normals = np.zeros((nb_collocation_points, 3))  # Should not be used
-            else:
+            if not adjoint_double_layer: # Computing the D matrix
+                early_dot_product_normals = mesh2.faces_normals
+            else: # Computing the K matrix
                 early_dot_product_normals = mesh1.faces_normals
-        elif isinstance(mesh1, np.ndarray) and mesh1.ndim ==2 and mesh1.shape[1] == 3:
+
+        elif isinstance(mesh1, np.ndarray) and mesh1.ndim == 2 and mesh1.shape[1] == 3:
             # This is used when computing potential or velocity at given points in postprocessing
             collocation_points = mesh1
             nb_collocation_points = mesh1.shape[0]
-            early_dot_product_normals = np.zeros((nb_collocation_points, 3))  # Should not be used
-            if ( adjoint_double_layer == False ):
-                raise NotImplementedError("Using a list of points as collocation points is not supported in computing adjoint double layer matrices.")
+            if not adjoint_double_layer: # Computing the D matrix
+                early_dot_product_normals = mesh2.faces_normals
+            else: # Computing the K matrix
+                early_dot_product_normals = np.zeros((nb_collocation_points, 3))
+                # Dummy argument since this method is meant to be used either
+                # - to compute potential, then only S is needed and early_dot_product_normals is irrelevant,
+                # - to compute velocity, then the adjoint full gradient is needed and early_dot_product is False and this value is unused.
+                # TODO: add an only_S argument and return an error here if (early_dot_product and not only_S)
+
         else:
-            raise ValueError(f"Unrecognized input for {self.__class__.__name__}.evaluate")
+            raise ValueError(f"Unrecognized first input for {self.__class__.__name__}.evaluate:\n{mesh1}")
+
+        if (np.any(abs(mesh2.faces_centers[:, 2]) < 1e-6)  # free surface panel
+            and self.gf_singularities != "low_freq"):
+            raise NotImplementedError("Free surface panels are only supported for cpt.Delhommeau(..., gf_singularities='low_freq').")
 
         if self.floating_point_precision == "float32":
             dtype = "complex64"
         elif self.floating_point_precision == "float64":
             dtype = "complex128"
         else:
-            raise NotImplementedError
+            raise NotImplementedError(f"Unsupported floating point precision: {self.floating_point_precision}")
 
         S = np.empty((nb_collocation_points, mesh2.nb_faces), order="F", dtype=dtype)
         K = np.empty((nb_collocation_points, mesh2.nb_faces, 1 if early_dot_product else 3), order="F", dtype=dtype)
@@ -355,9 +408,10 @@ class Delhommeau(AbstractGreenFunction):
             *mesh2.quadrature_points,
             wavenumber, water_depth,
             coeffs,
-            self.tabulation_method_index, self.tabulated_r_range, self.tabulated_z_range, self.tabulated_integrals,
+            self.tabulation_nb_integration_points, self.tabulation_grid_shape_index,
+            self.tabulated_r_range, self.tabulated_z_range, self.tabulated_integrals,
             lamda_exp, a_exp,
-            mesh1 is mesh2, adjoint_double_layer,
+            mesh1 is mesh2, self.gf_singularities_index, adjoint_double_layer,
             S, K
         )
 
@@ -372,9 +426,7 @@ class Delhommeau(AbstractGreenFunction):
 ################################
 
 class XieDelhommeau(Delhommeau):
-    """Variant of Nemoh's Green function, more accurate near the free surface.
-
-    Same arguments and methods as :class:`Delhommeau`.
-    """
+    """Legacy way to call the gf_singularities="low_freq" variant."""
 
-    fortran_core_basename = "XieDelhommeau"
+    def __init__(self, **kwargs):
+        super().__init__(gf_singularities="low_freq", **kwargs)