capytaine 2.3__cp311-cp311-win_amd64.whl → 3.0.0a1__cp311-cp311-win_amd64.whl

capytaine/bem/problems_and_results.py

@@ -9,8 +9,8 @@ import pandas as pd
 from scipy.optimize import newton
 
 from capytaine.tools.deprecation_handling import _get_water_depth
-from capytaine.meshes.collections import CollectionOfMeshes
 from capytaine.bem.airy_waves import airy_waves_velocity, froude_krylov_force
+from capytaine.bodies.dofs import AbstractDof
 from capytaine.tools.symbolic_multiplication import SymbolicMultiplication
 
 LOG = logging.getLogger(__name__)
@@ -195,8 +195,7 @@ class LinearPotentialFlowProblem:
 
 
         if self.body is not None:
-            if ((isinstance(self.body.mesh, CollectionOfMeshes) and len(self.body.mesh) == 0)
-                    or len(self.body.mesh.faces) == 0):
+            if self.body.mesh.nb_faces == 0:
                 raise ValueError(f"The mesh of the body {self.body.__short_str__()} is empty.")
 
             self.body._check_dofs_shape_consistency()
@@ -360,16 +359,18 @@ class DiffractionProblem(LinearPotentialFlowProblem):
 
         if self.body is not None:
 
-            self.boundary_condition = -(
+            self.boundary_condition = np.zeros(
+                shape=(self.body.mesh_including_lid.nb_faces,),
+                dtype=np.complex128
+            )
+
+            self.boundary_condition[self.body.hull_mask] = -(
                     airy_waves_velocity(self.body.mesh.faces_centers, self)
                     * self.body.mesh.faces_normals
             ).sum(axis=1)
             # 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!")
 
@@ -420,27 +421,35 @@ class RadiationProblem(LinearPotentialFlowProblem):
                                  f"The dofs of the body are {list(self.body.dofs.keys())}")
 
             dof = self.body.dofs[self.radiating_dof]
+            if isinstance(dof, AbstractDof):
+                dof_motion = dof.evaluate_motion(self.body.mesh)
+            else:
+                dof_motion = dof
 
-            displacement_on_face = np.sum(dof * self.body.mesh.faces_normals, axis=1)  # This is a dot product on each face
-            if self.body.lid_mesh is not None:
-                displacement_on_face = np.concatenate([displacement_on_face, np.zeros(self.body.lid_mesh.nb_faces)])
+            self.boundary_condition = self.encounter_omega * np.zeros(
+                shape=(self.body.mesh_including_lid.nb_faces,),
+                dtype=np.complex128
+            )
+            # The multiplication by encounter_omega is just a programming trick to ensure that boundary_condition
+            # is implemented with the correct type (for zero and infinite frequencies), it does not affect the value.
+            # Below the value is update on the hull. It remains zero on the lid.
 
-            self.boundary_condition = -1j * self.encounter_omega * displacement_on_face
+            displacement_on_face = np.sum(dof_motion * self.body.mesh.faces_normals, axis=1)  # This is a dot product on each face
+            self.boundary_condition[self.body.hull_mask] = -1j * self.encounter_omega * displacement_on_face
 
             if self.forward_speed != 0.0:
-                if self.radiating_dof.lower() == "pitch":
-                    ddofdx_dot_n = np.array([nz for (nx, ny, nz) in self.body.mesh.faces_normals])
-                elif self.radiating_dof.lower() == "yaw":
-                    ddofdx_dot_n = np.array([-ny for (nx, ny, nz) in self.body.mesh.faces_normals])
-                elif self.radiating_dof.lower() in {"surge", "sway", "heave", "roll"}:
-                    ddofdx_dot_n = 0.0
-                else:
+                # Adding the "m-terms":
+                try:
+                    ddofdx = dof.evaluate_gradient_of_motion(self.body.mesh)[:, :, 0]
+                    ddofdx_dot_n = np.sum(ddofdx * self.body.mesh.faces_normals)
+                except AttributeError:
                     raise NotImplementedError(
-                            "Radiation problem with forward speed is currently only implemented for a single rigid body.\n"
-                            "Only radiating dofs with name in {'Surge', 'Sway', 'Heave', 'Roll', 'Pitch', 'Yaw'} are supported.\n"
+                            "Radiation problem with forward speed is currently only implemented for rigid bodies.\n"
+                            "Only radiating dofs instantiating a TranslationDof or a RotationDof are supported.\n"
                             f"Got instead `radiating_dof={self.radiating_dof}`"
                             )
