capytaine 2.3.1__cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl

capytaine/green_functions/hams.py

@@ -0,0 +1,204 @@
+from importlib import import_module
+from scipy.optimize import brentq
+import numpy as np
+
+from capytaine.green_functions.abstract_green_function import AbstractGreenFunction, GreenFunctionEvaluationError
+
+
+class LiangWuNoblesseGF(AbstractGreenFunction):
+    """Wrapper for the Fortran implementation of the infinite depth Green function of [Liang, Wu, Noblesse, 2018].
+
+    Uses the same implementation as Delhommeau() for the Rankine and reflected Rankine terms.
+
+    """
+    floating_point_precision = "float64"
+
+    fortran_core = import_module("capytaine.green_functions.libs.Delhommeau_float64")
+    tabulation_grid_shape_index = fortran_core.constants.liang_wu_noblesse
+    exportable_settings = {'green_function': "LiangWuNoblesseGF"}
+
+    # Dummy arrays that won't actually be used by the fortran code.
+    prony_decomposition = np.zeros((1, 1))
+    dispersion_relation_roots = np.empty(1)
+    finite_depth_method_index = -9999
+    tabulation_nb_integration_points = 1
+    tabulated_r_range = np.empty(1)
+    tabulated_z_range = np.empty(1)
+    tabulated_integrals = np.empty(1)
+    dummy_param = -999
+
+    def __str__(self):
+        return "LiangWuNoblesseGF()"
+
+    def __repr__(self):
+        return "LiangWuNoblesseGF()"
+
+    def _repr_pretty_(self, p, cycle):
+        p.text(self.__repr__())
+
+    def evaluate(self,
+                 mesh1, mesh2,
+                 free_surface=0.0, water_depth=np.inf, wavenumber=1.0,
+                 adjoint_double_layer=True, early_dot_product=True
+                 ):
+
+        if free_surface == np.inf or water_depth < np.inf:
+            raise NotImplementedError("LiangWuNoblesseGF() is only implemented for infinite depth with a free surface")
+
+        if wavenumber == np.inf:
+            gf_singularities_index = self.fortran_core.constants.high_freq
+        else:
+            gf_singularities_index = self.fortran_core.constants.low_freq
+
+        collocation_points, early_dot_product_normals = \
+                self._get_colocation_points_and_normals(mesh1, mesh2, adjoint_double_layer)
+
+        S, K = self._init_matrices(
+            (collocation_points.shape[0], mesh2.nb_faces), early_dot_product=early_dot_product
+        )
+
+        self.fortran_core.matrices.build_matrices(
+            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,
+            wavenumber, np.inf,
+            self.tabulation_nb_integration_points, self.tabulation_grid_shape_index,
+            self.tabulated_r_range, self.tabulated_z_range, self.tabulated_integrals,
+            self.dummy_param, self.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 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
+
+
+class FinGreen3D(AbstractGreenFunction):
+    """Wrapper for the Fortran implementation of the finite depth Green function of [Liu et al.].
+
+    Uses the same implementation as Delhommeau() for the Rankine and reflected Rankine terms.
+
+    """
+    floating_point_precision = "float64"
+
+    fortran_core = import_module("capytaine.green_functions.libs.Delhommeau_float64")
+    finite_depth_method_index = fortran_core.constants.fingreen3d_method
+    gf_singularities_index = fortran_core.constants.low_freq
+
+    # Dummy arrays that won't actually be used by the fortran code.
+    prony_decomposition = np.zeros((1, 1))
+    tabulation_nb_integration_points = 1
+    tabulated_r_range = np.empty(1)
+    tabulated_z_range = np.empty(1)
+    tabulated_integrals = np.empty(1)
+    dummy_param = -999
+
+    def __init__(self, *, nb_dispersion_roots=200):
+        self.nb_dispersion_roots = nb_dispersion_roots
+        self.exportable_settings = {
+            'green_function': "FinGreen3D",
+            'nb_dispersion_roots': nb_dispersion_roots
+        }
+
+    def __str__(self):
+        return f"FinGreen3D(nb_dispersion_roots={self.nb_dispersion_roots})"
+
+    def __repr__(self):
+        return f"FinGreen3D(nb_dispersion_roots={self.nb_dispersion_roots})"
+
+    def _repr_pretty_(self, p, cycle):
+        p.text(self.__repr__())
+
+    def compute_dispersion_relation_roots(self, nk, wavenumber, depth):
+        omega2_h_over_g = wavenumber*np.tanh(wavenumber*depth)*depth
+        def root(i_root):
+            return brentq(lambda y: omega2_h_over_g + y*np.tan(y), (2*i_root+1)*np.pi/2 + 1e-10, (2*i_root+2)*np.pi/2 - 1e-10)/depth
+        return np.array([wavenumber] + [root(i_root) for i_root in range(nk-1)])
+
+    def evaluate(self, mesh1, mesh2, free_surface, water_depth, wavenumber, adjoint_double_layer=True, early_dot_product=True):
+
+        if free_surface == np.inf or water_depth == np.inf:
+            raise NotImplementedError("FinGreen3D is only implemented for finite depth with a free surface.")
+        if wavenumber == 0.0 or wavenumber == np.inf:
+            raise NotImplementedError("FinGreen3D is only implemented for non-zero and non-infinite frequencies")
+
+        dispersion_relation_roots = self.compute_dispersion_relation_roots(
+            self.nb_dispersion_roots,
+            wavenumber,
+            water_depth
+        )
+
+        collocation_points, early_dot_product_normals = \
+                self._get_colocation_points_and_normals(mesh1, mesh2, adjoint_double_layer)
+
+        S, K = self._init_matrices(
+            (collocation_points.shape[0], mesh2.nb_faces), early_dot_product=early_dot_product
+        )
+
+        self.fortran_core.matrices.build_matrices(
+            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,
+            wavenumber, water_depth,
+            self.tabulation_nb_integration_points, self.dummy_param,
+            self.tabulated_r_range, self.tabulated_z_range, self.tabulated_integrals,
+            self.finite_depth_method_index, self.prony_decomposition, dispersion_relation_roots,
+            self.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 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
+
+
+class HAMS_GF(AbstractGreenFunction):
+    floating_point_precision = "float64"
+
+    exportable_settings = {'green_function': "HAMS_GF"}
+
+    def __init__(self):
+        self.infinite_depth_gf = LiangWuNoblesseGF()
+        self.finite_depth_gf = FinGreen3D(nb_dispersion_roots=200)
+
+    def __str__(self):
+        return "HAMS_GF()"
+
+    def __repr__(self):
+        return "HAMS_GF()"
+
+    def _repr_pretty_(self, p, cycle):
+        p.text(self.__repr__())
+
+    def evaluate(self, mesh1, mesh2, free_surface, water_depth, wavenumber, adjoint_double_layer=True, early_dot_product=True):
+        if water_depth == np.inf:
+            return self.infinite_depth_gf.evaluate(mesh1, mesh2, free_surface, water_depth, wavenumber, adjoint_double_layer, early_dot_product)
+        else:
+            return self.finite_depth_gf.evaluate(mesh1, mesh2, free_surface, water_depth, wavenumber, adjoint_double_layer, early_dot_product)

capytaine/io/bemio.py

@@ -0,0 +1,153 @@
+import logging
+
+import numpy as np
+import pandas as pd
+from scipy.optimize import newton
+
+LOG = logging.getLogger(__name__)
+
+#######################
+#  Import from Bemio  #
+#######################
+
+def dataframe_from_bemio(bemio_obj, wavenumber, wavelength):
+    """Transform a :class:`bemio.data_structures.bem.HydrodynamicData` into a
+        :class:`pandas.DataFrame`.
+
+        Parameters
+        ----------
+        bemio_obj: Bemio data_stuctures.bem.HydrodynamicData class
+            Loaded NEMOH, AQWA, or WAMIT data created using `bemio.io.nemoh.read`,
+            `bemio.io.aqwa.read`, or `bemio.io.wamit.read` functions, respectively.
+        wavenumber: bool
+            If True, the coordinate 'wavenumber' will be added to the output dataset.
+        wavelength: bool
+            If True, the coordinate 'wavelength' will be added to the output dataset.
+        """
+
+
+    dofs = np.array(['Surge', 'Sway', 'Heave', 'Roll', 'Pitch', 'Yaw'])
+    for i in range(bemio_obj.body[0].num_bodies):
+        difr_dict = []
+        rad_dict = []
+
+        rho = bemio_obj.body[0].rho
+        g = bemio_obj.body[0].g
+
+        if bemio_obj.body[i].water_depth == 'infinite':
+            bemio_obj.body[i].water_depth = np.inf
+
+        from_wamit = (bemio_obj.body[i].bem_code == 'WAMIT') # WAMIT coefficients need to be dimensionalized
+
+        for omega_idx, omega in enumerate(np.sort(bemio_obj.body[i].w)):
+
+            # DiffractionProblem variable equivalents
+            for dir_idx, dir in enumerate(bemio_obj.body[i].wave_dir):
+                temp_dict = {}
+                temp_dict['body_name'] = bemio_obj.body[i].name
+                temp_dict['water_depth'] = bemio_obj.body[i].water_depth
+                temp_dict['omega'] = omega
+                temp_dict['freq'] = omega/(2*np.pi)
+                temp_dict['period'] = 2*np.pi/omega
+                temp_dict['rho'] = rho
+                temp_dict['g'] = g
+                temp_dict['kind'] = "DiffractionResult"
+                temp_dict['forward_speed'] = 0.0
+                temp_dict['free_surface'] = 0.0
+                temp_dict['wave_direction'] = np.radians(dir)
+                temp_dict['influenced_dof'] = dofs
+
+                if wavenumber or wavelength:
+                    if temp_dict['water_depth'] == np.inf or omega**2*temp_dict['water_depth']/temp_dict['g'] > 20:
+                        k = omega**2/temp_dict['g']
+                    else:
+                        k = newton(lambda x: x*np.tanh(x) - omega**2*temp_dict['water_depth']/temp_dict['g'], x0=1.0)/temp_dict['water_depth']
+
+                    if wavenumber:
+                        temp_dict['wavenumber'] = k
+
+                    if wavelength:
+                        if k == 0.0:
+                            temp_dict['wavelength'] = np.inf
+                        else:
+                            temp_dict['wavelength'] = 2*np.pi/k
+
+                Fexc = np.empty(shape=bemio_obj.body[i].ex.re[:, dir_idx, omega_idx].shape, dtype=np.complex128)
+                if from_wamit:
+                    Fexc.real = bemio_obj.body[i].ex.re[:, dir_idx, omega_idx] * rho * g
+                    Fexc.imag = bemio_obj.body[i].ex.im[:, dir_idx, omega_idx] * rho * g
+                else:
+                    Fexc.real = bemio_obj.body[i].ex.re[:, dir_idx, omega_idx]
+                    Fexc.imag = bemio_obj.body[i].ex.im[:, dir_idx, omega_idx]
+                temp_dict['diffraction_force'] = Fexc.flatten()
+
+                try:
+                    Fexc_fk = np.empty(shape=bemio_obj.body[i].ex.fk.re[:, dir_idx, omega_idx].shape, dtype=np.complex128)
+                    if from_wamit:
+                        Fexc_fk.real = bemio_obj.body[i].ex.fk.re[:, dir_idx, omega_idx] * rho * g
+                        Fexc_fk.imag = bemio_obj.body[i].ex.fk.im[:, dir_idx, omega_idx] * rho * g
+                    else:
+                        Fexc_fk.real = bemio_obj.body[i].ex.fk.re[:, dir_idx, omega_idx]
+                        Fexc_fk.imag = bemio_obj.body[i].ex.fk.im[:, dir_idx, omega_idx]
+                    temp_dict['Froude_Krylov_force'] = Fexc_fk.flatten()
+
+                except AttributeError:
+                        # LOG.warning('\tNo Froude-Krylov forces found for ' + bemio_obj.body[i].name + ' at ' + str(dir) + \
+                        #       ' degrees (omega = ' + str(omega) + '), replacing with zeros.')
+                        temp_dict['Froude_Krylov_force'] = np.zeros((bemio_obj.body[i].ex.re[:, dir_idx, omega_idx].size,), dtype=np.complex128)
+
+                difr_dict.append(temp_dict)
+
+            # RadiationProblem + Hydrostatics variable equivalents
+            for radiating_dof_idx, radiating_dof in enumerate(dofs):
+                temp_dict = {}
+                temp_dict['body_name'] = bemio_obj.body[i].name
+                temp_dict['water_depth'] = bemio_obj.body[i].water_depth
+                temp_dict['omega'] = omega
+                temp_dict['freq'] = omega/(2*np.pi)
+                temp_dict['rho'] = rho
+                temp_dict['g'] = g
+                temp_dict['kind'] = "RadiationResult"
+                temp_dict['free_surface'] = 0.0
+                temp_dict['forward_speed'] = 0.0
+                temp_dict['wave_direction'] = 0.0
+                temp_dict['influenced_dof'] = dofs
+                temp_dict['radiating_dof'] = radiating_dof
+                temp_dict['added_mass'] = bemio_obj.body[i].am.all[radiating_dof_idx, :, omega_idx].flatten()
+                temp_dict['radiation_damping'] = bemio_obj.body[i].rd.all[radiating_dof_idx, :, omega_idx].flatten()
+
+                if from_wamit:
+                    temp_dict['added_mass'] = temp_dict['added_mass'] * rho
+                    temp_dict['radiation_damping'] = temp_dict['radiation_damping'] * rho * omega
+
+                if wavenumber or wavelength:
+                    if temp_dict['water_depth'] == np.inf or omega**2*temp_dict['water_depth']/temp_dict['g'] > 20:
+                        k = omega**2/temp_dict['g']
+                    else:
+                        k = newton(lambda x: x*np.tanh(x) - omega**2*temp_dict['water_depth']/temp_dict['g'], x0=1.0)/temp_dict['water_depth']
+
+                    if wavenumber:
+                        temp_dict['wavenumber'] = k
+
+                    if wavelength:
+                        if k == 0.0:
+                            temp_dict['wavelength'] = np.inf
+                        else:
+                            temp_dict['wavelength'] = 2*np.pi/k
+
+                rad_dict.append(temp_dict)
+
+    df = pd.concat([
+        pd.DataFrame.from_dict(difr_dict).explode(['influenced_dof', 'diffraction_force', 'Froude_Krylov_force']),
+        pd.DataFrame.from_dict(rad_dict).explode(['influenced_dof', 'added_mass', 'radiation_damping'])
+        ])
+    df = df.astype({'added_mass': np.float64, 'radiation_damping': np.float64, 'diffraction_force': np.complex128, 'Froude_Krylov_force': np.complex128})
+
+    all_dofs_in_order = ['Surge', 'Sway', 'Heave', 'Roll', 'Pitch', 'Yaw']
+    inf_dof_cat = pd.CategoricalDtype(categories=all_dofs_in_order)
+    df["influenced_dof"] = df["influenced_dof"].astype(inf_dof_cat)
+    if 'added_mass' in df.columns:
+        rad_dof_cat = pd.CategoricalDtype(categories=all_dofs_in_order)
+        df["radiating_dof"] = df["radiating_dof"].astype(rad_dof_cat)
+
+    return df