capytaine 2.2.1__cp312-cp312-macosx_14_0_arm64.whl → 2.3.1__cp312-cp312-macosx_14_0_arm64.whl

capytaine/meshes/meshes.py

@@ -644,9 +644,18 @@ class Mesh(ClippableMixin, SurfaceIntegralsMixin, Abstract3DObject):
     #  Combine meshes  #
     ####################
 
-    def join_meshes(*meshes, name=None):
+    def join_meshes(*meshes, name=None, return_masks=False):
         from capytaine.meshes.collections import CollectionOfMeshes
-        return CollectionOfMeshes(meshes, name=name).merged()
+        coll = CollectionOfMeshes(meshes, name=name)
+        if return_masks:
+            masks = []
+            for i_mesh in range(len(meshes)):
+                mask = np.full((coll.nb_faces,), False)
+                mask[coll.indices_of_mesh(i_mesh)] = True
+                masks.append(mask)
+            return coll.merged(), masks
+        else:
+            return coll.merged()
 
     def __add__(self, mesh_to_add) -> 'Mesh':
         return self.join_meshes(mesh_to_add)
@@ -761,17 +770,19 @@ class Mesh(ClippableMixin, SurfaceIntegralsMixin, Abstract3DObject):
                 z_lid = min(z_lid, z_lid_comp)
         return 0.9*z_lid  # Add a small safety margin
 
