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

capytaine/__about__.py

@@ -5,7 +5,7 @@ __all__ = ["__title__", "__description__", "__version__", "__author__", "__uri__
 __title__ = "capytaine"
 __description__ = """Python BEM solver for linear potential flow, based on Nemoh"""
 
-__version__ = "2.1"
+__version__ = "2.2.1"
 
 __author__ = "Matthieu Ancellin"
 __uri__ = "https://github.com/capytaine/capytaine"

capytaine/__init__.py

@@ -3,7 +3,7 @@
 
 
 # start delvewheel patch
-def _delvewheel_patch_1_5_4():
+def _delvewheel_patch_1_9_0():
     import ctypes
     import os
     import platform
@@ -14,19 +14,22 @@ def _delvewheel_patch_1_5_4():
         if os.path.isdir(libs_dir):
             os.add_dll_directory(libs_dir)
     else:
-        load_order_filepath = os.path.join(libs_dir, '.load-order-capytaine-2.1')
+        load_order_filepath = os.path.join(libs_dir, '.load-order-capytaine-2.2.1')
         if os.path.isfile(load_order_filepath):
-            with open(os.path.join(libs_dir, '.load-order-capytaine-2.1')) as file:
+            import ctypes.wintypes
+            with open(os.path.join(libs_dir, '.load-order-capytaine-2.2.1')) as file:
                 load_order = file.read().split()
+            kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
+            kernel32.LoadLibraryExW.restype = ctypes.wintypes.HMODULE
+            kernel32.LoadLibraryExW.argtypes = ctypes.wintypes.LPCWSTR, ctypes.wintypes.HANDLE, ctypes.wintypes.DWORD
             for lib in load_order:
                 lib_path = os.path.join(os.path.join(libs_dir, lib))
-                kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
-                if os.path.isfile(lib_path) and not kernel32.LoadLibraryExW(ctypes.c_wchar_p(lib_path), None, 0x00000008):
+                if os.path.isfile(lib_path) and not kernel32.LoadLibraryExW(lib_path, None, 8):
                     raise OSError('Error loading {}; {}'.format(lib, ctypes.FormatError(ctypes.get_last_error())))
 
 
-_delvewheel_patch_1_5_4()
-del _delvewheel_patch_1_5_4
+_delvewheel_patch_1_9_0()
+del _delvewheel_patch_1_9_0
 # end delvewheel patch
 
 from .__about__ import (

capytaine/bem/engines.py

@@ -123,10 +123,10 @@ class BasicMatrixEngine(MatrixEngine):
 
             S_a, V_a = self.build_matrices(
                 mesh1[0], mesh2[0], free_surface, water_depth, wavenumber,
-                green_function)
+                green_function, adjoint_double_layer=adjoint_double_layer)
             S_b, V_b = self.build_matrices(
                 mesh1[0], mesh2[1], free_surface, water_depth, wavenumber,
-                green_function)
+                green_function, adjoint_double_layer=adjoint_double_layer)
 
             return BlockSymmetricToeplitzMatrix([[S_a, S_b]]), BlockSymmetricToeplitzMatrix([[V_a, V_b]])
 

capytaine/bem/problems_and_results.py

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

capytaine/bem/solver.py

@@ -1,5 +1,5 @@
-# Copyright (C) 2017-2019 Matthieu Ancellin
-# See LICENSE file at <https://github.com/mancellin/capytaine>
+# Copyright (C) 2017-2024 Matthieu Ancellin
+# See LICENSE file at <https://github.com/capytaine/capytaine>
 """Solver for the BEM problem.
 
 .. code-block:: python
@@ -83,8 +83,9 @@ class BEMSolver:
         keep_details: bool, optional
             if True, store the sources and the potential on the floating body in the output object
             (default: True)
-        _check_wavelength: bool, optional
-            if True, check the mesh resolution with respect to the wavelength
+        _check_wavelength: bool, optional (default: True)
+            If True, the frequencies are compared to the mesh resolution and
+            the estimated first irregular frequency to warn the user.
 
         Returns
         -------
@@ -93,7 +94,9 @@ class BEMSolver:
         """
         LOG.info("Solve %s.", problem)
 
-        if _check_wavelength: self._check_wavelength([problem])
+        if _check_wavelength:
+            self._check_wavelength_and_mesh_resolution([problem])
+            self._check_wavelength_and_irregular_frequencies([problem])
 
         if problem.forward_speed != 0.0:
             omega, wavenumber = problem.encounter_omega, problem.encounter_wavenumber
@@ -106,7 +109,7 @@ class BEMSolver:
                 raise NotImplementedError("Direct solver is not able to solve problems with forward speed.")
 
             S, D = self.engine.build_matrices(
-                    problem.body.mesh, problem.body.mesh,
+                    problem.body.mesh_including_lid, problem.body.mesh_including_lid,
                     problem.free_surface, problem.water_depth, wavenumber,
                     self.green_function, adjoint_double_layer=False
                     )
