capytaine 2.3.1__cp310-cp310-win_amd64.whl → 3.0.0a1__cp310-cp310-win_amd64.whl

capytaine/bodies/multibodies.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+import logging
+from itertools import chain, accumulate
+from typing import Union, List, Optional
+from functools import cached_property, lru_cache
+
+import numpy as np
+import xarray as xr
+
+from capytaine.bodies.dofs import (
+    AbstractDof,
+    DofOnSubmesh,
+    add_dofs_labels_to_vector,
+    add_dofs_labels_to_matrix
+)
+
+LOG = logging.getLogger(__name__)
+
+
+class Multibody:
+    def __init__(
+        self,
+        bodies: List[Union[FloatingBody, Multibody]],
+        # own_dofs: Optional[Dict[str, np.array]] = None,
+        *,
+        name: Optional[str] = None
+    ):
+        self.bodies = bodies
+
+        if len(set(b.name for b in self.bodies)) < len(self.bodies):
+            raise ValueError(
+                "In Multibody, all component bodies must have a distinct name.\n"
+                f"Got: {[b.name for b in self.bodies]}"
+                )
+
+        # if own_dofs is None:
+        #     self.own_dofs = {}
+        # else:
+        #     self.own_dofs = own_dofs
+
+        if name is None:
+            self.name = '+'.join(b.name for b in self.bodies)
+        else:
+            self.name = name
+
+        # Keep legacy behavior of former mesh joining
+        for matrix_name in ["inertia_matrix", "hydrostatic_stiffness"]:
+            if all(hasattr(body, matrix_name) for body in bodies):
+                from scipy.linalg import block_diag
+                setattr(self, matrix_name, self.add_dofs_labels_to_matrix(
+                        block_diag(*[getattr(body, matrix_name) for body in bodies])
+                        ))
+
+        LOG.debug(f"New multibody: {self.__str__()}.")
+
+    @lru_cache
+    def as_FloatingBody(self):
+        from capytaine.bodies.bodies import FloatingBody
+        if all(body.mass is not None for body in self.bodies):
+            total_mass = sum(body.mass for body in self.bodies)
+        else:
+            total_mass = None
+
+        if (all(body.mass is not None for body in self.bodies)
+                and all(body.center_of_mass is not None for body in self.bodies)):
+            new_cog = sum(body.mass*np.asarray(body.center_of_mass) for body in self.bodies)/total_mass
+        else:
+            new_cog = None
+
+        return FloatingBody(
+                mesh=self.mesh,
+                dofs=self.dofs,
+                lid_mesh=self.lid_mesh,
+                mass=total_mass,
+                center_of_mass=new_cog,
+                name=self.name,
+                )
+
+    def __str__(self):
+        short_bodies = ', '.join(b.__short_str__() for b in self.bodies)
+        # short_dofs = '{' + ', '.join('"{}": ...'.format(d) for d in self.own_dofs) + '}'
+        return f"Multibody({short_bodies})" #, own_dofs={short_dofs})"
+
+    def __short_str__(self):
+        return str(self)
+
+    def __repr__(self):
+        return str(self)
+
+    def _check_dofs_shape_consistency(self):
+        # TODO
+        ...
+
+    @cached_property
+    def minimal_computable_wavelength(self):
+        return min(b.minimal_computable_wavelength for b in self.bodies)
+
+    def first_irregular_frequency_estimate(self, *args, **kwargs):
+        return min(b.first_irregular_frequency_estimate(*args, **kwargs) for b in self.bodies)
+
+    @cached_property
+    def mesh(self):
+        return self.bodies[0].mesh.join_meshes(*[b.mesh for b in self.bodies[1:]])
+
+    @cached_property
+    def lid_mesh(self):
+        if all(body.lid_mesh is None for body in self.bodies):
+            return None
+        else:
+            lid_meshes = [body.lid_mesh.copy() for body in self.bodies if body.lid_mesh is not None]
+            joined_lid = lid_meshes[0].join_meshes(*lid_meshes[1:], name=f"{self.name}_lid_mesh")
+            return joined_lid
+
+    @cached_property
+    def mesh_including_lid(self):
+        return self.bodies[0].mesh_including_lid.join_meshes(*[b.mesh_including_lid for b in self.bodies[1:]])
+
+    @cached_property
+    def hull_mask(self):
+        return np.concatenate([b.hull_mask for b in self.bodies])
+
+    @property
+    def nb_dofs(self):
+        return sum(b.nb_dofs for b in self.bodies) # + len(self.own_dofs)
+
+    @cached_property
+    def dofs(self):
+        for body in self.bodies:
+            body._check_dofs_shape_consistency()
+
+        componenents_dofs = {}
+        cum_nb_faces = accumulate(chain([0], (body.mesh.nb_faces for body in self.bodies)))
+        total_nb_faces = sum(body.mesh.nb_faces for body in self.bodies)
+        for body, nbf in zip(self.bodies, cum_nb_faces):
+            # nbf is the cumulative number of faces of the previous subbodies,
+            # that is the offset of the indices of the faces of the current body.
+            for name, dof in body.dofs.items():
+                if isinstance(dof, AbstractDof):
+                    new_dof = DofOnSubmesh(dof, range(nbf, nbf+body.mesh.nb_faces))
+                else:
+                    new_dof = np.zeros((total_nb_faces, 3))
+                    new_dof[nbf:nbf+len(dof), :] = dof
+
+                if '__' not in name:
+                    new_dof_name = '__'.join([body.name, name])
+                else:
+                    # The body is probably a combination of bodies already.
+                    # So for the associativity of the + operation,
+                    # it is better to keep the same name.
+                    new_dof_name = name
+                componenents_dofs[new_dof_name] = new_dof
+
+        return {**componenents_dofs} #, **self.own_dofs}
+
+    def add_dofs_labels_to_vector(self, vector):
+        """Helper function turning a bare vector into a vector labelled by the name of the dofs of the body,
+        to be used for instance for the computation of RAO."""
+        return add_dofs_labels_to_vector(self.dofs.keys(), vector)
+
+    def add_dofs_labels_to_matrix(self, matrix):
+        """Helper function turning a bare matrix into a matrix labelled by the name of the dofs of the body,
+        to be used for instance for the computation of RAO."""
+        return add_dofs_labels_to_matrix(self.dofs.keys(), matrix)
+
+    def immersed_part(self, *args, **kwargs):
+        return Multibody(
+                [b.immersed_part() for b in self.bodies],
+                # own_dofs=None,  # TODO
+                )
+
+    def __add__(self, body_to_add):
+        return self.join_bodies(body_to_add)
+
+    def join_bodies(*bodies, name=None):
+        from capytaine.bodies.multibodies import Multibody
+        return Multibody(bodies, name=name)
+
+    def integrate_pressure(self, pressure):
+        return self.as_FloatingBody().integrate_pressure(pressure)
+
+    @cached_property
+    def center_of_buoyancy(self):
+        return {b.name: b.center_of_buoyancy for b in self.bodies}
+
+    @cached_property
+    def center_of_mass(self):
+        return {b.name: b.center_of_mass for b in self.bodies}
+
+    @cached_property
+    def volume(self):
+        return {b.name: b.volume for b in self.bodies}
+
+    @cached_property
+    def mass(self):
+        return {b.name: b.mass for b in self.bodies}
+
+    def _combine_component_matrices(self, matrices):
+        for m, b in zip(matrices, self.bodies):
+            m.coords['radiating_dof'] = np.array([b.name + '__' + k for k in m.coords['radiating_dof'].values])
+            m.coords['influenced_dof'] = np.array([b.name + '__' + k for k in m.coords['influenced_dof'].values])
+
+        return xr.concat(
+            matrices,
+            dim="radiating_dof",
+            fill_value=0.0
+        ).sel(
+            radiating_dof=list(self.dofs.keys()),
+            influenced_dof=list(self.dofs.keys())
+        )
+
+    def compute_hydrostatic_stiffness(self, *, rho=1000.0, g=9.81):
+        return self._combine_component_matrices([b.compute_hydrostatic_stiffness(rho=rho, g=g) for b in self.bodies])
+
+    def compute_rigid_body_inertia(self, rho=1000.0):
+        return self._combine_component_matrices([b.compute_rigid_body_inertia(rho=rho) for b in self.bodies])

