capytaine 2.2.1__cp312-cp312-macosx_14_0_arm64.whl → 2.3.1__cp312-cp312-macosx_14_0_arm64.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.2.1"
+__version__ = "2.3.1"
 
 __author__ = "Matthieu Ancellin"
 __uri__ = "https://github.com/capytaine/capytaine"

capytaine/__init__.py

@@ -24,11 +24,12 @@ from capytaine.bem.problems_and_results import RadiationProblem, DiffractionProb
 from capytaine.bem.solver import BEMSolver
 from capytaine.bem.engines import BasicMatrixEngine, HierarchicalToeplitzMatrixEngine, HierarchicalPrecondMatrixEngine
 from capytaine.green_functions.delhommeau import Delhommeau, XieDelhommeau
+from capytaine.green_functions.hams import LiangWuNoblesseGF, FinGreen3D, HAMS_GF
 
 from capytaine.post_pro.free_surfaces import FreeSurface
 
 from capytaine.io.mesh_loaders import load_mesh
-from capytaine.io.xarray import assemble_dataset
+from capytaine.io.xarray import assemble_dataframe, assemble_dataset, assemble_matrices, export_dataset
 
 from capytaine.ui.rich import set_logging
 

capytaine/bem/airy_waves.py

@@ -22,6 +22,9 @@ def airy_waves_potential(points, pb):
     """
     points, output_shape = _normalize_points(points)
 
+    if float(pb.wavenumber) == 0.0 or float(pb.wavenumber) == np.inf:
+        return np.nan * np.ones(output_shape)
+
     x, y, z = points.T
     k = pb.wavenumber
     h = pb.water_depth
@@ -54,9 +57,11 @@ def airy_waves_velocity(points, pb):
     array of shape (3) or (N x 3)
         the velocity vectors
     """
-
     points, output_shape = _normalize_points(points)
 
+    if float(pb.wavenumber) == 0.0 or float(pb.wavenumber) == np.inf:
+        return np.nan * np.ones((*output_shape, 3))
+
     x, y, z = points.T
     k = pb.wavenumber
     h = pb.water_depth
@@ -79,7 +84,7 @@ def airy_waves_velocity(points, pb):
 
 
 def airy_waves_pressure(points, pb):
-    return 1j * pb.omega * pb.rho * airy_waves_potential(points, pb)
+    return 1j * float(pb.omega) * pb.rho * airy_waves_potential(points, pb)
 
 
 def froude_krylov_force(pb):

capytaine/bem/problems_and_results.py