@@ -116,7 +119,7 @@ class BEMSolver:
             sources = None
         else:
             S, K = self.engine.build_matrices(
-                    problem.body.mesh, problem.body.mesh,
+                    problem.body.mesh_including_lid, problem.body.mesh_including_lid,
                     problem.free_surface, problem.water_depth, wavenumber,
                     self.green_function, adjoint_double_layer=True
                     )
@@ -127,10 +130,11 @@ class BEMSolver:
             if problem.forward_speed != 0.0:
                 result = problem.make_results_container(sources=sources)
                 # Temporary result object to compute the ∇Φ term
-                nabla_phi = self._compute_potential_gradient(problem.body.mesh, result)
+                nabla_phi = self._compute_potential_gradient(problem.body.mesh_including_lid, result)
                 pressure += problem.rho * problem.forward_speed * nabla_phi[:, 0]
 
-        forces = problem.body.integrate_pressure(pressure)
+        pressure_on_hull = pressure[:problem.body.mesh.nb_faces]  # Discards pressure on lid if any
+        forces = problem.body.integrate_pressure(pressure_on_hull)
 
         if not keep_details:
             result = problem.make_results_container(forces)
@@ -156,13 +160,18 @@ class BEMSolver:
             By defaults: do not use joblib and solve sequentially.
         progress_bar: bool, optional (default: True)
             Display a progress bar while solving
+        _check_wavelength: bool, optional (default: True)
+            If True, the frequencies are compared to the mesh resolution and
+            the estimated first irregular frequency to warn the user.
 
         Returns
         -------
         list of LinearPotentialFlowResult
             the solved problems
         """
-        if _check_wavelength: self._check_wavelength(problems)
+        if _check_wavelength:
+            self._check_wavelength_and_mesh_resolution(problems)
+            self._check_wavelength_and_irregular_frequencies(problems)
 
         if n_jobs == 1:  # force sequential resolution
             problems = sorted(problems)
@@ -184,33 +193,64 @@ class BEMSolver:
             return results
 
     @staticmethod
-    def _check_wavelength(problems):
+    def _check_wavelength_and_mesh_resolution(problems):
         """Display a warning if some of the problems have a mesh resolution
         that might not be sufficient for the given wavelength."""
+        LOG.debug("Check wavelength with mesh resolution.")
         risky_problems = [pb for pb in problems
-                          if pb.wavelength < pb.body.minimal_computable_wavelength]
+                          if 0.0 < pb.wavelength < pb.body.minimal_computable_wavelength]
         nb_risky_problems = len(risky_problems)
         if nb_risky_problems == 1:
             pb = risky_problems[0]
             freq_type = risky_problems[0].provided_freq_type
             freq = pb.__getattribute__(freq_type)
             LOG.warning(f"Mesh resolution for {pb}:\n"
-                    f"The resolution of the mesh of the body {pb.body.__short_str__()} might "
-                    f"be insufficient for {freq_type}={freq}.\n"
-                     "This warning appears because the largest panel of this mesh "
-                    f"has radius {pb.body.mesh.faces_radiuses.max():.3f} > wavelength/8."
-                    )
+                        f"The resolution of the mesh of the body {pb.body.__short_str__()} might "
+                        f"be insufficient for {freq_type}={freq}.\n"
+                        "This warning appears because the largest panel of this mesh "
+                        f"has radius {pb.body.mesh.faces_radiuses.max():.3f} > wavelength/8."
+                        )
         elif nb_risky_problems > 1:
             freq_type = risky_problems[0].provided_freq_type
             freqs = np.array([float(pb.__getattribute__(freq_type)) for pb in risky_problems])
             LOG.warning(f"Mesh resolution for {nb_risky_problems} problems:\n"
-                         "The resolution of the mesh might be insufficient "
+                        "The resolution of the mesh might be insufficient "
                         f"for {freq_type} ranging from {freqs.min():.3f} to {freqs.max():.3f}.\n"
-                         "This warning appears when the largest panel of this mesh "
-                         "has radius > wavelength/8."
-                    )
+                        "This warning appears when the largest panel of this mesh "
+                        "has radius > wavelength/8."
+                        )
 
-    def fill_dataset(self, dataset, bodies, *, method='indirect', n_jobs=1, **kwargs):
+    @staticmethod
+    def _check_wavelength_and_irregular_frequencies(problems):
+        """Display a warning if some of the problems might encounter irregular frequencies."""
+        LOG.debug("Check wavelength with estimated irregular frequency.")
+        risky_problems = [pb for pb in problems
+                          if pb.body.first_irregular_frequency_estimate(g=pb.g) < pb.omega < np.inf]
+        nb_risky_problems = len(risky_problems)
+        if nb_risky_problems >= 1:
+            if any(pb.body.lid_mesh is None for pb in problems):
+                recommendation = "Setting a lid for the floating body is recommended."
+            else:
+                recommendation = "The lid might need to be closer to the free surface."
+            if nb_risky_problems == 1:
+                pb = risky_problems[0]
+                freq_type = risky_problems[0].provided_freq_type
+                freq = pb.__getattribute__(freq_type)
+                LOG.warning(f"Irregular frequencies for {pb}:\n"
+                            f"The body {pb.body.__short_str__()} might display irregular frequencies "
+                            f"for {freq_type}={freq}.\n"
+                            + recommendation
+                            )
+            elif nb_risky_problems > 1:
+                freq_type = risky_problems[0].provided_freq_type
+                freqs = np.array([float(pb.__getattribute__(freq_type)) for pb in risky_problems])
+                LOG.warning(f"Irregular frequencies for {nb_risky_problems} problems:\n"
+                            "Irregular frequencies might be encountered "
+                            f"for {freq_type} ranging from {freqs.min():.3f} to {freqs.max():.3f}.\n"
+                            + recommendation
+                            )
+
+    def fill_dataset(self, dataset, bodies, *, method='indirect', n_jobs=1, _check_wavelength=True, **kwargs):
         """Solve a set of problems defined by the coordinates of an xarray dataset.
 
         Parameters