-                self.boundary_condition += self.forward_speed * ddofdx_dot_n
+
+                self.boundary_condition[self.body.hull_mask] += self.forward_speed * ddofdx_dot_n
 
 
 

capytaine/bem/solver.py

@@ -5,24 +5,26 @@
 .. code-block:: python
 
     problem = RadiationProblem(...)
-    result = BEMSolver(green_functions=..., engine=...).solve(problem)
+    result = BEMSolver(engine=..., method=...).solve(problem)
 
 """
 
 import os
+import shutil
+import textwrap
 import logging
 
 import numpy as np
-import pandas as pd
 
 from datetime import datetime
+from collections import defaultdict
 
 from rich.progress import track
 
 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.memory_monitor import MemoryMonitor
 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
@@ -30,15 +32,20 @@ from capytaine.tools.timer import Timer
 
 LOG = logging.getLogger(__name__)
 
+# Mapping between a dtype and its complex version
+COMPLEX_DTYPE = {
+                    np.float32: np.complex64,
+                    np.float64: np.complex128,
+                    np.complex64 : np.complex64,
+                    np.complex128 : np.complex128
+                }
+
 class BEMSolver:
     """
     Solver for linear potential flow problems.
 
     Parameters
     ----------
-    green_function: AbstractGreenFunction, optional
-        Object handling the computation of the Green function.
-        (default: :class:`~capytaine.green_function.delhommeau.Delhommeau`)
     engine: MatrixEngine, optional
         Object handling the building of matrices and the resolution of linear systems with these matrices.
         (default: :class:`~capytaine.bem.engines.BasicMatrixEngine`)
@@ -46,50 +53,72 @@ class BEMSolver:
         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"
+    green_function: AbstractGreenFunction, optional
+        For convenience and backward compatibility, the Green function can be
+        set here if the engine is the default one.
+        This argument is just passed to the default engine at initialization.
 
     Attributes
     ----------
-    timer: dict[str, Timer]
+    timer: 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, method="indirect"):
-        self.green_function = Delhommeau() if green_function is None else green_function
-        self.engine = BasicMatrixEngine() if engine is None else engine
+
+        if engine is None:
+            self.engine = BasicMatrixEngine(green_function=green_function)
+        else:
+            if green_function is not None:
+                raise ValueError("If you are not using the default engine, set the Green function in the engine.\n"
+                                 "Setting the Green function in the solver is only a shortcut to set up "
+                                 "the Green function of the default engine since Capytaine version 3.0")
+            self.engine = 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)
+        self.reset_timer()
 
-        try:
-            self.exportable_settings = {
-                **self.green_function.exportable_settings,
-                **self.engine.exportable_settings,
-                "method": self.method,
-            }
-        except AttributeError:
-            self.exportable_settings = {}
+        self.exportable_settings = {
+            **self.engine.exportable_settings,
+            "method": self.method,
+        }
 
     def __str__(self):
-        return f"BEMSolver(engine={self.engine}, green_function={self.green_function})"
+        return f"BEMSolver(engine={self.engine}, method={self.method})"
 
     def __repr__(self):
         return self.__str__()
 
+    def reset_timer(self):
+        self.timer = Timer(default_tags={"process": 0})
+        self.solve = self.timer.wraps_function(step="Total solve function")(self._solve)
+
     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")
+        df = self.timer.as_dataframe()
+        df["step"] = df["step"].where(
+                df["step"].str.startswith("Total"), "  " + df["step"]
+                )
+        total = (
+                df.groupby(["step", "process"])
+                ["timing"].sum()
+                .unstack()
+                )
+        return total
+
+    def displayed_total_summary(self, width=None):
+        total = self.timer_summary()
+        if width is None:
+            width = shutil.get_terminal_size(fallback=(80, 20)).columns - 25
+        total_str = total.to_string(
+                float_format="{:.2f}".format,
+                line_width=width,
+                )
+        return textwrap.indent(total_str, "  ")
 
     def _repr_pretty_(self, p, cycle):
         p.text(self.__str__())
