wavesimpro 1.5.0__tar.gz → 1.6.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavesimpro
-Version: 1.5.0
+Version: 1.6.0
 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.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wavesimpro"
-version = "1.5.0"
+version = "1.6.0"
 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.0}/src/wavesimpro/__init__.py

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

{wavesimpro-1.5.0 → wavesimpro-1.6.0}/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,10 +322,14 @@ 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,
@@ -435,6 +500,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]),

{wavesimpro-1.5.0 → wavesimpro-1.6.0}/src/wavesimpro/json_helper.py

@@ -559,6 +559,8 @@ def create_wavesim_properties(
     wavelength_unit: str = "Micrometers",
     voxel_unit: str = "Micrometers",
     boundary_size_um: float = 0.0,
+    boundary_sides_um: Optional[List[Tuple[float, float]]] = None,
+    boundary_strength: Optional[float] = None,
     residual_norm_threshold: float = 1.0e-6,
     residual_norm_max_iterations: int = 10000,
     periodic_x: bool = False,
@@ -585,7 +587,13 @@ def create_wavesim_properties(
         voxel_size: Voxel size value
         wavelength_unit: Wavelength unit (default: 'Micrometers')
         voxel_unit: Voxel size unit (default: 'Micrometers')
-        boundary_size_um: Boundary size in micrometers
+        boundary_size_um: Boundary size in micrometers (symmetric fallback)
+        boundary_sides_um: Optional three (left, right) pairs in micrometers
+            (x, y, z) → emitted as BoundarySizesX/Y/Z for asymmetric
+            boundaries. None = symmetric (boundary_size_um everywhere).
+        boundary_strength: Optional largest imaginary permittivity of the
+            absorbing ramp → emitted as BoundaryStrength. None = engine
+            default 1.0. C++ engine only.
         residual_norm_threshold: Convergence threshold
         residual_norm_max_iterations: Max iterations
         periodic_x, periodic_y, periodic_z: Periodic boundary conditions
@@ -594,7 +602,7 @@ def create_wavesim_properties(
             residual_norm_max_iterations (threshold still stops the run early).
             C++ engine only.
     """
-    return {
+    props = {
         "SimulationDomain": simulation_domain,
         "BackgroundMediumId": background_medium_id,
         "Primitives": primitives,
@@ -629,6 +637,20 @@ def create_wavesim_properties(
         }
     }
 
+    # Asymmetric per-side boundary widths (BoundarySides on the C# model).
+    # Omitted entirely when symmetric so old servers see the same JSON as before.
+    if boundary_sides_um is not None:
+        for key, (left, right) in zip(("BoundarySizesX", "BoundarySizesY", "BoundarySizesZ"),
+                                      boundary_sides_um):
+            props[key] = {
+                "Left":  {"Value": float(left),  "Unit": "Micrometers"},
+                "Right": {"Value": float(right), "Unit": "Micrometers"},
+            }
+    if boundary_strength is not None:
+        props["BoundaryStrength"] = float(boundary_strength)
+
+    return props
+
 
 def parse_progress_data(progress_obj: Optional[Dict[str, Any]]) -> Dict[str, Any]:
     """

{wavesimpro-1.5.0 → wavesimpro-1.6.0}/src/wavesimpro/simulate.py

@@ -97,7 +97,9 @@ def simulate(
     sources: Sequence[tuple],
     wavelength: float,
     pixel_size: float,
-    boundary_width: float,  # μm — REQUIRED, no default: the right value depends on the wavelength
+    boundary_width: Optional[float] = None,  # μm — REQUIRED unless boundary_widths is given
+    boundary_widths=None,        # per-axis [x, y, z] µm; each a number or (left, right) — asymmetric boundaries
+    boundary_strength=None,      # None = engine default 1.0 (C++ engine only)
     periodic: tuple = (False, False, False),  # forwarded to PeriodicX/Y/Z in JSON
     use_gpu=None,                              # forwarded to API (None = auto)
     n_domains=None,          # local only — accepted and ignored
@@ -212,6 +214,8 @@ def simulate(
         wavelength=wavelength,
         pixel_size=pixel_size,
         boundary_width=boundary_width,  # μm end-to-end; execute_via_api takes μm
+        boundary_widths=boundary_widths,
+        boundary_strength=boundary_strength,
         is_vectorial=is_vectorial,
         data_type="Permittivity",
         max_iterations=max_iterations,
@@ -246,7 +250,9 @@ def simulate_pro(
     sources: Sequence[tuple],
     wavelength: float,
     pixel_size: float,
-    boundary_width: float,  # μm — REQUIRED, no default: the right value depends on the wavelength
+    boundary_width: Optional[float] = None,  # μm — REQUIRED unless boundary_widths is given
+    boundary_widths=None,        # per-axis [x, y, z] µm; each a number or (left, right) — asymmetric boundaries
+    boundary_strength=None,      # None = engine default 1.0 (C++ engine only)
     periodic: tuple = (False, False, False),
     max_iterations: int = 100000,
     threshold: float = 1.0e-6,
@@ -355,6 +361,8 @@ def simulate_pro(
         wavelength=wavelength,
         pixel_size=pixel_size,
         boundary_width=boundary_width,  # μm end-to-end; execute_via_api takes μm
+        boundary_widths=boundary_widths,
+        boundary_strength=boundary_strength,
         is_vectorial=is_vectorial,
         data_type="Permittivity",
         max_iterations=max_iterations,

{wavesimpro-1.5.0 → wavesimpro-1.6.0}/src/wavesimpro.egg-info/PKG-INFO

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