wavesimpro 1.6.5__tar.gz → 1.9.0__tar.gz

wavesimpro-1.9.0/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: wavesimpro
+Version: 1.9.0
+Summary: WavesimPro Python API — cloud execution client for the Rayfos simulation platform
+Author: Rayfos
+Project-URL: Repository, https://github.com/rayfos/wavesimpro
+Keywords: wavesim,simulation,electromagnetic,rayfos,api
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: tqdm>=4.60.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+
+# wavesimpro
+
+Python client for the Rayfos Wavesim cloud: build a simulation setup, run it on a Rayfos
+compute node, and read the results back as NumPy arrays.
+
+Wavesim is a single-wavelength frequency-domain solver (vectorial Maxwell when a polarized
+source is present, scalar Helmholtz otherwise). This package talks to the Rayfos JobServer
+REST API; it does not contain the solver.
+
+## Install
+
+```bash
+pip install wavesimpro
+python -m wavesimpro setup      # one-time: API key + server URL wizard
+```
+
+The wizard stores the credentials; `wavesimpro.configure(api_key=..., api_url=...)` sets
+them for one process instead.
+
+## Quick start
+
+```python
+import wavesimpro as wp
+
+props = wp.create_wavesim_properties(
+    wavelength=1.0, pixel_size=0.1, boundary_width=5.0,
+    domain=wp.create_simulation_domain(20, 20, 20),
+    mediums=[wp.create_medium("Silicon", 3.48, 0.0)],
+    primitives=[wp.create_box_primitive("core", 0, 0, 0, 10, 0.5, 20, medium="Silicon")],
+    sources=[wp.create_mode_source("in", 0, 0, -8.0, polarization="X")],
+    monitors=[wp.create_monitor("out", 0, 0, 8.0, 10, 10, 0)],
+)
+run = wp.simulate(props, name="strip waveguide")
+field = wp.read_binary_field(run.download("output.bin"))
+```
+
+## What the API covers
+
+- Setup helpers for domains, media, primitives (box, STL, voxel arrays), sources
+  (point, plane wave, Gaussian beam, custom field, engine-solved waveguide mode) and monitors.
+- Per-axis pixel sizes (`pixel_size=[dx, dy, dz]`) and sub-pixel permittivity averaging
+  (`subpixel_factor=`), when the compute node supports them.
+- Preflight memory check and cost estimate before a run.
+- Binary upload/download helpers for permittivity volumes, source fields and monitors.
+
+See `CHANGELOG.md` for what each version added. Issues and feature requests: support@rayfos.com.

wavesimpro-1.9.0/README.md

@@ -0,0 +1,46 @@
+# wavesimpro
+
+Python client for the Rayfos Wavesim cloud: build a simulation setup, run it on a Rayfos
+compute node, and read the results back as NumPy arrays.
+
+Wavesim is a single-wavelength frequency-domain solver (vectorial Maxwell when a polarized
+source is present, scalar Helmholtz otherwise). This package talks to the Rayfos JobServer
+REST API; it does not contain the solver.
+
+## Install
+
+```bash
+pip install wavesimpro
+python -m wavesimpro setup      # one-time: API key + server URL wizard
+```
+
+The wizard stores the credentials; `wavesimpro.configure(api_key=..., api_url=...)` sets
+them for one process instead.
+
+## Quick start
+
+```python
+import wavesimpro as wp
+
+props = wp.create_wavesim_properties(
+    wavelength=1.0, pixel_size=0.1, boundary_width=5.0,
+    domain=wp.create_simulation_domain(20, 20, 20),
+    mediums=[wp.create_medium("Silicon", 3.48, 0.0)],
+    primitives=[wp.create_box_primitive("core", 0, 0, 0, 10, 0.5, 20, medium="Silicon")],
+    sources=[wp.create_mode_source("in", 0, 0, -8.0, polarization="X")],
+    monitors=[wp.create_monitor("out", 0, 0, 8.0, 10, 10, 0)],
+)
+run = wp.simulate(props, name="strip waveguide")
+field = wp.read_binary_field(run.download("output.bin"))
+```
+
+## What the API covers
+
+- Setup helpers for domains, media, primitives (box, STL, voxel arrays), sources
+  (point, plane wave, Gaussian beam, custom field, engine-solved waveguide mode) and monitors.
+- Per-axis pixel sizes (`pixel_size=[dx, dy, dz]`) and sub-pixel permittivity averaging
+  (`subpixel_factor=`), when the compute node supports them.
+- Preflight memory check and cost estimate before a run.
+- Binary upload/download helpers for permittivity volumes, source fields and monitors.
+
+See `CHANGELOG.md` for what each version added. Issues and feature requests: support@rayfos.com.

