capytaine 2.3__cp310-cp310-macosx_14_0_arm64.whl → 3.0.0a1__cp310-cp310-macosx_14_0_arm64.whl

capytaine/meshes/predefined/cylinders.py

@@ -1,5 +1,5 @@
 """Generate meshes of cylinders and disks"""
-# Copyright (C) 2017-2022 Matthieu Ancellin
+# Copyright (C) 2017-2025 Matthieu Ancellin
 # See LICENSE file at <https://github.com/capytaine/capytaine>
 
 import logging
@@ -8,10 +8,8 @@ from itertools import product
 import numpy as np
 from numpy import pi, cos, sin
 
-from capytaine.meshes.geometry import xOz_Plane, yOz_Plane, Oz_axis
 from capytaine.meshes.meshes import Mesh
-from capytaine.meshes.collections import CollectionOfMeshes
-from capytaine.meshes.symmetric import TranslationalSymmetricMesh, AxialSymmetricMesh, ReflectionSymmetricMesh
+from capytaine.meshes.symmetric_meshes import RotationSymmetricMesh, ReflectionSymmetricMesh
 
 LOG = logging.getLogger(__name__)
 
@@ -61,9 +59,6 @@ def mesh_disk(*, radius=1.0, center=(0, 0, 0), normal=(0, 0, 1),
             nr = int(np.ceil(radius / (np.sqrt(2) * faces_max_radius)))
             ntheta = int(np.ceil(2*pi*radius / (np.sqrt(2) * faces_max_radius)))
 
-    if name is None:
-        name = f"disk_{next(Mesh._ids)}"
-
     if reflection_symmetry and axial_symmetry:
         raise NotImplementedError("Disks with both symmetries have not been implemented.")
 
@@ -77,13 +72,13 @@ def mesh_disk(*, radius=1.0, center=(0, 0, 0), normal=(0, 0, 1),
         half_mesh = mesh_disk(radius=radius, _theta_max=_theta_max/2, resolution=(nr, ntheta//2),
                 center=(0, 0, 0), normal=(0, 0, 1),
                 reflection_symmetry=False, axial_symmetry=False, name=f"half_of_{name}")
-        mesh = ReflectionSymmetricMesh(half_mesh, plane=xOz_Plane, name=name)
+        mesh = ReflectionSymmetricMesh(half_mesh, plane='xOz', name=name)
 
     elif axial_symmetry:
         mesh_slice = mesh_disk(radius=radius, _theta_max=_theta_max/ntheta, resolution=(nr, 1),
                 center=(0, 0, 0), normal=(0, 0, 1),
                 reflection_symmetry=False, axial_symmetry=False, name=f"slice_of_{name}")
-        mesh = AxialSymmetricMesh(mesh_slice, axis=Oz_axis, nb_repetitions=ntheta - 1, name=name)
+        mesh = RotationSymmetricMesh(mesh_slice, axis='z+', n=ntheta, name=name)
 
     else:
         theta_range = np.linspace(0, _theta_max, ntheta+1)
@@ -94,10 +89,8 @@ def mesh_disk(*, radius=1.0, center=(0, 0, 0), normal=(0, 0, 1),
 
         mesh = Mesh(nodes, panels, name=name)
 
-    mesh.heal_mesh()
-    mesh.translate(center)
-    mesh.rotate_around_center_to_align_vectors(center, mesh.faces_normals[0], normal)
-    mesh.geometric_center = np.asarray(center, dtype=float)
+    mesh = mesh.rotated_such_that_vectors_are_aligned(mesh.faces_normals[0], normal)
+    mesh = mesh.translated(center, name=name)
     return mesh
 
 
@@ -153,9 +146,6 @@ def mesh_vertical_cylinder(*, length=10.0, radius=1.0, center=(0, 0, 0),
             ntheta = 2*int(np.ceil(pi*radius / (np.sqrt(2) * faces_max_radius)))
             nz = int(np.ceil(length / (np.sqrt(2) * faces_max_radius)))
 
-    if name is None:
-        name = f"cylinder_{next(Mesh._ids)}"
-
     LOG.debug(f"New vertical cylinder of length {length}, radius {radius} and resolution {resolution}, named {name}.")
 
     if reflection_symmetry and axial_symmetry:
@@ -170,13 +160,13 @@ def mesh_vertical_cylinder(*, length=10.0, radius=1.0, center=(0, 0, 0),
                 resolution=(nr, ntheta//2, nz), reflection_symmetry=False, axial_symmetry=False,
                 name=f"half_{name}", _theta_max=_theta_max/2)
 
-        mesh = ReflectionSymmetricMesh(half_cylinder, plane=yOz_Plane, name=name)
+        mesh = ReflectionSymmetricMesh(half_cylinder, plane='yOz', name=name)
 
     elif axial_symmetry:
 
         mesh_slice = mesh_vertical_cylinder(length=length, radius=radius, resolution=(nr, 1, nz), center=(0, 0, 0),
                 reflection_symmetry=False, axial_symmetry=False, name=f"slice_of_{name}", _theta_max=_theta_max/ntheta)
-        mesh = AxialSymmetricMesh(mesh_slice, axis=Oz_axis, nb_repetitions=ntheta - 1, name=name)
+        mesh = RotationSymmetricMesh(mesh_slice, axis='z+', n=ntheta, name=name)
 
     else:
         theta_range = np.linspace(0, _theta_max, ntheta+1)
@@ -196,15 +186,13 @@ def mesh_vertical_cylinder(*, length=10.0, radius=1.0, center=(0, 0, 0),
 
         mesh = Mesh(nodes, panels, name=name)
 
-    mesh.heal_mesh()
-    mesh.translate(center)
-    mesh.geometric_center = np.asarray(center, dtype=float)
+    mesh = mesh.translated(center, name=name)
     return mesh
 
 
 def mesh_horizontal_cylinder(*, length=10.0, radius=1.0, center=(0, 0, 0),
         resolution=(2, 8, 10), faces_max_radius=None,
-        reflection_symmetry=False, translation_symmetry=False, name=None, _theta_max=2*pi):
+        reflection_symmetry=False, name=None, _theta_max=2*pi):
     """Cylinder aligned along Ox axis.
 
     Total number of panels = (2*resolution[0] + resolution[2])*resolution[1]
@@ -243,9 +231,6 @@ def mesh_horizontal_cylinder(*, length=10.0, radius=1.0, center=(0, 0, 0),
 
     assert len(center) == 3, "Position of the center of a cylinder should be given a 3-ple of values."
 
-    if name is None:
-        name = f"cylinder_{next(Mesh._ids)}"
-
     LOG.debug(f"New horizontal cylinder of length {length}, radius {radius} and resolution {resolution}, named {name}.")
 
     nr, ntheta, nx = resolution
@@ -268,47 +253,28 @@ def mesh_horizontal_cylinder(*, length=10.0, radius=1.0, center=(0, 0, 0),
         half_cylinder = mesh_horizontal_cylinder(
                 length=length, radius=radius, center=(0, 0, 0),
                 resolution=(nr, ntheta//2, nx),
-                reflection_symmetry=False, translation_symmetry=translation_symmetry,
+                reflection_symmetry=False,
                 name=f"half_{name}", _theta_max=_theta_max/2,
                 )
 
-        mesh = ReflectionSymmetricMesh(half_cylinder, plane=xOz_Plane, name=name)
-
-    else:
-        if translation_symmetry:
-            slice = mesh_horizontal_cylinder(
-                    length=length/nx, radius=radius, center=(-length/2 + length/(2*nx), 0, 0),
-                    resolution=(0, ntheta, 1),
-                    reflection_symmetry=False, translation_symmetry=False,
-                    name=f"slice_of_{name}", _theta_max=_theta_max,
-                    )
-
-            open_cylinder = TranslationalSymmetricMesh(
-                    slice, translation=np.asarray([length / nx, 0.0, 0.0]),
-                    nb_repetitions=nx-1, name=f"open_{name}")
+        mesh = ReflectionSymmetricMesh(half_cylinder, plane='xOz', name=name)
 
-        else: # General case
-            theta_range = np.linspace(0, _theta_max, ntheta+1)
-            x_range = np.linspace(-length/2, length/2, nx+1)
-            nodes = np.array([(x, radius*sin(t), -radius*cos(t)) for (x, t) in product(x_range, theta_range)])
+    else: # General case
+        theta_range = np.linspace(0, _theta_max, ntheta+1)
+        x_range = np.linspace(-length/2, length/2, nx+1)
+        nodes = np.array([(x, radius*sin(t), -radius*cos(t)) for (x, t) in product(x_range, theta_range)])
 
-            panels = np.array([(i+j*(ntheta+1), i+1+j*(ntheta+1), i+1+(j+1)*(ntheta+1), i+(j+1)*(ntheta+1))
-                                for (i, j) in product(range(ntheta), range(nx))])
+        panels = np.array([(i+j*(ntheta+1), i+1+j*(ntheta+1), i+1+(j+1)*(ntheta+1), i+(j+1)*(ntheta+1))
+                            for (i, j) in product(range(ntheta), range(nx))])
 
-            open_cylinder = Mesh(nodes, panels, name=f"open_{name}")
+        mesh = Mesh(nodes, panels, name=f"open_{name}")
 
         if nr > 0:
             side = mesh_disk(radius=radius, center=(-length/2, 0, 0), normal=(-1, 0, 0),
                              reflection_symmetry=False, resolution=(nr, ntheta), name=f"side_of_{name}",
                              _theta_max=_theta_max)
-            other_side = side.mirrored(yOz_Plane, name=f"other_side_of_{name}")
-            mesh = CollectionOfMeshes([open_cylinder, side, other_side], name=name)
-            if not translation_symmetry:
-                mesh = mesh.merged()
-        else:
-            mesh = open_cylinder.copy(name=name)
+            other_side = side.mirrored('yOz', name=f"other_side_of_{name}")
+            mesh = Mesh.join_meshes(mesh, side, other_side, name=name)
 
-    mesh.heal_mesh()
-    mesh.translate(center)
-    mesh.geometric_center = np.asarray(center, dtype=float)
+    mesh = mesh.translated(center, name=name)
     return mesh

capytaine/meshes/predefined/rectangles.py

@@ -1,22 +1,21 @@
 """Generate rectangular bodies."""
 # Copyright (C) 2017-2024 Matthieu Ancellin
 # See LICENSE file at <https://github.com/capytaine/capytaine>
+
 import logging
 from itertools import product
 
 import numpy as np
 
-from capytaine.meshes.geometry import xOz_Plane, yOz_Plane
 from capytaine.meshes.meshes import Mesh
-from capytaine.meshes.symmetric import TranslationalSymmetricMesh, ReflectionSymmetricMesh
-from capytaine.meshes.collections import CollectionOfMeshes
+from capytaine.meshes.symmetric_meshes import ReflectionSymmetricMesh
 
 LOG = logging.getLogger(__name__)
 
 def mesh_rectangle(*, size=(5.0, 5.0), center=(0.0, 0.0, 0.0),
         resolution=(5, 5), faces_max_radius=None,
         normal=(0.0, 0.0, 1.0),
-        translation_symmetry=False, reflection_symmetry=False,
+        reflection_symmetry=False,
         name=None):
     """One-sided rectangle.
 
@@ -36,8 +35,6 @@ def mesh_rectangle(*, size=(5.0, 5.0), center=(0.0, 0.0, 0.0),
         changed to fit the constraint on the maximal radius.
     normal: 3-ple of floats, optional
         normal vector, default: (0, 0, 1)
-    translation_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
@@ -62,33 +59,21 @@ def mesh_rectangle(*, size=(5.0, 5.0), center=(0.0, 0.0, 0.0),
             nw = int(np.ceil(width / (np.sqrt(2) * faces_max_radius)))
             nh = int(np.ceil(height / (np.sqrt(2) * faces_max_radius)))
 
-    if name is None:
-        name = f"rectangle_{next(Mesh._ids)}"
-
-    if translation_symmetry and reflection_symmetry:
-        raise NotImplementedError("Rectangle generation with both reflection and translation symmetries "
-                                  "has not been implemented.")
-
     if reflection_symmetry:
         if nw % 2 == 1:
-            raise ValueError("To use the reflection symmetry of the mesh, "
+            raise ValueError("To define a rectangle mesh with reflection symmetry, "
                              "it should have an even number of panels in this direction.")
 
+        if not np.isclose(center[1], 0.0) or not np.isclose(normal[1], 0.0):
+            raise ValueError("To define a rectangle mesh with reflection symmetry, "
+                             "its center should be in the xOz plane (that is y=0) "
+                             "and so should also be its normal vector.")
+
         half_mesh = mesh_rectangle(size=(width/2, height), resolution=(nw//2, nh),
-                                   center=(0, -width/4, 0), normal=(0.0, 0.0, 1.0),
-                                   translation_symmetry=False, reflection_symmetry=False,
+                                   center=(0, -width/4, 0), normal=normal,
+                                   reflection_symmetry=False,
                                    name=f"half_of_{name}")
-        mesh = ReflectionSymmetricMesh(half_mesh, plane=xOz_Plane, name=name)
-
-    elif translation_symmetry:
-            strip = mesh_rectangle(size=(width/nw, height), resolution=(1, nh),
-                                   center=(0, -width/2 + width/(2*nw), 0), normal=(0.0, 0.0, 1.0),
-                                   translation_symmetry=False, reflection_symmetry=False,
-                                   name=f"strip_of_{name}")
-            mesh = TranslationalSymmetricMesh(strip,
-                                              translation=np.asarray([0, width/nw, 0]),
-                                              nb_repetitions=int(nw)-1,
-                                              name=name)
+        mesh = ReflectionSymmetricMesh(half_mesh, plane='xOz', name=name)
 
     else:
         y_range = np.linspace(-width/2, width/2, nw+1)
@@ -98,17 +83,15 @@ def mesh_rectangle(*, size=(5.0, 5.0), center=(0.0, 0.0, 0.0),
                              for (i, j) in product(range(nw), range(nh))])
 
         mesh = Mesh(nodes, panels, name=name)
+        mesh = mesh.rotated_such_that_vectors_are_aligned(mesh.faces_normals[0], normal)
 
-    mesh.heal_mesh()
-    mesh.translate(center)
-    mesh.rotate_around_center_to_align_vectors(center, mesh.faces_normals[0], normal)
-    mesh.geometric_center = np.asarray(center, dtype=float)
+    mesh = mesh.translated(center, name=name)
     return mesh
 
 
 def mesh_parallelepiped(size=(1.0, 1.0, 1.0), center=(0, 0, 0),
                         resolution=(4, 4, 4), faces_max_radius=None,
-                        missing_sides=set(), reflection_symmetry=False, translation_symmetry=False,
+                        missing_sides=set(), reflection_symmetry=False,
                         name=None):
     """Six rectangles forming a parallelepiped.
 
@@ -130,9 +113,6 @@ def mesh_parallelepiped(size=(1.0, 1.0, 1.0), center=(0, 0, 0),
         May be ignored when building a mesh with a symmetry.
     reflection_symmetry : bool, optional
         use xOz and yOz symmetry plane to generate the mesh
-    translation_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
     """
@@ -163,62 +143,25 @@ def mesh_parallelepiped(size=(1.0, 1.0, 1.0), center=(0, 0, 0),
             nth = int(np.ceil(thickness / (np.sqrt(2) * faces_max_radius)))
             nh = int(np.ceil(height / (np.sqrt(2) * faces_max_radius)))
 
-    if name is None:
-        name = f"rectangular_parallelepiped_{next(Mesh._ids)}"
-
-    if translation_symmetry and reflection_symmetry:
-        raise NotImplementedError("Parallelepiped generation with both reflection and translation symmetries "
-                                  "has not been implemented.")
-
     if reflection_symmetry:
         if (nw % 2 == 1 or nth % 2 == 1):
-            raise ValueError("To use the reflection symmetry of the mesh, "
-                             "it should have an even number of panels in this direction.")
+            raise ValueError("To define a parallelepiped mesh with reflection symmetry, "
+                             "it should have an even number of panels in both direction.")
+
+        if not np.isclose(center[0], 0.0) or not np.isclose(center[1], 0.0):
+            raise ValueError("To define a rectangle mesh with reflection symmetry, "
+                             "its center should be on the Oz axis (that is x=0 and y=0).")
 
         missing_sides_in_quarter = missing_sides | {"right", "back"}
         quarter_mesh = mesh_parallelepiped(
                 size=(width/2, thickness/2, height), resolution=(nw//2, nth//2, nh),
                 center=(-width/4, -thickness/4, 0), missing_sides=missing_sides_in_quarter,
-                reflection_symmetry=False, translation_symmetry=False,
+                reflection_symmetry=False,
                 name=f"quarter_of_{name}"
                 )
 
-        half_mesh = ReflectionSymmetricMesh(quarter_mesh, plane=yOz_Plane, name=f"half_of_{name}")
-        mesh = ReflectionSymmetricMesh(half_mesh, plane=xOz_Plane, name=f"{name}")
-
-    elif translation_symmetry:
-
-        missing_sides_in_strip = missing_sides | {"left", "right"}
-        strip = mesh_parallelepiped(
-                size=(width/nw, thickness, height), resolution=(1, nth, nh),
-                center=(-width/2 + width/(2*nw), 0, 0), missing_sides=missing_sides_in_strip,
-                reflection_symmetry=False, translation_symmetry=False,
-                name=f"strip_of_{name}"
-                )
-
-        open_parallelepiped = TranslationalSymmetricMesh(
-            strip,
-            translation=(width/nw, 0, 0), nb_repetitions=int(nw)-1,
-            name=f"body_of_{name}"
-        )
-
-        components_of_mesh = [open_parallelepiped]
-        if "right" not in missing_sides:
-            components_of_mesh.append(
-                    mesh_rectangle(
-                        size=(thickness, height), resolution=(nth, nh),
-                        center=(width/2, 0, 0), normal=(1, 0, 0),
-                        name=f"right_side_of_{name}"
-                        ))
-        if "left" not in missing_sides:
-            components_of_mesh.append(
-                    mesh_rectangle(
-                        size=(thickness, height), resolution=(nth, nh),
-                        center=(-width/2, 0, 0), normal=(-1, 0, 0),
-                        name=f"left_side_of_{name}"
-                        ))
-
-        mesh = CollectionOfMeshes(components_of_mesh, name=name)
+        half_mesh = ReflectionSymmetricMesh(quarter_mesh, plane='yOz', name=f"half_of_{name}")
+        mesh = ReflectionSymmetricMesh(half_mesh, plane='xOz', name=f"{name}")
 
     else:
 
@@ -253,9 +196,7 @@ def mesh_parallelepiped(size=(1.0, 1.0, 1.0), center=(0, 0, 0),
                     mesh_rectangle(size=(thickness, width), resolution=(nth, nw), center=(0, 0, -height/2),
                         normal=(0, 0, -1), name=f"bottom_of_{name}")
                     )
-        mesh = CollectionOfMeshes(sides, name=name).merged()
+        mesh = Mesh.join_meshes(*sides, name=name)
 
-    mesh.heal_mesh()
-    mesh.translate(center)
-    mesh.geometric_center = np.asarray(center, dtype=float)
+    mesh = mesh.translated(center, name=name)
     return mesh

capytaine/meshes/predefined/spheres.py

@@ -1,14 +1,13 @@
 """Generate spherical bodies."""
 # Copyright (C) 2017-2024 Matthieu Ancellin
 # See LICENSE file at <https://github.com/capytaine/capytaine>
+
 import logging
 
 import numpy as np
 from numpy import pi
 
-from capytaine.meshes.geometry import Axis
-from capytaine.meshes.meshes import Mesh
-from capytaine.meshes.symmetric import AxialSymmetricMesh
+from capytaine.meshes.symmetric_meshes import RotationSymmetricMesh
 
 LOG = logging.getLogger(__name__)
 
@@ -37,9 +36,6 @@ def mesh_sphere(*, radius=1.0, center=(0.0, 0.0, 0.0),
         a name identifying the sphere (default: "sphere_id" where id is an unique integer).
     """
 
-    if name is None:
-        name = f"sphere_{next(Mesh._ids)}"
-
     ntheta, nphi = resolution
     if faces_max_radius is not None:
         perimeter = 2*np.pi*radius
@@ -50,13 +46,10 @@ def mesh_sphere(*, radius=1.0, center=(0.0, 0.0, 0.0),
     theta = np.linspace(0.0, pi, ntheta+1)
     points_on_a_meridian = radius * np.stack([np.sin(theta), np.zeros_like(theta), -np.cos(theta)], axis=1)
 
-    symmetry_axis = Axis(vector=[0, 0, 1], point=[0, 0, 0])
-    mesh = AxialSymmetricMesh.from_profile(points_on_a_meridian, axis=symmetry_axis, nphi=nphi, name=name)
+    mesh = RotationSymmetricMesh.from_profile_points(points_on_a_meridian, n=nphi, name=name)
 
     if not axial_symmetry:
         mesh = mesh.merged()
 
-    mesh.heal_mesh()
-    mesh.translate(center)
-    mesh.geometric_center = np.asarray(center, dtype=float)
+    mesh = mesh.translated(center, name=name)
     return mesh