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

capytaine/meshes/quadratures.py

@@ -1,80 +0,0 @@
-import logging
-
-import numpy as np
-
-from capytaine.tools.optional_imports import silently_import_optional_dependency
-
-LOG = logging.getLogger(__name__)
-
-# The builtin methods are stored as a list of 2D-points in [-1, 1]² and a list
-# of corresponding weights. The 2D points will be remapped to the actual shape
-# of the faces. They are only defined for quadrilaterals. They also work for
-# triangles (although they might be subobtimal).
-
-builtin_methods = {
-        "First order": (np.array([(0.0, 0.0)]), np.array([1.0])),
-        "Gauss-Legendre 2": (
-            np.array([(+1/np.sqrt(3), +1/np.sqrt(3)),
-             (+1/np.sqrt(3), -1/np.sqrt(3)),
-             (-1/np.sqrt(3), +1/np.sqrt(3)),
-             (-1/np.sqrt(3), -1/np.sqrt(3))]),
-            np.array([1/4, 1/4, 1/4, 1/4])
-            )
-        }
-
-
-def compute_quadrature_on_faces(faces, method):
-    """
-    Compute the quadrature points and weight for numerical integration over the faces.
-
-    Parameters
-    ----------
-    faces: array of shape (nb_faces, 4, 3)
-        The 3D-coordinates of each of the 4 corners of each face.
-    method: string or quadpy object
-        The method used to compute the quadrature scheme
-
-    Returns
-    -------
-    points: array of shape (nb_faces, nb_quad_points, 3)
-        The 3D-coordinates of each of the quadrature points (their number depends on the method) of each face.
-    weights: array of shape (nb_faces, nb_quad_points)
-        Weights associated to each of the quadrature points.
-    """
-
-    if method in builtin_methods:
-        LOG.debug("Quadrature method found in builtin methods.")
-        local_points, local_weights = builtin_methods[method]
-
-    elif ((quadpy := silently_import_optional_dependency("quadpy")) is not None
-                and isinstance(method, quadpy.c2._helpers.C2Scheme)):
-        LOG.debug("Quadrature method is a Quadpy scheme: %s", method.name)
-        local_points = method.points.T
-        local_weights = method.weights
-
-    else:
-        raise ValueError(f"Unrecognized quadrature scheme: {method}.\n"
-                         f"Consider using one of the following: {set(builtin_methods.keys())}")
-
-    nb_faces = faces.shape[0]
-    nb_quad_points = len(local_weights)
-    points = np.empty((nb_faces, nb_quad_points, 3))
-    weights = np.empty((nb_faces, nb_quad_points))
-
-    for i_face in range(nb_faces):
-        for k_quad in range(nb_quad_points):
-            xk, yk = local_points[k_quad, :]
-            points[i_face, k_quad, :] = (
-                      (1+xk)*(1+yk) * faces[i_face, 0, :]
-                    + (1+xk)*(1-yk) * faces[i_face, 1, :]
-                    + (1-xk)*(1-yk) * faces[i_face, 2, :]
-                    + (1-xk)*(1+yk) * faces[i_face, 3, :]
-                    )/4
-            dxidx = ((1+yk)*faces[i_face, 0, :] + (1-yk)*faces[i_face, 1, :]
-                     - (1-yk)*faces[i_face, 2, :] - (1+yk)*faces[i_face, 3, :])/4
-            dxidy = ((1+xk)*faces[i_face, 0, :] - (1+xk)*faces[i_face, 1, :]
-                     - (1-xk)*faces[i_face, 2, :] + (1-xk)*faces[i_face, 3, :])/4
-            detJ = np.linalg.norm(np.cross(dxidx, dxidy))
-            weights[i_face, k_quad] = local_weights[k_quad] * 4 * detJ
-
-    return points, weights

capytaine/meshes/symmetric.py