{wavesimpro-1.6.5 → wavesimpro-1.9.0}/pyproject.toml

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

{wavesimpro-1.6.5 → wavesimpro-1.9.0}/src/wavesimpro/__init__.py

@@ -37,6 +37,7 @@ from .json_helper import (
     create_point_source,
     create_plane_wave_source,
     create_gaussian_beam_source,
+    create_mode_source,
     create_voxels_model_primitive,
     create_custom_field_source,
     create_custom_from_file_source,
@@ -45,7 +46,7 @@ from .json_helper import (
     parse_progress_data,
 )
 
-__version__ = "1.6.5"
+__version__ = "1.9.0"
 __all__ = [
     # Client
     "RayfosClient",
@@ -81,6 +82,7 @@ __all__ = [
     "create_point_source",
     "create_plane_wave_source",
     "create_gaussian_beam_source",
+    "create_mode_source",
     "create_voxels_model_primitive",
     "create_custom_field_source",
     "create_custom_from_file_source",

{wavesimpro-1.6.5 → wavesimpro-1.9.0}/src/wavesimpro/client.py

@@ -280,7 +280,7 @@ class RayfosClient:
     def preflight_check(
         self,
         domain_um: tuple,
-        voxel_um: float,
+        voxel_um,   # float, or (dx, dy, dz) µm for a per-axis grid
         boundary_sides_um: Sequence[Tuple[float, float]],
         periodic: tuple = (False, False, False),
         engine_preference: str = "Any",
@@ -329,6 +329,12 @@ class RayfosClient:
         def _um(v: float) -> Dict[str, Any]:
             return {"value": float(v), "unit": "Micrometers"}
 
+        voxels = (tuple(float(v) for v in voxel_um)
+                  if isinstance(voxel_um, (list, tuple)) else (float(voxel_um),) * 3)
+        if len(voxels) != 3:
+            raise ValueError("voxel_um must be one number or (dx, dy, dz)")
+        anisotropic = any(abs(v - voxels[0]) > 1e-6 * max(voxels) for v in voxels)
+
         body = {
             "wavesimProperties": {
                 "simulationDomain": {
@@ -336,7 +342,11 @@ class RayfosClient:
                     "position": {"x": _um(0.0), "y": _um(0.0), "z": _um(0.0)},
                     "size": {"width": _um(size_x), "height": _um(size_y), "depth": _um(size_z)},
                 },
-                "voxelSize": _um(voxel_um),
+                # voxelSize = the smallest axis (what scalar readers use); voxelSizes carries
+                # the per-axis pitch so the estimator sizes the grid the engine will pad.
+                "voxelSize": _um(min(voxels)),
+                **({"voxelSizes": {"x": _um(voxels[0]), "y": _um(voxels[1]), "z": _um(voxels[2])}}
+                   if anisotropic else {}),
                 # boundarySize is the symmetric fallback older servers read; the
                 # per-side widths below are what the current estimator uses.
                 "boundarySize": _um(sides[0][0]),

{wavesimpro-1.6.5 → wavesimpro-1.9.0}/src/wavesimpro/execute.py

@@ -92,11 +92,37 @@ def _normalize_boundary_widths(boundary_widths) -> Optional[List[Tuple[float, fl
     return out
 
 
+def pixel_sizes_um(pixel_size) -> Tuple[float, float, float]:
+    """
+    Normalise a pixel size to a per-axis (dx, dy, dz) tuple in micrometres.
+
+    ``pixel_size`` may be one number (isotropic, the usual case) or three
+    ``[dx, dy, dz]`` (anisotropic: coarsen axes the field is band-limited along,
+    e.g. the transverse axes of a paraxial beam or a weakly guiding waveguide;
+    Python engine only). Every axis must be positive.
+    """
+    if isinstance(pixel_size, (int, float, np.integer, np.floating)):
+        p = float(pixel_size)
+        return (p, p, p)
+    vals = tuple(float(v) for v in pixel_size)
+    if len(vals) != 3:
+        raise ValueError(f"pixel_size must be one number or [dx, dy, dz], got {pixel_size!r}")
+    if any(v <= 0 for v in vals):
+        raise ValueError(f"pixel_size components must be positive, got {vals}")
+    return vals  # type: ignore[return-value]
+
+
+def is_anisotropic(pixel_sizes: Sequence[float]) -> bool:
+    """True when the three pitches differ beyond float round-off."""
+    m = max(pixel_sizes)
+    return any(abs(v - pixel_sizes[0]) > 1e-6 * m for v in pixel_sizes)
+
+
 def execute_via_api(
     refractive_index: np.ndarray,
     source,
     wavelength: float,
-    pixel_size: float,
+    pixel_size,   # float, or [dx, dy, dz] µm (see pixel_sizes_um)
     threshold: float = 1e-2,
     max_iterations: int = 1000,
     boundary_width: Optional[float] = None,  # in MICROMETERS; REQUIRED unless boundary_widths is given
@@ -134,7 +160,9 @@ def execute_via_api(
             - dict with 'Es' (complex field array) and 'position' ([x,y,z] or [x,y,z,pol])
             - list of such dicts for multiple sources
         wavelength: Wavelength in micrometers
-        pixel_size: Pixel size in micrometers
+        pixel_size: Pixel size in micrometers — one number, or [dx, dy, dz] for a
+            per-axis grid (coarsen axes the field is band-limited along; Python
+            engine only, see pixel_sizes_um)
         threshold: Convergence threshold (default: 1e-2)
         max_iterations: Max iterations (default: 1000)
         boundary_width: Absorbing boundary width in MICROMETERS (μm). Required —
@@ -248,13 +276,17 @@ def execute_via_api(
 
     logger.info(f"  Domain: [{nx}, {ny}, {nz}]")
     logger.info(f"  Wavelength: {wavelength:.3f} um")
-    logger.info(f"  Pixel size: {pixel_size:.3f} um")
+    ps = pixel_sizes_um(pixel_size)
+    anisotropic = is_anisotropic(ps)
+    ps_min = min(ps)
+    ps_label = f"({ps[0]:.4g}, {ps[1]:.4g}, {ps[2]:.4g})" if anisotropic else f"{ps[0]:.3f}"
+    logger.info(f"  Pixel size: {ps_label} um")
     logger.info(f"  Threshold: {threshold:.2e}")
     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)")
     if boundary_sides_um is None:
-        logger.info(f"  Boundary width: {boundary_width} um ({int(round(boundary_width / pixel_size))} pixels)")
+        logger.info(f"  Boundary width: {boundary_width} um ({int(round(boundary_width / ps_min))} pixels on the finest axis)")
     else:
         logger.info("  Boundary widths (um): " + "  ".join(
             f"{ax}:[{left:g}, {right:g}]" for ax, (left, right) in zip("XYZ", boundary_sides_um)))
@@ -318,9 +350,9 @@ def execute_via_api(
 
     # 5b. Preflight check — abort BEFORE creating a project / uploading anything
     #     if the simulation won't fit on the available compute targets.
-    domain_x_um = float(nx) * float(pixel_size)
-    domain_y_um = float(ny) * float(pixel_size)
-    domain_z_um = float(nz) * float(pixel_size)
+    domain_x_um = float(nx) * ps[0]
+    domain_y_um = float(ny) * ps[1]
+    domain_z_um = float(nz) * ps[2]
     #     The preflight describes exactly the grid the engine will pad: the same
     #     per-side boundary widths that go into the submitted properties.
     preflight_sides_um = (boundary_sides_um if boundary_sides_um is not None
@@ -328,7 +360,7 @@ def execute_via_api(
     try:
         pre = client.preflight_check(
             domain_um=(domain_x_um, domain_y_um, domain_z_um),
-            voxel_um=float(pixel_size),
+            voxel_um=ps,
             boundary_sides_um=preflight_sides_um,
             periodic=(bool(periodic[0]), bool(periodic[1]), bool(periodic[2])),
             engine_preference=engine_preference,
@@ -379,7 +411,7 @@ def execute_via_api(
 
     # 7. Validate parameters
     validate_parameters(
-        em_data, sources_info, wavelength, pixel_size,
+        em_data, sources_info, wavelength, ps,
         threshold, max_iterations, boundary_width, is_vectorial,
         strict_validation=strict_validation,
         gpu_memory_max_gb=gpu_memory_max_gb,
@@ -424,9 +456,9 @@ def execute_via_api(
 
     # 10. Build WavesimProperties payload
     logger.info("Building command payload...")
-    domain_x_um = float(nx) * float(pixel_size)
-    domain_y_um = float(ny) * float(pixel_size)
-    domain_z_um = float(nz) * float(pixel_size)
+    domain_x_um = float(nx) * ps[0]
+    domain_y_um = float(ny) * ps[1]
+    domain_z_um = float(nz) * ps[2]
 
     simulation_domain = create_simulation_domain(domain_x_um, domain_y_um, domain_z_um)
     background_medium = create_medium("background", "Background", background_ri)
@@ -435,7 +467,7 @@ def execute_via_api(
     voxel_primitive = create_voxels_model_primitive(
         primitive_name, em_data_id, "background",
         0.0, 0.0, 0.0,
-        float(pixel_size), float(pixel_size), float(pixel_size),
+        ps[0], ps[1], ps[2],
         int(nx), int(ny), int(nz),
         "Complex64", data_type,
     )
@@ -459,9 +491,9 @@ def execute_via_api(
         # 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)
+        src_extent_x = float(src_nx) * ps[0]
+        src_extent_y = float(src_ny) * ps[1]
+        src_extent_z = float(src_nz) * ps[2]
         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
@@ -493,7 +525,8 @@ def execute_via_api(
         monitors=monitors or [],
         background_medium_id="background",
         wavelength=float(wavelength),
-        voxel_size=float(pixel_size),
+        voxel_size=ps_min,                                  # smallest axis: scalar readers over-resolve
+        voxel_sizes=list(ps) if anisotropic else None,      # per-axis pitch, Python engine only
         boundary_size_um=boundary_size_um,
         boundary_sides_um=boundary_sides_um,
         boundary_strength=boundary_strength,
@@ -534,7 +567,7 @@ def execute_via_api(
     print(f"  Version   : {version_id}")
     print(f"  Command   : {command_id}")
     print(f"  Mode      : {_mode}")
-    print(f"  Domain    : {_domain_str}  lambda={wavelength} um  dx={pixel_size} um")
+    print(f"  Domain    : {_domain_str}  lambda={wavelength} um  dx={ps_label} um")
     print(f"  Engine    : {_engine}  |  GPU: {_gpu}")
     if preferred_machine_id:
         print(f"  Machine   : {preferred_machine_id}")

{wavesimpro-1.6.5 → wavesimpro-1.9.0}/src/wavesimpro/json_helper.py

@@ -118,10 +118,11 @@ def create_box_primitive(
             "Y": {"Value": center_y, "Unit": unit},
             "Z": {"Value": center_z, "Unit": unit}
         },
+        # Size3D on the server is Width/Height/Depth (X/Y/Z keys were silently ignored → 4 µm default).
         "Size": {
-            "X": {"Value": size_x, "Unit": unit},
-            "Y": {"Value": size_y, "Unit": unit},
-            "Z": {"Value": size_z, "Unit": unit}
+            "Width": {"Value": size_x, "Unit": unit},
+            "Height": {"Value": size_y, "Unit": unit},
+            "Depth": {"Value": size_z, "Unit": unit}
         }
     }
 
@@ -321,10 +322,11 @@ def create_gaussian_beam_source(
             "Imaginary": amplitude_imag
         },
         "SourcePlane": source_plane,
+        # Size3D on the server is Width/Height/Depth (X/Y/Z keys were silently ignored → 10 µm default).
         "Size": {
-            "X": {"Value": size_x, "Unit": unit},
-            "Y": {"Value": size_y, "Unit": unit},
-            "Z": {"Value": size_z, "Unit": unit}
+            "Width": {"Value": size_x, "Unit": unit},
+            "Height": {"Value": size_y, "Unit": unit},
+            "Depth": {"Value": size_z, "Unit": unit}
         },
         "Alpha": alpha,
         "Origin": origin
@@ -397,6 +399,97 @@ def create_voxels_model_primitive(
     }
 
 
+def create_mode_source(
+    name: str = "Mode1",
+    position_x: float = 0.0,
+    position_y: float = 0.0,
+    position_z: float = 0.0,
+    polarization: str = "None",
+    amplitude_real: float = 1.0,
+    amplitude_imag: float = 0.0,
+    neff_guess: Optional[float] = None,
+    solver: str = "Engine",
+    file_id: Optional[str] = None,
+    size_x: float = 0.0,
+    size_y: float = 0.0,
+    unit: str = "Micrometers"
+) -> Dict[str, Any]:
+    """
+    Create a waveguide Mode source.
+
+    solver="Engine" (default): the compute node solves the eigenmode of the voxelised
+    permittivity cross-section at the source's z when the run starts — the real geometry,
+    every primitive and material included — and launches it along +z on the XY plane. Nothing
+    is uploaded. The eigenmode closest to ``neff_guess`` is injected; leave it None for the
+    fundamental mode (the guess defaults to just below the highest index in the cross-section).
+    Runs need a compute node advertising the ``ModeSource:Cpp`` feature (C++ engine); the
+    solved n_eff is written to the run's ``modeSources.json`` output.
+
+    solver="Client": a precomputed mode profile uploaded as a field file (``file_id``), run
+    like a CustomField source — the Studio designer's flow.
+
+    Args:
+        name: Source name
+        position_x, position_y, position_z: Source position (centre-based). The engine solves on
+            the XY plane at z, inside the size_x × size_y window centred on (x, y).
+        polarization: "None" (scalar Helmholtz mode), "X" (Ex) or "Y" (Ey). "Z" is not a mode
+            field in the XY plane and is rejected for the engine solver.
+        amplitude_real, amplitude_imag: Complex amplitude applied to the normalised profile
+        neff_guess: Engine solver: effective-index guess; the closest eigenmode is injected
+        solver: "Engine" or "Client"
+        file_id: Client solver: id of the uploaded mode-profile field file (required)
+        size_x, size_y: Engine solver: the solve window around the position (clamped to the
+            domain); 0 = the whole cross-section. Client solver: extent of the uploaded profile.
+        unit: Unit of measurement
+    """
+    solver_norm = str(solver).strip().capitalize()
+    if solver_norm not in ("Engine", "Client"):
+        raise ValueError(f"solver must be 'Engine' or 'Client', got {solver!r}")
+    if solver_norm == "Client" and not file_id:
+        raise ValueError("solver='Client' needs file_id (the uploaded mode-profile field)")
+    if solver_norm == "Engine" and str(polarization) == "Z":
+        raise ValueError("an engine-solved mode is 'None' (scalar), 'X' (Ex) or 'Y' (Ey); 'Z' has no mode field in the XY plane")
+    if neff_guess is not None and not neff_guess > 0:
+        raise ValueError("neff_guess must be positive (or None for automatic)")
+
+    source: Dict[str, Any] = {
+        "Id": str(uuid.uuid4()),
+        "SourceType": "Mode",
+        "Name": name,
+        "IsEnabled": True,
+        "Position": {
+            "X": {"Value": position_x, "Unit": unit},
+            "Y": {"Value": position_y, "Unit": unit},
+            "Z": {"Value": position_z, "Unit": unit}
+        },
+        "Polarization": polarization,
+        "Origin": "Center",
+        "Amplitude": {
+            "Real": amplitude_real,
+            "Imaginary": amplitude_imag
+        },
+        "Solver": solver_norm,
+        # The engine works on the XY cross-section and launches along +z; these describe the
+        # same plane for the client/designer path and for Studio's drawing.
+        "SourcePlane": "xy",
+        "Size": {
+            "Width": {"Value": size_x, "Unit": unit},
+            "Height": {"Value": size_y, "Unit": unit},
+            "Depth": {"Value": 0.0, "Unit": unit}
+        },
+        # Designer bookkeeping Studio expects on a Mode source (not used by the engine solver).
+        "WaveguideGeometry": "Rectangular",
+        "ModeFamily": "TE",
+        "ModeIndex_n": 0,
+        "ModeIndex_m": 1,
+    }
+    if neff_guess is not None:
+        source["NeffGuess"] = float(neff_guess)
+    if file_id:
+        source["FileId"] = file_id
+    return source
+
+
 def create_custom_field_source(
     name: str,
     field_data_id: str,
@@ -564,6 +657,7 @@ def create_wavesim_properties(
     wavelength_unit: str = "Micrometers",
     voxel_unit: str = "Micrometers",
     boundary_size_um: float = 0.0,
+    voxel_sizes: Optional[List[float]] = None,
     boundary_sides_um: Optional[List[Tuple[float, float]]] = None,
     boundary_strength: Optional[float] = None,
     residual_norm_threshold: float = 1.0e-6,
@@ -574,6 +668,7 @@ def create_wavesim_properties(
     alpha: float = 0.75,
     keep_residuals_list: bool = False,
     pseudo_propagation_distance: float = 0.0,
+    subpixel_factor: Optional[int] = None,
 ) -> Dict[str, Any]:
     """
     Create complete WavesimProperties structure
@@ -654,6 +749,32 @@ def create_wavesim_properties(
     if boundary_strength is not None:
         props["BoundaryStrength"] = float(boundary_strength)
 
+    # Per-axis voxel sizes (VoxelSizes3D on the C# model). Omitted when isotropic so
+    # old servers see the same JSON as before; when present, VoxelSize above must be
+    # the smallest axis (callers pass min(voxel_sizes)) so scalar readers over-resolve.
+    if voxel_sizes is not None:
+        if len(voxel_sizes) != 3:
+            raise ValueError("voxel_sizes must be [dx, dy, dz]")
+        props["VoxelSizes"] = {
+            axis: {"Value": float(v), "Unit": voxel_unit}
+            for axis, v in zip(("X", "Y", "Z"), voxel_sizes)
+        }
+
+    # Sub-pixel permittivity averaging (PermittivitySampling on the C# model). Omitted =
+    # Staircase. The service probes each voxel of primitives / STL / GDSII at
+    # subpixel_factor points per axis and stores the mean permittivity; it does NOT
+    # re-sample a VoxelsModel array (average that yourself before upload).
+    if subpixel_factor is not None:
+        s = int(subpixel_factor)
+        if s < 1 or s > 64:
+            raise ValueError("subpixel_factor must be an integer between 1 and 64 (16 is the reference value)")
+        props["PermittivitySampling"] = {
+            "Mode": "SubPixel" if s > 1 else "Staircase",
+            "Factor": s,
+            "Rule": "ArithmeticMean",
+            "InterfaceOnly": True,
+        }
+
     return props
 
 

{wavesimpro-1.6.5 → wavesimpro-1.9.0}/src/wavesimpro/simulate.py

@@ -17,7 +17,7 @@ from typing import Callable, Optional, Sequence
 
 import numpy as np
 
-from .execute import execute_via_api
+from .execute import execute_via_api, pixel_sizes_um
 
 
 def _caller_script_name() -> str:
@@ -100,7 +100,7 @@ def simulate(
     permittivity: np.ndarray,
     sources: Sequence[tuple],
     wavelength: float,
-    pixel_size: float,
+    pixel_size,   # float µm, or [dx, dy, dz] µm per axis (Python engine only; see pixel_sizes_um)
     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)
@@ -183,15 +183,17 @@ def simulate(
 
     is_vectorial = any(len(s[1]) == 4 for s in sources)
 
+    # Source positions are voxel indices; convert per axis (pixel_size may be [dx, dy, dz]).
+    dx, dy, dz = pixel_sizes_um(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]
+            api_pos = [pos[1] * dx, pos[2] * dy, pos[3] * dz, 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]
+            api_pos = [pos[0] * dx, pos[1] * dy, pos[2] * dz]
             src_field = src_array.astype(np.complex64)
         api_sources.append({"Es": src_field, "position": api_pos})
 
@@ -253,7 +255,7 @@ def simulate_pro(
     permittivity: np.ndarray,
     sources: Sequence[tuple],
     wavelength: float,
-    pixel_size: float,
+    pixel_size,   # float µm, or [dx, dy, dz] µm per axis (Python engine only; see pixel_sizes_um)
     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)
@@ -330,15 +332,17 @@ def simulate_pro(
 
     is_vectorial = any(len(s[1]) == 4 for s in sources)
 
+    # Source positions are voxel indices; convert per axis (pixel_size may be [dx, dy, dz]).
+    dx, dy, dz = pixel_sizes_um(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]
+            api_pos = [pos[1] * dx, pos[2] * dy, pos[3] * dz, 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]
+            api_pos = [pos[0] * dx, pos[1] * dy, pos[2] * dz]
             src_field = src_array.astype(np.complex64)
         api_sources.append({"Es": src_field, "position": api_pos})
 

{wavesimpro-1.6.5 → wavesimpro-1.9.0}/src/wavesimpro/validate.py

@@ -43,7 +43,7 @@ def validate_parameters(
     refractive_index: np.ndarray,
     sources: List[Dict[str, Any]],
     wavelength: float,
-    pixel_size: float,
+    pixel_size,   # float, or [dx, dy, dz] µm per axis
     threshold: float = 1e-2,
     max_iterations: int = 1000,
     boundary_width: Optional[float] = None,
@@ -179,24 +179,49 @@ def validate_parameters(
     # 3. Validate pixel size against the wavelength IN THE HIGHEST-INDEX MEDIUM
     #    (lambda_medium = lambda_vacuum / n_max). n_max is the refractive index
     #    — derived as sqrt(eps) when permittivity was passed.
+    #    pixel_size may be one number or [dx, dy, dz]: every axis must resolve the field.
+    #    Scalar checks further down (boundary pixels, domain extents) use the finest axis.
+    pixel_sizes = None
     if pixel_size is None:
         errors.append("Pixel size is required")
-    elif pixel_size <= 0:
-        errors.append(f"Pixel size must be positive (got {pixel_size:.4f})")
-    elif n_max is not None and wavelength and wavelength > 0:
-        nyquist_limit = wavelength / (2 * n_max)
-        if pixel_size > nyquist_limit:
-            warnings.append(
-                f"Pixel size ({pixel_size:.4f} um) exceeds Nyquist limit "
-                f"({nyquist_limit:.4f} um for n_max={n_max:.2f}). Results may be inaccurate."
-            )
-        pixels_per_wavelength = wavelength / (n_max * pixel_size)
-        if pixels_per_wavelength < 10:
-            warnings.append(
-                f"Only {pixels_per_wavelength:.1f} pixels per wavelength in the "
-                f"highest-index medium (n_max={n_max:.2f}). Recommend >= 10."
-            )
-        logger.info(f"  Pixels per wavelength in n_max={n_max:.2f}: {pixels_per_wavelength:.1f}")
+    else:
+        try:
+            pixel_sizes = ((float(pixel_size),) * 3 if not isinstance(pixel_size, (list, tuple, np.ndarray))
+                           else tuple(float(v) for v in pixel_size))
+        except (TypeError, ValueError):
+            errors.append(f"Pixel size must be a number or [dx, dy, dz] (got {pixel_size!r})")
+        if pixel_sizes is not None and len(pixel_sizes) != 3:
+            errors.append(f"Pixel size must be one number or [dx, dy, dz] (got {pixel_size!r})")
+            pixel_sizes = None
+    if pixel_sizes is not None and any(v <= 0 for v in pixel_sizes):
+        errors.append(f"Pixel size must be positive (got {pixel_sizes})")
+        pixel_sizes = None
+    if pixel_sizes is not None:
+        pixel_size = min(pixel_sizes)
+        anisotropic = any(abs(v - pixel_sizes[0]) > 1e-6 * max(pixel_sizes) for v in pixel_sizes)
+        if anisotropic:
+            logger.info(f"  Per-axis pixel size: {pixel_sizes} um (Python engine only)")
+        if n_max is not None and wavelength and wavelength > 0:
+            nyquist_limit = wavelength / (2 * n_max)
+            for axis, p in zip("xyz", pixel_sizes):
+                label = f"Pixel size {axis} ({p:.4f} um)" if anisotropic else f"Pixel size ({p:.4f} um)"
+                if p > nyquist_limit:
+                    warnings.append(
+                        f"{label} exceeds Nyquist limit "
+                        f"({nyquist_limit:.4f} um for n_max={n_max:.2f}). Results may be inaccurate."
+                    )
+                if not anisotropic:
+                    break
+            pixels_per_wavelength = wavelength / (n_max * max(pixel_sizes))
+            if pixels_per_wavelength < 10:
+                warnings.append(
+                    f"Only {pixels_per_wavelength:.1f} pixels per wavelength in the "
+                    f"highest-index medium (n_max={n_max:.2f}) on the coarsest axis. Recommend >= 10 "
+                    f"unless that axis is deliberately coarse (band-limited field)."
+                )
+            logger.info(f"  Pixels per wavelength in n_max={n_max:.2f} (coarsest axis): {pixels_per_wavelength:.1f}")
+    else:
+        pixel_size = None
 
     # 4. Validate threshold
     if threshold is None:
@@ -319,10 +344,10 @@ def validate_parameters(
             pos = src.get("position")
             if pos is None or len(pos) < 3:
                 errors.append(f"Source {i + 1}: position must have at least 3 elements [x, y, z]")
-            elif pixel_size and pixel_size > 0:
-                domain_x = nx * pixel_size
-                domain_y = ny * pixel_size
-                domain_z = nz * pixel_size
+            elif pixel_sizes is not None:
+                domain_x = nx * pixel_sizes[0]
+                domain_y = ny * pixel_sizes[1]
+                domain_z = nz * pixel_sizes[2]
                 if pos[0] < 0 or pos[0] > domain_x:
                     warnings.append(f"Source {i + 1}: x position ({pos[0]:.2f} um) outside domain [0, {domain_x:.2f}]")
                 if pos[1] < 0 or pos[1] > domain_y:

wavesimpro-1.9.0/src/wavesimpro.egg-info/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: wavesimpro
+Version: 1.9.0
+Summary: WavesimPro Python API — cloud execution client for the Rayfos simulation platform
+Author: Rayfos
+Project-URL: Repository, https://github.com/rayfos/wavesimpro
+Keywords: wavesim,simulation,electromagnetic,rayfos,api
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: tqdm>=4.60.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+
+# wavesimpro
+
+Python client for the Rayfos Wavesim cloud: build a simulation setup, run it on a Rayfos
+compute node, and read the results back as NumPy arrays.
+
+Wavesim is a single-wavelength frequency-domain solver (vectorial Maxwell when a polarized
+source is present, scalar Helmholtz otherwise). This package talks to the Rayfos JobServer
+REST API; it does not contain the solver.
+
+## Install
+
+```bash
+pip install wavesimpro
+python -m wavesimpro setup      # one-time: API key + server URL wizard
+```
+
+The wizard stores the credentials; `wavesimpro.configure(api_key=..., api_url=...)` sets
+them for one process instead.
+
+## Quick start
+
+```python
+import wavesimpro as wp
+
+props = wp.create_wavesim_properties(
+    wavelength=1.0, pixel_size=0.1, boundary_width=5.0,
+    domain=wp.create_simulation_domain(20, 20, 20),
+    mediums=[wp.create_medium("Silicon", 3.48, 0.0)],
+    primitives=[wp.create_box_primitive("core", 0, 0, 0, 10, 0.5, 20, medium="Silicon")],
+    sources=[wp.create_mode_source("in", 0, 0, -8.0, polarization="X")],
+    monitors=[wp.create_monitor("out", 0, 0, 8.0, 10, 10, 0)],
+)
+run = wp.simulate(props, name="strip waveguide")
+field = wp.read_binary_field(run.download("output.bin"))
+```
+
+## What the API covers
+
+- Setup helpers for domains, media, primitives (box, STL, voxel arrays), sources
+  (point, plane wave, Gaussian beam, custom field, engine-solved waveguide mode) and monitors.
+- Per-axis pixel sizes (`pixel_size=[dx, dy, dz]`) and sub-pixel permittivity averaging
+  (`subpixel_factor=`), when the compute node supports them.
+- Preflight memory check and cost estimate before a run.
+- Binary upload/download helpers for permittivity volumes, source fields and monitors.
+
+See `CHANGELOG.md` for what each version added. Issues and feature requests: support@rayfos.com.

{wavesimpro-1.6.5 → wavesimpro-1.9.0}/src/wavesimpro.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+README.md
 pyproject.toml
 src/wavesimpro/__init__.py
 src/wavesimpro/__main__.py

wavesimpro-1.6.5/PKG-INFO

@@ -1,22 +0,0 @@
-Metadata-Version: 2.4
-Name: wavesimpro
-Version: 1.6.5
-Summary: WavesimPro Python API — cloud execution client for the Rayfos simulation platform
-Author: Rayfos
-Project-URL: Repository, https://github.com/rayfos/wavesimpro
-Keywords: wavesim,simulation,electromagnetic,rayfos,api
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Science/Research
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-Requires-Dist: numpy>=1.20.0
-Requires-Dist: requests>=2.28.0
-Requires-Dist: python-dotenv>=1.0.0
-Requires-Dist: tqdm>=4.60.0
-Provides-Extra: dev
-Requires-Dist: pytest>=7.0.0; extra == "dev"
-Requires-Dist: black>=23.0.0; extra == "dev"
-Requires-Dist: mypy>=1.0.0; extra == "dev"

wavesimpro-1.6.5/src/wavesimpro.egg-info/PKG-INFO

@@ -1,22 +0,0 @@
-Metadata-Version: 2.4
-Name: wavesimpro
-Version: 1.6.5
-Summary: WavesimPro Python API — cloud execution client for the Rayfos simulation platform
-Author: Rayfos
-Project-URL: Repository, https://github.com/rayfos/wavesimpro
-Keywords: wavesim,simulation,electromagnetic,rayfos,api
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Science/Research
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-Requires-Dist: numpy>=1.20.0
-Requires-Dist: requests>=2.28.0
-Requires-Dist: python-dotenv>=1.0.0
-Requires-Dist: tqdm>=4.60.0
-Provides-Extra: dev
-Requires-Dist: pytest>=7.0.0; extra == "dev"
-Requires-Dist: black>=23.0.0; extra == "dev"
-Requires-Dist: mypy>=1.0.0; extra == "dev"