Reverting pop axis for box and splitting the mode symmetry validator

Author: momchil-flex

CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
  - Clarified license terms to not include scripts written using the tidy3d python API.
+ - Simulation symmetries are now enabled but currently only affect the mode solver, if the mode plane lies on the simulation center and there's a symmetry.
+ - Validator that mode objects with symmetries are either entirely in the main quadrant, or lie on the symmetry axis.
 
 ### Changed
 - Fixed a bug in python 3.6 where polyslab vertices loaded as List of List.

tidy3d/components/geometry.py

@@ -705,7 +705,6 @@ def _arrow_length(self, ax: Ax, length_factor: float = ARROW_LENGTH_FACTOR) -> f
         # apply length factor to the minimum size to get arrow width
         return length_factor * min(ax_width, ax_height)
 
-
 class Sphere(Circular):
     """Spherical geometry.
 

tidy3d/components/simulation.py

@@ -11,6 +11,7 @@
 from descartes import PolygonPatch
 
 from .validators import assert_unique_names, assert_objects_in_sim_bounds
+from .validators import validate_mode_objects_symmetry
 from .geometry import Box
 from .types import Symmetry, Ax, Shapely, FreqBound, GridSize
 from .grid import Coords1D, Grid, Coords
@@ -196,6 +197,8 @@ def set_none_to_zero_layers(cls, val):
     _structures_in_bounds = assert_objects_in_sim_bounds("structures")
     _sources_in_bounds = assert_objects_in_sim_bounds("sources")
     _monitors_in_bounds = assert_objects_in_sim_bounds("monitors")
+    _mode_sources_symmetries = validate_mode_objects_symmetry("sources")
+    _mode_monitors_symmetries = validate_mode_objects_symmetry("monitors")
 
     # assign names to unnamed structures, sources, and mediums
     # _structure_names = set_names("structures")

tidy3d/components/validators.py

@@ -64,6 +64,37 @@ def field_has_unique_names(cls, val):
     return field_has_unique_names
 
 
+def validate_mode_objects_symmetry(field_name: str):
+    """If a Mode object, this checks that the object is fully in the main quadrant in the presence
+    of symmetry along a given axis, or else centered on the symmetry center."""
+
+    obj_type = "ModeSource" if field_name == "sources" else "ModeMonitor"
+
+    @pydantic.validator(field_name, allow_reuse=True, always=True)
+    def check_symmetry(cls, val, values):
+        """check for intersection of each structure with simulation bounds."""
+        sim_center = values.get("center")
+        for position_index, geometric_object in enumerate(val):
+            if geometric_object.type == obj_type:
+                bounds_min, _ = geometric_object.bounds
+                for dim, sym in enumerate(values.get("symmetry")):
+                    if (
+                        sym != 0
+                        and bounds_min[dim] < sim_center[dim]
+                        and geometric_object.center[dim] != sim_center[dim]
+                    ):
+                        raise SetupError(
+                            f"Mode object '{geometric_object}' "
+                            f"(at `simulation.{field_name}[{position_index}]`) "
+                            "in presence of symmetries must be in the main quadrant, "
+                            "or centered on the symmetry axis."
+                        )
+
+        return val
+
+    return check_symmetry
+
+
 def assert_unique_names(field_name: str, check_mediums=False):
     """makes sure all elements of a field have unique .name values"""
 
@@ -85,9 +116,7 @@ def field_has_unique_names(cls, val, values):
 
 
 def assert_objects_in_sim_bounds(field_name: str):
-    """Makes sure all objects in field are at least partially inside of simulation bounds.
-    If a Mode object, this checks that the object is fully in the main quadrant in the presence
-    of symmetry along a given axis, or else centered on the symmetry center."""
+    """Makes sure all objects in field are at least partially inside of simulation bounds."""
 
     @pydantic.validator(field_name, allow_reuse=True, always=True)
     def objects_in_sim_bounds(cls, val, values):
@@ -103,21 +132,6 @@ def objects_in_sim_bounds(cls, val, values):
                     "is completely outside of simulation domain."
                 )
 
-            if geometric_object.type in ["ModeSource", "ModeMonitor"]:
-                bounds_min, _ = geometric_object.bounds
-                for dim, sym in enumerate(values.get("symmetry")):
-                    if (
-                        sym != 0
-                        and bounds_min[dim] < sim_center[dim]
-                        and geometric_object.center[dim] != sim_center[dim]
-                    ):
-                        raise SetupError(
-                            f"Mode object '{geometric_object}' "
-                            f"(at `simulation.{field_name}[{position_index}]`) "
-                            "in presence of symmetries must be in the main quadrant, "
-                            "or centered on the symmetry axis."
-                        )
-
         return val
 
     return objects_in_sim_bounds

tidy3d/plugins/mode/mode_solver.py

@@ -118,12 +118,12 @@ def solve(self, mode_spec: ModeSpec) -> List[ModeInfo]:
         plane_grid_sym = self.simulation.discretize(plane_sym)
 
         # Coords and symmetry arguments to the solver (restricted to in-plane)
-        _, solver_coords = self.plane.pop_axis(plane_grid_sym.boundaries.to_list)
+        _, solver_coords = self.plane.pop_axis(plane_grid_sym.boundaries.to_list, axis=normal_axis)
         mode_symmetry = list(self.simulation.symmetry)
         for dim in range(3):
             if self.simulation.center[dim] != self.plane.center[dim]:
                 mode_symmetry[dim] = 0
-        _, solver_symmetry = self.plane.pop_axis(mode_symmetry)
+        _, solver_symmetry = self.plane.pop_axis(mode_symmetry, axis=normal_axis)
 
         # Get diagonal epsilon components in the plane
         (eps_xx, eps_yy, eps_zz) = self.get_epsilon(plane_sym)
@@ -134,7 +134,9 @@ def solve(self, mode_spec: ModeSpec) -> List[ModeInfo]:
         eps_zz = np.squeeze(eps_zz, axis=normal_axis)
 
         # swap axes to waveguide coordinates (propagating in z)
-        eps_wg_zz, (eps_wg_xx, eps_wg_yy) = self.plane.pop_axis((eps_xx, eps_yy, eps_zz))
+        eps_wg_zz, (eps_wg_xx, eps_wg_yy) = self.plane.pop_axis(
+            (eps_xx, eps_yy, eps_zz), axis=normal_axis
+        )
 
         # construct eps_cross section to feed to mode solver
         eps_cross = np.stack((eps_wg_xx, eps_wg_yy, eps_wg_zz))
@@ -151,7 +153,7 @@ def solve(self, mode_spec: ModeSpec) -> List[ModeInfo]:
         def rotate_field_coords(field):
             """move the propagation axis=z to the proper order in the array"""
             f_x, f_y, f_z = np.moveaxis(field, source=3, destination=1 + normal_axis)
-            f_rot = np.stack(self.plane.unpop_axis(f_z, (f_x, f_y)), axis=0)
+            f_rot = np.stack(self.plane.unpop_axis(f_z, (f_x, f_y), axis=normal_axis), axis=0)
             return f_rot
 
         modes = []