@@ -24,8 +24,8 @@ _default_parameters = {'rho': 1000.0, 'g': 9.81, 'omega': 1.0,
 class LinearPotentialFlowProblem:
     """General class of a potential flow problem.
 
-    At most one of the following parameter must be provided: omega, period, wavenumber or wavelength.
-    Internally only omega is stored, hence setting another parameter can lead to small rounding errors.
+    At most one of the following parameters must be provided:
+        omega, freq, period, wavenumber or wavelength.
 
     Parameters
     ----------
@@ -39,6 +39,8 @@ class LinearPotentialFlowProblem:
         The position of the sea bottom (deprecated: please prefer setting water_depth)
     omega: float, optional
         The angular frequency of the waves in rad/s
+    freq: float, optional
+        The frequency of the waves in Hz
     period: float, optional
         The period of the waves in s
     wavenumber: float, optional
@@ -59,7 +61,7 @@ class LinearPotentialFlowProblem:
                  body=None,
                  free_surface=_default_parameters['free_surface'],
                  water_depth=None, sea_bottom=None,
-                 omega=None, period=None, wavenumber=None, wavelength=None,
+                 omega=None, freq=None, period=None, wavenumber=None, wavelength=None,
                  forward_speed=_default_parameters['forward_speed'],
                  rho=_default_parameters['rho'],
                  g=_default_parameters['g'],
@@ -76,14 +78,14 @@ class LinearPotentialFlowProblem:
         self.boundary_condition = boundary_condition
 
         self.water_depth = _get_water_depth(free_surface, water_depth, sea_bottom, default_water_depth=_default_parameters["water_depth"])
-        self.omega, self.period, self.wavenumber, self.wavelength, self.provided_freq_type = \
-                self._get_frequencies(omega=omega, period=period, wavenumber=wavenumber, wavelength=wavelength)
+        self.omega, self.freq, self.period, self.wavenumber, self.wavelength, self.provided_freq_type = \
+                self._get_frequencies(omega=omega, freq=freq, period=period, wavenumber=wavenumber, wavelength=wavelength)
 
         self._check_data()
 
         if forward_speed != 0.0:
             dopplered_omega = self.omega - self.wavenumber*self.forward_speed*np.cos(self.wave_direction)
-            self.encounter_omega, self.encounter_period, self.encounter_wavenumber, self.encounter_wavelength, _ = \
+            self.encounter_omega, self.encounter_freq, self.encounter_period, self.encounter_wavenumber, self.encounter_wavelength, _ = \
                     self._get_frequencies(omega=abs(dopplered_omega))
 
             if dopplered_omega >= 0.0:
@@ -92,18 +94,19 @@ class LinearPotentialFlowProblem:
                 self.encounter_wave_direction = self.wave_direction + np.pi
         else:
             self.encounter_omega = self.omega
+            self.encounter_freq = self.freq
             self.encounter_period = self.period
             self.encounter_wavenumber = self.wavenumber
             self.encounter_wavelength = self.wavelength
             self.encounter_wave_direction = self.wave_direction
 
 
-    def _get_frequencies(self, *, omega=None, period=None, wavenumber=None, wavelength=None):
-        frequency_data = dict(omega=omega, period=period, wavenumber=wavenumber, wavelength=wavelength)
-        nb_provided_frequency_data = 4 - list(frequency_data.values()).count(None)
+    def _get_frequencies(self, *, omega=None, freq=None, period=None, wavenumber=None, wavelength=None):
+        frequency_data = dict(omega=omega, freq=freq, period=period, wavenumber=wavenumber, wavelength=wavelength)
+        nb_provided_frequency_data = len(frequency_data) - list(frequency_data.values()).count(None)
 
         if nb_provided_frequency_data > 1:
-            raise ValueError("Settings a problem requires at most one of the following: omega (angular frequency) OR period OR wavenumber OR wavelength.\n"
+            raise ValueError("Settings a problem requires at most one of the following: omega (angular frequency) OR freq (in Hz) OR period OR wavenumber OR wavelength.\n"
                              "Received {} of them: {}".format(nb_provided_frequency_data, {k: v for k, v in frequency_data.items() if v is not None}))
 
         if nb_provided_frequency_data == 0:
@@ -112,27 +115,35 @@ class LinearPotentialFlowProblem:
         else:
             provided_freq_type = [k for (k, v) in frequency_data.items() if v is not None][0]
 
-        if ((float(frequency_data[provided_freq_type]) == 0.0 and provided_freq_type in {'omega', 'wavenumber'})
+        if ((float(frequency_data[provided_freq_type]) == 0.0 and provided_freq_type in {'omega', 'freq', 'wavenumber'})
             or (float(frequency_data[provided_freq_type]) == np.inf and provided_freq_type in {'period', 'wavelength'})):
                 omega = SymbolicMultiplication("0")
+                freq = SymbolicMultiplication("0")
                 wavenumber = SymbolicMultiplication("0")
                 period = SymbolicMultiplication("∞")
                 wavelength = SymbolicMultiplication("∞")
         elif ((float(frequency_data[provided_freq_type]) == 0.0 and provided_freq_type in {'period', 'wavelength'})
-            or (float(frequency_data[provided_freq_type]) == np.inf and provided_freq_type in {'omega', 'wavenumber'})):
+            or (float(frequency_data[provided_freq_type]) == np.inf and provided_freq_type in {'omega', 'freq', 'wavenumber'})):
                 omega = SymbolicMultiplication("∞")
+                freq = SymbolicMultiplication("∞")
                 wavenumber = SymbolicMultiplication("∞")
                 period = SymbolicMultiplication("0")
                 wavelength = SymbolicMultiplication("0")
         else:
 
-            if provided_freq_type in {'omega', 'period'}:
+            if provided_freq_type in {'omega', 'freq', 'period'}:
                 if provided_freq_type == 'omega':
                     omega = frequency_data['omega']
                     period = 2*np.pi/omega
+                    freq = omega/2/np.pi
+                elif provided_freq_type == 'freq':
+                    freq = frequency_data['freq']
+                    omega = 2*np.pi*freq
+                    period = 1/freq
                 else:  # provided_freq_type is 'period'
                     period = frequency_data['period']
                     omega = 2*np.pi/period
+                    freq = 1/period
 
                 if self.water_depth == np.inf:
                     wavenumber = omega**2/self.g
@@ -150,8 +161,9 @@ class LinearPotentialFlowProblem:
 
                 omega = np.sqrt(self.g*wavenumber*np.tanh(wavenumber*self.water_depth))
                 period = 2*np.pi/omega
+                freq = 1/period
 
-        return omega, period, wavenumber, wavelength, provided_freq_type
+        return omega, freq, period, wavenumber, wavelength, provided_freq_type
 
     def _check_data(self):
         """Sanity checks on the data."""
@@ -168,7 +180,6 @@ class LinearPotentialFlowProblem:
                          "If you were actually giving an angle in radians, use the modulo operator to give a value between -2π and 2π to disable this warning.")
 
         if self.free_surface == np.inf and self.water_depth != np.inf:
-
             raise NotImplementedError(
                 "Problems with a sea bottom but no free surface have not been implemented."
             )
@@ -177,11 +188,6 @@ class LinearPotentialFlowProblem:
             raise ValueError("`water_depth` should be strictly positive (provided water depth: {self.water_depth}).")
 
         if float(self.omega) in {0, np.inf}:
-            if self.water_depth != np.inf:
-                LOG.warning(
-                        f"Default Green function allows for {self.provided_freq_type}={float(self.__getattribute__(self.provided_freq_type))} only for infinite depth (provided water depth: {self.water_depth})."
-                        )
-
             if self.forward_speed != 0.0:
                 raise NotImplementedError(
                         f"omega={float(self.omega)} is only implemented without forward speed (provided forward speed: {self.forward_speed})."
@@ -193,6 +199,8 @@ class LinearPotentialFlowProblem:
                     or len(self.body.mesh.faces) == 0):
                 raise ValueError(f"The mesh of the body {self.body.__short_str__()} is empty.")
 
+            self.body._check_dofs_shape_consistency()
+
             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)):
@@ -231,8 +239,11 @@ class LinearPotentialFlowProblem:
     def _asdict(self):
         return {"body_name": self.body_name,
                 "water_depth": self.water_depth,
+                "free_surface": self.free_surface,
                 "omega": float(self.omega),
+                "freq": float(self.freq),
                 "encounter_omega": float(self.encounter_omega),
+                "encounter_freq": float(self.encounter_freq),
                 "period": float(self.period),
                 "wavelength": float(self.wavelength),
                 "wavenumber": float(self.wavenumber),
@@ -322,8 +333,11 @@ class LinearPotentialFlowProblem:
         # TODO: let the user choose the influenced dofs
         return self.body.dofs if self.body is not None else set()
 
-    def make_results_container(self):
-        return LinearPotentialFlowResult(self)
+    def make_results_container(self, *args, **kwargs):
+        return LinearPotentialFlowResult(self, *args, **kwargs)
+
+    def make_failed_results_container(self, *args, **kwargs):
+        return FailedLinearPotentialFlowResult(self, *args, **kwargs)
 
 
 class DiffractionProblem(LinearPotentialFlowProblem):
@@ -334,31 +348,30 @@ class DiffractionProblem(LinearPotentialFlowProblem):
                  body=None,
                  free_surface=_default_parameters['free_surface'],
                  water_depth=None, sea_bottom=None,
-                 omega=None, period=None, wavenumber=None, wavelength=None,
+                 omega=None, freq=None, period=None, wavenumber=None, wavelength=None,
                  forward_speed=_default_parameters['forward_speed'],
                  rho=_default_parameters['rho'],
                  g=_default_parameters['g'],
                  wave_direction=_default_parameters['wave_direction']):
 
         super().__init__(body=body, free_surface=free_surface, water_depth=water_depth, sea_bottom=sea_bottom,
-                         omega=omega, period=period, wavenumber=wavenumber, wavelength=wavelength, wave_direction=wave_direction,
+                         omega=omega, freq=freq, period=period, wavenumber=wavenumber, wavelength=wavelength, wave_direction=wave_direction,
                          forward_speed=forward_speed, rho=rho, g=g)
 
-        if float(self.omega) in {0.0, np.inf}:
-            raise NotImplementedError("DiffractionProblem does not support zero or infinite frequency.")
-
         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!")
 
@@ -371,6 +384,9 @@ class DiffractionProblem(LinearPotentialFlowProblem):
     def make_results_container(self, *args, **kwargs):
         return DiffractionResult(self, *args, **kwargs)
 
+    def make_failed_results_container(self, *args, **kwargs):
+        return FailedDiffractionResult(self, *args, **kwargs)
+
 
 class RadiationProblem(LinearPotentialFlowProblem):
     """Particular LinearPotentialFlowProblem whose boundary conditions have
@@ -379,7 +395,7 @@ class RadiationProblem(LinearPotentialFlowProblem):
     def __init__(self, *, body=None,
                  free_surface=_default_parameters['free_surface'],
                  water_depth=None, sea_bottom=None,
-                 omega=None, period=None, wavenumber=None, wavelength=None,
+                 omega=None, freq=None, period=None, wavenumber=None, wavelength=None,
                  forward_speed=_default_parameters['forward_speed'],
                  wave_direction=_default_parameters['wave_direction'],
                  rho=_default_parameters['rho'],
@@ -389,7 +405,7 @@ class RadiationProblem(LinearPotentialFlowProblem):
         self.radiating_dof = radiating_dof
 
         super().__init__(body=body, free_surface=free_surface, water_depth=water_depth, sea_bottom=sea_bottom,
-                         omega=omega, period=period, wavenumber=wavenumber, wavelength=wavelength,
+                         omega=omega, freq=freq, period=period, wavenumber=wavenumber, wavelength=wavelength,
                          wave_direction=wave_direction, forward_speed=forward_speed, rho=rho, g=g)
 
         if self.body is not None:
@@ -407,7 +423,16 @@ class RadiationProblem(LinearPotentialFlowProblem):
 
             dof = self.body.dofs[self.radiating_dof]
 
-            self.boundary_condition = -1j * self.encounter_omega * np.sum(dof * self.body.mesh.faces_normals, axis=1)
+            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.
+
+            displacement_on_face = np.sum(dof * 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":
@@ -422,10 +447,9 @@ class RadiationProblem(LinearPotentialFlowProblem):
                             "Only radiating dofs with name in {'Surge', 'Sway', 'Heave', 'Roll', 'Pitch', 'Yaw'} are supported.\n"
                             f"Got instead `radiating_dof={self.radiating_dof}`"
                             )
-                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)])
+                self.boundary_condition[self.body.hull_mask] += self.forward_speed * ddofdx_dot_n
+
 
 
     def _astuple(self):
