capytaine 2.2.1__cp311-cp311-macosx_14_0_arm64.whl → 2.3__cp311-cp311-macosx_14_0_arm64.whl

capytaine/green_functions/LiangWuNoblesse/Makefile

@@ -0,0 +1,18 @@
+BUILD_DIR=build
+
+run_test: $(BUILD_DIR)/test_program
+	$(BUILD_DIR)/test_program
+
+$(BUILD_DIR)/test_program: test_program.f90 $(BUILD_DIR)/LiangWuNoblesseWaveTerm.o
+	mkdir -p $(BUILD_DIR)
+	gfortran -fopenmp $^ -o $@ -J$(BUILD_DIR)
+
+$(BUILD_DIR)/LiangWuNoblesseWaveTerm.o: LiangWuNoblesseWaveTerm.f90
+	mkdir -p $(BUILD_DIR)
+	gfortran -c $< -o $@ -J$(BUILD_DIR)
+
+clean:
+	rm -rf $(BUILD_DIR)
+.PHONY: run_test clean
+
+

capytaine/green_functions/LiangWuNoblesse/README.md

@@ -0,0 +1,2 @@
+# Green-function-in-deep-water
+Fortran routine for the evaluation of the Green function in deep water

capytaine/green_functions/LiangWuNoblesse/test_program.f90

@@ -0,0 +1,28 @@
+! Just test that the library compiles and run
+
+program test
+  use LiangWuNoblesseWaveTerm, only: HavelockGF
+  implicit none
+
+  integer, parameter :: n = 10
+
+  real(8), dimension(n) :: r, z
+  complex(8), dimension(n) :: gf, gf_r
+  integer :: i
+
+  do i = 1, n
+    r(i) = real(i, kind=8)/n
+  end do
+
+  do i = 1, n
+    z(i) = -real(i, kind=8)/n
+  end do
+
+  !$OMP PARALLEL DO PRIVATE(i)
+  do i = 1, n
+    call HavelockGF(r(i), z(i), gf(i), gf_r(i))
+  end do
+
+  print*, real(gf(:))
+
+end program test

capytaine/green_functions/abstract_green_function.py

@@ -1,12 +1,64 @@
 """Abstract structure of a class used to compute the Green function"""
-# 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>
 
 from abc import ABC, abstractmethod
 
+import numpy as np
+
+from capytaine.meshes.mesh_like_protocol import MeshLike
+
+
+class GreenFunctionEvaluationError(Exception):
+    pass
+
+
 class AbstractGreenFunction(ABC):
     """Abstract method to evaluate the Green function."""
 
+    floating_point_precision: str
+
+    def _get_colocation_points_and_normals(self, mesh1, mesh2, adjoint_double_layer):
+        if isinstance(mesh1, MeshLike):
+            collocation_points = mesh1.faces_centers
+            nb_collocation_points = mesh1.nb_faces
+            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:
+            # This is used when computing potential or velocity at given points in postprocessing
+            collocation_points = mesh1
+            nb_collocation_points = mesh1.shape[0]
+            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 first input for {self.__class__.__name__}.evaluate:\n{mesh1}")
+
+        return collocation_points, early_dot_product_normals
+
+    def _init_matrices(self, shape, early_dot_product):
+        if self.floating_point_precision == "float32":
+            dtype = "complex64"
+        elif self.floating_point_precision == "float64":
+            dtype = "complex128"
+        else:
+            raise NotImplementedError(
+                    f"Unsupported floating point precision: {self.floating_point_precision}"
+                    )
+
+        S = np.zeros(shape, order="F", dtype=dtype)
+        K = np.zeros((shape[0], shape[1], 1 if early_dot_product else 3), order="F", dtype=dtype)
+        return S, K
+
     @abstractmethod
-    def evaluate(self, mesh1, mesh2, free_surface, sea_bottom, wavenumber):
+    def evaluate(self, mesh1, mesh2, free_surface, water_depth, wavenumber, adjoint_double_layer=True, early_dot_product=True):
         pass

capytaine/green_functions/delhommeau.py

@@ -9,12 +9,10 @@ from importlib import import_module
 
 import numpy as np
 
-from capytaine.meshes.meshes import Mesh
-from capytaine.meshes.collections import CollectionOfMeshes
-from capytaine.tools.prony_decomposition import exponential_decomposition, error_exponential_decomposition
+from capytaine.tools.prony_decomposition import find_best_exponential_decomposition, PronyDecompositionFailure
 from capytaine.tools.cache_on_disk import cache_directory
 
