capytaine 2.3.1__cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl

capytaine/bodies/dofs.py

@@ -0,0 +1,19 @@
+# Copyright (C) 2017-2022 Matthieu Ancellin
+# See LICENSE file at <https://github.com/capytaine/capytaine>
+
+
+class RigidBodyDofsPlaceholder:
+    """Pass an instance of this class to the FloatingBody initializer to initialize the 6 ridig body dofs."""
+
+    def __init__(self, rotation_center=None):
+        self.rotation_center = rotation_center
+
+    def __str__(self):
+        return "RigidBodyDofsPlaceholder()"
+
+    def _repr_pretty_(self, p, cycle):
+        p.text(self.__str__())
+
+
+def rigid_body_dofs(rotation_center=None):
+    return RigidBodyDofsPlaceholder(rotation_center=rotation_center)

capytaine/bodies/predefined/__init__.py

@@ -0,0 +1,6 @@
+# Copyright (C) 2017-2019 Matthieu Ancellin
+# See LICENSE file at <https://github.com/mancellin/capytaine>
+
+from capytaine.bodies.predefined.spheres import Sphere
+from capytaine.bodies.predefined.cylinders import HorizontalCylinder, VerticalCylinder
+from capytaine.bodies.predefined.rectangles import Rectangle, RectangularParallelepiped

capytaine/bodies/predefined/cylinders.py

@@ -0,0 +1,151 @@
+"""Legacy interfaces to predefined meshes"""
+# Copyright (C) 2017-2022 Matthieu Ancellin
+# See LICENSE file at <https://github.com/capytaine/capytaine>
+
+import logging
+import numpy as np
+
+from capytaine.meshes.predefined import mesh_disk, mesh_vertical_cylinder, mesh_horizontal_cylinder
+from capytaine.meshes.meshes import Mesh
+from capytaine.bodies.bodies import FloatingBody
+
+LOG = logging.getLogger(__name__)
+
+
+##########
+#  Disk  #
+##########
+
+class Disk(FloatingBody):
+    """(One-sided) disk.
+    Deprecated: please prefer capytaine.meshes.predefined.mesh_disk()
+
+    Parameters
+    ----------
+    radius : float, optional
+        radius of the disk
+    resolution : 2-ple of int, optional
+        number of panels along a radius and around the disk
+    center : 3-ple or array of shape (3,), optional
+        position of the geometric center of the disk
+    normal: 3-ple of floats, optional
+        normal vector, default: along x axis
+    axial_symmetry : bool, optional
+        if True, use the axial symmetry to speed up the computations
+    reflection_symmetry : bool, optional
+        if True, use the reflection symmetry to speed up the computations
+    name : str, optional
+        a string naming the floating body
+    """
+
+    def __init__(self, radius=1.0, resolution=(3, 5),
+                 center=(0, 0, 0), normal=(1, 0, 0),
+                 reflection_symmetry=False, axial_symmetry=False,
+                 name=None):
+        LOG.warning("Deprecation warning: The class Disk() is deprecated. "
+                "Please prefer the function capytaine.meshes.predefined.mesh_disk()")
+
+        if name is None:
+            name = f"disk_{next(Mesh._ids)}"
+
+        self.radius = float(radius)
+        self.geometric_center = np.asarray(center, dtype=float)
+        mesh = mesh_disk(radius=radius, center=center, normal=normal, resolution=resolution,
+                reflection_symmetry=reflection_symmetry, axial_symmetry=axial_symmetry, name=f"{name}_mesh")
+        FloatingBody.__init__(self, mesh=mesh, name=name)
+
+
+##############
+#  Cylinder  #
+##############
+
+class HorizontalCylinder(FloatingBody):
+    """Horizontal cylinder
+    Deprecated: please prefer capytaine.meshes.predefined.mesh_horizontal_cylinder()
+
+    Parameters
+    ----------
+    length : float, optional
+        length of the cylinder
+    radius : float, optional
+        radius of the cylinder
+    center : 3-ple or array of shape (3,), optional
+        position of the geometric center of the cylinder
+    nx : int, optional
+        number of circular slices
+    ntheta : int, optional
+        number of panels along a circular slice of the cylinder
+    nr : int, optional
+        number of panels along a radius on the extremities of the cylinder
+    reflection_symmetry : bool, optional
+        if True, returns a ReflectionSymmetricMesh
+    translation_symmetry : bool, optional
+        if True, uses a TranslationalSymmetricMesh internally for the main part of the cylinder
+    name : str, optional
+        a string naming the floating body
+    """
+
+    def __init__(self, length=10.0, radius=1.0, center=(0, 0, 0),
+                 nx=10, ntheta=10, nr=2,
+                 reflection_symmetry=True, translation_symmetry=False,
+                 clever=None,
+                 name=None):
+
+        LOG.warning("Deprecation warning: The class HorizontalCylinder() is deprecated. "
+                "Please prefer the function capytaine.meshes.predefined.mesh_horizontal_cylinder()")
+
+        self.length = length
+        self.radius = radius
+        self.geometric_center = np.asarray(center, dtype=float)
+
+        if name is None:
+            name = f"cylinder_{next(Mesh._ids)}"
+
+        mesh = mesh_horizontal_cylinder(length=length, radius=radius, center=center,
+                resolution=(nr, ntheta, nx), reflection_symmetry=reflection_symmetry,
+                translation_symmetry=translation_symmetry, name=f"{name}_mesh")
+        FloatingBody.__init__(self, mesh=mesh, name=name)
+
+
+class VerticalCylinder(FloatingBody):
+    """Vertical cylinder.
+    Deprecated: please prefer capytaine.meshes.predefined.mesh_vertical_cylinder()
+
+    Parameters
+    ----------
+    length : float, optional
+        length of the cylinder
+    radius : float, optional
+        radius of the cylinder
+    center : 3-ple or array of shape (3,), optional
+        position of the geometric center of the cylinder
+    nx : int, optional
+        number of circular slices
+    ntheta : int, optional
+        number of panels along a circular slice of the cylinder
+    nr : int, optional
+        number of panels along a radius on the extremities of the cylinder
+    clever : bool, optional
+        if True, uses the mesh symmetries
+    name : str, optional
+        a string naming the floating body
+    """
+
+    def __init__(self, length=10.0, radius=1.0, center=(0, 0, 0),
+                 nx=10, ntheta=10, nr=2,
+                 clever=True, name=None):
+        LOG.warning("Deprecation warning: The class VerticalCylinder() is deprecated. "
+                "Please prefer the function capytaine.meshes.predefined.mesh_vertical_cylinder()")
+
+        self.length = length
+        self.radius = radius
+        self.geometric_center = np.asarray(center, dtype=float)
+
+        if name is None:
+            name = f"cylinder_{next(Mesh._ids)}"
+
+        mesh = mesh_vertical_cylinder(length=length, radius=radius, center=center,
+                resolution=(nr, ntheta, nx), reflection_symmetry=False,
+                axial_symmetry=clever, name=f"{name}_mesh")
+
+        FloatingBody.__init__(self, mesh=mesh, name=name)