@@ -448,6 +472,9 @@ class RadiationProblem(LinearPotentialFlowProblem):
     def make_results_container(self, *args, **kwargs):
         return RadiationResult(self, *args, **kwargs)
 
+    def make_failed_results_container(self, *args, **kwargs):
+        return FailedRadiationResult(self, *args, **kwargs)
+
 
 class LinearPotentialFlowResult:
 
@@ -465,12 +492,14 @@ class LinearPotentialFlowResult:
         self.body               = self.problem.body
         self.free_surface       = self.problem.free_surface
         self.omega              = self.problem.omega
+        self.freq              = self.problem.freq
         self.period             = self.problem.period
         self.wavenumber         = self.problem.wavenumber
         self.wavelength         = self.problem.wavelength
         self.forward_speed      = self.problem.forward_speed
         self.wave_direction     = self.problem.wave_direction
         self.encounter_omega    = self.problem.encounter_omega
+        self.encounter_freq    = self.problem.encounter_freq
         self.encounter_period   = self.problem.encounter_period
         self.encounter_wavenumber = self.problem.encounter_wavenumber
         self.encounter_wavelength = self.problem.encounter_wavelength
@@ -495,6 +524,13 @@ class LinearPotentialFlowResult:
     __rich_repr__ = LinearPotentialFlowProblem.__rich_repr__
 
 