capytaine/green_functions/abstract_green_function.py

@@ -6,7 +6,7 @@ from abc import ABC, abstractmethod
 
 import numpy as np
 
-from capytaine.meshes.mesh_like_protocol import MeshLike
+from capytaine.meshes.abstract_meshes import AbstractMesh
 
 
 class GreenFunctionEvaluationError(Exception):
@@ -19,7 +19,7 @@ class AbstractGreenFunction(ABC):
     floating_point_precision: str
 
     def _get_colocation_points_and_normals(self, mesh1, mesh2, adjoint_double_layer):
-        if isinstance(mesh1, MeshLike):
+        if isinstance(mesh1, AbstractMesh):
             collocation_points = mesh1.faces_centers
             nb_collocation_points = mesh1.nb_faces
             if not adjoint_double_layer: # Computing the D matrix

capytaine/green_functions/delhommeau.py

@@ -116,7 +116,7 @@ class Delhommeau(AbstractGreenFunction):
                  gf_singularities=_default_parameters["gf_singularities"],
                  ):
 
-        self.fortran_core = import_module(f"capytaine.green_functions.libs.Delhommeau_{floating_point_precision}")
+        self.fortran_core = import_module(f"capytaine.green_functions.Delhommeau_{floating_point_precision}")
 
         self.tabulation_grid_shape = tabulation_grid_shape
         fortran_enum = {
@@ -322,20 +322,22 @@ class Delhommeau(AbstractGreenFunction):
         else:
             raise ValueError(f"Unrecognized name for the Prony decomposition method: {repr(method)}. Expected 'python' or 'fortran'.")
 
-    def evaluate_rankine_only(self,
-                              mesh1, mesh2,
-                              adjoint_double_layer=True, early_dot_product=True
-                              ):
+    def evaluate_rankine_only(
+            self,
+            mesh1, mesh2, *,
+            adjoint_double_layer=True, early_dot_product=True,
+            diagonal_term_in_double_layer=True,
+            ):
         r"""Construct the matrices between mesh1 (that can also be a list of points)
         and mesh2 for a Rankine kernel.
 
         Parameters
         ----------
-        mesh1: Mesh or CollectionOfMeshes or list of points
+        mesh1: MeshLike or list of points
             mesh of the receiving body (where the potential is measured)
             if only S is wanted or early_dot_product is False, then only a list
             of points as an array of shape (n, 3) can be passed.
-        mesh2: Mesh or CollectionOfMeshes
+        mesh2: MeshLike
             mesh of the source body (over which the source distribution is integrated)
         adjoint_double_layer: bool, optional
             compute double layer for direct method (F) or adjoint double layer
@@ -343,6 +345,11 @@ class Delhommeau(AbstractGreenFunction):
         early_dot_product: boolean, optional
             if False, return K as a (n, m, 3) array storing ∫∇G
             if True, return K as a (n, m) array storing ∫∇G·n
+        diagonal_term_in_double_layer: boolean, optional
+            if True, add the I/2 term in the double layer operator
+            It is assumed that mesh1 == mesh2, or at least that
+            the `n := min(mesh1.nb_faces, mesh2.nb_faces)` first faces
+            of each mesh are identical.
 
         Returns
         -------
@@ -365,9 +372,10 @@ class Delhommeau(AbstractGreenFunction):
                 adjoint_double_layer,
                 S, K)
 
-        if mesh1 is mesh2:
+        if diagonal_term_in_double_layer:
+            n = min(K.shape[0], K.shape[1])
             self.fortran_core.matrices.add_diagonal_term(
-                    mesh2.faces_centers, early_dot_product_normals, np.inf, K,
+                    mesh2.faces_centers[:n, :], early_dot_product_normals, np.inf, K,
                     )
 
         S, K = np.real(S), np.real(K)
@@ -383,11 +391,12 @@ class Delhommeau(AbstractGreenFunction):
         return S, K
 
 
-    def evaluate(self,
-                 mesh1, mesh2,
-                 free_surface=0.0, water_depth=np.inf, wavenumber=1.0,
-                 adjoint_double_layer=True, early_dot_product=True
-                 ):
+    def evaluate(
+            self, mesh1, mesh2, *,
+            free_surface=0.0, water_depth=np.inf, wavenumber=1.0,
+            adjoint_double_layer=True, early_dot_product=True,
+            diagonal_term_in_double_layer=True,
+            ):
         r"""The main method of the class, called by the engine to assemble the influence matrices.
 
         Parameters
@@ -408,6 +417,11 @@ class Delhommeau(AbstractGreenFunction):
         early_dot_product: boolean, optional
             if False, return K as a (n, m, 3) array storing ∫∇G
             if True, return K as a (n, m) array storing ∫∇G·n
+        diagonal_term_in_double_layer: boolean, optional
+            if True, add the I/2 term in the double layer operator.
+            It is assumed that mesh1 == mesh2, or at least that
+            the `n := min(mesh1.nb_faces, mesh2.nb_faces)` first faces
+            of each mesh are identical.
 
         Returns
         -------
@@ -483,9 +497,10 @@ class Delhommeau(AbstractGreenFunction):
             S, K
         )
 