-from capytaine.green_functions.abstract_green_function import AbstractGreenFunction
+from capytaine.green_functions.abstract_green_function import AbstractGreenFunction, GreenFunctionEvaluationError
 
 LOG = logging.getLogger(__name__)
 
@@ -25,7 +23,8 @@ _default_parameters = dict(
     tabulation_zmin=-251.0,
     tabulation_nb_integration_points=1001,
     tabulation_grid_shape="scaled_nemoh3",
-    finite_depth_prony_decomposition_method="fortran",
+    finite_depth_method="newer",
+    finite_depth_prony_decomposition_method="python",
     floating_point_precision="float64",
     gf_singularities="low_freq",
 )
@@ -66,6 +65,8 @@ class Delhommeau(AbstractGreenFunction):
         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_method: string, optional
+        The method used to compute the finite depth Green function.
     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'`
@@ -88,7 +89,9 @@ class Delhommeau(AbstractGreenFunction):
         Compiled Fortran module with functions used to compute the Green
         function.
     tabulation_grid_shape_index: int
-        Integer passed to Fortran code to describe which method is used.
+    gf_singularities_index: int
+    finite_depth_method_index: int
+        Integers 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.
@@ -96,6 +99,7 @@ class Delhommeau(AbstractGreenFunction):
         Tabulated Delhommeau integrals.
     """
 
+    dispersion_relation_roots = np.empty(1)  # dummy array
 
 
     def __init__(self, *,
@@ -106,6 +110,7 @@ class Delhommeau(AbstractGreenFunction):
                  tabulation_nb_integration_points=_default_parameters["tabulation_nb_integration_points"],
                  tabulation_grid_shape=_default_parameters["tabulation_grid_shape"],
                  tabulation_cache_dir=cache_directory(),
+                 finite_depth_method=_default_parameters["finite_depth_method"],
                  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"],
@@ -121,12 +126,18 @@ class Delhommeau(AbstractGreenFunction):
         self.tabulation_grid_shape_index = fortran_enum[tabulation_grid_shape]
 
         self.gf_singularities = gf_singularities
-        fortran_enum = {
+        self.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.finite_depth_method = finite_depth_method
+        fortran_enum = {
+                'legacy': self.fortran_core.constants.legacy_finite_depth,
+                'newer': self.fortran_core.constants.newer_finite_depth,
                               }
-        self.gf_singularities_index = fortran_enum[gf_singularities]
+        self.finite_depth_method_index = fortran_enum[finite_depth_method]
 
         self.floating_point_precision = floating_point_precision
         self.tabulation_nb_integration_points = tabulation_nb_integration_points
@@ -152,6 +163,7 @@ class Delhommeau(AbstractGreenFunction):
             'tabulation_zmin': tabulation_zmin,
             'tabulation_nb_integration_points': tabulation_nb_integration_points,
             'tabulation_grid_shape': tabulation_grid_shape,
+            'finite_depth_method': finite_depth_method,
             'finite_depth_prony_decomposition_method': finite_depth_prony_decomposition_method,
             'floating_point_precision': floating_point_precision,
             'gf_singularities': gf_singularities,
@@ -233,8 +245,14 @@ class Delhommeau(AbstractGreenFunction):
                 self.tabulated_r_range, self.tabulated_z_range, tabulation_nb_integration_points,
                 )
 
+    @property
+    def all_tabulation_parameters(self):
+        """An alias meant to pass to the Fortran functions all the parameters controlling the tabulation in a single item."""
+        return (self.tabulation_nb_integration_points, self.tabulation_grid_shape_index,
+                self.tabulated_r_range, self.tabulated_z_range, self.tabulated_integrals)
+
     @lru_cache(maxsize=128)
-    def find_best_exponential_decomposition(self, dimensionless_omega, dimensionless_wavenumber):
+    def find_best_exponential_decomposition(self, dimensionless_wavenumber, *, method=None):
         """Compute the decomposition of a part of the finite water_depth Green function as a sum of exponential functions.
 
         Two implementations are available: the legacy Fortran implementation from Nemoh and a newer one written in Python.
@@ -246,70 +264,134 @@ class Delhommeau(AbstractGreenFunction):
 
         Parameters
         ----------
-        dimensionless_omega: float
-            dimensionless angular frequency: :math:`kh \\tanh (kh) = \\omega^2 h/g`
         dimensionless_wavenumber: float
             dimensionless wavenumber: :math:`kh`
