wavesimpro 0.9.2__tar.gz → 0.11.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavesimpro
-Version: 0.9.2
+Version: 0.11.0
 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.2 → wavesimpro-0.11.0}/pyproject.toml

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

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

@@ -49,7 +49,7 @@ from .json_helper import (
     parse_progress_data,
 )
 
-__version__ = "0.9.2"
+__version__ = "0.11.0"
 __all__ = [
     # Client
     "RayfosClient",

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

@@ -66,6 +66,8 @@ def execute_via_api(
     preferred_machine_id: Optional[str] = None,
     alpha: float = 0.75,
     keep_residuals_list: bool = False,
+    strict_validation: bool = False,
+    gpu_memory_max_gb: Optional[float] = None,
 ) -> Tuple[np.ndarray, bool]:
     """
     Execute a Wavesim simulation via the Rayfos REST API.
@@ -222,7 +224,9 @@ def execute_via_api(
     # 7. Validate parameters
     validate_parameters(
         em_data, sources_info, wavelength, pixel_size,
-        threshold, max_iterations, boundary_width, is_vectorial
+        threshold, max_iterations, boundary_width, is_vectorial,
+        strict_validation=strict_validation,
+        gpu_memory_max_gb=gpu_memory_max_gb,
     )
 
     # 8. Upload RI/permittivity
@@ -280,12 +284,27 @@ def execute_via_api(
         pol_map = {0: "x", 1: "y", 2: "z"}
         pol_str = pol_map.get(pol_num, "none")
 
+        # Convert the user's source position (top-left corner in absolute
+        # corner-based μm — the MATLAB/Python convention) into the canonical
+        # WavesimProperties convention used by Rayfos Studio and consumed by
+        # the C# CommonServices: Position = CENTER of the source, expressed
+        # relative to the coordinate-system centre (which sits at the domain
+        # centre, world 0,0,0).  Keeping every client emitting the same shape
+        # of WavesimProperties means the server has one coordinate path, not
+        # one per client.
+        src_extent_x = float(src_nx) * float(pixel_size)
+        src_extent_y = float(src_ny) * float(pixel_size)
+        src_extent_z = float(src_nz) * float(pixel_size)
+        position_x_centered = float(src["position"][0]) + src_extent_x / 2.0 - domain_x_um / 2.0
+        position_y_centered = float(src["position"][1]) + src_extent_y / 2.0 - domain_y_um / 2.0
+        position_z_centered = float(src["position"][2]) + src_extent_z / 2.0 - domain_z_um / 2.0
+
         custom_source = create_custom_field_source(
             name=f"source_{i + 1}",
             field_data_id=source_ids[i],
-            position_x=src["position"][0],
-            position_y=src["position"][1],
-            position_z=src["position"][2],
+            position_x=position_x_centered,
+            position_y=position_y_centered,
+            position_z=position_z_centered,
             grid_nx=src_nx,
             grid_ny=src_ny,
             grid_nz=src_nz,
@@ -293,7 +312,7 @@ def execute_via_api(
             amplitude_real=1.0,
             amplitude_imag=0.0,
             data_format="Complex64",
-            origin="topleft",
+            origin="center",
         )
         input_sources.append(custom_source)
 

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

@@ -27,6 +27,11 @@ def _caller_script_name() -> str:
             return Path(path).stem
     return "wavesimpro"
 
+# Sentinel for configure() — distinguishes "not passed" from explicit None,
+# which is meaningful for use_gpu (None = auto), gpu_memory_max_gb (None = default cap)
+# and strict_validation (False = default).
+_UNSET = object()
+
 # Module-level defaults — overridden by configure() or per-call kwargs
 _defaults = {
     "api_key": None,
@@ -35,6 +40,8 @@ _defaults = {
     "poll_interval": 10.0,
     "engine_preference": "Any",
     "use_gpu": None,
+    "strict_validation": False,
+    "gpu_memory_max_gb": None,
 }
 
 
@@ -46,6 +53,8 @@ def configure(
     poll_interval: Optional[float] = None,
     engine_preference: Optional[str] = None,
     use_gpu: Optional[bool] = None,
+    strict_validation=_UNSET,
+    gpu_memory_max_gb=_UNSET,
 ):
     """Set module-level defaults for remote execution.
 
@@ -59,6 +68,11 @@ def configure(
         poll_interval: Status polling interval in seconds.
         engine_preference: 'Any' (default), 'Python', or 'Cpp'.
         use_gpu: None (auto), True (require GPU), False (force CPU).
+        strict_validation: When True, soft validation issues (GPU memory cap
+            exceeded, source field larger than domain) raise instead of
+            warning. Default False — simulations are not stopped by these.
+        gpu_memory_max_gb: Override the soft GPU memory cap (default 65 GB).
+            Pass math.inf to disable entirely.
     """
     if api_key is not None:
         _defaults["api_key"] = api_key
@@ -72,6 +86,10 @@ def configure(
         _defaults["engine_preference"] = engine_preference
     if use_gpu is not None:
         _defaults["use_gpu"] = use_gpu
+    if strict_validation is not _UNSET:
+        _defaults["strict_validation"] = bool(strict_validation)
+    if gpu_memory_max_gb is not _UNSET:
+        _defaults["gpu_memory_max_gb"] = gpu_memory_max_gb
 
 
 def simulate(
@@ -89,6 +107,8 @@ def simulate(
     full_residuals: bool = False,
     crop_boundaries: bool = True,  # local only — accepted and ignored
     callback: Optional[Callable] = None,
+    strict_validation: Optional[bool] = None,
+    gpu_memory_max_gb=_UNSET,
     **kwargs,
 ):
     """Execute a Wavesim simulation remotely via the Rayfos API.
@@ -122,6 +142,12 @@ def simulate(
     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"]
+    effective_strict = (
+        _defaults["strict_validation"] if strict_validation is None else bool(strict_validation)
+    )
+    effective_gpu_max = (
+        _defaults["gpu_memory_max_gb"] if gpu_memory_max_gb is _UNSET else gpu_memory_max_gb
+    )
 
     is_vectorial = any(len(s[1]) == 4 for s in sources)
     boundary_width_px = int(np.round(boundary_width / pixel_size))
@@ -169,6 +195,8 @@ def simulate(
         alpha=alpha,
         keep_residuals_list=full_residuals,
         progress_callback=_progress_cb,
+        strict_validation=effective_strict,
+        gpu_memory_max_gb=effective_gpu_max,
     )
 
     iterations = _last["iteration"] or 1
@@ -201,6 +229,8 @@ def simulate_pro(
     poll_interval: float = 10.0,
     description: Optional[str] = None,
     server: Optional[str] = None,
+    strict_validation: Optional[bool] = None,
+    gpu_memory_max_gb=_UNSET,
     **kwargs,
 ):
     """Execute a Wavesim simulation remotely with full control over execution options.
@@ -227,6 +257,12 @@ def simulate_pro(
 
     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"]
+    effective_strict = (
+        _defaults["strict_validation"] if strict_validation is None else bool(strict_validation)
+    )
+    effective_gpu_max = (
+        _defaults["gpu_memory_max_gb"] if gpu_memory_max_gb is _UNSET else gpu_memory_max_gb
+    )
 
     is_vectorial = any(len(s[1]) == 4 for s in sources)
     boundary_width_px = int(np.round(boundary_width / pixel_size))
@@ -275,6 +311,8 @@ def simulate_pro(
         alpha=alpha,
         keep_residuals_list=full_residuals,
         progress_callback=_progress_cb,
+        strict_validation=effective_strict,
+        gpu_memory_max_gb=effective_gpu_max,
     )
 
     iterations = _last["iteration"] or 1

{wavesimpro-0.9.2 → wavesimpro-0.11.0}/src/wavesimpro/validate.py

@@ -24,6 +24,10 @@ class ParameterValidationError(Exception):
         super().__init__(msg)
 
 
+DEFAULT_GPU_MEMORY_OK_GB = 16
+DEFAULT_GPU_MEMORY_MAX_GB = 65
+
+
 def validate_parameters(
     refractive_index: np.ndarray,
     sources: List[Dict[str, Any]],
@@ -33,6 +37,8 @@ def validate_parameters(
     max_iterations: int = 1000,
     boundary_width: int = 0,
     is_vectorial: bool = True,
+    strict_validation: bool = False,
+    gpu_memory_max_gb: Optional[float] = None,
 ) -> List[str]:
     """
     Validate simulation parameters before upload.
@@ -46,16 +52,30 @@ def validate_parameters(
         max_iterations: Maximum iterations
         boundary_width: Boundary width in pixels
         is_vectorial: True for Maxwell, False for Helmholtz
+        strict_validation: If True, "soft" issues (GPU memory cap exceeded,
+            source field larger than domain) raise ParameterValidationError.
+            If False (default), they are emitted as warnings and the
+            simulation proceeds. Hard issues (NaN/Inf, empty arrays, missing
+            wavelength/pixel_size) always raise regardless of this flag.
+        gpu_memory_max_gb: Hard cap (GB) above which estimated GPU memory
+            triggers a soft error. Default 65. Pass math.inf (or any large
+            value) to disable the cap entirely.
 
     Returns:
         List of warning strings (empty if no warnings)
 
     Raises:
-        ParameterValidationError: If any parameter is invalid
+        ParameterValidationError: If any hard error is found, or if any soft
+            error is found while strict_validation=True.
     """
     errors: List[str] = []
+    soft_errors: List[str] = []
     warnings: List[str] = []
 
+    gpu_memory_max_gb = (
+        DEFAULT_GPU_MEMORY_MAX_GB if gpu_memory_max_gb is None else float(gpu_memory_max_gb)
+    )
+
     logger.info("Validating simulation parameters...")
 
     # 1. Validate refractive index / permittivity array
@@ -172,19 +192,17 @@ def validate_parameters(
         bytes_per_voxel = 120 if is_vectorial else 40
         gpu_memory_gb = (total_voxels * bytes_per_voxel) / (1024 ** 3)
 
-        GPU_MEMORY_OK_GB = 16
-        GPU_MEMORY_MAX_GB = 65
-
         logger.info(f"  GPU memory estimate: {gpu_memory_gb:.2f} GB ({'Vectorial' if is_vectorial else 'Scalar'})")
 
-        if gpu_memory_gb > GPU_MEMORY_MAX_GB:
-            errors.append(
+        if gpu_memory_gb > gpu_memory_max_gb:
+            soft_errors.append(
                 f"Domain size too large for GPU. Estimated memory: {gpu_memory_gb:.2f} GB "
-                f"exceeds maximum {GPU_MEMORY_MAX_GB:.0f} GB. Reduce domain size or pixel count."
+                f"exceeds cap {gpu_memory_max_gb:.0f} GB. Reduce domain size or pixel count, "
+                f"raise gpu_memory_max_gb, or keep strict_validation=False to proceed anyway."
             )
-        elif gpu_memory_gb > GPU_MEMORY_OK_GB:
+        elif gpu_memory_gb > DEFAULT_GPU_MEMORY_OK_GB:
             warnings.append(
-                f"GPU memory {gpu_memory_gb:.2f} GB exceeds standard {GPU_MEMORY_OK_GB:.0f} GB. "
+                f"GPU memory {gpu_memory_gb:.2f} GB exceeds standard {DEFAULT_GPU_MEMORY_OK_GB:.0f} GB. "
                 f"Will use advanced GPU instance."
             )
 
@@ -211,7 +229,7 @@ def validate_parameters(
                 while len(src_shape) < 3:
                     src_shape = src_shape + (1,)
                 if src_shape[0] > nx or src_shape[1] > ny or src_shape[2] > nz:
-                    errors.append(
+                    soft_errors.append(
                         f"Source {i + 1}: field size [{src_shape[0]},{src_shape[1]},{src_shape[2]}] "
                         f"exceeds domain [{nx},{ny},{nz}]"
                     )
@@ -239,6 +257,12 @@ def validate_parameters(
             if pol is not None and is_vectorial and pol not in (0, 1, 2):
                 warnings.append(f"Source {i + 1}: invalid polarization {pol} for vectorial simulation (expected 0=x, 1=y, 2=z)")
 
+    # In non-strict mode, soft errors are downgraded to warnings.
+    if strict_validation:
+        errors = errors + soft_errors
+    else:
+        warnings = warnings + soft_errors
+
     # Report warnings
     for w in warnings:
         logger.warning(f"  [!] {w}")

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

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