@@ -98,7 +127,7 @@ class BEMSolver:
     def from_exported_settings(settings):
         raise NotImplementedError
 
-    def solve(self, problem, method=None, 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
@@ -141,6 +170,7 @@ class BEMSolver:
             omega, wavenumber = problem.encounter_omega, problem.encounter_wavenumber
         else:
             omega, wavenumber = problem.omega, problem.wavenumber
+        gf_params = dict(free_surface=problem.free_surface, water_depth=problem.water_depth, wavenumber=wavenumber)
 
         linear_solver = supporting_symbolic_multiplication(self.engine.linear_solver)
         method = method if method is not None else self.method
@@ -148,34 +178,29 @@ class BEMSolver:
             if problem.forward_speed != 0.0:
                 raise NotImplementedError("Direct solver is not able to solve problems with forward speed.")
 
-            with self.timer["  Green function"]:
+            with self.timer(step="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
+                        **gf_params, adjoint_double_layer=False, diagonal_term_in_double_layer=True,
                         )
-            rhs = S @ problem.boundary_condition
-            with self.timer["  Linear solver"]:
+            with self.timer(step="Matrix-vector product"):
+                rhs = S @ problem.boundary_condition
+            with self.timer(step="Linear solver"):
+                rhs = rhs.astype(COMPLEX_DTYPE[D.dtype.type])
                 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:
-            with self.timer["  Green function"]:
+            with self.timer(step="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
+                        **gf_params, adjoint_double_layer=True, diagonal_term_in_double_layer=True,
                         )
-
-            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
+            with self.timer(step="Linear solver"):
+                rhs = problem.boundary_condition.astype(COMPLEX_DTYPE[K.dtype.type])
+                sources = linear_solver(K, rhs)
+            with self.timer(step="Matrix-vector product"):
+                potential = S @ sources
             pressure = 1j * omega * problem.rho * potential
             if problem.forward_speed != 0.0:
                 result = problem.make_results_container(sources=sources)
@@ -183,9 +208,8 @@ class BEMSolver:
                 nabla_phi = self._compute_potential_gradient(problem.body.mesh_including_lid, result)
                 pressure += problem.rho * problem.forward_speed * nabla_phi[:, 0]
 
-        pressure_on_hull = pressure[:problem.body.mesh.nb_faces]  # Discards pressure on lid if any
+        pressure_on_hull = pressure[problem.body.hull_mask]  # Discards pressure on lid if any
         forces = problem.body.integrate_pressure(pressure_on_hull)
-
         if not keep_details:
             result = problem.make_results_container(forces)
         else:
@@ -195,17 +219,40 @@ class BEMSolver:
 
         return result
 
-    def _solve_and_catch_errors(self, problem, *args, **kwargs):
+    def _solve_and_catch_errors(self, problem, *args, _display_errors, **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)
+            if _display_errors:
+                self._display_errors([res])
         return res
 
-    def solve_all(self, problems, *, method=None, n_jobs=1, progress_bar=None, _check_wavelength=True, **kwargs):
+    @staticmethod
+    def _display_errors(results):
+        """Displays errors that occur during the solver execution and groups them according
+        to the problem type and exception type for easier reading."""
+        failed_results = defaultdict(list)
+        for res in results:
+            if hasattr(res, "exception") and hasattr(res, "problem"):
+                key = (type(res.exception), str(res.exception), res.problem.omega, res.problem.water_depth, res.problem.forward_speed)
+                failed_results[key].append(res.problem)
+
+        for (exc_type, exc_msg, omega, water_depth, forward_speed), problems in failed_results.items():
+            nb = len(problems)
+            if nb > 1:
+                if forward_speed != 0.0:
+                    LOG.warning("Skipped %d problems for body=%s, omega=%s, water_depth=%s, forward_speed=%s\nbecause of %s(%r)",
+                                nb, problems[0].body.__short_str__(), omega, water_depth, forward_speed, exc_type.__name__, exc_msg)
+                else:
+                    LOG.warning("Skipped %d problems for body=%s, omega=%s, water_depth=%s\nbecause of %s(%r)",
+                                nb, problems[0].body.__short_str__(), omega, water_depth, exc_type.__name__, exc_msg)
+            else:
+                LOG.warning("Skipped %s\nbecause of %s(%r)", problems[0], exc_type.__name__, exc_msg)
+
+    def solve_all(self, problems, *, method=None, n_jobs=1, n_threads=None, progress_bar=None, _check_wavelength=True, _display_errors=True, **kwargs):
         """Solve several problems.
         Optional keyword arguments are passed to `BEMSolver.solve`.
 
@@ -218,8 +265,14 @@ class BEMSolver:
             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`
+            the number of jobs to run in parallel using the optional dependency ``joblib``
             By defaults: do not use joblib and solve sequentially.
+        n_threads: int, optional
+            the number of threads used to solve each problem.
+            The total number of used CPU will be n_jobs×n_threads.
+            By default: use as much as possible.
+            Requires the optional dependency ``threadpoolctl`` if ``n_jobs==1``.
+            Also controlled by the environment variables ``OMP_NUM_THREADS`` and ``MKL_NUM_THREADS``.
         progress_bar: bool, optional
             Display a progress bar while solving.
             If no value is provided to this method directly,
@@ -238,6 +291,8 @@ class BEMSolver:
             self._check_wavelength_and_mesh_resolution(problems)
             self._check_wavelength_and_irregular_frequencies(problems)
 
+        self._check_ram(problems, n_jobs)
+
         if progress_bar is None:
             if "CAPYTAINE_PROGRESS_BAR" in os.environ:
                 env_var = os.environ["CAPYTAINE_PROGRESS_BAR"].lower()
@@ -250,26 +305,68 @@ class BEMSolver:
             else:
                 progress_bar = True
 
+        monitor = MemoryMonitor()
         if n_jobs == 1:  # force sequential resolution
             problems = sorted(problems)
             if progress_bar:
                 problems = track(problems, total=len(problems), description="Solving BEM problems")
-            results = [self._solve_and_catch_errors(pb, method=method, _check_wavelength=False, **kwargs) for pb in problems]
+            if n_threads is None:
+                results = [self._solve_and_catch_errors(pb, method=method, _display_errors=_display_errors, _check_wavelength=False, **kwargs) for pb in problems]
+            else:
+                threadpoolctl = silently_import_optional_dependency("threadpoolctl")
+                if threadpoolctl is None:
+                    raise ImportError(f"Setting the `n_threads` argument to {n_threads} with `n_jobs=1` requires the missing optional dependency 'threadpoolctl'.")
+                with threadpoolctl.threadpool_limits(limits=n_threads):
+                    results = [self._solve_and_catch_errors(pb, method=method, _display_errors=_display_errors, _check_wavelength=False, **kwargs) for pb in problems]
         else:
             joblib = silently_import_optional_dependency("joblib")
             if joblib is None:
                 raise ImportError(f"Setting the `n_jobs` argument to {n_jobs} requires the missing optional dependency 'joblib'.")
             groups_of_problems = LinearPotentialFlowProblem._group_for_parallel_resolution(problems)
-            parallel = joblib.Parallel(return_as="generator", n_jobs=n_jobs)
-            groups_of_results = parallel(joblib.delayed(self.solve_all)(grp, method=method, n_jobs=1, progress_bar=False, _check_wavelength=False, **kwargs) for grp in groups_of_problems)
+            with joblib.parallel_config(backend='loky', inner_max_num_threads=n_threads):
+                parallel = joblib.Parallel(return_as="generator", n_jobs=n_jobs)
+                groups_of_results = parallel(joblib.delayed(self._solve_all_and_return_timer)(grp, method=method, n_threads=None, progress_bar=False, _display_errors=False, _check_wavelength=False, **kwargs) for grp in groups_of_problems)
             if progress_bar:
                 groups_of_results = track(groups_of_results,
                                           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
-        LOG.info("Solver timer summary:\n%s", self.timer_summary())
+                                          description=f"Solving BEM problems with {n_jobs} processes:")
+            results = []
+            process_id_mapping = {}
+            for grp_results, other_timer, process_id in groups_of_results:
+                results.extend(grp_results)
+                self._display_errors(grp_results)
+                if process_id not in process_id_mapping:
+                    process_id_mapping[process_id] = len(process_id_mapping) + 1
+                self.timer.add_data_from_other_timer(other_timer, process=process_id_mapping[process_id])
+        memory_peak = monitor.get_memory_peak()
+        if memory_peak is None:
+            LOG.info("Actual peak RAM usage: Not measured since optional dependency `psutil` cannot be found.")
+        else:
+            LOG.info(f"Actual peak RAM usage: {memory_peak} GB.")
+        LOG.info("Solver timer summary (in seconds):\n%s", self.displayed_total_summary())
         return results
 
+    def _solve_all_and_return_timer(
+        self, grp, *,
+        method, n_threads,
+        progress_bar, _check_wavelength, **kwargs
+    ):
+        # This method is only called in joblib's Parallel loop.
+        # It contains some pre-processing and post-processing that
+        # should be done in each process when solving the batch of problems.
+
+        self.reset_timer()
+        # Timer data will be concatenated to the Timer of process 0.
+        # We reset the timer at each call to avoid concatenating
+        # the same data twice in the main process.
+
+        results = self.solve_all(
+            grp, method=method, n_jobs=1,
+            n_threads=n_threads, progress_bar=progress_bar,
+            _check_wavelength=_check_wavelength, **kwargs
+        )
+        return results, self.timer, os.getpid()
+
     @staticmethod
     def _check_wavelength_and_mesh_resolution(problems):
         """Display a warning if some of the problems have a mesh resolution
@@ -329,14 +426,37 @@ class BEMSolver:
                             + recommendation
                             )
 