-        method: string, optional
-            the implementation that should be used to compute the Prony decomposition
+        method: str, optional
+            "python" or "fortran". If not provided, uses self.finite_depth_prony_decomposition_method.
 
         Returns
         -------
         Tuple[np.ndarray, np.ndarray]
             the amplitude and growth rates of the exponentials
         """
+        kh = dimensionless_wavenumber
+
+        if method is None:
+            method = self.finite_depth_prony_decomposition_method
 
         LOG.debug("\tCompute Prony decomposition in finite water_depth Green function "
-                  "for dimless_omega=%.2e and dimless_wavenumber=%.2e",
-                  dimensionless_omega, dimensionless_wavenumber)
+                  "for dimensionless_wavenumber=%.2e", dimensionless_wavenumber)
+
+        if method.lower() == 'python':
+            if kh <= 0.1:
+                raise NotImplementedError(
+                    f"{self} cannot evaluate finite depth Green function "
+                    f"for kh<0.1 (kh={kh})"
+                    )
+            elif kh < 1e5:
+                # The function that will be approximated.
+                sing_coef = (1 + np.tanh(kh))**2/(1 - np.tanh(kh)**2 + np.tanh(kh)/kh)
+                def ref_function(x):
+                    """The function that should be approximated by a sum of exponentials."""
+                    return ((x + kh*np.tanh(kh)) * np.exp(x))/(x*np.sinh(x) - kh*np.tanh(kh)*np.cosh(x)) - sing_coef/(x - kh) - 2
+            else:
+                # Asymptotic approximation of the function for large kh, including infinite frequency
+                def ref_function(x):
+                    return -2/(1 + np.exp(-2*x)) + 2
+
+            try:
+                a, lamda = find_best_exponential_decomposition(ref_function, x_min=-0.1, x_max=20.0, n_exp_range=range(4, 31, 2), tol=1e-4)
+                return np.stack([lamda, a])
+            except PronyDecompositionFailure as e:
+                raise GreenFunctionEvaluationError(
+                    f"{self} cannot evaluate finite depth Green function "
+                    f"for kh={dimensionless_wavenumber}"
+                ) from e
+
+        elif method.lower() == 'fortran':
+            if kh > 1e5:
+                raise NotImplementedError("Fortran implementation of the Prony decomposition does not support infinite frequency")
+            omega2_h_over_g = kh*np.tanh(kh)
+            nexp, pr_d = self.fortran_core.old_prony_decomposition.lisc(omega2_h_over_g, kh)
+            return pr_d[0:2, :nexp]
 
-        if self.finite_depth_prony_decomposition_method.lower() == 'python':
-            # The function that will be approximated.
-            @np.vectorize
-            def f(x):
-                return self.fortran_core.initialize_green_wave.ff(x, dimensionless_omega, dimensionless_wavenumber)
+        else:
+            raise ValueError(f"Unrecognized name for the Prony decomposition method: {repr(method)}. Expected 'python' or 'fortran'.")
 
-            # Try different increasing number of exponentials
-            for n_exp in range(4, 31, 2):
+    def evaluate_rankine_only(self,
+                              mesh1, mesh2,
+                              adjoint_double_layer=True, early_dot_product=True
+                              ):
+        r"""Construct the matrices between mesh1 (that can also be a list of points)
+        and mesh2 for a Rankine kernel.
 
-                # The coefficients are computed on a resolution of 4*n_exp+1 ...
-                X = np.linspace(-0.1, 20.0, 4*n_exp+1)
-                a, lamda = exponential_decomposition(X, f(X), n_exp)
+        Parameters
+        ----------
+        mesh1: Mesh or CollectionOfMeshes or list of points
+            mesh of the receiving body (where the potential is measured)
+            if only S is wanted or early_dot_product is False, then only a list
+            of points as an array of shape (n, 3) can be passed.
+        mesh2: Mesh or CollectionOfMeshes
+            mesh of the source body (over which the source distribution is integrated)
+        adjoint_double_layer: bool, optional
+            compute double layer for direct method (F) or adjoint double layer
+            for indirect method (T) matrices (default: True)
+        early_dot_product: boolean, optional
+            if False, return K as a (n, m, 3) array storing ∫∇G
+            if True, return K as a (n, m) array storing ∫∇G·n
 