-        if mesh1 is mesh2:
+        if diagonal_term_in_double_layer:
+            n = min(K.shape[0], K.shape[1])
             self.fortran_core.matrices.add_diagonal_term(
-                    mesh2.faces_centers, early_dot_product_normals, free_surface, K,
+                    mesh2.faces_centers[:n, :], early_dot_product_normals, free_surface, K,
                     )
 
         if np.any(np.isnan(S)) or np.any(np.isnan(K)):

capytaine/green_functions/hams.py

@@ -13,7 +13,7 @@ class LiangWuNoblesseGF(AbstractGreenFunction):
     """
     floating_point_precision = "float64"
 
-    fortran_core = import_module("capytaine.green_functions.libs.Delhommeau_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"}
 
@@ -36,11 +36,12 @@ class LiangWuNoblesseGF(AbstractGreenFunction):
     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
-                 ):
+    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")
@@ -71,7 +72,7 @@ class LiangWuNoblesseGF(AbstractGreenFunction):
             S, K
         )
 
-        if mesh1 is mesh2:
+        if diagonal_term_in_double_layer:
             self.fortran_core.matrices.add_diagonal_term(
                     mesh2.faces_centers, early_dot_product_normals, free_surface, K,
                     )
@@ -95,7 +96,7 @@ class FinGreen3D(AbstractGreenFunction):
     """
     floating_point_precision = "float64"
 