-    def generate_lid(self, z=0.0, faces_max_radius=None):
+    def generate_lid(self, z=0.0, faces_max_radius=None, name=None):
         """
         Return a mesh of the internal free surface of the body.
 
         Parameters
         ----------
-        z: float
+        z: float, optional
             Vertical position of the lid. Default: 0.0
-        faces_max_radius: float
+        faces_max_radius: float, optional
             resolution of the mesh of the lid.
             Default: mean of hull mesh resolution.
+        name: str, optional
+            A name for the new mesh
 
         Returns
         -------
@@ -795,8 +806,14 @@ class Mesh(ClippableMixin, SurfaceIntegralsMixin, Abstract3DObject):
         if faces_max_radius is None:
             faces_max_radius = np.mean(clipped_hull_mesh.faces_radiuses)
 
+        candidate_lid_size = (
+                    max(faces_max_radius/2, 1.1*x_span),
+                    max(faces_max_radius/2, 1.1*y_span),
+                )
+        # The size of the lid is at least the characteristic length of a face
+
         candidate_lid_mesh = mesh_rectangle(
-                size=(1.1*y_span, 1.1*x_span),  # TODO Fix mesh_rectangle
+                size=(candidate_lid_size[1], candidate_lid_size[0]),  # TODO Fix: Exchange x and y in mesh_rectangle
                 faces_max_radius=faces_max_radius,
                 center=(x_mean, y_mean, z),
                 normal=(0.0, 0.0, -1.0),
@@ -825,10 +842,13 @@ class Mesh(ClippableMixin, SurfaceIntegralsMixin, Abstract3DObject):
 
         lid_faces = candidate_lid_mesh.faces[np.all(np.isin(candidate_lid_mesh.faces, needs_lid), axis=-1), :]
 
+        if name is None:
+            name = "lid for {}".format(self.name)
+
         if len(lid_faces) == 0:
-            return Mesh(None, None, name="lid for {}".format(self.name))
+            return Mesh(None, None, name=name)
 
-        lid_mesh = Mesh(candidate_lid_mesh.vertices, lid_faces, name="lid for {}".format(self.name))
+        lid_mesh = Mesh(candidate_lid_mesh.vertices, lid_faces, name=name)
         lid_mesh.heal_mesh()
 
         return lid_mesh

capytaine/meshes/symmetric.py

@@ -10,7 +10,7 @@ import numpy as np
 
 from capytaine.meshes.meshes import Mesh
 from capytaine.meshes.collections import CollectionOfMeshes
-from capytaine.meshes.geometry import Axis, Plane, Oz_axis, inplace_transformation
+from capytaine.meshes.geometry import Axis, Plane, xOy_Plane, Oz_axis, inplace_transformation
 
 LOG = logging.getLogger(__name__)
 
@@ -84,13 +84,27 @@ class ReflectionSymmetricMesh(SymmetricMesh):
     def __deepcopy__(self, *args):
         return ReflectionSymmetricMesh(self.half.copy(), self.plane, name=self.name)
 
-    def join_meshes(*meshes, name=None):
+    def join_meshes(*meshes, name=None, return_masks=False):
         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 = CollectionOfMeshes([mesh.half for mesh in meshes], name=f"half_of_{name}" if name is not None else None)
-        return ReflectionSymmetricMesh(half_mesh, plane=meshes[0].plane, name=name)
+        if not return_masks:
+            name = name=f"half_of_{name}" if name is not None else None
+            half_mesh = meshes[0].half.join_meshes(
+                *(mesh.half for mesh in meshes[1:]),
+                name=name, return_masks=False
+            )
+            return ReflectionSymmetricMesh(half_mesh, plane=meshes[0].plane, name=name)
+        else:
+            name = name=f"half_of_{name}" if name is not None else None
+            half_mesh, half_masks = meshes[0].half.join_meshes(
+                *(mesh.half for mesh in meshes[1:]),
+                name=name, return_masks=True
+            )
+            masks = [np.concatenate([half_mask, half_mask]) for half_mask in half_masks]
+            joined = ReflectionSymmetricMesh(half_mesh, plane=meshes[0].plane, name=name)
+            return joined, masks
 
     @inplace_transformation
     def translate(self, vector):
@@ -110,6 +124,15 @@ class ReflectionSymmetricMesh(SymmetricMesh):
         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.
@@ -194,15 +217,43 @@ class TranslationalSymmetricMesh(SymmetricMesh):
         CollectionOfMeshes.mirror(self, plane)
         return self
 
-    def join_meshes(*meshes, name=None):
+    def join_meshes(*meshes, name=None, return_masks=False):
         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)
+        if not return_masks:
+            strip_name = f"strip_of_{name}" if name is not None else None
+            mesh_strip = meshes[0].first_slice.join_meshes(
+                *(mesh.first_slice for mesh in meshes[1:]),
+                name=strip_name,
+                return_masks=False
+            )
+            return TranslationalSymmetricMesh(
+                mesh_strip,
+                translation=meshes[0].translation,
+                nb_repetitions=len(meshes[0]) - 1,
+                name=name
+            )
+        else:
+            strip_name = f"strip_of_{name}" if name is not None else None
+            mesh_strip, strip_masks = meshes[0].first_slice.join_meshes(
+                *(mesh.first_slice for mesh in meshes[1:]),
+                name=strip_name,
+                return_masks=True
+            )
+            joined = TranslationalSymmetricMesh(
+                mesh_strip,
+                translation=meshes[0].translation,
+                nb_repetitions=len(meshes[0]) - 1,
+                name=name
+            )
+            masks = [np.concatenate([
+                strip_mask for _ in range(len(meshes[0]))
+            ]) for strip_mask in strip_masks]
+            return joined, masks
 
 
 def build_regular_array_of_meshes(base_mesh, distance, nb_bodies):
@@ -354,15 +405,43 @@ class AxialSymmetricMesh(SymmetricMesh):
     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):
+    def join_meshes(*meshes, name=None, return_masks=False):
         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)
+        if not return_masks:
+            slice_name = f"slice_of_{name}" if name is not None else None
+            mesh_slice = meshes[0].first_slice.join_meshes(
+                *(mesh.first_slice for mesh in meshes[1:]),
+                name=slice_name,
+                return_masks=False
+            )
+            return AxialSymmetricMesh(
+                mesh_slice,
+                axis=meshes[0].axis,
+                nb_repetitions=len(meshes[0]) - 1,
+                name=name
+            )
+        else:
+            slice_name = f"slice_of_{name}" if name is not None else None
+            mesh_slice, slice_masks = meshes[0].first_slice.join_meshes(
+                *(mesh.first_slice for mesh in meshes[1:]),
+                name=slice_name,
+                return_masks=True
+            )
+            joined = AxialSymmetricMesh(
+                mesh_slice,
+                axis=meshes[0].axis,
+                nb_repetitions=len(meshes[0]) - 1,
+                name=name
+            )
+            masks = [np.concatenate([
+                slice_mask for _ in range(len(meshes[0]))
+            ]) for slice_mask in slice_masks]
+            return joined, masks
 
     @inplace_transformation
     def translate(self, vector):

capytaine/post_pro/kochin.py

@@ -1,6 +1,6 @@
 """Computation of the Kochin function."""
 # Copyright (C) 2017-2019 Matthieu Ancellin
-# See LICENSE file at <https://github.com/mancellin/capytaine>
+# See LICENSE file at <https://github.com/capytaine/capytaine>
 
 import logging
 import numpy as np
@@ -29,9 +29,9 @@ def compute_kochin(result, theta, ref_point=(0.0, 0.0)):
         LOG.warning("Kochin functions with forward speed have never been validated.")
 
     if result.sources is None:
-        raise Exception(f"""The values of the sources of {result} cannot been found.
-        They probably have not been stored by the solver because the option keep_details=True have not been set.
-        Please re-run the resolution with this option.""")
+        raise ValueError(f"""The values of the sources of {result} cannot been found.
+        They have not been stored by the solver either because the direct method has been used or the option keep_details=True have not been set.
+        Please re-run the resolution with `method='indirect'` and `keep_details=True`.""")
 
     k = result.wavenumber
     h = result.water_depth

capytaine/tools/lists_of_points.py

@@ -1,7 +1,7 @@
 import numpy as np
 from capytaine.bodies import FloatingBody
 from capytaine.post_pro.free_surfaces import FreeSurface
-from capytaine.meshes import Mesh, CollectionOfMeshes
+from capytaine.meshes.mesh_like_protocol import MeshLike
 
 
 def _normalize_points(points, keep_mesh=False):
@@ -11,7 +11,7 @@ def _normalize_points(points, keep_mesh=False):
         else:
             return points.mesh.faces_centers, (points.mesh.nb_faces,)
 
-    if isinstance(points, (Mesh, CollectionOfMeshes)):
+    if isinstance(points, MeshLike):
         if keep_mesh:
             return points, (points.nb_faces,)
         else:
@@ -41,7 +41,7 @@ def _normalize_free_surface_points(points, keep_mesh=False):
     if keep_mesh and isinstance(points, (FloatingBody, FreeSurface)):
         return points.mesh, (points.mesh.nb_faces,)
 
-    if keep_mesh and isinstance(points, (Mesh, CollectionOfMeshes)):
+    if keep_mesh and isinstance(points, MeshLike):
         return points, (points.nb_faces,)
 
     points, output_shape = _normalize_points(points, keep_mesh)

capytaine/tools/prony_decomposition.py

@@ -1,8 +1,8 @@
 """Prony decomposition: tool to approximate a function as a sum of exponentials.
 Used in particular in the finite depth Green function.
 """
-# Copyright (C) 2017-2019 Matthieu Ancellin
-# See LICENSE file at <https://github.com/mancellin/capytaine>
+# Copyright (C) 2017-2024 Matthieu Ancellin
+# See LICENSE file at <https://github.com/capytaine/capytaine>
 
 import logging
 
@@ -12,6 +12,7 @@ from scipy.optimize import curve_fit
 from scipy.linalg import toeplitz
 
 LOG = logging.getLogger(__name__)
+RNG = np.random.default_rng()
 
 
 def exponential_decomposition(X, F, m):
@@ -66,8 +67,8 @@ def exponential_decomposition(X, F, m):
 
 
 def error_exponential_decomposition(X, F, a, lamda):
-    """Compare exponential decomposition defined by the coefficients a and lamda to the reference
-    values in F.
+    """Mean square error of the exponential decomposition defined by the
+    coefficients a and lamda with respect to the reference values in F.
 
     Parameters
     ----------
@@ -92,3 +93,58 @@ def error_exponential_decomposition(X, F, a, lamda):
         return np.sum(a * np.exp(lamda*x), axis=0)
 
     return np.square(f(X) - F).mean()
+
+
+class PronyDecompositionFailure(Exception):
+    pass
+
+
+def find_best_exponential_decomposition(f, x_min, x_max, n_exp_range, *, tol=1e-4, noise_on_domain_points_std=0.01):
+    """Tries to construct an exponential decompositoin of the function f on the
+    domain [x_min, x_max] by testing the number of exponentials in n_exp_range.
+
+    Parameters
+    ----------
+    f: callable
+        The function ℝ→ℝ to be approximated.
+        Should support vectorized calls (that is passing a vector of inputs
+        and get the vector of corresponding outputs)
+    x_min, x_max: floats
+        The bounds of the domain of input in which f should be approximated
+    n_exp_range: iterable of ints
+        The decomposition sizes that will be tested
+    tol: float, optional
+        The target mean square error.
+    noise_on_domain_points_std: float, optional
+        Introduces some random variability on the points where the function is evaluated.
+        Set this parameter to zero to disable randomness.
+
+    """
+    # Try different range of evaluation points to construct the decomposition.
+    for n_exp in n_exp_range:
+
+        # f might be ill-defined at some single specific values
+        # (for the use-case of delhommeau.py, it is when x = kh exactly).
+        # Thus we slightly randomize the range of evaluation points for the Prony decomposition.
+        # This way, if one of the evaluation points hits the singular point, it will most likely not hit it again at the next iteration.
+        x_max_iter = (1 + noise_on_domain_points_std*RNG.uniform())*x_max
+
+        try:
+            # The coefficients are computed on a resolution of 4*n_exp+1 ...
+            X = np.linspace(x_min, x_max_iter, 4*n_exp+1)
+            a, lamda = exponential_decomposition(X, f(X), n_exp)
+
+            # ... and they are evaluated on a finer discretization.
+            X = np.linspace(x_min, x_max_iter, 8*n_exp+1)
+            if error_exponential_decomposition(X, f(X), a, lamda) < tol:
+                return a, lamda
+        except Exception:
+            # If something bad happened while computing the decomposition, try
+            # the next one.
+            continue
+
+    raise PronyDecompositionFailure(
+            "No suitable Prony decomposition has been found in "
+            f"[{x_min}, {x_max}] for tol={tol} "
+            f"using a number of terms in {n_exp_range}."
+            )

capytaine/tools/symbolic_multiplication.py

@@ -11,11 +11,12 @@ output of the form `SymbolicMultiplication("0", np.array(...))`
 import numpy as np
 from functools import wraps, total_ordering
 
-@total_ordering
 class SymbolicMultiplication:
     def __init__(self, symbol, value=1.0):
         self.symbol = symbol
         self.value = value
+        if hasattr(value, "shape"):
+            self.shape = value.shape  # When wrapping Numpy arrays
 
     def __format__(self, format_spec):
         return f"{self.symbol}×{self.value.__format__(format_spec)}"
@@ -40,6 +41,9 @@ class SymbolicMultiplication:
     def __radd__(self, x):
         return x + self._concretize()
 
+    def __neg__(self):
+        return SymbolicMultiplication(self.symbol, -self.value)
+
     def __mul__(self, x):
         return SymbolicMultiplication(self.symbol, self.value * x)
 
@@ -77,11 +81,26 @@ class SymbolicMultiplication:
     def __getitem__(self, item):
         return SymbolicMultiplication(self.symbol, self.value[item])
 
-    def __eq__(self, x):
-        return float(self) == x
+    def __setitem__(self, item, val):
+        if isinstance(val, SymbolicMultiplication) and self.symbol == val.symbol:
+            self.value.__setitem__(item, val.value)
+        else:
+            raise NotImplementedError
 
     def __lt__(self, x):
-        return float(self) < x
+        return self._concretize() < x
+
+    def __le__(self, x):
+        return self._concretize() <= x
+
+    def __eq__(self, x):
+        return self._concretize() == x
+
+    def __ge__(self, x):
+        return self._concretize() >= x
+
+    def __gt__(self, x):
+        return self._concretize() > x
 
     def __hash__(self):
         return hash((self.symbol, self.value))
@@ -106,6 +125,13 @@ class SymbolicMultiplication:
     def reshape(self, *args):
         return SymbolicMultiplication(self.symbol, self.value.reshape(*args))
 
+    def sum(self, *args, **kwargs):
+        return SymbolicMultiplication(self.symbol, self.value.sum(*args, **kwargs))
+
+    @property
+    def T(self):
+        return SymbolicMultiplication(self.symbol, self.value.T)
+
 
 def supporting_symbolic_multiplication(f):
     """