-                # ... and they are evaluated on a finer discretization.
-                X = np.linspace(-0.1, 20.0, 8*n_exp+1)
-                if error_exponential_decomposition(X, f(X), a, lamda) < 1e-4:
-                    break
+        Returns
+        -------
+        tuple of real-valued numpy arrays
+            the matrices :math:`S` and :math:`K`
+        """
+        collocation_points, early_dot_product_normals = \
+                self._get_colocation_points_and_normals(mesh1, mesh2, adjoint_double_layer)
 
-            else:
-                LOG.warning("No suitable exponential decomposition has been found"
-                            "for dimless_omega=%.2e and dimless_wavenumber=%.2e",
-                            dimensionless_omega, dimensionless_wavenumber)
+        S, K = self._init_matrices(
+            (collocation_points.shape[0], mesh2.nb_faces), early_dot_product
+        )
 
-        elif self.finite_depth_prony_decomposition_method.lower() == 'fortran':
-            lamda, a, nexp = self.fortran_core.old_prony_decomposition.lisc(dimensionless_omega, dimensionless_wavenumber)
-            lamda = lamda[:nexp]
-            a = a[:nexp]
+        self.fortran_core.matrices.add_rankine_term_only(
+                collocation_points,  early_dot_product_normals,
+                mesh2.vertices,      mesh2.faces + 1,
+                mesh2.faces_centers, mesh2.faces_normals,
+                mesh2.faces_areas,   mesh2.faces_radiuses,
+                *mesh2.quadrature_points,
+                adjoint_double_layer,
+                S, K)
 
-        else:
-            raise ValueError("Unrecognized method name for the Prony decomposition.")
+        if mesh1 is mesh2:
+            self.fortran_core.matrices.add_diagonal_term(
+                    mesh2.faces_centers, early_dot_product_normals, np.inf, K,
+                    )
 
-        # Add one more exponential function (actually a constant).
-        # It is not clear where it comes from exactly in the theory...
-        a = np.concatenate([a, np.array([2])])
-        lamda = np.concatenate([lamda, np.array([0.0])])
+        S, K = np.real(S), np.real(K)
+
+        if np.any(np.isnan(S)) or np.any(np.isnan(K)):
+            raise GreenFunctionEvaluationError(
+                    "Green function returned a NaN in the interaction matrix.\n"
+                    "It could be due to overlapping panels.")
+
+        if early_dot_product:
+            K = K.reshape((collocation_points.shape[0], mesh2.nb_faces))
+
+        return S, K
 
-        return a, lamda
 
-    def evaluate(self, mesh1, mesh2, free_surface=0.0, water_depth=np.inf, wavenumber=1.0, adjoint_double_layer=True, early_dot_product=True):
+    def evaluate(self,
+                 mesh1, mesh2,
+                 free_surface=0.0, water_depth=np.inf, wavenumber=1.0,
+                 adjoint_double_layer=True, early_dot_product=True
+                 ):
         r"""The main method of the class, called by the engine to assemble the influence matrices.
 
         Parameters
         ----------
-        mesh1: Mesh or CollectionOfMeshes or list of points
+        mesh1: MeshLike or list of points
             mesh of the receiving body (where the potential is measured)
             if only S is wanted or early_dot_product is False, then only a list of points as an array of shape (n, 3) can be passed.
-        mesh2: Mesh or CollectionOfMeshes
+        mesh2: MeshLike
             mesh of the source body (over which the source distribution is integrated)
         free_surface: float, optional
             position of the free surface (default: :math:`z = 0`)
@@ -327,77 +409,61 @@ class Delhommeau(AbstractGreenFunction):
         -------
         tuple of numpy arrays
             the matrices :math:`S` and :math:`K`