-    fortran_core = import_module("capytaine.green_functions.libs.Delhommeau_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
 
@@ -129,7 +130,12 @@ class FinGreen3D(AbstractGreenFunction):
             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):
+    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.")
@@ -163,7 +169,7 @@ class FinGreen3D(AbstractGreenFunction):
             S, K
         )
 
-        if mesh1 is mesh2:
+        if diagonal_term_in_double_layer:
             self.fortran_core.matrices.add_diagonal_term(
                     mesh2.faces_centers, early_dot_product_normals, free_surface, K,
                     )
@@ -197,8 +203,8 @@ class HAMS_GF(AbstractGreenFunction):
     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):
+    def evaluate(self, mesh1, mesh2, *, water_depth=np.inf, **kwargs):
         if water_depth == np.inf:
-            return self.infinite_depth_gf.evaluate(mesh1, mesh2, free_surface, water_depth, wavenumber, adjoint_double_layer, early_dot_product)
+            return self.infinite_depth_gf.evaluate(mesh1, mesh2, water_depth=water_depth, **kwargs)
         else:
-            return self.finite_depth_gf.evaluate(mesh1, mesh2, free_surface, water_depth, wavenumber, adjoint_double_layer, early_dot_product)
+            return self.finite_depth_gf.evaluate(mesh1, mesh2, water_depth=water_depth, **kwargs)

capytaine/io/legacy.py

@@ -9,10 +9,9 @@ import numpy as np
 
 from capytaine.bem.solver import BEMSolver
 from capytaine.io.xarray import assemble_dataset
-from capytaine.io.mesh_writers import write_MAR
+from capytaine.meshes.io import load_mesh
 from capytaine.bodies.bodies import FloatingBody
 from capytaine.bem.problems_and_results import DiffractionProblem, RadiationProblem
-from capytaine.meshes.geometry import Axis
 
 LOG = logging.getLogger(__name__)
 
@@ -47,7 +46,7 @@ def import_cal_file(filepath):
                 spec.loader.exec_module(body_initialization)
                 body = body_initialization.body
             else:
-                body = FloatingBody.from_file(mesh_file)
+                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):
@@ -58,7 +57,7 @@ def import_cal_file(filepath):
                 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(Axis(vector=direction, point=center_of_mass))
+                    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):
@@ -123,105 +122,6 @@ def import_cal_file(filepath):
     return problems
 
 
