improve test

Author: dmarek-flex

tests/test_plugins/test_mode_solver.py

@@ -1561,61 +1561,58 @@ def test_mode_solver_pec_boundary_truncation():
     # Get the mode solver data
     data = ms.data
 
-    # Get simulation grid boundaries
+    # Get simulation boundaries
     sim_bounds = simulation.bounds
     sim_x_min, sim_x_max = sim_bounds[0][0], sim_bounds[1][0]
     sim_z_min, sim_z_max = sim_bounds[0][2], sim_bounds[1][2]
 
-    # Get solver grid boundaries (may extend beyond simulation)
-    solver_grid = ms._solver_grid
-    solver_x = solver_grid.boundaries.x
-    solver_z = solver_grid.boundaries.z
-
-    # Check if the solver grid extends beyond simulation bounds
-    grid_extends_x_min = solver_x[0] < sim_x_min - fp_eps
-    grid_extends_x_max = solver_x[-1] > sim_x_max + fp_eps
-    grid_extends_z_min = solver_z[0] < sim_z_min - fp_eps
-    grid_extends_z_max = solver_z[-1] > sim_z_max + fp_eps
-
     # Test 1: Fields outside simulation boundaries should be exactly 0 (zero-padded)
     for field_name in ("Ex", "Ey", "Ez", "Hx", "Hy", "Hz"):
         field = data.field_components[field_name]
         field_coords_x = field.coords["x"].values
         field_coords_z = field.coords["z"].values
 
         # Check fields at x positions outside simulation
-        if grid_extends_x_min:
-            x_outside_min = field_coords_x[field_coords_x < sim_x_min - fp_eps]
-            if len(x_outside_min) > 0:
-                field_outside = field.sel(x=x_outside_min)
-                assert np.all(field_outside.values == 0.0), (
-                    f"{field_name} should be exactly 0 outside x_min boundary, got {np.max(np.abs(field_outside.values))}"
-                )
-
-        if grid_extends_x_max:
-            x_outside_max = field_coords_x[field_coords_x > sim_x_max + fp_eps]
-            if len(x_outside_max) > 0:
-                field_outside = field.sel(x=x_outside_max)
-                assert np.all(field_outside.values == 0.0), (
-                    f"{field_name} should be exactly 0 outside x_max boundary, got {np.max(np.abs(field_outside.values))}"
-                )
+        x_outside_min = field_coords_x[
+            (field_coords_x < sim_x_min)
+            & ~np.isclose(field_coords_x, sim_x_min, rtol=fp_eps, atol=fp_eps)
+        ]
+        if len(x_outside_min) > 0:
+            field_outside = field.sel(x=x_outside_min)
+            assert np.all(field_outside.values == 0.0), (
+                f"{field_name} should be exactly 0 outside x_min boundary, got {np.max(np.abs(field_outside.values))}"
+            )
+
+        x_outside_max = field_coords_x[
+            (field_coords_x > sim_x_max)
+            & ~np.isclose(field_coords_x, sim_x_max, rtol=fp_eps, atol=fp_eps)
+        ]
+        if len(x_outside_max) > 0:
+            field_outside = field.sel(x=x_outside_max)
+            assert np.all(field_outside.values == 0.0), (
+                f"{field_name} should be exactly 0 outside x_max boundary, got {np.max(np.abs(field_outside.values))}"
+            )
 
         # Check fields at z positions outside simulation
-        if grid_extends_z_min:
-            z_outside_min = field_coords_z[field_coords_z < sim_z_min - fp_eps]
-            if len(z_outside_min) > 0:
-                field_outside = field.sel(z=z_outside_min)
-                assert np.all(field_outside.values == 0.0), (
-                    f"{field_name} should be exactly 0 outside z_min boundary, got {np.max(np.abs(field_outside.values))}"
-                )
-
-        if grid_extends_z_max:
-            z_outside_max = field_coords_z[field_coords_z > sim_z_max + fp_eps]
-            if len(z_outside_max) > 0:
-                field_outside = field.sel(z=z_outside_max)
-                assert np.all(field_outside.values == 0.0), (
-                    f"{field_name} should be exactly 0 outside z_max boundary, got {np.max(np.abs(field_outside.values))}"
-                )
+        z_outside_min = field_coords_z[
+            (field_coords_z < sim_z_min)
+            & ~np.isclose(field_coords_z, sim_z_min, rtol=fp_eps, atol=fp_eps)
+        ]
+        if len(z_outside_min) > 0:
+            field_outside = field.sel(z=z_outside_min)
+            assert np.all(field_outside.values == 0.0), (
+                f"{field_name} should be exactly 0 outside z_min boundary, got {np.max(np.abs(field_outside.values))}"
+            )
+
+        z_outside_max = field_coords_z[
+            (field_coords_z > sim_z_max)
+            & ~np.isclose(field_coords_z, sim_z_max, rtol=fp_eps, atol=fp_eps)
+        ]
+        if len(z_outside_max) > 0:
+            field_outside = field.sel(z=z_outside_max)
+            assert np.all(field_outside.values == 0.0), (
+                f"{field_name} should be exactly 0 outside z_max boundary, got {np.max(np.abs(field_outside.values))}"
+            )
 
     # Test 2: Tangential E-fields at PEC boundaries should be exactly 0
     # At x boundaries: Ey and Ez are tangential