@@ -227,6 +267,9 @@ class BEMSolver:
             By defaults: do not use joblib and solve sequentially.
         progress_bar: bool, optional (default: True)
             Display a progress bar while solving
+        _check_wavelength: bool, optional (default: True)
+            If True, the frequencies are compared to the mesh resolution and
+            the estimated first irregular frequency to warn the user.
 
         Returns
         -------
@@ -236,12 +279,12 @@ class BEMSolver:
                  **self.exportable_settings}
         problems = problems_from_dataset(dataset, bodies)
         if 'theta' in dataset.coords:
-            results = self.solve_all(problems, keep_details=True, method=method, n_jobs=n_jobs)
+            results = self.solve_all(problems, keep_details=True, method=method, n_jobs=n_jobs, _check_wavelength=_check_wavelength)
             kochin = kochin_data_array(results, dataset.coords['theta'])
             dataset = assemble_dataset(results, attrs=attrs, **kwargs)
             dataset.update(kochin)
         else:
-            results = self.solve_all(problems, keep_details=False, method=method, n_jobs=n_jobs)
+            results = self.solve_all(problems, keep_details=False, method=method, n_jobs=n_jobs, _check_wavelength=_check_wavelength)
             dataset = assemble_dataset(results, attrs=attrs, **kwargs)
         return dataset
 
@@ -271,7 +314,7 @@ class BEMSolver:
             They probably have not been stored by the solver because the option keep_details=True have not been set or the direct method has been used.
             Please re-run the resolution with the indirect method and keep_details=True.""")
 
-        S, _ = self.green_function.evaluate(points, result.body.mesh, result.free_surface, result.water_depth, result.encounter_wavenumber)
+        S, _ = self.green_function.evaluate(points, result.body.mesh_including_lid, result.free_surface, result.water_depth, result.encounter_wavenumber)
         potential = S @ result.sources  # Sum the contributions of all panels in the mesh
         return potential.reshape(output_shape)
 
@@ -283,7 +326,7 @@ class BEMSolver:
             They probably have not been stored by the solver because the option keep_details=True have not been set.
             Please re-run the resolution with this option.""")
 
-        _, gradG = self.green_function.evaluate(points, result.body.mesh, result.free_surface, result.water_depth, result.encounter_wavenumber,
+        _, gradG = self.green_function.evaluate(points, result.body.mesh_including_lid, result.free_surface, result.water_depth, result.encounter_wavenumber,
                                                 early_dot_product=False)
         velocities = np.einsum('ijk,j->ik', gradG, result.sources)  # Sum the contributions of all panels in the mesh
         return velocities.reshape((*output_shape, 3))
@@ -409,7 +452,7 @@ class BEMSolver:
         if chunk_size > mesh.nb_faces:
             S = self.engine.build_S_matrix(
                 mesh,
-                result.body.mesh,
+                result.body.mesh_including_lid,
                 result.free_surface, result.water_depth, result.wavenumber,
                 self.green_function
             )
@@ -421,7 +464,7 @@ class BEMSolver:
                 faces_to_extract = list(range(i, min(i+chunk_size, mesh.nb_faces)))
                 S = self.engine.build_S_matrix(
                     mesh.extract_faces(faces_to_extract),
-                    result.body.mesh,
+                    result.body.mesh_including_lid,
                     result.free_surface, result.water_depth, result.wavenumber,
                     self.green_function
                 )