Mode solver symmetries reorganized to come from simulation symmetries

Author: momchil-flex

tests/test_components.py

@@ -59,7 +59,7 @@ def test_sim():
         sources=[
             VolumeSource(
                 size=(0, 0, 0),
-                center=(0, -50.5, 0),
+                center=(0, -0.5, 0),
                 polarization="Hx",
                 source_time=GaussianPulse(
                     freq0=1e14,
@@ -819,3 +819,57 @@ def surface_monitor_helper(center, size, monitor_test):
     # z+ surface
     assert monitor_surfaces[5].center == (center[0], center[1], center[2] + size[2] / 2.0)
     assert monitor_surfaces[5].size == (size[0], size[1], 0.0)
+
+
+""" modes """
+
+
+def test_mode_object_syms():
+    """Test that errors are raised if a mode object is not placed right in the presence of syms."""
+    g = GaussianPulse(freq0=1, fwidth=0.1)
+
+    # wrong mode source
+    with pytest.raises(SetupError) as e_info:
+        sim = Simulation(
+            center=(1.0, -1.0, 0.5),
+            size=(2.0, 2.0, 2.0),
+            grid_size=(0.01, 0.01, 0.01),
+            run_time=1e-12,
+            symmetry=(1, -1, 0),
+            sources=[ModeSource(size=(2, 2, 0), direction="+", source_time=g)],
+        )
+
+    # wrong mode monitor
+    with pytest.raises(SetupError) as e_info:
+        sim = Simulation(
+            center=(1.0, -1.0, 0.5),
+            size=(2.0, 2.0, 2.0),
+            grid_size=(0.01, 0.01, 0.01),
+            run_time=1e-12,
+            symmetry=(1, -1, 0),
+            monitors=[ModeMonitor(size=(2, 2, 0), name="mnt", freqs=[2], mode_spec=ModeSpec())],
+        )
+
+    # right mode source (centered on the symmetry)
+    sim = Simulation(
+        center=(1.0, -1.0, 0.5),
+        size=(2.0, 2.0, 2.0),
+        grid_size=(0.01, 0.01, 0.01),
+        run_time=1e-12,
+        symmetry=(1, -1, 0),
+        sources=[ModeSource(center=(1, -1, 1), size=(2, 2, 0), direction="+", source_time=g)],
+    )
+
+    # right mode monitor (entirely in the main quadrant)
+    sim = Simulation(
+        center=(1.0, -1.0, 0.5),
+        size=(2.0, 2.0, 2.0),
+        grid_size=(0.01, 0.01, 0.01),
+        run_time=1e-12,
+        symmetry=(1, -1, 0),
+        monitors=[
+            ModeMonitor(
+                center=(2, 0, 1), size=(2, 2, 0), name="mnt", freqs=[2], mode_spec=ModeSpec()
+            )
+        ],
+    )

tidy3d/components/data.py

@@ -302,110 +302,6 @@ def ensure_member_exists(self, member_name: str):
 
 """ Subclasses of MonitorData and CollectionData """
 
-class FreqData(MonitorData, ABC):
-    """Stores frequency-domain data using an ``f`` dimension for frequency in Hz."""
-
-    f: Array[float]
-
-    @abstractmethod
-    def normalize(self, source_freq_amps: Array[complex]) -> None:
-        """Normalize values of frequency-domain data by source amplitude spectrum."""
-
-
-class TimeData(MonitorData, ABC):
-    """Stores time-domain data using a ``t`` attribute for time in seconds."""
-
-    t: Array[float]
-
-
-class AbstractScalarFieldData(MonitorData, ABC):
-    """Stores a single, scalar field as a function of spatial coordinates x,y,z."""
-
-    x: Array[float]
-    y: Array[float]
-    z: Array[float]
-
-
-class PlanarData(MonitorData, ABC):
-    """Stores data that must be found via a planar monitor."""
-
-
-class AbstractFluxData(PlanarData, ABC):
-    """Stores electromagnetic flux through a plane."""
-
-
-""" usable monitors """
-
-
-class ScalarFieldData(AbstractScalarFieldData, FreqData):
-    """Stores a single scalar field in frequency-domain.
-
-    Parameters
-    ----------
-    x : numpy.ndarray
-        Data coordinates in x direction (um).
-    y : numpy.ndarray
-        Data coordinates in y direction (um).
-    z : numpy.ndarray
-        Data coordinates in z direction (um).
-    f : numpy.ndarray
-        Frequency coordinates (Hz).
-    values : numpy.ndarray
-        Complex-valued array of shape ``(len(x), len(y), len(z), len(f))`` storing field values.
-
-    Example
-    -------
-    >>> f = np.linspace(1e14, 2e14, 1001)
-    >>> x = np.linspace(-1, 1, 10)
-    >>> y = np.linspace(-2, 2, 20)
-    >>> z = np.linspace(0, 0, 1)
-    >>> values = (1+1j) * np.random.random((len(x), len(y), len(z), len(f)))
-    >>> data = ScalarFieldData(values=values, x=x, y=y, z=z, f=f)
-    """
-
-    values: Array[complex]
-    data_attrs: Dict[str, str] = None  # {'units': '[E] = V/um, [H] = A/um'}
-    type: Literal["ScalarFieldData"] = "ScalarFieldData"
-
-    _dims = ("x", "y", "z", "f")
-
-    def normalize(self, source_freq_amps: Array[complex]) -> None:
-        """normalize the values by the amplitude of the source."""
-        self.values /= 1j * source_freq_amps  # pylint: disable=no-member
-
-
-class ScalarFieldTimeData(AbstractScalarFieldData, TimeData):
-    """stores a single scalar field in time domain
-
-    Parameters
-    ----------
-    x : numpy.ndarray
-        Data coordinates in x direction (um).
-    y : numpy.ndarray
-        Data coordinates in y direction (um).
-    z : numpy.ndarray
-        Data coordinates in z direction (um).
-    t : numpy.ndarray
-        Time coordinates (sec).
-    values : numpy.ndarray
-        Real-valued array of shape ``(len(x), len(y), len(z), len(t))`` storing field values.
-
-    Example
-    -------
-    >>> t = np.linspace(0, 1e-12, 1001)
-    >>> x = np.linspace(-1, 1, 10)
-    >>> y = np.linspace(-2, 2, 20)
-    >>> z = np.linspace(0, 0, 1)
-    >>> values = np.random.random((len(x), len(y), len(z), len(t)))
-    >>> data = ScalarFieldTimeData(values=values, x=x, y=y, z=z, t=t)
-    """
-
-    values: Array[float]
-    data_attrs: Dict[str, str] = None  # {'units': '[E] = V/m, [H] = A/m'}
-    type: Literal["ScalarFieldTimeData"] = "ScalarFieldTimeData"
-
-    _dims = ("x", "y", "z", "t")
-
 
 class AbstractFieldData(CollectionData, ABC):
     """Sores a collection of EM fields either in freq or time domain."""
@@ -502,6 +398,7 @@ def colocate(self, x, y, z) -> xr.Dataset:
         # import pdb; pdb.set_trace()
         return xr.Dataset(centered_data_dict)
 
+    # pylint:disable=too-many-locals
     def apply_syms(self, new_grid: YeeGrid, sym_center: Coordinate, symmetry: Symmetry):
         """Create a new AbstractFieldData subclass by interpolating on the supplied ``new_grid``,
         using symmetries as defined by ``sym_center`` and ``symmetry``."""
@@ -520,7 +417,7 @@ def apply_syms(self, new_grid: YeeGrid, sym_center: Coordinate, symmetry: Symmet
 
         for field, scalar_data in self.data_dict.items():
             new_data = scalar_data.data
-                
+
             # Get new grid locations
             yee_coords = yee_grid_dict[field].to_list
 
@@ -544,11 +441,116 @@ def apply_syms(self, new_grid: YeeGrid, sym_center: Coordinate, symmetry: Symmet
                 # Apply the correct +/-1 for the field component
                 new_data[{dim_name: flip_inds}] *= sym * component_sym_dict[field][dim]
 
-            new_data_dict[field] = ScalarFieldData(values=new_data.values, **new_data.coords)
+            new_data_dict[field] = type(scalar_data)(values=new_data.values, **new_data.coords)
 
         return type(self)(data_dict=new_data_dict)
 
 
+class FreqData(MonitorData, ABC):
+    """Stores frequency-domain data using an ``f`` dimension for frequency in Hz."""
+
+    f: Array[float]
+
+    @abstractmethod
+    def normalize(self, source_freq_amps: Array[complex]) -> None:
+        """Normalize values of frequency-domain data by source amplitude spectrum."""
+
+
+class TimeData(MonitorData, ABC):
+    """Stores time-domain data using a ``t`` attribute for time in seconds."""
+
+    t: Array[float]
+
+
+class AbstractScalarFieldData(MonitorData, ABC):
+    """Stores a single, scalar field as a function of spatial coordinates x,y,z."""
+
+    x: Array[float]
+    y: Array[float]
+    z: Array[float]
+
+
+class PlanarData(MonitorData, ABC):
+    """Stores data that must be found via a planar monitor."""
+
+
+class AbstractFluxData(PlanarData, ABC):
+    """Stores electromagnetic flux through a plane."""
+
+
+""" usable monitors """
+
+
+class ScalarFieldData(AbstractScalarFieldData, FreqData):
+    """Stores a single scalar field in frequency-domain.
+
+    Parameters
+    ----------
+    x : numpy.ndarray
+        Data coordinates in x direction (um).
+    y : numpy.ndarray
+        Data coordinates in y direction (um).
+    z : numpy.ndarray
+        Data coordinates in z direction (um).
+    f : numpy.ndarray
+        Frequency coordinates (Hz).
+    values : numpy.ndarray
+        Complex-valued array of shape ``(len(x), len(y), len(z), len(f))`` storing field values.
+
+    Example
+    -------
+    >>> f = np.linspace(1e14, 2e14, 1001)
+    >>> x = np.linspace(-1, 1, 10)
+    >>> y = np.linspace(-2, 2, 20)
+    >>> z = np.linspace(0, 0, 1)
+    >>> values = (1+1j) * np.random.random((len(x), len(y), len(z), len(f)))
+    >>> data = ScalarFieldData(values=values, x=x, y=y, z=z, f=f)
+    """
+
+    values: Array[complex]
+    data_attrs: Dict[str, str] = None  # {'units': '[E] = V/um, [H] = A/um'}
+    type: Literal["ScalarFieldData"] = "ScalarFieldData"
+
+    _dims = ("x", "y", "z", "f")
+
+    def normalize(self, source_freq_amps: Array[complex]) -> None:
+        """normalize the values by the amplitude of the source."""
+        self.values /= 1j * source_freq_amps  # pylint: disable=no-member
+
+
+class ScalarFieldTimeData(AbstractScalarFieldData, TimeData):
+    """stores a single scalar field in time domain
+
+    Parameters
+    ----------
+    x : numpy.ndarray
+        Data coordinates in x direction (um).
+    y : numpy.ndarray
+        Data coordinates in y direction (um).
+    z : numpy.ndarray
+        Data coordinates in z direction (um).
+    t : numpy.ndarray
+        Time coordinates (sec).
+    values : numpy.ndarray
+        Real-valued array of shape ``(len(x), len(y), len(z), len(t))`` storing field values.
+
+    Example
+    -------
+    >>> t = np.linspace(0, 1e-12, 1001)
+    >>> x = np.linspace(-1, 1, 10)
+    >>> y = np.linspace(-2, 2, 20)
+    >>> z = np.linspace(0, 0, 1)
+    >>> values = np.random.random((len(x), len(y), len(z), len(t)))
+    >>> data = ScalarFieldTimeData(values=values, x=x, y=y, z=z, t=t)
+    """
+
+    values: Array[float]
+    data_attrs: Dict[str, str] = None  # {'units': '[E] = V/m, [H] = A/m'}
+    type: Literal["ScalarFieldTimeData"] = "ScalarFieldTimeData"
+
+    _dims = ("x", "y", "z", "t")
+
+
 class FieldData(AbstractFieldData):
     """Stores a collection of scalar fields in the frequency domain from a :class:`FieldMonitor`.
 

tidy3d/components/geometry.py

@@ -14,7 +14,7 @@
 from .types import Bound, Size, Coordinate, Axis, Coordinate2D, ArrayLike
 from .types import Vertices, Ax, Shapely
 from .viz import add_ax_if_none, equal_aspect
-from ..log import Tidy3dKeyError, SetupError, ValidationError
+from ..log import Tidy3dKeyError, SetupError, ValidationError, Tidy3dError
 from ..constants import MICROMETER, LARGE_NUMBER
 
 # add this around extents of plots
@@ -626,6 +626,36 @@ def geometry(self):
         """
         return Box(center=self.center, size=self.size)
 
+    def pop_axis(
+        self, coord: Tuple[Any, Any, Any], axis: int = None
+    ) -> Tuple[Any, Tuple[Any, Any]]:
+        """Overwrites ``geometry.pop_axis`` to allow ``axis==None``, in which case the first
+        axis along which ``self.size==0`` is taken."""
+        if axis is None:
+            try:
+                axis = self.size.index(0.0)
+            except ValueError as e:
+                raise Tidy3dError(
+                    "Box must have at least one zero-sized dimension or ``axis`` "
+                    "must be provided to ``pop_axis``."
+                ) from e
+        return super().pop_axis(coord, axis)
+
+    def unpop_axis(
+        self, ax_coord: Any, plane_coords: Tuple[Any, Any], axis: int = None
+    ) -> Tuple[Any, Any, Any]:
+        """Overwrites ``geometry.unpop_axis`` to allow ``axis==None``, in which case the first
+        axis along which ``self.size==0`` is taken."""
+        if axis is None:
+            try:
+                axis = self.size.index(0.0)
+            except ValueError as e:
+                raise Tidy3dError(
+                    "Box must have at least one zero-sized dimension or ``axis`` "
+                    "must be provided to ``unpop_axis``."
+                ) from e
+        return super().unpop_axis(ax_coord, plane_coords, axis)
+
 
 class Sphere(Circular):
     """Spherical geometry.

tidy3d/components/grid.py

@@ -100,6 +100,7 @@ class YeeGrid(Tidy3dBaseModel):
 
     @property
     def grid_dict(self):
+        """The Yee grid coordinates associated to various field components as a dictionary."""
         yee_grid_dict = {
             "Ex": self.E.x,
             "Ey": self.E.y,
@@ -110,6 +111,7 @@ def grid_dict(self):
         }
         return yee_grid_dict
 
+
 class Grid(Tidy3dBaseModel):
     """Contains all information about the spatial positions of the FDTD grid.
 

tidy3d/components/mode.py

@@ -6,7 +6,7 @@
 
 from ..constants import MICROMETER
 from .base import Tidy3dBaseModel
-from .types import Symmetry, Axis2D
+from .types import Axis2D
 from ..log import SetupError
 
 
@@ -17,7 +17,7 @@ class ModeSpec(Tidy3dBaseModel):
 
     Example
     -------
-    >>> mode_spec = ModeSpec(num_modes=3, target_neff=1.5, symmetries=(1, -1))
+    >>> mode_spec = ModeSpec(num_modes=3, target_neff=1.5)
     """
 
     num_modes: pd.PositiveInt = pd.Field(