-    def fill_dataset(self, dataset, bodies, *, method=None, n_jobs=1, _check_wavelength=True, progress_bar=None, **kwargs):
+    def _check_ram(self,problems, n_jobs = 1):
+        """Display a warning if the RAM estimation is larger than a certain limit."""
+        LOG.debug("Check RAM estimation.")
+        psutil = silently_import_optional_dependency("psutil")
+        if psutil is None:
+            ram_limit = 8
+        else :
+            ram_limit = psutil.virtual_memory().total / (1024**3) * 0.3
+
+        if n_jobs == - 1:
+            n_jobs = os.cpu_count()
+
+        estimated_peak_memory = n_jobs*max(self.engine.compute_ram_estimation(pb) for pb in problems)
+
+        if estimated_peak_memory < 0.5:
+            LOG.info("Estimated peak RAM usage: <1 GB.")
+
+        elif estimated_peak_memory < ram_limit:
+            LOG.info(f"Estimated peak RAM usage: {int(np.ceil(estimated_peak_memory))} GB.")
+
+        else:
+            LOG.warning(f"Estimated peak RAM usage: {int(np.ceil(estimated_peak_memory))} GB.")
+
+    def fill_dataset(self, dataset, bodies, *, method=None, n_jobs=1, n_threads=None, _check_wavelength=True, progress_bar=None, **kwargs):
         """Solve a set of problems defined by the coordinates of an xarray dataset.
 
         Parameters
         ----------
         dataset : xarray Dataset
             dataset containing the problems parameters: frequency, radiating_dof, water_depth, ...
-        bodies : FloatingBody or list of FloatingBody
+        bodies : FloatingBody or Multibody or list of FloatingBody or list of Multibody
             The body or bodies involved in the problems
             They should all have different names.
         method: string, optional
@@ -344,8 +464,14 @@ class BEMSolver:
             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`
+            the number of jobs to run in parallel using the optional dependency ``joblib``.
             By defaults: do not use joblib and solve sequentially.
+        n_threads: int, optional
+            the number of threads used to solve each problem.
+            The total number of used CPU will be n_jobs×n_threads.
+            By default: use as much as possible.
+            Requires the optional dependency ``threadpoolctl`` if ``n_jobs==1``.
+            Also controlled by the environment variables ``OMP_NUM_THREADS`` and ``MKL_NUM_THREADS``.
         progress_bar: bool, optional
             Display a progress bar while solving.
             If no value is provided to this method directly,
@@ -365,12 +491,12 @@ class BEMSolver:
             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, _check_wavelength=_check_wavelength, progress_bar=progress_bar)
+            results = self.solve_all(problems, keep_details=True, method=method, n_jobs=n_jobs, n_threads=n_threads, _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, _check_wavelength=_check_wavelength, progress_bar=progress_bar)
+            results = self.solve_all(problems, keep_details=False, method=method, n_jobs=n_jobs, n_threads=n_threads, _check_wavelength=_check_wavelength, progress_bar=progress_bar)
             dataset = assemble_dataset(results, attrs=attrs, **kwargs)
         return dataset
 
@@ -394,29 +520,32 @@ class BEMSolver:
         ------
         Exception: if the :code:`LinearPotentialFlowResult` object given as input does not contain the source distribution.
         """