@@ -1626,8 +1623,8 @@ def test_mode_solver_pec_boundary_truncation():
         field = data.field_components[field_name]
         field_coords_x = field.coords["x"].values
         # Find coordinates exactly at boundaries
-        x_at_min = field_coords_x[np.isclose(field_coords_x, sim_x_min, atol=fp_eps)]
-        x_at_max = field_coords_x[np.isclose(field_coords_x, sim_x_max, atol=fp_eps)]
+        x_at_min = field_coords_x[np.isclose(field_coords_x, sim_x_min, rtol=fp_eps, atol=fp_eps)]
+        x_at_max = field_coords_x[np.isclose(field_coords_x, sim_x_max, rtol=fp_eps, atol=fp_eps)]
 
         if len(x_at_min) > 0:
             field_at_boundary = field.sel(x=x_at_min[0])
@@ -1645,8 +1642,8 @@ def test_mode_solver_pec_boundary_truncation():
         field = data.field_components[field_name]
         field_coords_z = field.coords["z"].values
         # Find coordinates exactly at boundaries
-        z_at_min = field_coords_z[np.isclose(field_coords_z, sim_z_min, atol=fp_eps)]
-        z_at_max = field_coords_z[np.isclose(field_coords_z, sim_z_max, atol=fp_eps)]
+        z_at_min = field_coords_z[np.isclose(field_coords_z, sim_z_min, rtol=fp_eps, atol=fp_eps)]
+        z_at_max = field_coords_z[np.isclose(field_coords_z, sim_z_max, rtol=fp_eps, atol=fp_eps)]
 
         if len(z_at_min) > 0:
             field_at_boundary = field.sel(z=z_at_min[0])
@@ -1665,8 +1662,8 @@ def test_mode_solver_pec_boundary_truncation():
     # At z boundaries: Hz is normal
     field = data.field_components["Hx"]
     field_coords_x = field.coords["x"].values
-    x_at_min = field_coords_x[np.isclose(field_coords_x, sim_x_min, atol=fp_eps)]
-    x_at_max = field_coords_x[np.isclose(field_coords_x, sim_x_max, atol=fp_eps)]
+    x_at_min = field_coords_x[np.isclose(field_coords_x, sim_x_min, rtol=fp_eps, atol=fp_eps)]
+    x_at_max = field_coords_x[np.isclose(field_coords_x, sim_x_max, rtol=fp_eps, atol=fp_eps)]
 
     if len(x_at_min) > 0:
         field_at_boundary = field.sel(x=x_at_min[0])
@@ -1682,8 +1679,8 @@ def test_mode_solver_pec_boundary_truncation():
 
     field = data.field_components["Hz"]
     field_coords_z = field.coords["z"].values
-    z_at_min = field_coords_z[np.isclose(field_coords_z, sim_z_min, atol=fp_eps)]
-    z_at_max = field_coords_z[np.isclose(field_coords_z, sim_z_max, atol=fp_eps)]
+    z_at_min = field_coords_z[np.isclose(field_coords_z, sim_z_min, rtol=fp_eps, atol=fp_eps)]
+    z_at_max = field_coords_z[np.isclose(field_coords_z, sim_z_max, rtol=fp_eps, atol=fp_eps)]
 
     if len(z_at_min) > 0:
         field_at_boundary = field.sel(z=z_at_min[0])

tidy3d/components/mode/mode_solver.py