+class FailedLinearPotentialFlowResult(LinearPotentialFlowResult):
+    def __init__(self, problem, exception):
+        LinearPotentialFlowResult.__init__(self, problem)
+        self.forces = {dof: np.nan + 1j*np.nan for dof in self.influenced_dofs}
+        self.exception = exception
+
+
 class DiffractionResult(LinearPotentialFlowResult):
 
     def __init__(self, problem, *args, **kwargs):
@@ -510,10 +546,18 @@ class DiffractionResult(LinearPotentialFlowResult):
         return [dict(**params,
                      influenced_dof=dof,
                      diffraction_force=self.forces[dof],
-                     Froude_Krylov_force=FK[dof])
+                     Froude_Krylov_force=FK[dof],
+                     kind="DiffractionResult")
                 for dof in self.influenced_dofs]
 
 
+class FailedDiffractionResult(DiffractionResult):
+    def __init__(self, problem, exception):
+        DiffractionResult.__init__(self, problem)
+        self.forces = {dof: np.nan for dof in self.influenced_dofs}
+        self.exception = exception
+
+
 class RadiationResult(LinearPotentialFlowResult):
 
     def __init__(self, problem, *args, **kwargs):
@@ -544,5 +588,13 @@ class RadiationResult(LinearPotentialFlowResult):
         return [dict(params,
                      influenced_dof=dof,
                      added_mass=self.added_mass[dof],
-                     radiation_damping=self.radiation_damping[dof])
+                     radiation_damping=self.radiation_damping[dof],
+                     kind="RadiationResult")
                 for dof in self.influenced_dofs]
+
+
+class FailedRadiationResult(RadiationResult):
+    def __init__(self, problem, exception):
+        RadiationResult.__init__(self, problem)
+        self.forces = {dof: np.nan + 1j*np.nan for dof in self.influenced_dofs}
+        self.exception = exception