-def export_as_Nemoh_directory(problem, directory_name, omega_range=None):
-    """Export radiation problems as Nemoh 2.0 directory (experimental).
-
-    TODO: Diffraction problem.
-
-    Parameters
-    ----------
-    problem : RadiationProblem
-        the problem that should be exported
-    directory_name : string
-        path to the directory
-    omega_range : list of float or array of float, optional
-        the exported problem will be set up with the following linear range:
-        linspace(min(omega_range), max(omega_range), len(omega_range))
-    """
-
-    if os.path.isdir(directory_name):
-        LOG.warning(f"""Exporting problem in already existing directory: {directory_name}
-             You might be overwriting existing files!""")
-    else:
-        os.makedirs(directory_name)
-
-    # Export the mesh
-    write_MAR(
-        os.path.join(directory_name, f'{problem.body.name}.dat'),
-        problem.body.mesh.vertices,
-        problem.body.mesh.faces,
-        # xOz_symmetry=isinstance(problem.body, ReflectionSymmetry)
-    )
-
-    # Set range of frequencies
-    if omega_range is None:
-        omega_nb_steps = 1
-        omega_start = problem.omega
-        omega_stop = problem.omega
-    else:
-        omega_nb_steps = len(omega_range)
-        omega_start = min(omega_range)
-        omega_stop = max(omega_range)
-
-    # Write Nemoh.cal
-    with open(os.path.join(directory_name, "Nemoh.cal"), "w") as nemoh_cal:
-        nemoh_cal.write(
-                DEFAULT_NEMOH_CAL.format(
-                    rho=problem.rho,
-                    g=problem.g,
-                    depth=problem.water_depth if problem.water_depth < np.inf else 0,
-                    mesh_filename=f'{problem.body.name}.dat',
-                    mesh_vertices=problem.body.mesh.nb_vertices,
-                    mesh_faces=problem.body.mesh.nb_faces,
-                    omega_nb_steps=omega_nb_steps,
-                    omega_start=omega_start,
-                    omega_stop=omega_stop,
-                    )
-                )
-
-    # Write input.txt
-    with open(os.path.join(directory_name, "input.txt"), "w") as input_txt:
-        input_txt.write(DEFAULT_INPUT_TXT)
-
-    # Write ID.dat
-    with open(os.path.join(directory_name, "ID.dat"), "w") as id_dat:
-        id_dat.write(f"1\n.")
-
-
-DEFAULT_NEMOH_CAL = """--- Environment ------------------------------------------------------------------------------------------------------------------
-{rho}			! RHO			! KG/M**3	! Fluid specific volume
-{g}				! G			! M/S**2	! Gravity
-{depth}			! DEPTH			! M		! Water depth
-0.	0.			! XEFF YEFF		! M		! Wave measurement point
---- Description of floating bodies -----------------------------------------------------------------------------------------------
-1				! Number of bodies
---- Body 1 -----------------------------------------------------------------------------------------------------------------------
-{mesh_filename}
-{mesh_vertices} {mesh_faces}
-1				! Number of degrees of freedom
-1 0. 0. 1. 0. 0. 0.		! Heave
-1				! Number of resulting generalised forces
-1 0. 0. 1. 0. 0. 0.		! Heave
-0				! Number of lines of additional information
---- Load cases to be solved -------------------------------------------------------------------------------------------------------
-{omega_nb_steps} {omega_start} {omega_stop} ! Frequencies range
-0	0.	0.		! Number of wave directions, Min and Max (degrees)
---- Post processing ---------------------------------------------------------------------------------------------------------------
-0	0.1	10.		! IRF				! IRF calculation (0 for no calculation), time step and duration
-0				! Show pressure
-0	0.	180.		! Kochin function		! Number of directions of calculation (0 for no calculations), Min and Max (degrees)
-0	0	100.	100.	! Free surface elevation	! Number of points in x direction (0 for no calcutions) and y direction and dimensions of domain in x and y direction
-"""
-
-DEFAULT_INPUT_TXT = """--- Calculation parameters ------------------------------------------------------------------------------------
-1				! Indiq_solver		! -		! Solver (0) Direct Gauss (1) GMRES (2) GMRES with FMM acceleration (2 not implemented yet)
-20				! IRES			! -		! Restart parameter for GMRES
-5.E-07				! TOL_GMRES		! -		! Stopping criterion for GMRES
-100				! MAXIT			! -		! Maximum iterations for GMRES
-1				! Sav_potential		! -		! Save potential for visualization
-"""
-
-
 def write_dataset_as_tecplot_files(results_directory, data):
     """Write some of the data from a xarray dataset into legacy tecplot file outputs."""
 