@@ -1,392 +0,0 @@
-"""Special meshes with symmetries, useful to speed up the computations."""
-# Copyright (C) 2017-2019 Matthieu Ancellin
-# See LICENSE file at <https://github.com/mancellin/capytaine>
-
-import logging
-import reprlib
-from typing import Union, Callable, Iterable
-
-import numpy as np
-
-from capytaine.meshes.meshes import Mesh
-from capytaine.meshes.collections import CollectionOfMeshes
-from capytaine.meshes.geometry import Axis, Plane, xOy_Plane, Oz_axis, inplace_transformation
-
-LOG = logging.getLogger(__name__)
-
-
-class SymmetricMesh(CollectionOfMeshes):
-    def __repr__(self):
-        reprer = reprlib.Repr()
-        reprer.maxstring = 90
-        reprer.maxother = 90
-        slice_name = reprer.repr(self._meshes[0])
-        if self.name is not None:
-            return f"{self.__class__.__name__}({slice_name}, name={self.name})"
-        else:
-            return f"{self.__class__.__name__}({slice_name})"
-
-
-class ReflectionSymmetricMesh(SymmetricMesh):
-    """A mesh with one vertical symmetry plane.
-
-    Parameters
-    ----------
-    half : Mesh or CollectionOfMeshes
-        a mesh describing half of the body
-    plane : Plane
-        the symmetry plane across which the half body is mirrored
-    name :str, optional
-        a name for the mesh
-    """
-
-    def __init__(self, half: Union[Mesh, CollectionOfMeshes], plane: Plane, name=None):
-        assert isinstance(half, Mesh) or isinstance(half, CollectionOfMeshes)
-        assert isinstance(plane, Plane)
-        assert plane.normal[2] == 0, "Only vertical reflection planes are supported in ReflectionSymmetry classes."
-
-        other_half = half.mirrored(plane, name=f"mirrored_of_{half.name}")
-
-        if name is None:
-            name = f"reflection_of_{half.name}"
-
-        self.plane = plane.copy()
-
-        super().__init__((half, other_half), name=name)
-
-        if self.name is not None:
-            LOG.debug(f"New mirror symmetric mesh: {self.name}.")
-        else:
-            LOG.debug(f"New mirror symmetric mesh.")
-
-    def __str__(self):
-        return f"{self.__class__.__name__}({self.half.__short_str__()}, plane={self.plane}, name=\"{self.name}\")"
-
-    def __repr__(self):
-        return f"{self.__class__.__name__}({self.half}, plane={self.plane}, name=\"{self.name}\")"
-
-    def __rich_repr__(self):
-        yield self.half
-        yield "plane", self.plane
-        yield "name", self.name
-
-    @property
-    def half(self):
-        return self[0]
-
-    def tree_view(self, fold_symmetry=True, **kwargs):
-        if fold_symmetry:
-            return (self.__short_str__() + '\n' + ' ├─' + self.half.tree_view().replace('\n', '\n │ ') + '\n'
-                    + f" └─mirrored copy of the above {self.half.__short_str__()}")
-        else:
-            return CollectionOfMeshes.tree_view(self, **kwargs)
-
-    def __deepcopy__(self, *args):
-        return ReflectionSymmetricMesh(self.half.copy(), self.plane, name=self.name)
-
-    def join_meshes(*meshes, name=None):
-        assert all(isinstance(mesh, ReflectionSymmetricMesh) for mesh in meshes), \
-            "Only meshes with the same symmetry can be joined together."
-        assert all(meshes[0].plane == mesh.plane for mesh in meshes), \
-            "Only reflection symmetric meshes with the same reflection plane can be joined together."
-        half_mesh = meshes[0].half.join_meshes(*(mesh.half for mesh in meshes[1:]), name=f"half_of_{name}" if name is not None else None)
-        return ReflectionSymmetricMesh(half_mesh, plane=meshes[0].plane, name=name)
-
-    @inplace_transformation
-    def translate(self, vector):
-        self.plane.translate(vector)
-        CollectionOfMeshes.translate(self, vector)
-        return self
-
-    @inplace_transformation
-    def rotate(self, axis: Axis, angle: float):
-        self.plane.rotate(axis, angle)
-        CollectionOfMeshes.rotate(self, axis, angle)
-        return self
-
-    @inplace_transformation
-    def mirror(self, plane: Plane):
-        self.plane.mirror(plane)
-        CollectionOfMeshes.mirror(self, plane)
-        return self
-
-    def generate_lid(self, z=0.0, faces_max_radius=None, name=None):
-        if name is None:
-            name = "lid for {}".format(self.name)
-        return ReflectionSymmetricMesh(self.half.generate_lid(z, faces_max_radius), self.plane, name=name)
-
-    def extract_lid(self, plane=xOy_Plane):
-        hull, lid = self.half.extract_lid(plane)
-        return ReflectionSymmetricMesh(hull, self.plane), ReflectionSymmetricMesh(lid, self.plane)
-
-
-class TranslationalSymmetricMesh(SymmetricMesh):
-    """A mesh with a repeating pattern by translation.
-
-    Parameters
-    ----------
-    mesh_slice : Mesh or CollectionOfMeshes
-        the pattern that will be repeated to form the whole body
-    translation : array(3)
-        the vector of the translation
-    nb_repetitions : int, optional
-        the number of repetitions of the pattern (excluding the original one, default: 1)
-    name : str, optional
-        a name for the mesh
-    """
-
-    def __init__(self, mesh_slice: Union[Mesh, CollectionOfMeshes], translation, nb_repetitions=1, name=None):
-        assert isinstance(mesh_slice, Mesh) or isinstance(mesh_slice, CollectionOfMeshes)
-        assert isinstance(nb_repetitions, int)
-        assert nb_repetitions >= 1
-
-        translation = np.asarray(translation).copy()
-        assert translation.shape == (3,)
-        assert translation[2] == 0  # Only horizontal translation are supported.
-
-        slices = [mesh_slice]
-        for i in range(1, nb_repetitions+1):
-            slices.append(mesh_slice.translated(vector=i*translation, name=f"repetition_{i}_of_{mesh_slice.name}"))
-
-        if name is None:
-            name = f"translation_of_{mesh_slice.name}"
-
-        self.translation = translation
-
-        super().__init__(slices, name=name)
-
-        if self.name is not None:
-            LOG.debug(f"New translation symmetric mesh: {self.name}.")
-        else:
-            LOG.debug(f"New translation symmetric mesh.")
-
-    @property
-    def first_slice(self):
-        return self[0]
-
-    def __str__(self):
-        return f"{self.__class__.__name__}({self.first_slice.__short_str__()}, translation={self.translation}, nb_repetitions={len(self)-1}, name=\"{self.name}\")"
-
-    def __repr__(self):
-        return f"{self.__class__.__name__}({self.first_slice}, translation={self.translation}, nb_repetitions={len(self)-1}, name=\"{self.name}\")"
-
-    def __rich_repr__(self):
-        yield self.first_slice
-        yield "translation", self.translation
-        yield "nb_repetitions", len(self)-1
-        yield "name", self.name
-
-    def tree_view(self, fold_symmetry=True, **kwargs):
-        if fold_symmetry:
-            return (self.__short_str__() + '\n' + ' ├─' + self.first_slice.tree_view().replace('\n', '\n │ ') + '\n'
-                    + f" └─{len(self)-1} translated copies of the above {self.first_slice.__short_str__()}")
-        else:
-            return CollectionOfMeshes.tree_view(self, **kwargs)
-
-    def __deepcopy__(self, *args):
-        return TranslationalSymmetricMesh(self.first_slice.copy(), self.translation, nb_repetitions=len(self) - 1, name=self.name)
-
-    @inplace_transformation
-    def translate(self, vector):
-        CollectionOfMeshes.translate(self, vector)
-        return self
-
-    @inplace_transformation
-    def rotate(self, axis: Axis, angle: float):
-        self.translation = axis.rotate_vectors([self.translation], angle)[0, :]
-        CollectionOfMeshes.rotate(self, axis, angle)
-        return self
-
-    @inplace_transformation
-    def mirror(self, plane: Plane):
-        self.translation -= 2 * (self.translation @ plane.normal) * plane.normal
-        CollectionOfMeshes.mirror(self, plane)
-        return self
-
-    def join_meshes(*meshes, name=None):
-        assert all(isinstance(mesh, TranslationalSymmetricMesh) for mesh in meshes), \
-            "Only meshes with the same symmetry can be joined together."
-        assert all(np.allclose(meshes[0].translation, mesh.translation) for mesh in meshes), \
-            "Only translation symmetric meshes with the same translation vector can be joined together."
-        assert all(len(meshes[0]) == len(mesh) for mesh in meshes), \
-            "Only symmetric meshes with the same number of elements can be joined together."
-        mesh_strip = CollectionOfMeshes([mesh.first_slice for mesh in meshes], name=f"strip_of_{name}" if name is not None else None)
-        return TranslationalSymmetricMesh(mesh_strip, translation=meshes[0].translation, nb_repetitions=len(meshes[0]) - 1, name=name)
-
-
-def build_regular_array_of_meshes(base_mesh, distance, nb_bodies):
-    """Create an array of objects using TranslationalSymmetries.
-
-    Parameters
-    ----------
-    base_mesh : Mesh or CollectionOfMeshes or SymmetricMesh
-        The mesh to duplicate to create the array
-    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.
-
-    Returns
-    -------
-    TranslationalSymmetricMesh
-    """
-    if nb_bodies[0] == 1:
-        line = base_mesh
-    else:
-        line = TranslationalSymmetricMesh(base_mesh, translation=(distance, 0.0, 0.0), nb_repetitions=nb_bodies[0] - 1,
-                                          name=f'line_of_{base_mesh.name}')
-    if nb_bodies[1] == 1:
-        array = line
-    else:
-        array = TranslationalSymmetricMesh(line, translation=(0.0, distance, 0.0), nb_repetitions=nb_bodies[1] - 1,
-                                           name=f'array_of_{base_mesh.name}')
-    return array
-
-
-class AxialSymmetricMesh(SymmetricMesh):
-    """A mesh with a repeating pattern by rotation.
-
-    Parameters
-    ----------
-    mesh_slice : Mesh or CollectionOfMeshes
-        the pattern that will be repeated to form the whole body
-    axis : Axis, optional
-        symmetry axis
-    nb_repetitions : int, optional
-        the number of repetitions of the pattern (excluding the original one, default: 1)
-    name : str, optional
-        a name for the mesh
-    """
-    def __init__(self, mesh_slice: Union[Mesh, CollectionOfMeshes], axis: Axis=Oz_axis, nb_repetitions: int=1, name=None):
-        assert isinstance(mesh_slice, Mesh) or isinstance(mesh_slice, CollectionOfMeshes)
-        assert isinstance(nb_repetitions, int)
-        assert nb_repetitions >= 1
-        assert isinstance(axis, Axis)
-
-        slices = [mesh_slice]
-        for i in range(1, nb_repetitions+1):
-            slices.append(mesh_slice.rotated(axis, angle=2*i*np.pi/(nb_repetitions+1),
-                                             name=f"rotation_{i}_of_{mesh_slice.name}"))
-
-        if name is None:
-            name = f"rotation_of_{mesh_slice.name}"
-
-        self.axis = axis.copy()
-
-        super().__init__(slices, name=name)
-
-        if not axis.is_parallel_to(Oz_axis):
-            LOG.warning(f"{self.name} is an axi-symmetric mesh along a non vertical axis.")
-
-        if self.name is not None:
-            LOG.debug(f"New rotation symmetric mesh: {self.name}.")
-        else:
-            LOG.debug(f"New rotation symmetric mesh.")
-
-    @staticmethod
-    def from_profile(profile: Union[Callable, Iterable[float]],
-                     z_range: Iterable[float]=np.linspace(-5, 0, 20),
-                     axis: Axis=Oz_axis,
-                     nphi: int=20,
-                     name=None):
-        """Return a floating body using the axial symmetry.
-        The shape of the body can be defined either with a function defining the profile as [f(z), 0, z] for z in z_range.
-        Alternatively, the profile can be defined as a list of points.
-        The number of vertices along the vertical direction is len(z_range) in the first case and profile.shape[0] in the second case.
-
-        Parameters
-        ----------
-        profile : function(float → float)  or  array(N, 3)
-            define the shape of the body either as a function or a list of points.
-        z_range: array(N), optional
-            used only if the profile is defined as a function.
-        axis : Axis
-            symmetry axis
-        nphi : int, optional
-            number of vertical slices forming the body
-        name : str, optional
-            name of the generated body (optional)
-
-        Returns
-        -------
-        AxialSymmetricMesh
-            the generated mesh
-        """
-
-        if name is None:
-            name = "axisymmetric_mesh"
-
-        if callable(profile):
-            z_range = np.asarray(z_range)
-            x_values = [profile(z) for z in z_range]
-            profile_array = np.stack([x_values, np.zeros(len(z_range)), z_range]).T
-        else:
-            profile_array = np.asarray(profile)
-
-        assert len(profile_array.shape) == 2
-        assert profile_array.shape[1] == 3
-
-        n = profile_array.shape[0]
-        angle = 2 * np.pi / nphi
-
-        nodes_slice = np.concatenate([profile_array, axis.rotate_points(profile_array, angle)])
-        faces_slice = np.array([[i, i+n, i+n+1, i+1] for i in range(n-1)])
-        body_slice = Mesh(nodes_slice, faces_slice, name=f"slice_of_{name}")
-        body_slice.merge_duplicates()
-        body_slice.heal_triangles()
-
-        return AxialSymmetricMesh(body_slice, axis=axis, nb_repetitions=nphi - 1, name=name)
-
-    @property
-    def first_slice(self):
-        return self[0]
-
-    def __str__(self):
-        return f"{self.__class__.__name__}({self.first_slice.__short_str__()}, axis={self.axis}, nb_repetitions={len(self)-1}, name=\"{self.name}\")"
-
-    def __repr__(self):
-        return f"{self.__class__.__name__}({self.first_slice}, axis={self.axis}, nb_repetitions={len(self)-1}, name=\"{self.name}\")"
-
-    def __rich_repr__(self):
-        yield self.first_slice
-        yield "axis", self.axis
-        yield "nb_repetitions", len(self)-1
-        yield "name", self.name
-
-    def tree_view(self, fold_symmetry=True, **kwargs):
-        if fold_symmetry:
-            return (self.__short_str__() + '\n' + ' ├─' + self.first_slice.tree_view().replace('\n', '\n │ ') + '\n'
-                    + f" └─{len(self)-1} rotated copies of the above {self.first_slice.__short_str__()}")
-        else:
-            return CollectionOfMeshes.tree_view(self, **kwargs)
-
-    def __deepcopy__(self, *args):
-        return AxialSymmetricMesh(self.first_slice.copy(), axis=self.axis.copy(), nb_repetitions=len(self) - 1, name=self.name)
-
-    def join_meshes(*meshes, name=None):
-        assert all(isinstance(mesh, AxialSymmetricMesh) for mesh in meshes), \
-            "Only meshes with the same symmetry can be joined together."
-        assert all(meshes[0].axis == mesh.axis for mesh in meshes), \
-            "Only axisymmetric meshes with the same symmetry axis can be joined together."
-        assert all(len(meshes[0]) == len(mesh) for mesh in meshes), \
-            "Only axisymmetric meshes with the same number of elements can be joined together."
-        mesh_slice = CollectionOfMeshes([mesh.first_slice for mesh in meshes], name=f"slice_of_{name}" if name is not None else None)
-        return AxialSymmetricMesh(mesh_slice, axis=meshes[0].axis, nb_repetitions=len(meshes[0]) - 1, name=name)
-
-    @inplace_transformation
-    def translate(self, vector):
-        self.axis.translate(vector)
-        CollectionOfMeshes.translate(self, vector)
-        return self
-
-    @inplace_transformation
-    def rotate(self, other_axis: Axis, angle: float):
-        self.axis.rotate(other_axis, angle)
-        CollectionOfMeshes.rotate(self, other_axis, angle)
-        return self
-
-    @inplace_transformation
-    def mirror(self, plane: Plane):
-        self.axis.mirror(plane)
-        CollectionOfMeshes.mirror(self, plane)
-        return self