capytaine/bodies/predefined/rectangles.py

@@ -0,0 +1,111 @@
+"""Legacy interfaces to predefined meshes"""
+# Copyright (C) 2017-2022 Matthieu Ancellin
+# See LICENSE file at <https://github.com/capytaine/capytaine>
+
+import logging
+import numpy as np
+
+from capytaine.meshes.predefined import mesh_rectangle, mesh_parallelepiped
+from capytaine.meshes.meshes import Mesh
+from capytaine.bodies.bodies import FloatingBody
+
+LOG = logging.getLogger(__name__)
+
+
+class Rectangle(FloatingBody):
+    """One-sided vertical rectangle (along y and z).
+
+    By default, the normals are oriented in the positive y direction.
+
+    Parameters
+    ----------
+    size : couple of floats, optional
+        dimensions of the rectangle (width and height)
+    resolution : couple of ints, optional
+        number of faces along each of the two directions
+    center : 3-ple of floats, optional
+        position of the geometric center of the rectangle, default: (0, 0, 0)
+    normal: 3-ple of floats, optional
+        normal vector, default: along x axis
+    translational_symmetry : bool, optional
+        if True, use the translation symmetry to speed up the computations
+    reflection_symmetry : bool, optional
+        if True, use the reflection symmetry to speed up the computations
+    name : string, optional
+        a name for the body
+    """
+
+    def __init__(self, size=(5.0, 5.0), resolution=(5, 5),
+                 center=(0, 0, 0), normal=(1, 0, 0),
+                 translational_symmetry=False, reflection_symmetry=False, name=None):
+
+        LOG.warning("Deprecation warning: The class Rectangle() is deprecated. "
+                    "Please prefer the function capytaine.meshes.predefined.mesh_rectangle()")
+
+        self.size = np.asarray(size, dtype=float)
+        self.geometric_center = np.asarray(center, dtype=float)
+
+        if name is None:
+            name = f"rectangle_{next(Mesh._ids)}"
+
+        mesh = mesh_rectangle(size=size, resolution=resolution, center=center, normal=normal,
+                translation_symmetry=translational_symmetry, reflection_symmetry=reflection_symmetry,
+                name=f"{name}_mesh")
+        FloatingBody.__init__(self, mesh=mesh, name=name)
+
+
+class RectangularParallelepiped(FloatingBody):
+    """Six rectangles forming a parallelepiped.
+
+    Parameters
+    ----------
+    size : 3-ple of floats, optional
+        dimensions of the parallelepiped (width, thickness, height) for coordinates (x, y, z).
+    resolution : 3-ple of ints, optional
+        number of faces along the three directions
+    center : 3-ple of floats, optional
+        coordinates of the geometric center of the parallelepiped
+    top: bool, optional
+        whether or not to close the parallelepiped on the top
+    bottom: bool, optional
+        whether or not to close the parallelepiped on the bottom
+    reflection_symmetry : bool, optional
+        use xOz and yOz symmetry plane to generate the mesh
+    translational_symmetry : bool, optional
+        if True, use the translation symmetry in the x direction to speed up the computations.
+        To use the translation symmetry in the y direction, create a x-symmetric body and then rotate it by pi/2.
+    name : string, optional
+        a name for the body
+    """
+
+    def __init__(self,
+                 size=(1.0, 1.0, 1.0), resolution=(4, 4, 4),
+                 center=(0, 0, 0),
+                 top=True, bottom=True,
+                 reflection_symmetry=False,
+                 translational_symmetry=False,
+                 name=None):
+
+        LOG.warning("Deprecation warning: The class RectangularParallelepiped() is deprecated. "
+                    "Please prefer the function capytaine.meshes.predefined.mesh_parallelepiped()")
+
+        if name is None:
+            name = f"rectangular_parallelepiped_{next(Mesh._ids)}"
+
+        missing_sides = set()
+        if not top: missing_sides.add("top")
+        if not bottom: missing_sides.add("bottom")
+
+        mesh = mesh_parallelepiped(size=size, resolution=resolution, center=center,
+                missing_sides=missing_sides,
+                translation_symmetry=translational_symmetry, reflection_symmetry=reflection_symmetry,
+                name=f"{name}_mesh")
+
+        self.geometric_center = np.asarray(center, dtype=float)
+
+        FloatingBody.__init__(self, mesh=mesh, name=name)
+
+class OpenRectangularParallelepiped(RectangularParallelepiped):
+    def __init__(self, *args, **kwargs):
+        RectangularParallelepiped.__init__(self, top=False, bottom=False, *args, **kwargs)
+        # Kept mostly for legacy