capytaine/io/xarray.py

@@ -11,6 +11,7 @@ from datetime import datetime
 from itertools import product
 from collections import Counter
 from typing import Sequence, List, Union
+from pathlib import Path
 
 import numpy as np
 import pandas as pd
@@ -18,6 +19,7 @@ import xarray as xr
 
 from capytaine import __version__
 from capytaine.bodies.bodies import FloatingBody
+from capytaine.bodies.multibodies import Multibody
 from capytaine.bem.problems_and_results import (
     LinearPotentialFlowProblem, DiffractionProblem, RadiationProblem,
     LinearPotentialFlowResult, _default_parameters)
@@ -43,7 +45,7 @@ def _unsqueeze_dimensions(data_array, dimensions=None):
 
 
 def problems_from_dataset(dataset: xr.Dataset,
-                          bodies: Union[FloatingBody, Sequence[FloatingBody]],
+                          bodies: Union[FloatingBody, Sequence[FloatingBody], Multibody, Sequence[Multibody]],
                           ) -> List[LinearPotentialFlowProblem]:
     """Generate a list of problems from a test matrix.
 
@@ -64,7 +66,7 @@ def problems_from_dataset(dataset: xr.Dataset,
     ValueError
         if required fields are missing in the dataset
     """
-    if isinstance(bodies, FloatingBody):
+    if isinstance(bodies, (FloatingBody, Multibody)):
         bodies = [bodies]
 
     # Should be done before looking for `frequency_keys`, otherwise
@@ -279,22 +281,24 @@ def kochin_data_array(results: Sequence[LinearPotentialFlowResult],
                                  compute_kochin(result, theta_range, **kwargs))
     ])
 
+    main_freq_type = Counter((res.provided_freq_type for res in results)).most_common(1)[0][0]
+
     kochin_data = xr.Dataset()
 
     if "RadiationResult" in set(records['kind']):
         radiation = _dataset_from_dataframe(
             records[records['kind'] == "RadiationResult"],
             variables=['kochin'],
-            dimensions=['omega', 'radiating_dof', 'theta'],
+            dimensions=[main_freq_type, 'radiating_dof', 'theta'],
             optional_dims=['g', 'rho', 'body_name', 'water_depth', 'forward_speed', 'wave_direction']
         )
-        kochin_data['kochin'] = radiation['kochin']
+        kochin_data['kochin_radiation'] = radiation['kochin']
 
     if "DiffractionResult" in set(records['kind']):
         diffraction = _dataset_from_dataframe(
             records[records['kind'] == "DiffractionResult"],
             ['kochin'],
-            dimensions=['omega', 'wave_direction', 'theta'],
+            dimensions=[main_freq_type, 'wave_direction', 'theta'],
             optional_dims=['g', 'rho', 'body_name', 'water_depth', 'forward_speed']
         )
         kochin_data['kochin_diffraction'] = diffraction['kochin']
@@ -532,7 +536,7 @@ def assemble_dataset(results,
 
 def assemble_matrices(results):
     """Simplified version of assemble_dataset, returning only bare matrices.
-    Meant mainly for teaching without introducing Xarray to beginers.
+    Meant mainly for teaching without introducing Xarray to beginners.
 
     Parameters
     ----------
@@ -662,6 +666,7 @@ def export_dataset(filename, dataset, format=None, **kwargs):
             (format is not None and format.lower() == "nemoh")
             ):
         from capytaine.io.legacy import write_dataset_as_tecplot_files
+        Path(filename).mkdir(exist_ok=True)
         write_dataset_as_tecplot_files(filename, dataset, **kwargs)
     else:
         raise ValueError("`export_dataset` could not infer export format based on filename or `format` argument.\n"

capytaine/meshes/__init__.py

@@ -1,6 +1,2 @@
-# Copyright (C) 2017-2019 Matthieu Ancellin, based on the work of François Rongère
-# See LICENSE file at <https://github.com/mancellin/capytaine>
-
-from capytaine.meshes.meshes import Mesh
-from capytaine.meshes.collections import CollectionOfMeshes
-from capytaine.meshes.symmetric import ReflectionSymmetricMesh, TranslationalSymmetricMesh, AxialSymmetricMesh
+from .meshes import Mesh
+from .symmetric_meshes import ReflectionSymmetricMesh, RotationSymmetricMesh