+            the dtype of the matrix can be real or complex and depends on self.floating_point_precision
         """
 
-        wavenumber = float(wavenumber)
-
-        if free_surface == np.inf: # No free surface, only a single Rankine source term
-
-            a_exp, lamda_exp = np.empty(1), np.empty(1)  # Dummy arrays that won't actually be used by the fortran code.
+        if free_surface == np.inf:  # No free surface, only a single Rankine source term
+            if water_depth != np.inf:
+                raise ValueError("When setting free_surface=inf, "
+                                 "the water depth should also be infinite "
+                                 f"(got water_depth={water_depth})")
 
-            coeffs = np.array((1.0, 0.0, 0.0))
+            return self.evaluate_rankine_only(
+                mesh1, mesh2,
+                adjoint_double_layer=adjoint_double_layer,
+                early_dot_product=early_dot_product,
+            )
 
-        elif water_depth == np.inf:
+        # Main case:
+        collocation_points, early_dot_product_normals = \
+                self._get_colocation_points_and_normals(mesh1, mesh2, adjoint_double_layer)
 
-            a_exp, lamda_exp = np.empty(1), np.empty(1)  # Idem
+        S, K = self._init_matrices(
+            (collocation_points.shape[0], mesh2.nb_faces), early_dot_product
+        )
 
-            if wavenumber == 0.0:
-                coeffs = np.array((1.0, 1.0, 0.0))
-            elif wavenumber == np.inf:
-                coeffs = np.array((1.0, -1.0, 0.0))
-            else:
-                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:
-                raise NotImplementedError("Zero or infinite frequencies not implemented for finite depth.")
-            else:
-                a_exp, lamda_exp = self.find_best_exponential_decomposition(
-                    wavenumber*water_depth*np.tanh(wavenumber*water_depth),
-                    wavenumber*water_depth,
-                )
-                coeffs = np.array((1.0, 1.0, 1.0))
-
-        if isinstance(mesh1, Mesh) or isinstance(mesh1, CollectionOfMeshes):
-            collocation_points = mesh1.faces_centers
-            nb_collocation_points = mesh1.nb_faces
-            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:
-            # This is used when computing potential or velocity at given points in postprocessing
-            collocation_points = mesh1
-            nb_collocation_points = mesh1.shape[0]
-            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)
+        wavenumber = float(wavenumber)
 
+        # Overrides gf_singularities setting in some specific cases, else use the class one.
+        if water_depth < np.inf and self.finite_depth_method == 'legacy' and not self.gf_singularities == 'low_freq':
+            gf_singularities = "low_freq"  # Reproduce legacy method behavior
+            LOG.debug(
+                f"Overriding gf_singularities='{self.gf_singularities}' because of finite_depth_method=='legacy'"
+            )
+        elif wavenumber == 0.0 and not self.gf_singularities == 'low_freq':
+            gf_singularities = "low_freq"
+            LOG.debug(
+                f"Overriding gf_singularities='{self.gf_singularities}' because of wavenumber==0.0"
+            )
+        elif wavenumber == np.inf and not self.gf_singularities == 'high_freq':
+            gf_singularities = "high_freq"
+            LOG.debug(
+                f"Overriding gf_singularities='{self.gf_singularities}' because of wavenumber==np.inf"
+            )
+        elif np.any(abs(mesh2.faces_centers[:, 2]) < 1e-6) and not self.gf_singularities == 'low_freq':
+            gf_singularities = "low_freq"
+            LOG.warning(
+                f"Overriding gf_singularities='{self.gf_singularities}' because of free surface panels, "
+                "which are currently only supported by gf_singularities='low_freq'"
+            )
         else:
-            raise ValueError(f"Unrecognized first input for {self.__class__.__name__}.evaluate:\n{mesh1}")
+            gf_singularities = self.gf_singularities
+        gf_singularities_index = self.gf_singularities_fortran_enum[gf_singularities]
 
-        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"
+        if water_depth == np.inf:
+            prony_decomposition = np.zeros((1, 1))  # Dummy array that won't actually be used by the fortran code.
         else:
-            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)
+            prony_decomposition = self.find_best_exponential_decomposition(wavenumber*water_depth)
 
         # Main call to Fortran code
         self.fortran_core.matrices.build_matrices(
@@ -407,19 +473,24 @@ class Delhommeau(AbstractGreenFunction):
             mesh2.faces_areas,   mesh2.faces_radiuses,
             *mesh2.quadrature_points,
             wavenumber, water_depth,
-            coeffs,
-            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, self.gf_singularities_index, adjoint_double_layer,
+            *self.all_tabulation_parameters,
+            self.finite_depth_method_index, prony_decomposition, self.dispersion_relation_roots,
+            gf_singularities_index, adjoint_double_layer,
             S, K
         )
 
+        if mesh1 is mesh2:
+            self.fortran_core.matrices.add_diagonal_term(
+                    mesh2.faces_centers, early_dot_product_normals, free_surface, K,
+                    )
+
         if np.any(np.isnan(S)) or np.any(np.isnan(K)):
-            raise RuntimeError("Green function returned a NaN in the interaction matrix.\n"
+            raise GreenFunctionEvaluationError(
+                    "Green function returned a NaN in the interaction matrix.\n"
                     "It could be due to overlapping panels.")
 
-        if early_dot_product: K = K.reshape((nb_collocation_points, mesh2.nb_faces))
+        if early_dot_product:
+            K = K.reshape((collocation_points.shape[0], mesh2.nb_faces))
 
         return S, K