capytaine/tools/timer.py

@@ -0,0 +1,66 @@
+"""A simple timer class used to measure the time spent in various parts of the BEM solver."""
+
+from functools import wraps
+import time
+
+class Timer:
+    """A simple timer class that can be used as context manager or as decorator using `wraps_function` method
+
+    Example
+    -------
+    ::
+
+        timer = Timer()
+        with timer:
+            sleep(1.0)
+
+        print(timer.total)  # 1.0...
+
+        @timer.wraps_function
+        def my_function():
+            sleep(0.5)
+
+        my_function()
+        print(timer.total)  # 1.5...
+        my_function()
+        print(timer.total)  # 2.0...
+
+        print(timer.timings)  # [1.0, 0.5, 0.5]
+    """
+
+    def __init__(self, timings=None):
+        if timings is None:
+            self.timings = []
+        else:
+            self.timings = timings
+
+    def __repr__(self):
+        return f"Timer({self.timings})"
+
+    @property
+    def nb_timings(self):
+        return len(self.timings)
+
+    @property
+    def total(self):
+        return sum(self.timings)
+
+    @property
+    def mean(self):
+        if self.nb_timings == 0:
+            return float('nan')
+        else:
+            return self.total/self.nb_timings
+
+    def __enter__(self):
+        self.start_time = time.perf_counter()
+
+    def __exit__(self, *exc):
+        self.timings.append(time.perf_counter() - self.start_time)
+
+    def wraps_function(self, f):
+        @wraps(f)
+        def wrapped_f(*args, **kwargs):
+            with self:
+                return f(*args, **kwargs)
+        return wrapped_f