-        points, output_shape = _normalize_points(points, keep_mesh=True)
+        gf_params = dict(free_surface=result.free_surface, water_depth=result.water_depth, wavenumber=result.encounter_wavenumber)
+
+        points, output_shape = _normalize_points(points)
         if result.sources is None:
             raise Exception(f"""The values of the sources of {result} cannot been found.
             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.""")
 
-        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
+        with self.timer(step="Post-processing potential"):
+            S = self.engine.build_S_matrix(points, result.body.mesh_including_lid, **gf_params)
+            potential = S @ result.sources  # Sum the contributions of all panels in the mesh
         return potential.reshape(output_shape)
 
     def _compute_potential_gradient(self, points, result):
         points, output_shape = _normalize_points(points, keep_mesh=True)
+        # keep_mesh, because we need the normal vectors associated with each collocation points to compute the fullK matrix
 
         if result.sources is None:
             raise Exception(f"""The values of the sources of {result} cannot been found.
             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.""")
 
-        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
+        gf_params = dict(free_surface=result.free_surface, water_depth=result.water_depth, wavenumber=result.encounter_wavenumber)
+        with self.timer(step="Post-processing velocity"):
+            gradG = self.engine.build_fullK_matrix(points, result.body.mesh_including_lid, **gf_params)
+            velocities = np.einsum('ijk,j->ik', gradG, result.sources)  # Sum the contributions of all panels in the mesh
         return velocities.reshape((*output_shape, 3))
 
     def compute_velocity(self, points, result):
