capytaine 3.0.0a1__cp38-cp38-macosx_15_0_x86_64.whl

capytaine/green_functions/hams.py

@@ -0,0 +1,210 @@
+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.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,
+            adjoint_double_layer=True, early_dot_product=True,
+            diagonal_term_in_double_layer=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 diagonal_term_in_double_layer:
+            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.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=0.0, water_depth=np.inf, wavenumber,
+            adjoint_double_layer=True, early_dot_product=True,
+            diagonal_term_in_double_layer=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 diagonal_term_in_double_layer:
+            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, *, water_depth=np.inf, **kwargs):
+        if water_depth == np.inf:
+            return self.infinite_depth_gf.evaluate(mesh1, mesh2, water_depth=water_depth, **kwargs)
+        else:
+            return self.finite_depth_gf.evaluate(mesh1, mesh2, water_depth=water_depth, **kwargs)

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

capytaine/io/legacy.py

@@ -0,0 +1,228 @@
+"""Import or export Nemoh.cal files for backward compatibility with Nemoh 2."""
+# Copyright (C) 2017-2019 Matthieu Ancellin
+# See LICENSE file at <https://github.com/mancellin/capytaine>
+
+import os
+import logging
+
+import numpy as np
+
+from capytaine.bem.solver import BEMSolver
+from capytaine.io.xarray import assemble_dataset
+from capytaine.meshes.io import load_mesh
+from capytaine.bodies.bodies import FloatingBody
+from capytaine.bem.problems_and_results import DiffractionProblem, RadiationProblem
+
+LOG = logging.getLogger(__name__)
+
+
+def import_cal_file(filepath):
+    """Read a Nemoh.cal file and return a list of problems."""
+
+    with open(filepath, 'r') as cal_file:
+
+        cal_file.readline()  # Unused line.
+        rho = float(cal_file.readline().split()[0])
+        g = float(cal_file.readline().split()[0])
+        water_depth = float(cal_file.readline().split()[0])
+        if water_depth == 0.0:
+            water_depth = np.inf
+        xeff, yeff = (float(x) for x in cal_file.readline().split()[0:2])
+
+        bodies = []
+
+        cal_file.readline()  # Unused line.
+        nb_bodies = int(cal_file.readline().split()[0])
+        for _ in range(nb_bodies):
+            cal_file.readline()  # Unused line.
+            mesh_file = cal_file.readline().split()[0].strip()
+            mesh_file = os.path.join(os.path.dirname(filepath), mesh_file)  # mesh path are relative to Nemoh.cal
+            cal_file.readline()  # Number of points, number of panels (unused)
+
+            if os.path.splitext(mesh_file)[1] == '.py':
+                from importlib.util import spec_from_file_location, module_from_spec
+                spec = spec_from_file_location("body_initialization_module", mesh_file)
+                body_initialization = module_from_spec(spec)
+                spec.loader.exec_module(body_initialization)
+                body = body_initialization.body
+            else:
+                body = FloatingBody(mesh=load_mesh(mesh_file, file_format='nemoh'))
+
+            nb_dofs = int(cal_file.readline().split()[0])
+            for i_dof in range(nb_dofs):
+                dof_data = cal_file.readline().split()
+                if int(dof_data[0]) == 1:
+                    direction = np.array([float(x) for x in dof_data[1:4]])
+                    body.add_translation_dof(direction=direction)
+                elif int(dof_data[0]) == 2:
+                    direction = np.array([float(x) for x in dof_data[1:4]])
+                    center_of_mass = np.array([float(x) for x in dof_data[4:7]])
+                    body.add_rotation_dof(direction=direction, rotation_center=center_of_mass)
+
+            nb_forces = int(cal_file.readline().split()[0])
+            for i_force in range(nb_forces):
+                force_data = cal_file.readline().split()
+                if int(force_data[0]) == 1:
+                    direction = np.array([float(x) for x in force_data[1:4]])
+                elif int(force_data[0]) == 2:
+                    direction = np.array([float(x) for x in force_data[1:4]])
+                    center_of_mass = np.array([float(x) for x in force_data[4:7]])
+            # TODO: use the generalized forces.
+
+            nb_additional_lines = int(cal_file.readline().split()[0])
+            for _ in range(nb_additional_lines):
+                cal_file.readline()  # The additional lines are just ignored.
+
+            bodies.append(body)
+
+        if nb_bodies > 1:
+            bodies = FloatingBody.join_bodies(*bodies)
+        else:
+            bodies = bodies[0]
+
+        cal_file.readline()  # Unused line.
+        frequency_data_string_without_comment = cal_file.readline().split('!')[0]
+        frequency_data = frequency_data_string_without_comment.split()
+        if len(frequency_data) == 3:  # Nemoh v2 format
+            omega_range = np.linspace(float(frequency_data[1]), float(frequency_data[2]), int(frequency_data[0]))
+        else:
+            type_of_frequency_data = int(frequency_data[0])
+            if type_of_frequency_data == 1:  # angular frequency
+                omega_range = np.linspace(float(frequency_data[2]), float(frequency_data[3]), int(frequency_data[1]))
+            elif type_of_frequency_data == 2:  # frequency
+                omega_range = 2*np.pi*np.linspace(float(frequency_data[2]), float(frequency_data[3]), int(frequency_data[1]))
+            elif type_of_frequency_data == 3:  # period
+                omega_range = 2*np.pi/np.linspace(float(frequency_data[2]), float(frequency_data[3]), int(frequency_data[1]))
+            else:
+                raise ValueError(f"Cannot parse the frequency data \"{frequency_data_string_without_comment}\" in {filepath}.")
+
+
+        direction_data = cal_file.readline().split()
+        direction_range = np.linspace(float(direction_data[1]), float(direction_data[2]), int(direction_data[0]))
+        direction_range = np.pi/180*direction_range  # conversion from degrees to radians.
+
+        # The options below are not implemented yet.
+
+        cal_file.readline()  # Unused line.
+        irf_data = cal_file.readline()
+        show_pressure = cal_file.readline().split()[0] == "1"
+        kochin_data = cal_file.readline().split()
+        kochin_range = np.linspace(float(kochin_data[1]), float(kochin_data[2]), int(kochin_data[0]))
+        free_surface_data = cal_file.readline().split()
+
+    # Generate Capytaine's problem objects
+    env_args = dict(body=bodies, rho=rho, water_depth=water_depth, g=g)
+    problems = []
+    for omega in omega_range:
+        for direction in direction_range:
+            problems.append(DiffractionProblem(wave_direction=direction, omega=omega, **env_args))
+        for dof in bodies.dofs:
+            problems.append(RadiationProblem(radiating_dof=dof, omega=omega, **env_args))
+
+    return problems
+
+
+def write_dataset_as_tecplot_files(results_directory, data):
+    """Write some of the data from a xarray dataset into legacy tecplot file outputs."""
+
+    if 'added_mass' in data:
+        with open(os.path.join(results_directory, 'RadiationCoefficients.tec'), 'w') as fi:
+            for i in range(len(data['radiating_dof'])+1):
+                fi.write(f'...\n')
+            for dof in data.radiating_dof:
+                fi.write(f'{dof.values}\n')
+                for o in data.omega:
+                    fi.write(f'  {o.values:e}  ')
+                    for dof2 in data.influenced_dof:
+                        fi.write(f"{data['added_mass'].sel(omega=o, radiating_dof=dof, influenced_dof=dof2).values:e}")
+                        fi.write('  ')
+                        fi.write(f"{data['radiation_damping'].sel(omega=o, radiating_dof=dof, influenced_dof=dof2).values:e}")
+                        fi.write('  ')
+                    fi.write('\n')
+
+    if 'diffraction_force' in data:
+        data['excitation_force'] = data['Froude_Krylov_force'] + data['diffraction_force']
+        with open(os.path.join(results_directory, 'ExcitationForce.tec'), 'w') as fi:
+            for i in range(len(data.influenced_dof)+1):
+                fi.write(f'...\n')
+            for wave_direction in data.wave_direction.values:
+                fi.write(f'angle={wave_direction}\n')
+                for o in data.omega.values:
+                    fi.write(f'  {o:e}  ')
+                    for dof in data.influenced_dof:
+                        val = data['excitation_force'].sel(omega=o, wave_direction=wave_direction, influenced_dof=dof).values
+                        fi.write(f'{np.abs(val):e}')
+                        fi.write('  ')
+                        fi.write(f'{np.angle(val):e}')
+                        fi.write('  ')
+                    fi.write('\n')
+
+
+def _hydrostatics_writer(hydrostatics_file_path, kh_file_path, body):
+    """Write the Hydrostatics.dat and KH.dat files"""
+    with open(hydrostatics_file_path, 'w') as hf:
+        for j in range(3):
+            line =  f'XF = {body.center_of_buoyancy[j]:7.4f} - XG = {body.center_of_mass[j]:7.4f} \n'
+            hf.write(line)
+        line = f'Displacement = {body.volume:1.6E}'
+        hf.write(line)
+        hf.close()
+    np.savetxt(kh_file_path, body.hydrostatic_stiffness.values, fmt='%1.6E')
+
+
+def export_hydrostatics(hydrostatics_directory, bodies):
+    """Export rigid body hydrostatics in Nemoh's format (KH.dat and Hydrostatics.dat).
+
+    Parameters
+    ----------
+    hydrostatics_directory: string
+        Path to the directory in which the data will be written (two files per body)
+    bodies: FloatingBody or list of FloatingBody
+        The body or the list of bodies. Each body is assumed to be a single
+        rigid body with 6 dofs. Each FloatingBody object is expected to have an
+        `inertia_matrix` and a `hydrostatic_stiffness` parameter.
+
+    Return
+    ------
+    None
+    """
+
+    if os.path.isdir(hydrostatics_directory):
+        LOG.warning(f"""Exporting problem in already existing directory: {hydrostatics_directory}
+             You might be overwriting existing files!""")
+    else:
+        os.makedirs(hydrostatics_directory)
+
+    if isinstance(bodies, FloatingBody):
+        bodies = [bodies]
+
+    hydrostatics_file_name = "Hydrostatics.dat"
+    kh_file_name = "KH.dat"
+
+    body_count = len(bodies)
+    if body_count == 1:
+        body = bodies[0]
+        hydrostatics_file_path = os.path.join(hydrostatics_directory, hydrostatics_file_name)
+        kh_file_path = os.path.join(hydrostatics_directory, kh_file_name)
+        _hydrostatics_writer(hydrostatics_file_path, kh_file_path, body)
+    else:
+        for (i, body) in enumerate(bodies):
+            hydrostatics_file_path = os.path.join(hydrostatics_directory, f"Hydrostatics_{i}.dat")
+            kh_file_path = os.path.join(hydrostatics_directory, f"KH_{i}.dat")
+            _hydrostatics_writer(hydrostatics_file_path, kh_file_path, body)
+
+
+def run_cal_file(paramfile):
+    problems = import_cal_file(paramfile)
+    solver = BEMSolver()
+    results = solver.solve_all(problems)
+    data = assemble_dataset(results)
+
+    results_directory = os.path.join(os.path.dirname(paramfile), 'results')
+    try:
+        os.mkdir(results_directory)
+    except FileExistsError:
+        LOG.warning(f"The output directory ({results_directory}) already exists. You might be overwriting existing data.")
+
+    LOG.info("Write results in legacy tecplot format.")
+    write_dataset_as_tecplot_files(results_directory, data)