FEAT: integrate sparrowpy method

example_settings/sparrowpy_setting.json

@@ -0,0 +1,72 @@
+{
+    "type": "simulationSettings",
+    "options": [
+        {
+            "name": "Speed of sound",
+            "id": "speed_of_sound",
+            "type": "float",
+            "display": "text",
+            "min": 100,
+            "max": 500,
+            "default": 343,
+            "step": 1,
+            "endAdornment": "m/s"
+        },
+        {
+            "name": "ETC time resolution",
+            "id": "etc_time_resolution_s",
+            "type": "float",
+            "display": "text",
+            "min": 0.0001,
+            "max": 0.1,
+            "step": 0.001,
+            "default": 0.001,
+            "endAdornment": "s"
+        },
+        {
+            "name": "ETC duration",
+            "id": "etc_duration_s",
+            "type": "float",
+            "display": "text",
+            "min": 0.1,
+            "max": 10,
+            "step": 0.1,
+            "default": 1,
+            "endAdornment": "s"
+        },
+        {
+            "name": "Maximum reflection order",
+            "id": "max_reflection_order",
+            "type": "int",
+            "display": "text",
+            "min": 1,
+            "max": 500,
+            "step": 1,
+            "default": 30,
+            "endAdornment": ""
+        },
+        {
+            "name": "Patch size",
+            "id": "patch_length",
+            "type": "float",
+            "display": "text",
+            "min": 0.01,
+            "max": 10,
+            "step": 0.01,
+            "default": 3,
+            "endAdornment": "m"
+        },
+        {
+            "name": "Source Power",
+            "id": "sound_power_W",
+            "type": "float",
+            "display": "text",
+            "min": 0,
+            "max": 10,
+            "step": 0.01,
+            "default": 0.0796,
+            "endAdornment": "W"
+        }
+
+    ]
+}

methods-config.json

@@ -19,6 +19,16 @@
         "repositoryURL":"https://github.com/Building-acoustics-TU-Eindhoven/acousticDE/",
         "documentationURL":"https://building-acoustics-tu-eindhoven.github.io/acousticDE/index.html"
     },
+    {
+        "simulationType": "sparrowpy", 
+        "containerImage": "sparrowpy_image:latest",
+        "envVars": {},
+        "label": "Acoustic Radiance Transfer assuming diffuse reflections",
+        "settings":"sparrowpy_setting.json",
+        "entryFile":"sparrowpy_interface.py",
+        "repositoryURL":"https://github.com/sparrow-acoustics/sparrowpy",
+        "documentationURL":"https://sparrowpy.readthedocs.io/en/stable"
+    },
     {
         "simulationType": "MyNewMethod",
         "containerImage": "mynewmethod_image:latest", 

sparrowpy_method/Dockerfile

@@ -0,0 +1,22 @@
+FROM python:3.11.13-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies for mesh generation and scientific computing
+RUN apt-get update && apt-get install -y \
+    git \
+    build-essential \
+    gmsh \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy method package directory
+COPY sparrowpy_method /app/sparrowpy_method
+
+# Install the method package
+RUN pip install --no-cache-dir /app/sparrowpy_method
+
+WORKDIR /app/sparrowpy_method
+
+# Default command to run the containerized sparrowpy method
+CMD ["python", "-m", "sparrowpy_interface"]

sparrowpy_method/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026, The sparrowpy developers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next
+paragraph) shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

sparrowpy_method/pyproject.toml

@@ -0,0 +1,78 @@
+[project]
+name = "sparrowpy_interface"
+version = "0.1.0"
+description = "Sound Propagation with Acoustic Radiosity for Realistic Outdoor Worlds"
+requires-python = ">=3.11,<3.15"
+authors = [
+    { name = "Anne Heimes", email = "ahe@akustik.rwth-aachen.de" },
+]
+keywords = [
+    "acoustic simulation",
+    "geometrical acoustics",
+    "acoustic radiance transfer",
+    "brdf",
+    "scattering",
+]
+
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Natural Language :: English",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
+dependencies = [
+    "numpy>=1.23.0",
+    "sparrowpy>=1",
+    "requests",
+    "gmsh",
+    "trimesh",
+    "pyfar",
+    "pyrato",
+]
+
+[project.optional-dependencies]
+deploy = [
+    "twine",
+    "wheel",
+    "build",
+    "setuptools",
+    "bump-my-version",
+]
+
+tests = [
+    "pytest",
+    "pytest-cov",
+    "watchdog",
+    "ruff",
+    "coverage",
+]
+
+docs = [
+    "sphinx",
+    "autodocsumm>=0.2.14",
+    "pydata-sphinx-theme",
+    "sphinx_mdinclude",
+    "sphinx-design",
+    "sphinx-favicon",
+    "sphinx-reredirects",
+]
+
+dev = ["sparrowpy_interface[deploy,tests,docs]"]
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["sparrowpy_interface"]
+
+[project.scripts]
+sparrowpy_interface = "sparrowpy_interface:main"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

