wavesimpro 1.5.0__tar.gz → 1.6.1__tar.gz

{wavesimpro-1.5.0 → wavesimpro-1.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavesimpro
-Version: 1.5.0
+Version: 1.6.1
 Summary: WavesimPro Python API — cloud execution client for the Rayfos simulation platform
 Author: Rayfos
 Project-URL: Repository, https://github.com/rayfos/wavesimpro

{wavesimpro-1.5.0 → wavesimpro-1.6.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wavesimpro"
-version = "1.5.0"
+version = "1.6.1"
 description = "WavesimPro Python API — cloud execution client for the Rayfos simulation platform"
 readme = "README.md"
 requires-python = ">=3.8"

{wavesimpro-1.5.0 → wavesimpro-1.6.1}/src/wavesimpro/__init__.py

@@ -45,7 +45,7 @@ from .json_helper import (
     parse_progress_data,
 )
 
-__version__ = "1.5.0"
+__version__ = "1.6.1"
 __all__ = [
     # Client
     "RayfosClient",

{wavesimpro-1.5.0 → wavesimpro-1.6.1}/src/wavesimpro/client.py

@@ -285,6 +285,7 @@ class RayfosClient:
         periodic: tuple = (False, False, False),
         engine_preference: str = "Any",
         use_gpu: Optional[bool] = None,
+        is_vectorial: Optional[bool] = None,
     ) -> Dict[str, Any]:
         """
         Ask the server (cloud or machine-service) whether a simulation of the
@@ -301,6 +302,10 @@ class RayfosClient:
             periodic: (periodic_x, periodic_y, periodic_z) — periodic axes don't get boundary padding
             engine_preference: "Any" | "Python" | "Cpp"
             use_gpu: None (auto), True (require GPU), False (force CPU)
+            is_vectorial: True = Maxwell (vectorial, 3 field components), False =
+                Helmholtz (scalar). Memory differs ~3x between the two, so ALWAYS
+                pass it: this payload carries no sources, and without the flag the
+                server falls back to "Maxwell unless engine_preference is Python".
 
         Returns:
             PreflightCheckResponse dict with keys:
@@ -339,6 +344,7 @@ class RayfosClient:
             },
             "enginePreference": engine_preference,
             "useGpu": use_gpu,
+            "isVectorial": is_vectorial,
         }
         # Machine service URL takes precedence (local single-machine preflight); else cloud aggregator.
         if self.config.machine_service_url:

{wavesimpro-1.5.0 → wavesimpro-1.6.1}/src/wavesimpro/execute.py

@@ -15,7 +15,7 @@ import shutil
 import logging
 import tempfile
 from pathlib import Path
-from typing import Tuple, Optional, Callable, Dict, Any, List, Union
+from typing import Tuple, Optional, Callable, Dict, Any, List, Union, Sequence
 
 import numpy as np
 
@@ -61,6 +61,37 @@ def _monitor_output_filename(monitor_name: str) -> str:
     return f"monitor_{core}.bin"
 
 
+def _normalize_boundary_widths(boundary_widths) -> Optional[List[Tuple[float, float]]]:
+    """Normalize a per-axis boundary spec into three (left, right) pairs in µm.
+
+    Accepts a sequence of exactly 3 entries (x, y, z); each entry is either a
+    single number (same width on both sides of that axis) or a (left, right)
+    pair. Returns None when boundary_widths is None.
+    """
+    if boundary_widths is None:
+        return None
+    if len(boundary_widths) != 3:
+        raise ValueError(
+            "boundary_widths must have exactly 3 entries (x, y, z); each entry is "
+            "a width in MICROMETERS or a (left, right) pair, e.g. "
+            "boundary_widths=[6.0, (6.0, 0.0), 6.0]"
+        )
+    out: List[Tuple[float, float]] = []
+    for axis, w in zip("xyz", boundary_widths):
+        if isinstance(w, (int, float)):
+            left = right = float(w)
+        else:
+            if len(w) != 2:
+                raise ValueError(
+                    f"boundary_widths[{axis}] must be a number or a (left, right) pair, got {w!r}"
+                )
+            left, right = float(w[0]), float(w[1])
+        if left < 0 or right < 0:
+            raise ValueError(f"boundary_widths[{axis}] sides must be >= 0, got ({left}, {right})")
+        out.append((left, right))
+    return out
+
+
 def execute_via_api(
     refractive_index: np.ndarray,
     source,
@@ -68,7 +99,9 @@ def execute_via_api(
     pixel_size: float,
     threshold: float = 1e-2,
     max_iterations: int = 1000,
-    boundary_width: Optional[float] = None,  # in MICROMETERS; REQUIRED — None raises; no silent default
+    boundary_width: Optional[float] = None,  # in MICROMETERS; REQUIRED unless boundary_widths is given
+    boundary_widths: Optional[Sequence[Any]] = None,  # per-axis [x, y, z] µm; each a number or (left, right)
+    boundary_strength: Optional[float] = None,  # None = engine default 1.0 (C++ engine only)
     is_vectorial: bool = True,
     data_type: str = "RefractiveIndex",
     api_url: Optional[str] = None,
@@ -113,6 +146,18 @@ def execute_via_api(
             BREAKING CHANGE: in earlier versions this parameter was in PIXELS
             and defaulted to 0. If you are migrating, pass your old pixel
             count × pixel_size instead.
+        boundary_widths: OPTIONAL asymmetric boundaries (C++ engine, 2026-09
+            machine service+). Sequence of exactly 3 entries (x, y, z) in
+            MICROMETERS; each entry is a single number (same width on both
+            sides of that axis) or a (left, right) pair, e.g.
+            ``boundary_widths=[6.0, (6.0, 0.0), 6.0]``. When given,
+            boundary_width becomes optional (it is then only the symmetric
+            fallback stored as BoundarySize for older servers, defaulting to
+            the X-left value). Jobs that resolve to the Python engine collapse
+            to a single scalar (the X-left value) with a machine-side warning.
+        boundary_strength: OPTIONAL largest imaginary permittivity the
+            absorbing ramp lerps towards (C++ engine only). None (default)
+            = engine default 1.0. Older servers ignore it.
         is_vectorial: True for Maxwell, False for Helmholtz (default: True)
         data_type: 'RefractiveIndex' or 'Permittivity' (default: 'RefractiveIndex')
         api_url: API base URL (default: from RAYFOS_API_URL env var)
@@ -149,16 +194,26 @@ def execute_via_api(
               each shaped per its own sub-cube.
             - converged: True if simulation completed successfully
     """
+    boundary_sides_um = _normalize_boundary_widths(boundary_widths)
     if boundary_width is None:
-        raise ValueError(
-            "boundary_width is required and has no default: the right value depends "
-            "on the wavelength. It is the absorbing boundary width in MICROMETERS "
-            "(μm) — typically 4–5 × the vacuum wavelength. Thinner boundaries "
-            "reflect grazing/guided waves back into the domain; thicker ones "
-            "increase memory (the boundary pads both sides of every non-periodic "
-            "axis). NOTE: in earlier versions this parameter was in PIXELS and "
-            "defaulted to 0 — if migrating, pass old_pixel_count * pixel_size."
-        )
+        if boundary_sides_um is not None:
+            # Symmetric fallback stored as BoundarySize: used by pre-2026-09
+            # servers (which ignore the per-side fields) and by the Python
+            # engine (single scalar). X-axis left, per the degradation rule.
+            boundary_width = boundary_sides_um[0][0]
+        else:
+            raise ValueError(
+                "boundary_width is required and has no default: the right value depends "
+                "on the wavelength. It is the absorbing boundary width in MICROMETERS "
+                "(μm) — typically 4–5 × the vacuum wavelength. Thinner boundaries "
+                "reflect grazing/guided waves back into the domain; thicker ones "
+                "increase memory (the boundary pads both sides of every non-periodic "
+                "axis). NOTE: in earlier versions this parameter was in PIXELS and "
+                "defaulted to 0 — if migrating, pass old_pixel_count * pixel_size. "
+                "For asymmetric boundaries pass boundary_widths instead."
+            )
+    if boundary_strength is not None and boundary_strength <= 0:
+        raise ValueError(f"boundary_strength must be > 0 (None = engine default 1.0), got {boundary_strength}")
 
     # 1. Load credentials
     api_url = api_url or os.environ.get("RAYFOS_API_URL", "http://localhost:5159")
@@ -198,7 +253,13 @@ def execute_via_api(
     logger.info(f"  Max iterations: {max_iterations}")
     if pseudo_propagation_distance > 0:
         logger.info(f"  Pseudo propagation distance: {pseudo_propagation_distance} um (overrides max iterations)")
-    logger.info(f"  Boundary width: {boundary_width} um ({int(round(boundary_width / pixel_size))} pixels)")
+    if boundary_sides_um is None:
+        logger.info(f"  Boundary width: {boundary_width} um ({int(round(boundary_width / pixel_size))} pixels)")
+    else:
+        logger.info("  Boundary widths (um): " + "  ".join(
+            f"{ax}:[{left:g}, {right:g}]" for ax, (left, right) in zip("XYZ", boundary_sides_um)))
+    if boundary_strength is not None:
+        logger.info(f"  Boundary strength: {boundary_strength}")
 
     # 3. Prepare electromagnetic data
     if data_type == "RefractiveIndex":
@@ -261,13 +322,18 @@ def execute_via_api(
     domain_y_um = float(ny) * float(pixel_size)
     domain_z_um = float(nz) * float(pixel_size)
     try:
+        # The preflight endpoint takes one scalar width; with asymmetric
+        # boundaries use the largest side so the estimate stays conservative.
+        preflight_boundary_um = (float(boundary_width) if boundary_sides_um is None
+                                 else max(side for pair in boundary_sides_um for side in pair))
         pre = client.preflight_check(
             domain_um=(domain_x_um, domain_y_um, domain_z_um),
             voxel_um=float(pixel_size),
-            boundary_um=float(boundary_width),
+            boundary_um=preflight_boundary_um,
             periodic=(bool(periodic[0]), bool(periodic[1]), bool(periodic[2])),
             engine_preference=engine_preference,
             use_gpu=use_gpu,
+            is_vectorial=is_vectorial,
         )
     except Exception as exc:
         logger.warning(f"Preflight check failed (server may not support /api/preflightCheck yet): {exc}. Proceeding without it.")
@@ -277,9 +343,10 @@ def execute_via_api(
         status = (pre.get("status") or "").lower()
         pre_description = pre.get("description") or ""
         est = pre.get("estimate") or {}
+        solver = est.get("solver") or ("Maxwell" if est.get("isVectorial") else "Helmholtz")
         logger.info(
             f"Preflight: status={status} "
-            f"est_total={est.get('totalMemoryGB', 0):.2f} GB "
+            f"est_total={est.get('totalMemoryGB', 0):.2f} GB ({solver}) "
             f"(E-field {est.get('efieldMemoryGB', 0):.2f} GB + workspace {est.get('workspaceMemoryGB', 0):.2f} GB) "
             f"grid={est.get('nx')}x{est.get('ny')}x{est.get('nz')}"
         )
@@ -326,6 +393,7 @@ def execute_via_api(
         gpu_memory_max_gb=gpu_memory_max_gb,
         periodic=periodic,
         pseudo_propagation_distance=pseudo_propagation_distance,
+        data_type=data_type,
     )
 
     # 8. Upload RI/permittivity
@@ -435,6 +503,8 @@ def execute_via_api(
         wavelength=float(wavelength),
         voxel_size=float(pixel_size),
         boundary_size_um=boundary_size_um,
+        boundary_sides_um=boundary_sides_um,
+        boundary_strength=boundary_strength,
         residual_norm_threshold=float(threshold),
         residual_norm_max_iterations=int(max_iterations),
         periodic_x=bool(periodic[0]),