@@ -490,7 +619,7 @@ class BEMSolver:
         ------
         Exception: if the :code:`LinearPotentialFlowResult` object given as input does not contain the source distribution.
         """
-        points, output_shape = _normalize_free_surface_points(points, keep_mesh=True)
+        points, output_shape = _normalize_free_surface_points(points)
 
         if result.forward_speed != 0:
             fs_elevation = -1/result.g * (-1j*result.encounter_omega) * self.compute_potential(points, result)
@@ -537,13 +666,9 @@ 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.""")
 
+        gf_params = dict(free_surface=result.free_surface, water_depth=result.water_depth, wavenumber=result.encounter_wavenumber)
         if chunk_size > mesh.nb_faces:
-            S = self.engine.build_S_matrix(
-                mesh,
-                result.body.mesh_including_lid,
-                result.free_surface, result.water_depth, result.wavenumber,
-                self.green_function
-            )
+            S = self.engine.build_S_matrix(mesh, result.body.mesh_including_lid, **gf_params)
             phi = S @ result.sources
 
         else:
@@ -553,8 +678,7 @@ class BEMSolver:
                 S = self.engine.build_S_matrix(
                     mesh.extract_faces(faces_to_extract),
                     result.body.mesh_including_lid,
-                    result.free_surface, result.water_depth, result.wavenumber,
-                    self.green_function
+                    **gf_params
                 )
                 phi[i:i+chunk_size] = S @ result.sources