capytaine 2.1__tar.gz → 2.2__tar.gz

{capytaine-2.1 → capytaine-2.2}/.github/workflows/build_docs.yml

@@ -14,6 +14,13 @@ on:
   workflow_dispatch:
 
 
+# The following block is meant to cancel the workflow if a newer commit is pushed on the pull request
+# From https://stackoverflow.com/questions/66335225/how-to-cancel-previous-runs-in-the-pr-when-you-push-new-commitsupdate-the-curre
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+
 jobs:
   build:
 

{capytaine-2.1 → capytaine-2.2}/.github/workflows/build_wheels.yaml

@@ -6,7 +6,7 @@ on:
     tags:
       - v*
   schedule:
-    - cron: '5 5 5/15 * *'  # On the 5th and 20th of each month at 5:05
+    - cron: '6 6 6/16 * *'  # On the 6th and 22nd of each month at 6:06
 
 
 jobs:
@@ -15,7 +15,8 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-20.04, macos-11, windows-2019]
+        os: [ubuntu-20.04, macos-12, macos-14, windows-2019]
+            # MacOS<=13 are Intel, while MacOS 14 is Apple Silicon
 
     steps:
       - uses: actions/checkout@v4

capytaine-2.2/.github/workflows/test_new_commits.yaml

@@ -0,0 +1,71 @@
+name: Build and test in fixed environments
+
+on:
+  push:
+    branches:
+      - 'master'
+    paths-ignore:
+      # Do not run if only the documentation has been changed
+      - 'docs/**'
+      - '**/*.md'
+  pull_request:
+    paths-ignore:
+      # Do not run if only the documentation has been changed
+      - 'docs/**'
+      - '**/*.md'
+
+env:
+  FORCE_COLOR: 3
+  # Colors for nox
+
+# The following block is meant to cancel the workflow if a newer commit is pushed on the pull request
+# From https://stackoverflow.com/questions/66335225/how-to-cancel-previous-runs-in-the-pr-when-you-push-new-commitsupdate-the-curre
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build_and_test:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        python-version: ['3.8', '3.12']
+
+    steps:
+
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Set up nox
+      uses: wntrblm/nox@2024.03.02
+
+    - name: Run nox session
+      run: nox -s build_and_test_on_locked_env
+
+  compile_fortran:
+
+    runs-on: ubuntu-latest
+
+    steps:
+
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    - name: Set up Fortran
+      uses: fortran-lang/setup-fortran@v1
+      with:
+        compiler: 'gcc'
+        version: '13'
+
+    - name: Compile and run example
+      working-directory: capytaine/green_functions/libDelhommeau/
+      run: make example && examples/minimal/minimal_example.bin
+      # Soundness of the results is not tested, only that the compiling and
+      # execution are succeeding.

{capytaine-2.1 → capytaine-2.2}/.github/workflows/test_with_latest_dependencies.yaml

@@ -16,7 +16,7 @@ jobs:
 
     strategy:
       matrix:
-        python-version: ['3.7', '3.12']
+        python-version: ['3.8', '3.12']
 
     steps:
 
@@ -32,4 +32,4 @@ jobs:
       uses: wntrblm/nox@2024.03.02
 
     - name: Run nox session
-      run: nox -s build_and_test_on_latest_env
+      run: nox -s build_and_test_on_latest_env editable_build_and_test_on_latest_env

{capytaine-2.1 → capytaine-2.2}/.pre-commit-config.yaml

@@ -37,4 +37,4 @@ repos:
     rev: "v2.2.5"
     hooks:
       - id: codespell
-        args: ["-L", "ba,informations,inout,ist,lamda,ment,noe,periode,sur"]
+        args: ["-L", "ba,informations,inout,ist,lamda,ment,noe,periode,sur", "--skip", "capytaine/green_functions/libDelhommeau/src/old_Prony_decomposition.f90"]

{capytaine-2.1 → capytaine-2.2}/Makefile

@@ -2,8 +2,8 @@ install:
 	pip install .
 
 develop:
-	pip install meson-python ninja "numpy>=2.0.0rc1,<2.3" charset-normalizer # No installed from pyproject.toml in this case...
-	pip install --no-build-isolation -e .
+	pip install -r editable_install_requirements.txt
+	pip install --no-build-isolation --editable .
 
 TEMP_DIR := $(shell mktemp -d)
 test_fortran_compilation:

{capytaine-2.1 → capytaine-2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: capytaine
-Version: 2.1
+Version: 2.2
 Summary: Python BEM solver for linear potential flow, based on Nemoh
 Author-Email: Matthieu Ancellin <matthieu.ancellin@eurobios.com>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -684,7 +684,8 @@ Classifier: License :: OSI Approved :: GNU General Public License v3 or later (G
 Classifier: Topic :: Scientific/Engineering
 Project-URL: Repository, https://github.com/capytaine/capytaine
 Requires-Python: >=3.8
-Requires-Dist: numpy>=1.20
+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: xarray
@@ -692,18 +693,12 @@ Requires-Dist: rich
 Requires-Dist: matplotlib; extra == "optional"
 Requires-Dist: joblib>=1.3; extra == "optional"
 Requires-Dist: meshio; extra == "optional"
-Requires-Dist: quadpy-gpl; extra == "optional"
-Requires-Dist: numpy<=1.26.2; extra == "build"
-Requires-Dist: ninja; extra == "build"
-Requires-Dist: meson-python; extra == "build"
-Requires-Dist: charset-normalizer; extra == "build"
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: sphinx; extra == "docs"
 Requires-Dist: sphinx-toolbox; extra == "docs"
 Requires-Dist: sphinxcontrib-proof; extra == "docs"
 Requires-Dist: sphinxcontrib-mermaid; extra == "docs"
 Provides-Extra: optional
-Provides-Extra: build
 Provides-Extra: test
 Provides-Extra: docs
 Description-Content-Type: text/markdown

{capytaine-2.1 → capytaine-2.2}/capytaine/__about__.py

@@ -5,7 +5,7 @@ __all__ = ["__title__", "__description__", "__version__", "__author__", "__uri__
 __title__ = "capytaine"
 __description__ = """Python BEM solver for linear potential flow, based on Nemoh"""
 
-__version__ = "2.1"
+__version__ = "2.2"
 
 __author__ = "Matthieu Ancellin"
 __uri__ = "https://github.com/capytaine/capytaine"

{capytaine-2.1 → capytaine-2.2}/capytaine/bem/problems_and_results.py

@@ -193,7 +193,7 @@ class LinearPotentialFlowProblem:
                     or len(self.body.mesh.faces) == 0):
                 raise ValueError(f"The mesh of the body {self.body.__short_str__()} is empty.")
 
-            panels_above_fs = self.body.mesh.faces_centers[:, 2] >= self.free_surface
+            panels_above_fs = self.body.mesh.faces_centers[:, 2] >= self.free_surface + 1e-8
             panels_below_sb = self.body.mesh.faces_centers[:, 2] <= -self.water_depth
             if (any(panels_above_fs) or any(panels_below_sb)):
 
@@ -218,7 +218,7 @@ class LinearPotentialFlowProblem:
             if len(self.boundary_condition.shape) != 1:
                 raise ValueError(f"Expected a 1-dimensional array as boundary_condition. Provided boundary condition's shape: {self.boundary_condition.shape}.")
 
-            if self.boundary_condition.shape[0] != self.body.mesh.nb_faces:
+            if self.boundary_condition.shape[0] != self.body.mesh_including_lid.nb_faces:
                 raise ValueError(
                     f"The shape of the boundary condition ({self.boundary_condition.shape})"
                     f"does not match the number of faces of the mesh ({self.body.mesh.nb_faces})."
@@ -256,7 +256,7 @@ class LinearPotentialFlowProblem:
     def __str__(self):
         """Do not display default values in str(problem)."""
         parameters = [f"body={self.body.__short_str__() if self.body is not None else None}",
-                      f"{self.provided_freq_type}={self.__getattribute__(self.provided_freq_type):.3f}",
+                      f"{self.provided_freq_type}={float(self.__getattribute__(self.provided_freq_type)):.3f}",
                       f"water_depth={self.water_depth}"]
 
         if not self.forward_speed == _default_parameters['forward_speed']:
@@ -345,7 +345,7 @@ class DiffractionProblem(LinearPotentialFlowProblem):
                          forward_speed=forward_speed, rho=rho, g=g)
 
         if float(self.omega) in {0.0, np.inf}:
-            raise NotImplementedError(f"DiffractionProblem does not support zero or infinite frequency.")
+            raise NotImplementedError("DiffractionProblem does not support zero or infinite frequency.")
 
         if self.body is not None:
 
@@ -356,6 +356,9 @@ class DiffractionProblem(LinearPotentialFlowProblem):
             # Note that even with forward speed, this is computed based on the
             # frequency and not the encounter frequency.
 
+            if self.body.lid_mesh is not None:
+                self.boundary_condition = np.concatenate([self.boundary_condition, np.zeros(self.body.lid_mesh.nb_faces)])
+
             if len(self.body.dofs) == 0:
                 LOG.warning(f"The body {self.body.name} used in diffraction problem has no dofs!")
 
@@ -398,10 +401,9 @@ class RadiationProblem(LinearPotentialFlowProblem):
                 self.radiating_dof = next(iter(self.body.dofs))
 
             if self.radiating_dof not in self.body.dofs:
-                LOG.error(f"In {self}: the radiating degree of freedom {self.radiating_dof} is not one of"
-                          f"the degrees of freedom of the body.\n"
-                          f"The dofs of the body are {list(self.body.dofs.keys())}")
-                raise ValueError("Unrecognized degree of freedom name.")
+                raise ValueError(f"In {self}:\n"
+                                 f"the radiating dof {repr(self.radiating_dof)} is not one of the degrees of freedom of the body.\n"
+                                 f"The dofs of the body are {list(self.body.dofs.keys())}")
 
             dof = self.body.dofs[self.radiating_dof]
 
@@ -422,6 +424,9 @@ class RadiationProblem(LinearPotentialFlowProblem):
                             )
                 self.boundary_condition += self.forward_speed * ddofdx_dot_n
 
+            if self.body.lid_mesh is not None:
+                self.boundary_condition = np.concatenate([self.boundary_condition, np.zeros(self.body.lid_mesh.nb_faces)])
+
 
     def _astuple(self):
         return super()._astuple() + (self.radiating_dof,)

{capytaine-2.1 → capytaine-2.2}/capytaine/bem/solver.py

@@ -1,5 +1,5 @@
-# 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>
 """Solver for the BEM problem.
 
 .. code-block:: python
@@ -93,7 +93,9 @@ class BEMSolver:
         """
         LOG.info("Solve %s.", problem)
 
-        if _check_wavelength: self._check_wavelength([problem])
+        if _check_wavelength:
+            self._check_wavelength_and_mesh_resolution([problem])
+            self._check_wavelength_and_irregular_frequencies([problem])
 
         if problem.forward_speed != 0.0:
             omega, wavenumber = problem.encounter_omega, problem.encounter_wavenumber
@@ -106,7 +108,7 @@ class BEMSolver:
                 raise NotImplementedError("Direct solver is not able to solve problems with forward speed.")
 
             S, D = self.engine.build_matrices(
-                    problem.body.mesh, problem.body.mesh,
+                    problem.body.mesh_including_lid, problem.body.mesh_including_lid,
                     problem.free_surface, problem.water_depth, wavenumber,
                     self.green_function, adjoint_double_layer=False
                     )
@@ -116,7 +118,7 @@ class BEMSolver:
             sources = None
         else:
             S, K = self.engine.build_matrices(
-                    problem.body.mesh, problem.body.mesh,
+                    problem.body.mesh_including_lid, problem.body.mesh_including_lid,
                     problem.free_surface, problem.water_depth, wavenumber,
                     self.green_function, adjoint_double_layer=True
                     )
@@ -127,10 +129,11 @@ class BEMSolver:
             if problem.forward_speed != 0.0:
                 result = problem.make_results_container(sources=sources)
                 # Temporary result object to compute the ∇Φ term
-                nabla_phi = self._compute_potential_gradient(problem.body.mesh, result)
+                nabla_phi = self._compute_potential_gradient(problem.body.mesh_including_lid, result)
                 pressure += problem.rho * problem.forward_speed * nabla_phi[:, 0]
 
-        forces = problem.body.integrate_pressure(pressure)
+        pressure_on_hull = pressure[:problem.body.mesh.nb_faces]  # Discards pressure on lid if any
+        forces = problem.body.integrate_pressure(pressure_on_hull)
 
         if not keep_details:
             result = problem.make_results_container(forces)
@@ -162,7 +165,9 @@ class BEMSolver:
         list of LinearPotentialFlowResult
             the solved problems
         """
-        if _check_wavelength: self._check_wavelength(problems)
+        if _check_wavelength:
+            self._check_wavelength_and_mesh_resolution(problems)
+            self._check_wavelength_and_irregular_frequencies(problems)
 
         if n_jobs == 1:  # force sequential resolution
             problems = sorted(problems)
@@ -184,31 +189,60 @@ class BEMSolver:
             return results
 
     @staticmethod
-    def _check_wavelength(problems):
+    def _check_wavelength_and_mesh_resolution(problems):
         """Display a warning if some of the problems have a mesh resolution
         that might not be sufficient for the given wavelength."""
         risky_problems = [pb for pb in problems
-                          if pb.wavelength < pb.body.minimal_computable_wavelength]
+                          if 0.0 < pb.wavelength < pb.body.minimal_computable_wavelength]
         nb_risky_problems = len(risky_problems)
         if nb_risky_problems == 1:
             pb = risky_problems[0]
             freq_type = risky_problems[0].provided_freq_type
             freq = pb.__getattribute__(freq_type)
             LOG.warning(f"Mesh resolution for {pb}:\n"
-                    f"The resolution of the mesh of the body {pb.body.__short_str__()} might "
-                    f"be insufficient for {freq_type}={freq}.\n"
-                     "This warning appears because the largest panel of this mesh "
-                    f"has radius {pb.body.mesh.faces_radiuses.max():.3f} > wavelength/8."
-                    )
+                        f"The resolution of the mesh of the body {pb.body.__short_str__()} might "
+                        f"be insufficient for {freq_type}={freq}.\n"
+                        "This warning appears because the largest panel of this mesh "
+                        f"has radius {pb.body.mesh.faces_radiuses.max():.3f} > wavelength/8."
+                        )
         elif nb_risky_problems > 1:
             freq_type = risky_problems[0].provided_freq_type
             freqs = np.array([float(pb.__getattribute__(freq_type)) for pb in risky_problems])
             LOG.warning(f"Mesh resolution for {nb_risky_problems} problems:\n"
-                         "The resolution of the mesh might be insufficient "
+                        "The resolution of the mesh might be insufficient "
                         f"for {freq_type} ranging from {freqs.min():.3f} to {freqs.max():.3f}.\n"
-                         "This warning appears when the largest panel of this mesh "
-                         "has radius > wavelength/8."
-                    )
+                        "This warning appears when the largest panel of this mesh "
+                        "has radius > wavelength/8."
+                        )
+
+    @staticmethod
+    def _check_wavelength_and_irregular_frequencies(problems):
+        """Display a warning if some of the problems might encounter irregular frequencies."""
+        risky_problems = [pb for pb in problems
+                          if pb.body.first_irregular_frequency_estimate() < pb.omega < np.inf]
+        nb_risky_problems = len(risky_problems)
+        if nb_risky_problems >= 1:
+            if any(pb.body.lid_mesh is None for pb in problems):
+                recommendation = "Setting a lid for the floating body is recommended."
+            else:
+                recommendation = "The lid might need to be closer to the free surface."
+            if nb_risky_problems == 1:
+                pb = risky_problems[0]
+                freq_type = risky_problems[0].provided_freq_type
+                freq = pb.__getattribute__(freq_type)
+                LOG.warning(f"Irregular frequencies for {pb}:\n"
+                            f"The body {pb.body.__short_str__()} might display irregular frequencies "
+                            f"for {freq_type}={freq}.\n"
+                            + recommendation
+                            )
+            elif nb_risky_problems > 1:
+                freq_type = risky_problems[0].provided_freq_type
+                freqs = np.array([float(pb.__getattribute__(freq_type)) for pb in risky_problems])
+                LOG.warning(f"Irregular frequencies for {nb_risky_problems} problems:\n"
+                            "Irregular frequencies might be encountered "
+                            f"for {freq_type} ranging from {freqs.min():.3f} to {freqs.max():.3f}.\n"
+                            + recommendation
+                            )
 
     def fill_dataset(self, dataset, bodies, *, method='indirect', n_jobs=1, **kwargs):
         """Solve a set of problems defined by the coordinates of an xarray dataset.
@@ -271,7 +305,7 @@ class BEMSolver:
             They probably have not been stored by the solver because the option keep_details=True have not been set or the direct method has been used.
             Please re-run the resolution with the indirect method and keep_details=True.""")
 
-        S, _ = self.green_function.evaluate(points, result.body.mesh, result.free_surface, result.water_depth, result.encounter_wavenumber)
+        S, _ = self.green_function.evaluate(points, result.body.mesh_including_lid, result.free_surface, result.water_depth, result.encounter_wavenumber)
         potential = S @ result.sources  # Sum the contributions of all panels in the mesh
         return potential.reshape(output_shape)
 
@@ -283,7 +317,7 @@ class BEMSolver:
             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.""")
 
-        _, gradG = self.green_function.evaluate(points, result.body.mesh, result.free_surface, result.water_depth, result.encounter_wavenumber,
+        _, gradG = self.green_function.evaluate(points, result.body.mesh_including_lid, result.free_surface, result.water_depth, result.encounter_wavenumber,
                                                 early_dot_product=False)
         velocities = np.einsum('ijk,j->ik', gradG, result.sources)  # Sum the contributions of all panels in the mesh
         return velocities.reshape((*output_shape, 3))
@@ -409,7 +443,7 @@ class BEMSolver:
         if chunk_size > mesh.nb_faces:
             S = self.engine.build_S_matrix(
                 mesh,
-                result.body.mesh,
+                result.body.mesh_including_lid,
                 result.free_surface, result.water_depth, result.wavenumber,
                 self.green_function
             )
@@ -421,7 +455,7 @@ class BEMSolver:
                 faces_to_extract = list(range(i, min(i+chunk_size, mesh.nb_faces)))
                 S = self.engine.build_S_matrix(
                     mesh.extract_faces(faces_to_extract),
-                    result.body.mesh,
+                    result.body.mesh_including_lid,
                     result.free_surface, result.water_depth, result.wavenumber,
                     self.green_function
                 )