@@ -1184,7 +1184,7 @@ def _reduced_simulation_copy_with_fallback(self) -> ModeSolver:
     @cached_property
     def _sim_boundary_positions(
         self,
-    ) -> tuple[tuple[Optional[float], Optional[float]], tuple[Optional[float], Optional[float]]]:
+    ) -> tuple[tuple[float, float], tuple[float, float]]:
         """Get simulation boundary positions for the mode plane's tangential axes.
 
         This method checks the simulation's boundary conditions and returns positions
@@ -1203,7 +1203,7 @@ def _sim_boundary_positions(
 
         Returns
         -------
-        tuple[tuple[Optional[float], Optional[float]], tuple[Optional[float], Optional[float]]]
+        tuple[tuple[float, float], tuple[float, float]]
             (pos_min, pos_max) where:
             - pos_min = (x_min, y_min) positions for supported boundaries at min edges (None otherwise)
             - pos_max = (x_max, y_max) positions for supported boundaries at max edges (None otherwise)
@@ -1227,24 +1227,26 @@ def _sim_boundary_positions(
             sim_max = sim_grid_list[axis][-1]
             solver_min = solver_grid_list[axis][0]
             solver_max = solver_grid_list[axis][-1]
-
+            pos_min[i] = sim_min
+            pos_max[i] = sim_max
             # Check if mode solver plane intersects simulation boundaries
             # Min side: intersects if solver grid extends beyond (below) sim boundary
-            intersects_min = solver_min < sim_min and not np.isclose(solver_min, sim_min)
+            intersects_min = solver_min < sim_min and not np.isclose(
+                solver_min, sim_min, rtol=fp_eps
+            )
             # Max side: intersects if solver grid extends beyond (above) sim boundary
-            intersects_max = solver_max > sim_max and not np.isclose(solver_max, sim_max)
+            intersects_max = solver_max > sim_max and not np.isclose(
+                solver_max, sim_max, rtol=fp_eps
+            )
 
             # Check minus side
             bc_minus = boundary.minus
-            if isinstance(bc_minus, PECBoundary):
-                pos_min[i] = sim_min
-            elif isinstance(bc_minus, PMCBoundary):
+            if isinstance(bc_minus, PMCBoundary):
                 if intersects_min:
                     log.warning(
                         f"Mode solver plane intersects simulation '{axis_name}-' boundary with "
                         f"unsupported PMC boundary condition. The mode solver will apply PEC instead."
                     )
-                pos_min[i] = sim_min
             elif isinstance(bc_minus, (Periodic, BlochBoundary)):
                 if intersects_min:
                     log.warning(
@@ -1256,15 +1258,12 @@ def _sim_boundary_positions(
 
             # Check plus side
             bc_plus = boundary.plus
-            if isinstance(bc_plus, PECBoundary):
-                pos_max[i] = sim_max
-            elif isinstance(bc_plus, PMCBoundary):
+            if isinstance(bc_plus, PMCBoundary):
                 if intersects_max:
                     log.warning(
                         f"Mode solver plane intersects simulation '{axis_name}+' boundary with "
                         f"unsupported PMC boundary condition. The mode solver will apply PEC instead."
                     )
-                pos_max[i] = sim_max
             elif isinstance(bc_plus, (Periodic, BlochBoundary)):
                 if intersects_max:
                     log.warning(
@@ -1273,7 +1272,6 @@ def _sim_boundary_positions(
                         f"Fields will not wrap around periodically."
                     )
             # ABC boundaries: no truncation, no warning (fields can extend)
-
         return (tuple(pos_min), tuple(pos_max))
 
     def _data_on_yee_grid(self) -> ModeSolverData:

tidy3d/components/mode/solver.py

@@ -95,13 +95,11 @@ def compute_modes(
             The center of the mode plane along the tangential axes of the global simulation. Used
             in case of bend modes to offset the coordinates correctly w.r.t. the bend radius, which
             is assumed to refer to the distance from the bend center to the mode plane center.
-        sim_pec_pos_min : Optional[tuple[Optional[float], Optional[float]]]
-            Simulation PEC boundary positions (x_min, y_min). Each component can be None if
-            no PEC boundary exists on that side. If the solver grid extends beyond a PEC
+        sim_pec_pos_min : Optional[tuple[float, float]]
+            Simulation PEC boundary positions (x_min, y_min). If the solver grid extends beyond a PEC
             position, it will be truncated and fields outside will be zero-padded.
-        sim_pec_pos_max : Optional[tuple[Optional[float], Optional[float]]]
-            Simulation PEC boundary positions (x_max, y_max). Each component can be None if
-            no PEC boundary exists on that side. If the solver grid extends beyond a PEC
+        sim_pec_pos_max : Optional[tuple[float, float]]
+            Simulation PEC boundary positions (x_max, y_max). If the solver grid extends beyond a PEC
             position, it will be truncated and fields outside will be zero-padded.
 
         Returns
@@ -133,20 +131,18 @@ def compute_modes(
         if sim_pec_pos_min is not None:
             # Find first coord index >= sim_pec_pos_min (for boundary coords)
             for i in range(2):
-                if sim_pec_pos_min[i] is not None:
-                    idx = np.searchsorted(coords[i], sim_pec_pos_min[i])
-                    # Only trim if sim_pec_pos is actually inside the coord range
-                    if idx > 0 and not np.isclose(coords[i][idx - 1], sim_pec_pos_min[i]):
-                        trim_min[i] = idx
+                idx = np.searchsorted(coords[i], sim_pec_pos_min[i])
+                # Only trim if sim_pec_pos is actually inside the coord range
+                if idx > 0 and not np.isclose(coords[i][idx - 1], sim_pec_pos_min[i]):
+                    trim_min[i] = idx
 
         if sim_pec_pos_max is not None:
             # Find last coord index <= sim_pec_pos_max (for boundary coords)
             for i in range(2):
-                if sim_pec_pos_max[i] is not None:
-                    idx = np.searchsorted(coords[i], sim_pec_pos_max[i], side="right")
-                    # Only trim if sim_pec_pos is actually inside the coord range
-                    if idx < len(coords[i]) and not np.isclose(coords[i][idx], sim_pec_pos_max[i]):
-                        trim_max[i] = idx
+                idx = np.searchsorted(coords[i], sim_pec_pos_max[i], side="right")
+                # Only trim if sim_pec_pos is actually inside the coord range
+                if idx < len(coords[i]) and not np.isclose(coords[i][idx], sim_pec_pos_max[i]):
+                    trim_max[i] = idx
 
         # Check if truncation is needed
         needs_truncation = trim_min != [0, 0] or trim_max != [len(coords[0]), len(coords[1])]