{capytaine-2.2.1.dist-info → capytaine-2.3.1.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: capytaine
-Version: 2.2.1
+Version: 2.3.1
 Summary: Python BEM solver for linear potential flow, based on Nemoh
-Author-Email: Matthieu Ancellin <matthieu.ancellin@eurobios.com>
+Author-Email: Matthieu Ancellin <matthieu.ancellin@mews-labs.com>
 License:                     GNU GENERAL PUBLIC LICENSE
                                 Version 3, 29 June 2007
          
@@ -683,25 +683,21 @@ Classifier: Programming Language :: Fortran
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Topic :: Scientific/Engineering
+Project-URL: homepage, https://capytaine.org
 Project-URL: repository, https://github.com/capytaine/capytaine
 Requires-Python: >=3.8
 Requires-Dist: numpy>=1.20; python_version >= "3.9"
 Requires-Dist: numpy>=1.24; python_version == "3.8"
 Requires-Dist: scipy
-Requires-Dist: pandas>=1.3
+Requires-Dist: pandas<3,>=1.3
 Requires-Dist: xarray
 Requires-Dist: rich
 Provides-Extra: optional
 Requires-Dist: matplotlib; extra == "optional"
 Requires-Dist: joblib>=1.3; extra == "optional"
 Requires-Dist: meshio; extra == "optional"
-Provides-Extra: test
-Requires-Dist: pytest; extra == "test"
-Provides-Extra: docs
-Requires-Dist: sphinx; extra == "docs"
-Requires-Dist: sphinx-toolbox; extra == "docs"
-Requires-Dist: sphinxcontrib-proof; extra == "docs"
-Requires-Dist: sphinxcontrib-mermaid; extra == "docs"
+Requires-Dist: netcdf4; extra == "optional"
+Requires-Dist: vtk; extra == "optional"
 Description-Content-Type: text/markdown
 
 # Capytaine: a linear potential flow BEM solver with Python.

capytaine-2.3.1.dist-info/RECORD

@@ -0,0 +1,92 @@
+capytaine/__init__.py,sha256=ffYPfnzVMU03arvItDaf5VoDa68KEGP4J9aE1MQlmQg,1822
+capytaine/__about__.py,sha256=14fwPZt3SRhKmIUSRPB6gpUnkNBLGgZLmq6_R2Xvy_k,415
+capytaine/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+capytaine/ui/rich.py,sha256=ZfMHUpCSVztNseIGpN2I69ts_Aw_HJ5RnZc0f73av5Q,233
+capytaine/ui/cli.py,sha256=o3MH2OCHXFww1kb2zM9R3qs4jjfkCeeZFRAgnFnb2NE,797
+capytaine/ui/vtk/mesh_viewer.py,sha256=y5f3Qc7vWuu_xWXxOQm1bcvwm3D_JKUbzd1M9NVqrac,14750
+capytaine/ui/vtk/__init__.py,sha256=7wIkVipz_3JCZmLuED4-aQXZJwBYylS32PFswAdwvo4,161
+capytaine/ui/vtk/animation.py,sha256=FYH-YAu0LY2zr7fTl36aOSkM8z74_gxQRKOJFhUSluo,12443
+capytaine/ui/vtk/helpers.py,sha256=sOK_a679a7n9ozhcEZY3IhTWmPyctoLkFwKTyzDHrm8,2640
+capytaine/ui/vtk/body_viewer.py,sha256=gGIla-gADWiYuiNdS2io-0whpO6AaH8A8KkEmqX4OSY,1032
+capytaine/green_functions/__init__.py,sha256=527Pd0SIqwR64-d4sT-_jyE89XU-PLgFL0et96ChAIo,107
+capytaine/green_functions/delhommeau.py,sha256=y9nkyVKj9ES0nL2jDLdx_5ejQ5nbMSKV0qYUnPnfTNg,23550
+capytaine/green_functions/hams.py,sha256=yxT0ysNFxsm4VbRtywHnhtWnHrxkU8q6_DL8eEwZPTs,8252
+capytaine/green_functions/abstract_green_function.py,sha256=6_YjjTKbYNgteWw4FWKQQI9nfpPzEETQxD3WOWFqosw,2834
+capytaine/green_functions/FinGreen3D/test_program.f90,sha256=BlQv3O0z0tYXejz261S8l7x5H01wHAdn9-YfsRurW1w,926
+capytaine/green_functions/FinGreen3D/LICENSE,sha256=2n6rt7r999OuXp8iOqW9we7ORaxWncIbOwN1ILRGR2g,7651
+capytaine/green_functions/FinGreen3D/Makefile,sha256=E5XU-1Ziejhp1dHfKVP_YaGzzX1u7L3m5kZoPhtSscE,354
+capytaine/green_functions/FinGreen3D/README.md,sha256=OAL_oCou4Lf3mXE88dBhDP41yx28lxMws4Dgcu4m3jc,1980
+capytaine/green_functions/FinGreen3D/FinGreen3D.f90,sha256=tBsSc6BfQJpaFQ6j6tEYWG25u_SixJnooiCfQ1Uu9MI,119957
+capytaine/green_functions/FinGreen3D/.gitignore,sha256=GBMUBl3y8v2vkgsai1MR2qIWotZImgatpbScxRTYlBc,7
+capytaine/green_functions/LiangWuNoblesse/test_program.f90,sha256=cettkRXfJDmhigo7oUACjU3qCNFLJVDU0vI6Og4UFs8,494
+capytaine/green_functions/LiangWuNoblesse/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
+capytaine/green_functions/LiangWuNoblesse/Makefile,sha256=txvf2ppXhnT9OPDcE8zQcEq5jQcQ3B_A0ge1vdR6huA,411
+capytaine/green_functions/LiangWuNoblesse/README.md,sha256=0pQbZxIAWTc-9eQ2Qb62SfM5Eh3dNx0bPSznuOCx8xU,102
+capytaine/green_functions/LiangWuNoblesse/.gitignore,sha256=GBMUBl3y8v2vkgsai1MR2qIWotZImgatpbScxRTYlBc,7
+capytaine/green_functions/LiangWuNoblesse/LiangWuNoblesseWaveTerm.f90,sha256=BYaVrslAbglcI-7-kOz7qH3AQKLY4rvCmXaa7zfDCaM,22552
+capytaine/green_functions/libs/Delhommeau_float32.cpython-312-darwin.so,sha256=O3VWLFhNFPYP2rPKivyIYyyVWpkFqdEXL43No7-ooUY,363136
+capytaine/green_functions/libs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+capytaine/green_functions/libs/Delhommeau_float64.cpython-312-darwin.so,sha256=s9cKd38rE_Z8zkO18BYB7Kzs2yCKdsyefPRBQz5-pEg,399680
+capytaine/bodies/dofs.py,sha256=M5nWTeVJxmxKl2BowOnrE3plv1rrqDHNb76D_qHroS8,598
+capytaine/bodies/bodies.py,sha256=KOBeLwpXDBQhZAjLePqXMQf8LcAl2TdOtYS_4rzIjMs,52708
+capytaine/bodies/__init__.py,sha256=wIYFs14NAWqaHLQWvDGUEZTBWp_kdthKkbOlXHup6LA,157
+capytaine/bodies/predefined/rectangles.py,sha256=PtNK7_RUjRIi1oJNlsBhOosC3Ib2cXX1SnW9llTmD44,4500
+capytaine/bodies/predefined/spheres.py,sha256=8lHMqCQBQneN8EqTSXQanumt6j5TeR70CR4ckrnDfo4,2598
+capytaine/bodies/predefined/__init__.py,sha256=IA1y5XDGmyzNDpgQvz8kjyGajBCYoClAnCPn1PxFwfw,338
+capytaine/bodies/predefined/cylinders.py,sha256=Zfp3ecpKD72dfzv5Dd2y87EvDBBRsOJPq6GR6B76r5Y,5596
+capytaine/tools/lru_cache.py,sha256=ssPo7sZMMe15GIxPiQ7rA0GrjwYWsE66x3A-d-4FQTI,1709
+capytaine/tools/cache_on_disk.py,sha256=Cj2J5pNKw9PbIvxUn53swSmuGJoMibZzIvB5Skt52ig,912
+capytaine/tools/timer.py,sha256=0kEIvYFnwa0F4ayecxLl_VtiCrVL-8i9_NrAKrlSVmo,1520
+capytaine/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+capytaine/tools/deprecation_handling.py,sha256=_QFNrkreLerm3-LzRZ3l6B_O249PM-fCCAXMsHA7kIU,809
+capytaine/tools/optional_imports.py,sha256=HNjtvNZGxsw-eYmr4ejq001KhLevrvqq7ASAqTOw8W8,860
+capytaine/tools/symbolic_multiplication.py,sha256=DCmVlUwGtyUBU7VZZ0xxNnIjNSC0rQbgSuHRnlFQ8VU,4842
+capytaine/tools/lists_of_points.py,sha256=6DyL9kr8jbkvB2IuCq288eSd4Xq6pwa8wiQCYZm9M1Q,1828
+capytaine/tools/prony_decomposition.py,sha256=Eg8CcedPuLKVUA-wpjwXBJsnXjBGZruHVy4jMU2cCSM,5147
+capytaine/bem/solver.py,sha256=j2ZoVGA8x46xQe61s1Dh0zCFVXnTDuehAKa3f3-bZ0o,28790
+capytaine/bem/engines.py,sha256=YauXkOHKLbrDbzM1qisKiJ1D3LZ0-ALOWIIRNzNchUU,18070
+capytaine/bem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+capytaine/bem/problems_and_results.py,sha256=4pdwswnrbp7D1v1xOnBA3aYSCxm5qiaFZDJt_u5BxaA,27430
+capytaine/bem/airy_waves.py,sha256=GAhX5xNEgjoOo2uEHXfKCxb2TnmbPBCqW6VWfvzJTM8,3498
+capytaine/io/wamit.py,sha256=dvmthwIZnzOM8L1kq814pilCpQPLeTHvjjgg21hV2po,16028
+capytaine/io/legacy.py,sha256=lARoaPGjTsUQ4YiLmD8ZYMSCU_UDmnOQx4_JppaCcRc,14730
+capytaine/io/bemio.py,sha256=WXT7QPJK0t2kgUdI0DOOQG8u5zh_zk9q_PmTXqW1dJE,7334
+capytaine/io/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+capytaine/io/mesh_loaders.py,sha256=NjSWrCR20ozIFu94B7ZveiSS1kzt-IWKoFnkvLHcNXU,31771
+capytaine/io/meshio.py,sha256=QmuHGJt_a1VDrCpA_OKVWftgHPdZyjNkao38QpGuPT8,1469
+capytaine/io/mesh_writers.py,sha256=zLHRdzTpbpXyPsf7c09s6Nk2ZXIAQCCfHYIF3vKKDBo,21084
+capytaine/io/xarray.py,sha256=IF-l5O9gGeBTRpcJontvvi11sYfgqwfK7wp1_MAtFHY,27057
+capytaine/.dylibs/libgfortran.5.dylib,sha256=6uNZS_KEqHsXxVzZp8qANpYBaOKVUp4PapKX4P8wvhE,1901520
+capytaine/.dylibs/libquadmath.0.dylib,sha256=AtjHD7yn1DtR6T2PA-Ry7z9iJFiYF9eZ4dfkBVTFa6k,363936
+capytaine/.dylibs/libgcc_s.1.1.dylib,sha256=a2klIEBZo0Ns9hxZzfO7_Aur4CtbIedHBYCDc5gRMbg,183040
+capytaine/meshes/clipper.py,sha256=CB38_cmha8q6hnaxKukKQPtB7sXx34fU2HBujF8hD24,18677
+capytaine/meshes/properties.py,sha256=eJHhTtXzW-aiokuvluqLSfumAGMFZGmI3ZLP-pfVh2I,10790
+capytaine/meshes/symmetric.py,sha256=CHBusSwTufKiGYOqVrUurQojYqlLsSWqxB-Z2kjVEYE,18239
+capytaine/meshes/mesh_like_protocol.py,sha256=BxFLfJsHZFobyN5L0siuPRPq0DFpJbGsQw1yuFN06GQ,1042
+capytaine/meshes/surface_integrals.py,sha256=ihxbuiSsgep4rbrBQlq2q_2p_uDXDkRPyz0S6OVofc8,2263
+capytaine/meshes/__init__.py,sha256=5-AE32KOmOcq_F09uZanLafy7SzOe0-Cl6PaDbbOLMQ,361
+capytaine/meshes/meshes.py,sha256=_b0DtxR_UDmV0UOuB3bZ47ClGkIKJynTWESJxiIsbio,32625
+capytaine/meshes/collections.py,sha256=uTXQovnoPsKZfl3HqUveHc94SyscyfELILikRuAcpG0,11403
+capytaine/meshes/geometry.py,sha256=ffeHvFzke3sXHzGexivRmSBQIOCk-pCMoveQF4eYyGM,14107
+capytaine/meshes/quality.py,sha256=OTZvqyDSJGKIHfFWwn-QROH1Je4PjgFxbwp3Ce-nzzI,14383
+capytaine/meshes/quadratures.py,sha256=eT5tsfonBJEDkrCnoUJbEPLX34I1rCkgzD_E6XhDu-E,3227
+capytaine/meshes/predefined/rectangles.py,sha256=lbT8lYsij1bEo1CB9_NVrTsFBpOfedK7fPu-jB8OsV8,12294
+capytaine/meshes/predefined/spheres.py,sha256=dJMcGBgGwJ93V9JBzACy7byKRZe_hj42bCb3wOuSlBI,2212
+capytaine/meshes/predefined/__init__.py,sha256=uc2b-3UJi_4NnTkk6wRlbq5UTKOyRU7JTpMDdlUrjiY,365
+capytaine/meshes/predefined/cylinders.py,sha256=s3VwoQknY9Fnun6zukVccHh6h3rG-5NvLsiTlONbJVs,14846
+capytaine/post_pro/rao.py,sha256=kLePr2sbh38f-ydjQTIyeRuoDDqEootqwLSt575aGik,2293
+capytaine/post_pro/free_surfaces.py,sha256=NIrPoaZGC6-F4mSG8ZwelJsjKaSMGBjtRlwSRG3wuvQ,3117
+capytaine/post_pro/__init__.py,sha256=fi9BE68OzphGjf08HYGcCPmZLJYnD-wHjz86QEXkBn8,274
+capytaine/post_pro/kochin.py,sha256=vEjH850aOnSUprD8cnOSkvTGFdn2X9KAIDvehsxud3s,1927
+capytaine/post_pro/impedance.py,sha256=gNMKkSyD4qN55_PrTZhrtsh2XsAbC3ciFCWtvpJLKLM,3492
+capytaine/matrices/builders.py,sha256=a4P0gamYOUdf4r6ZGK_PuAyec3UZGQQaUljotWp6d8E,3153
+capytaine/matrices/low_rank.py,sha256=Z9nOVsTCrIXQ9-A-upz8UTdcc2uNuZ9VlAO8Tee1Si0,15996
+capytaine/matrices/linear_solvers.py,sha256=_5R-CR7eJ07Z3GcOd1YiX2bRyukuXQnHE0Dgpo8G2R8,8937
+capytaine/matrices/block_toeplitz.py,sha256=yL4GFPghfdVZTKtden0RKVDhpiBZz3D1oZ-pAVjDBjg,12930
+capytaine/matrices/__init__.py,sha256=_b868RYRI8ANHHf2PUVI-2_c0RdBfRDHLvJW5Uq1qys,704
+capytaine/matrices/block.py,sha256=9Gv800-regvNmD62-h9MvbW7vtPb4N-_3o8Y8HPnxgc,25486
+capytaine-2.3.1.dist-info/RECORD,,
+capytaine-2.3.1.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+capytaine-2.3.1.dist-info/WHEEL,sha256=JnJiRvkXFaFU4HlzyoqCApZ07jy6hpFKd_LkfBpWZzk,122
+capytaine-2.3.1.dist-info/entry_points.txt,sha256=R72-je8lc6ELm8ftt7lJ7f1aalnQs5BWYrGDBMexHII,53
+capytaine-2.3.1.dist-info/METADATA,sha256=ftEZnZzzOAlQ85oSpm66yuOls3Sh6ypK-bEYP3EcKME,45072

capytaine-2.3.1.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: meson
+Root-Is-Purelib: false
+Tag: cp312-cp312-macosx_14_0_arm64
+Generator: delocate 0.13.0
+