capytaine.bodies.bodies module

Floating bodies to be used in radiation-diffraction problems.

class capytaine.bodies.bodies.FloatingBody(mesh=None, dofs=None, *, lid_mesh=None, center_of_mass=None, mass=None, name=None)

Bases: _FloatingBodyHydrostaticsMixin, AbstractBody

A floating body described as a mesh and some degrees of freedom.

The mesh structure is stored as a Mesh from capytaine.mesh.mesh or a CollectionOfMeshes from capytaine.mesh.meshes_collection.

The degrees of freedom (dofs) are stored as a dict associating a name to a complex-valued array of shape (nb_faces, 3). To each face of the body (as indexed in the mesh) corresponds a complex-valued 3d vector, which defines the displacement of the center of the face in frequency domain.

Parameters:

• mesh (AbstractMesh, optional) – the mesh describing the geometry of the hull of the floating body. If none is given, a empty one is created.

• dofs (dict, optional) – the degrees of freedom of the body. If none is given, a empty dictionary is initialized.

• lid_mesh (AbstractMesh or None, optional) – a mesh of an internal lid for irregular frequencies removal. Unlike the mesh of the hull, no dof is defined on the lid_mesh. If none is given, none is used when solving the Boundary Integral Equation.

• center_of_mass (3-element array, optional) – the position of the center of mass. Required only for some hydrostatics computation.

• mass (float or None, optional) – the mass of the body in kilograms. Required only for some hydrostatics computation. If None, the mass is implicitly assumed to be the mass of displaced water.

• name (str, optional) – a name for the body. If none is given, the one of the mesh is used.

Variables:

• mesh_including_lid (AbstractMesh) – The hull mesh joined with the lid mesh

• hull_mask (np.array) – The indices of the faces in mesh_including_lid that are part of the hull

add_all_rigid_body_dofs(rotation_center=None) → None

Add the six degrees of freedom of rigid bodies (in place).

add_rotation_dof(rotation_center=None, direction=None, name=None) → None

Add a new rotation dof (in place). If no axis is given, the code tries to infer it from the name.

Parameters:

• rotation_center (array of shape (3,), optional) – One point on the rotation axis

• direction (array of shape (3,), optional) – The direction of the rotation axis

• name (str, optional) – a name for the degree of freedom

add_translation_dof(direction=None, name=None) → None

Add a new translation dof (in place). If no direction is given, the code tries to infer it from the name.

Parameters:

• direction (array of shape (3,), optional) – the direction of the translation

• name (str, optional) – a name for the degree of freedom

animate(motion, *args, **kwargs)

assemble_arbitrary_array(locations: ndarray)

assemble_regular_array(distance, nb_bodies)

Create an regular array of identical bodies.

Parameters:

• distance (float) – Center-to-center distance between objects in the array

• nb_bodies (couple of ints) – Number of objects in the x and y directions.

Return type:

FloatingBody

property bodies

For consistency with Multibody

clipped(*, origin, normal, name=None) → FloatingBody

copy(name=None) → FloatingBody

Return a deep copy of the body.

Parameters:

name (str, optional) – a name for the new copy

first_irregular_frequency_estimate(*, g=9.81)

Estimates the angular frequency of the lowest irregular frequency. This is based on the formula for the lowest irregular frequency of a parallelepiped of size \(L \times B\) and draft \(H\):

(13)\[\omega = \sqrt{ \frac{\pi g \sqrt{\frac{1}{B^2} + \frac{1}{L^2}}} {\tanh\left(\pi H \sqrt{\frac{1}{B^2} + \frac{1}{L^2}} \right)} }\]

The formula is applied to all shapes to get an estimate that is usually conservative. The definition of a lid (supposed to be fully covering and horizontal) is taken into account.

static from_file(filename: str, file_format=None, name=None) → FloatingBody

Create a FloatingBody from a mesh file using meshmagick. Kinda deprecated, use cpt.load_mesh instead.

static from_meshio(mesh, name=None) → FloatingBody

Create a FloatingBody from a meshio mesh object. Kinda deprecated, use cpt.load_mesh instead.

immersed_part(free_surface=0.0, *, sea_bottom=None, water_depth=None, name=None) → FloatingBody

integrate_pressure(pressure)

integrate_pressure_on_moving_body(pressure, first_order_motion_amplitude)

Integrate the pressure on the moving body, up to second order. Experimental.

Computes the order-2 expansion of F_j = -∫ p(X+u) δu_j(X+u)·(A n) dS on the mean body surface, where u is the displacement of the body for the motion given by first_order_motion_amplitude, δu_j(X+u) the motion of dof j at the displaced point, and A n dS the displaced normal and surface element (Nanson’s formula, A = det(F) F^-T with F = I + ∇u).

Parameters:

• pressure (DifferenceFrequencyExpansion) – Pressure at the displaced faces centers p(X+u), with field (nb_faces,).

• first_order_motion_amplitude (DifferenceFrequencyExpansion, first order, with field (nb_dofs,)) – Complex amplitudes of the dofs at one frequency (order 1 of shape (nb_wave_directions, nb_dofs), for the wave directions of pressure).

Returns:

The generalized forces, with field (nb_dofs,).

Return type:

DifferenceFrequencyExpansion

integrate_pressure_on_waterline(pressure)

Integrate a lineic pressure along the mean waterline, up to second order. Experimental.

Parameters:

pressure (DifferenceFrequencyExpansion) – Pressure integrated over the width (along the hull) of the strip between the mean waterline and the free surface: force per unit length of waterline, at the middle of the edges of the waterline of self.mesh.merged(), with field (nb_edges_waterline,). It is projected on the normals of the faces containing the edges of the waterline.

Returns:

The generalized forces, with field (nb_dofs,).

Return type:

DifferenceFrequencyExpansion

keep_only_dofs(*args, **kwargs)

property minimal_computable_wavelength

For accuracy of the resolution, wavelength should not be smaller than this value.

mirrored(plane: Literal['xOz', 'yOz']) → FloatingBody

property nb_dofs: int

Number of degrees of freedom.

rename(name: str) → FloatingBody

rotated_with_matrix(R, *, name=None) → FloatingBody

property rotation_center: array

Try to infer a rotation center by looking at the dofs. Most bodies are rigid bodies with one and only one rotation center, but not all. Only used for exporting data, as it might not be defined.

translated(shift, *, name=None) → FloatingBody

with_only_dofs(dofs)