capytaine/bodies/predefined/spheres.py

@@ -0,0 +1,70 @@
+"""Generate spherical bodies."""
+# Copyright (C) 2017-2022 Matthieu Ancellin
+# See LICENSE file at <https://github.com/capytaine/capytaine>
+
+import logging
+
+import numpy as np
+
+from capytaine.meshes import Mesh
+from capytaine.meshes.predefined import mesh_sphere
+from capytaine.bodies.bodies import FloatingBody
+
+LOG = logging.getLogger(__name__)
+
+
+class Sphere(FloatingBody):
+    """Sphere
+    Deprecated: please prefer capytaine.meshes.predefined.mesh_sphere()
+
+    Parameters
+    ----------
+    radius : float
+        radius of the sphere
+    center : 3-ple or array of shape (3,)
+        position of the geometric center of the sphere
+    ntheta : int
+        number of panels along a meridian (or number of parallels-1)
+    nphi : int
+        number of panels along a parallel (or number of meridians-1)
+    axial_symmetry : bool
+        if True, use the axial symmetry to build the mesh (default: True)
+    clip_free_surface : bool
+        if True, only mesh the part of the sphere where z < 0 (default: False),
+        can be used with center to obtain any clipped sphere,
+        if True, then ntheta is the number of parallel below the free surface.
+    name : string
+        a name identifying the sphere (default: "sphere_id" where id is an unique integer).
+    """
+
+    def __init__(self, *, radius=1.0, center=(0, 0, 0),
+                 ntheta=10, nphi=10, clip_free_surface=False,
+                 axial_symmetry=True, clever=None,
+                 name=None):
+
+        LOG.warning("Deprecation warning: The class Sphere() is deprecated. "
+                "Please prefer the function capytaine.meshes.predefined.mesh_sphere()")
+
+        if clever is not None:
+            LOG.warning("Deprecation warning: `clever` argument for Sphere is deprecated. "
+                        "Use `axial_symmetry` instead.")
+
+        if name is None:
+            name = f"sphere_{next(Mesh._ids)}"
+
+        if clip_free_surface:
+            if center[2] < -radius:  # fully immersed
+                pass
+            elif center[2] < radius:
+                ntheta = int(ntheta*np.pi/np.arccos(center[2]/radius))
+            else:
+                raise ValueError("Impossible to mesh the immersed hull of a sphere completely out of the water")
+
+        mesh = mesh_sphere(radius=radius, center=center, resolution=(ntheta, nphi), axial_symmetry=axial_symmetry, name=f"{name}_mesh")
+
+        if clip_free_surface:
+            mesh.keep_immersed_part()
+
+        self.radius = radius
+        self.geometric_center = np.array(center, dtype=float)
+        FloatingBody.__init__(self, mesh=mesh, name=name)

capytaine/green_functions/FinGreen3D/.gitignore

@@ -0,0 +1 @@
+build/