capytaine/tools/lru_cache.py

@@ -1,49 +0,0 @@
-# Copyright (C) 2017-2024 Matthieu Ancellin
-# See LICENSE file at <https://github.com/capytaine/capytaine>
-"""Tools for memoization of functions."""
-from collections import OrderedDict
-from functools import wraps
-
-import logging
-
-LOG = logging.getLogger(__name__)
-
-
-def lru_cache_with_strict_maxsize(maxsize=1):
-    """Behaves mostly like functools.lru_cache(), but the oldest data in the cache is
-    deleted *before* computing a new one, in order to *never* have more that
-    `maxsize` items in memory.
-    This is useful to limit RAM usage when stored objects are big, like the interaction
-    matrices of Capytaine."""
-
-    def decorator(f):
-        cache = OrderedDict()
-
-        @wraps(f)
-        def decorated_f(*args, **kwargs):
-            hashable_kwargs = tuple((k, v) for (k, v) in kwargs.items())
-            # Might miss a cache hit if the order of kwargs is changed.
-            # But at least unlike a previous version, should not return a wrong value.
-
-            if (args, hashable_kwargs) in cache:
-                # Get item in cache
-                LOG.debug("Get cached version of %s(%s, %s)", f.__name__, args, hashable_kwargs)
-                return cache[(args, hashable_kwargs)]
-
-            if len(cache) + 1 > maxsize:
-                # Drop oldest item in cache.
-                cache.popitem(last=False)
-
-            # Compute and store
-            LOG.debug("Computing %s(%s, %s)", f.__name__, args, hashable_kwargs)
-            result = f(*args, **kwargs)
-            cache[(args, hashable_kwargs)] = result
-
-            return result
-
-        return decorated_f
-
-    return decorator
-
-
-delete_first_lru_cache = lru_cache_with_strict_maxsize  # For backward compatibility...

capytaine/ui/vtk/__init__.py

@@ -1,3 +0,0 @@
-from capytaine.ui.vtk.mesh_viewer import MeshViewer
-from capytaine.ui.vtk.body_viewer import FloatingBodyViewer
-from capytaine.ui.vtk.animation import Animation