sparrowpy_method/sparrowpy_interface/__cli__.py

@@ -0,0 +1,19 @@
+"""CLI module for sparrowpy method."""
+import os
+from .sparrowpy_interface import sparrowpyMethod
+
+
+def main() -> None:
+    """Run the sparrowpy method simulation."""
+    # JSON path in the uploads folder. This variable is set for the
+    # container when it is started up.
+    json_file_path = os.environ.get("JSON_PATH")
+
+    print(f"Running sparrowpy method with JSON_PATH={json_file_path}")
+    sparrowpy_method_object = sparrowpyMethod(json_file_path)
+    sparrowpy_method_object.run_simulation()
+
+    # Save the results to a separate file
+    sparrowpy_method_object.save_results()
+
+    print("sparrowpy container finished.")

sparrowpy_method/sparrowpy_interface/__init__.py

@@ -0,0 +1,8 @@
+"""sparrowpyMethod package."""
+from .__main__ import main
+from .sparrowpy_interface import sparrowpyMethod
+
+__all__ = [
+    "main",
+    "sparrowpyMethod"
+]

sparrowpy_method/sparrowpy_interface/__main__.py

@@ -0,0 +1,5 @@
+"""Main module for sparrowpy method."""
+from .__cli__ import main
+
+if __name__ == "__main__":
+    main()

sparrowpy_method/sparrowpy_interface/definition.py

@@ -0,0 +1,92 @@
+"""Base class implementation of the SimulationMethod interface class."""
+from abc import ABC, abstractmethod
+from pathlib import Path
+import time
+
+import requests
+
+
+class SimulationMethod(ABC):
+    """Abstract base class for simulation methods.
+
+    This class serves as a template for methods required to run a simulation
+    and return results to the simulation service executor.
+
+    """
+
+    def __init__(self, input_json_path: str | Path | None):
+        """Initialize the simulation method.
+
+        Parameters
+        ----------
+        input_json_path : str | Path | None, optional
+            The path to the input JSON file, by default None
+
+        Raises
+        ------
+        FileNotFoundError
+            If the input JSON file does not exist.
+
+        """
+        if input_json_path is None or (
+                isinstance(input_json_path, str) and input_json_path == ""):
+            raise FileNotFoundError("input_json_path cannot be None or empty")
+
+        input_path = Path(input_json_path)
+        if not input_path.exists():
+            raise FileNotFoundError(
+                f"Input JSON file not found: {input_json_path}")
+
+        self._input_json_path = input_json_path
+
+    @property
+    def input_json_path(self) -> str | Path:
+        """The input JSON file."""
+        return self._input_json_path
+
+    @abstractmethod
+    def run_simulation(self):
+        """Run the simulation for the given a JSON file."""
+        pass
+
+    def save_results(
+            self,
+            url="http://host.docker.internal:5001/receive",
+            max_retries=5,
+            delay=2,
+        ):
+        """Return the results back to the simulation service executor.
+
+        Parameters
+        ----------
+        url : str, optional
+            The URL of the results server,
+            by default "http://host.docker.internal:5001/receive" which
+            is the default address for local execution via Docker.
+        max_retries : int, optional
+            The maximum number of retries if the request fails, by default 5
+        delay : int, optional
+            The delay in seconds between retries, by default 2
+
+        """
+
+        json_tmp_file = self.input_json_path
+        for attempt in range(1, max_retries + 1):
+            try:
+                with open(json_tmp_file, "rb") as f:
+                    response = requests.post(url, files={"file": f})
+
+                if response.status_code == 200:
+                    print("Successfully sent file.")
+                    return True
+
+                print(
+                    f"Attempt {attempt}: ",
+                    f"Server returned {response.status_code}")
+            except requests.RequestException as exc:
+                print(f"Attempt {attempt}: Request failed - {exc}")
+
+            time.sleep(delay)
+
+        print("Max retries reached. Giving up.")
+        return False