wavesimpro 0.9.1__tar.gz → 0.9.2__tar.gz

{wavesimpro-0.9.1 → wavesimpro-0.9.2}/PKG-INFO

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

{wavesimpro-0.9.1 → wavesimpro-0.9.2}/pyproject.toml

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

{wavesimpro-0.9.1 → wavesimpro-0.9.2}/src/wavesimpro/__init__.py

@@ -30,7 +30,7 @@ from .binary_utils import (
 )
 from .validate import validate_parameters, ParameterValidationError
 from .execute import execute_via_api
-from .simulate import simulate, configure
+from .simulate import simulate, simulate_pro, configure
 from .json_helper import (
     create_simulation_domain,
     create_stl_primitive,
@@ -49,7 +49,7 @@ from .json_helper import (
     parse_progress_data,
 )
 
-__version__ = "0.9.0"
+__version__ = "0.9.2"
 __all__ = [
     # Client
     "RayfosClient",

{wavesimpro-0.9.1 → wavesimpro-0.9.2}/src/wavesimpro/client.py

@@ -896,6 +896,7 @@ class RayfosClient:
         version_id: str,
         engine_preference: str = 'Any',
         use_gpu: Optional[bool] = None,
+        preferred_machine_id: Optional[str] = None,
     ) -> Dict[str, Any]:
         """
         Create a simulation command for a project version.
@@ -927,7 +928,7 @@ class RayfosClient:
         if self.config.machine_service_url:
             return self._create_command_machine_service(project_id, version_id)
         else:
-            return self._create_command_cloud(project_id, version_id, engine_preference, use_gpu)
+            return self._create_command_cloud(project_id, version_id, engine_preference, use_gpu, preferred_machine_id)
     
     def _create_command_machine_service(
         self,
@@ -956,6 +957,7 @@ class RayfosClient:
         version_id: str,
         engine_preference: str = 'Any',
         use_gpu: Optional[bool] = None,
+        preferred_machine_id: Optional[str] = None,
     ) -> Dict[str, Any]:
         """Create command via RayfosJobServer (cloud mode)"""
         data: Dict[str, Any] = {}
@@ -963,6 +965,8 @@ class RayfosClient:
             data['enginePreference'] = engine_preference
         if use_gpu is not None:
             data['useGpu'] = use_gpu
+        if preferred_machine_id:
+            data['preferredMachineServiceId'] = preferred_machine_id
         return self._post(f"/api/projects/{project_id}/versions/{version_id}/command", json=data)
     
     # ========================================================================

{wavesimpro-0.9.1 → wavesimpro-0.9.2}/src/wavesimpro/execute.py

@@ -63,6 +63,9 @@ def execute_via_api(
     progress_callback: Optional[Callable[[Dict[str, Any]], None]] = None,
     engine_preference: str = "Any",
     use_gpu: Optional[bool] = None,
+    preferred_machine_id: Optional[str] = None,
+    alpha: float = 0.75,
+    keep_residuals_list: bool = False,
 ) -> Tuple[np.ndarray, bool]:
     """
     Execute a Wavesim simulation via the Rayfos REST API.
@@ -311,6 +314,8 @@ def execute_via_api(
         periodic_x=bool(periodic[0]),
         periodic_y=bool(periodic[1]),
         periodic_z=bool(periodic[2]),
+        alpha=float(alpha),
+        keep_residuals_list=bool(keep_residuals_list),
     )
 
     logger.info(f"  Payload created with {len(sources_info)} source(s)")
@@ -321,7 +326,7 @@ def execute_via_api(
 
     # 12. Submit command
     logger.info("Submitting simulation command...")
-    cmd_status = client.create_command(project_id, version_id, engine_preference, use_gpu)
+    cmd_status = client.create_command(project_id, version_id, engine_preference, use_gpu, preferred_machine_id)
     command_id = cmd_status.get("commandId") or cmd_status.get("id")
     if not command_id:
         raise RuntimeError("No command ID found in response")
@@ -342,6 +347,8 @@ def execute_via_api(
     print(f"  Mode      : {_mode}")
     print(f"  Domain    : {_domain_str}  λ={wavelength} µm  Δx={pixel_size} µm")
     print(f"  Engine    : {_engine}  |  GPU: {_gpu}")
+    if preferred_machine_id:
+        print(f"  Machine   : {preferred_machine_id}")
     print(f"  Threshold : {threshold:.1e}  max iter: {max_iterations}")
     print(f"  {'─'*54}")
     start_time = time.time()
@@ -513,10 +520,10 @@ def execute_via_api(
 
     E = read_binary_field(output_data, dims, "Complex64")
 
-    # Squeeze trailing size-1 spatial dimensions added for 1D/2D inputs
-    for _ in range(3 - _input_ndim):
-        if E.shape[-1] == 1:
-            E = E[..., 0]
+    # Squeeze all trailing size-1 spatial dimensions to match local wavesim.simulate() output.
+    # Local always squeezes: [nx,1,1]→(nx,), [3,nx,1,1]→[3,nx], etc.
+    while E.ndim > 1 and E.shape[-1] == 1:
+        E = E[..., 0]
 
     logger.info(f"  Output shape: {E.shape}")
 

{wavesimpro-0.9.1 → wavesimpro-0.9.2}/src/wavesimpro/json_helper.py

@@ -640,7 +640,9 @@ def create_wavesim_properties(
     residual_norm_max_iterations: int = 10000,
     periodic_x: bool = False,
     periodic_y: bool = False,
-    periodic_z: bool = False
+    periodic_z: bool = False,
+    alpha: float = 0.75,
+    keep_residuals_list: bool = False,
 ) -> Dict[str, Any]:
     """
     Create complete WavesimProperties structure
@@ -688,6 +690,8 @@ def create_wavesim_properties(
         "PeriodicX": periodic_x,
         "PeriodicY": periodic_y,
         "PeriodicZ": periodic_z,
+        "Alpha": alpha,
+        "KeepResidualsList": keep_residuals_list,
         "DefaultLengthUnit": "Micrometers",
         "CoordinateSystemCenter": {
             "X": {"Value": 0.0, "Unit": "Micrometers"},
@@ -719,6 +723,11 @@ def parse_progress_data(progress_obj: Optional[Dict[str, Any]]) -> Dict[str, Any
     if "status" in norm:
         info["status"] = norm["status"]
 
+    # Full residuals list (ProgressSnapshot.ResidualsList from machine service)
+    residuals_list = norm.get("residualslist") or norm.get("residuals_list")
+    if residuals_list and isinstance(residuals_list, list):
+        info["residuals_list"] = residuals_list
+
     progress_str = norm.get("progress")
     if progress_str and isinstance(progress_str, str):
         # Try JSON first
@@ -731,7 +740,15 @@ def parse_progress_data(progress_obj: Optional[Dict[str, Any]]) -> Dict[str, Any
             if "max_iterations" in progress_data:
                 info["max_iterations"] = progress_data["max_iterations"]
         except (json.JSONDecodeError, TypeError, ValueError):
-            # Parse human-readable summary text
+            # Intermediate C++ format: "C++ iteration 400, residual: 1.23E-04"
+            m = re.search(r'iteration\s+(\d+)', progress_str, re.IGNORECASE)
+            if m:
+                info["iteration"] = int(m.group(1))
+            m = re.search(r'residual[:\s]+([\d.E+\-]+)', progress_str, re.IGNORECASE)
+            if m:
+                info["residual_norm"] = float(m.group(1))
+
+            # Final completion summary: "Last Iteration : 200 / 10000"
             m = re.search(r'Last Iteration\s*:\s*(\d+)\s*/\s*(\d+)', progress_str)
             if m:
                 info["iteration"] = int(m.group(1))
@@ -752,7 +769,14 @@ def parse_progress_data(progress_obj: Optional[Dict[str, Any]]) -> Dict[str, Any
                 info["residual_norm"] = data_obj["residual_norm"]
             if "residual_norm_threshold" in data_obj:
                 info["threshold"] = data_obj["residual_norm_threshold"]
+            rlist = data_obj.get("ResidualsList") or data_obj.get("residuals_list")
+            if rlist and isinstance(rlist, list):
+                info["residuals_list"] = rlist
         except (json.JSONDecodeError, TypeError, ValueError):
             pass
 
+    # Derive percentage if not already set but iteration + max_iterations are known
+    if "percentage" not in info and info.get("iteration") and info.get("max_iterations"):
+        info["percentage"] = 100.0 * info["iteration"] / info["max_iterations"]
+
     return info

{wavesimpro-0.9.1 → wavesimpro-0.9.2}/src/wavesimpro/simulate.py

@@ -11,17 +11,27 @@ Credentials are resolved automatically — run the setup wizard once on each mac
 Call configure() to override programmatically.
 """
 
+import inspect
+from pathlib import Path
 from typing import Callable, Optional, Sequence
 
 import numpy as np
 
 from .execute import execute_via_api
 
+
+def _caller_script_name() -> str:
+    for frame_info in inspect.stack():
+        path = frame_info.filename
+        if "wavesimpro" not in path and path not in ("<stdin>", "<string>"):
+            return Path(path).stem
+    return "wavesimpro"
+
 # Module-level defaults — overridden by configure() or per-call kwargs
 _defaults = {
     "api_key": None,
     "api_url": None,
-    "description": "Wavesim Python API",
+    "description": None,
     "poll_interval": 10.0,
     "engine_preference": "Any",
     "use_gpu": None,
@@ -75,8 +85,8 @@ def simulate(
     n_domains=None,          # local only — accepted and ignored
     max_iterations: int = 100000,
     threshold: float = 1.0e-6,
-    alpha: float = 0.75,     # local only — accepted and ignored
-    full_residuals: bool = False,  # local only — accepted and ignored
+    alpha: float = 0.75,
+    full_residuals: bool = False,
     crop_boundaries: bool = True,  # local only — accepted and ignored
     callback: Optional[Callable] = None,
     **kwargs,
@@ -108,7 +118,7 @@ def simulate(
             "Run the setup wizard once to get started:\n\n"
             "    python -m wavesimpro setup\n"
         )
-    description = _defaults["description"]
+    description = _defaults["description"] or _caller_script_name()
     poll_interval = _defaults["poll_interval"]
     engine_preference = _defaults["engine_preference"]
     effective_use_gpu = use_gpu if use_gpu is not None else _defaults["use_gpu"]
@@ -128,11 +138,13 @@ def simulate(
             src_field = src_array.astype(np.complex64)
         api_sources.append({"Es": src_field, "position": api_pos})
 
-    _last = {"iteration": None, "residual_norm": None}
+    _last = {"iteration": None, "residual_norm": None, "residuals_list": None}
 
     def _progress_cb(info: dict):
         _last["iteration"] = info.get("iteration", _last["iteration"])
         _last["residual_norm"] = info.get("residual_norm", _last["residual_norm"])
+        if info.get("residuals_list") is not None:
+            _last["residuals_list"] = info["residuals_list"]
         if callback is not None and _last["iteration"] is not None:
             extra = {k: v for k, v in info.items() if k not in ("iteration", "residual_norm")}
             callback(None, _last["iteration"], None, _last["residual_norm"], **extra)
@@ -154,10 +166,121 @@ def simulate(
         poll_interval=poll_interval,
         engine_preference=engine_preference,
         use_gpu=effective_use_gpu,
+        alpha=alpha,
+        keep_residuals_list=full_residuals,
+        progress_callback=_progress_cb,
+    )
+
+    iterations = _last["iteration"] or 1
+    final_residual = _last["residual_norm"] if _last["residual_norm"] is not None else float("nan")
+    if full_residuals:
+        residual_norm = _last["residuals_list"] if _last["residuals_list"] else [final_residual] * iterations
+    else:
+        residual_norm = final_residual
+    return E, iterations, residual_norm
+
+
+def simulate_pro(
+    permittivity: np.ndarray,
+    sources: Sequence[tuple],
+    wavelength: float,
+    pixel_size: float,
+    boundary_width: float = 1.0,
+    periodic: tuple = (False, False, False),
+    max_iterations: int = 100000,
+    threshold: float = 1.0e-6,
+    alpha: float = 0.75,
+    n_domains=None,
+    full_residuals: bool = False,
+    crop_boundaries: bool = True,  # local only — accepted and ignored
+    callback: Optional[Callable] = None,
+    # remote execution options
+    engine: str = "Any",
+    use_gpu: Optional[bool] = None,
+    machine_id: Optional[str] = None,
+    poll_interval: float = 10.0,
+    description: Optional[str] = None,
+    server: Optional[str] = None,
+    **kwargs,
+):
+    """Execute a Wavesim simulation remotely with full control over execution options.
+
+    Drop-in compatible with wavesim.simulate() but exposes all remote-specific options
+    that simulate() manages via configure():
+
+        engine       : 'Any' (default) | 'Cpp' | 'Python'
+        use_gpu      : None (auto) | True (require GPU) | False (force CPU)
+        machine_id   : preferred machine service ID to pin the job to a specific machine
+        poll_interval: seconds between status polls (default 10)
+        description  : job label shown in the Rayfos dashboard (default: caller script name)
+    """
+    from .setup import resolve_credentials
+    _api_key, _api_url = resolve_credentials()
+    api_key = _defaults["api_key"] or _api_key
+    api_url = server or _defaults["api_url"] or _api_url
+    if not api_key:
+        raise SystemExit(
+            "\nwavesimpro: no API key configured.\n"
+            "Run the setup wizard once to get started:\n\n"
+            "    python -m wavesimpro setup\n"
+        )
+
+    effective_description = description or _defaults["description"] or _caller_script_name()
+    effective_use_gpu = use_gpu if use_gpu is not None else _defaults["use_gpu"]
+
+    is_vectorial = any(len(s[1]) == 4 for s in sources)
+    boundary_width_px = int(np.round(boundary_width / pixel_size))
+
+    api_sources = []
+    for src_array, src_pos in sources:
+        pos = list(src_pos)
+        if is_vectorial:
+            pol_1based = int(pos[0]) + 1
+            api_pos = [pos[1] * pixel_size, pos[2] * pixel_size, pos[3] * pixel_size, pol_1based]
+            src_field = (src_array[0] if src_array.ndim == 4 else src_array).astype(np.complex64)
+        else:
+            api_pos = [pos[0] * pixel_size, pos[1] * pixel_size, pos[2] * pixel_size]
+            src_field = src_array.astype(np.complex64)
+        api_sources.append({"Es": src_field, "position": api_pos})
+
+    _last = {"iteration": None, "residual_norm": None, "residuals_list": None}
+
+    def _progress_cb(info: dict):
+        _last["iteration"] = info.get("iteration", _last["iteration"])
+        _last["residual_norm"] = info.get("residual_norm", _last["residual_norm"])
+        if info.get("residuals_list") is not None:
+            _last["residuals_list"] = info["residuals_list"]
+        if callback is not None and _last["iteration"] is not None:
+            extra = {k: v for k, v in info.items() if k not in ("iteration", "residual_norm")}
+            callback(None, _last["iteration"], None, _last["residual_norm"], **extra)
+
+    E, _ = execute_via_api(
+        refractive_index=permittivity,
+        source=api_sources,
+        wavelength=wavelength,
+        pixel_size=pixel_size,
+        boundary_width=boundary_width_px,
+        is_vectorial=is_vectorial,
+        data_type="Permittivity",
+        max_iterations=max_iterations,
+        threshold=threshold,
+        periodic=periodic,
+        api_key=api_key,
+        api_url=api_url,
+        description=effective_description,
+        poll_interval=poll_interval,
+        engine_preference=engine,
+        use_gpu=effective_use_gpu,
+        preferred_machine_id=machine_id,
+        alpha=alpha,
+        keep_residuals_list=full_residuals,
         progress_callback=_progress_cb,
     )
 
     iterations = _last["iteration"] or 1
     final_residual = _last["residual_norm"] if _last["residual_norm"] is not None else float("nan")
-    residual_norm = [final_residual] * iterations if full_residuals else final_residual
+    if full_residuals:
+        residual_norm = _last["residuals_list"] if _last["residuals_list"] else [final_residual] * iterations
+    else:
+        residual_norm = final_residual
     return E, iterations, residual_norm

{wavesimpro-0.9.1 → wavesimpro-0.9.2}/src/wavesimpro.egg-info/PKG-INFO

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