formatting

Author: dbochkov-flexcompute

tidy3d/__init__.py

@@ -124,11 +124,11 @@
     FluxTimeDataArray,
     HeatDataArray,
     IndexedDataArray,
-    IndexedVoltageDataArray,
-    IndexedFieldDataArray, 
+    IndexedFieldDataArray,
     IndexedFieldTimeDataArray,
     IndexedFreqDataArray,
     IndexedTimeDataArray,
+    IndexedVoltageDataArray,
     ModeAmpsDataArray,
     ModeIndexDataArray,
     PointDataArray,
@@ -626,7 +626,7 @@ def set_logging_level(level: str) -> None:
     "CellDataArray",
     "IndexedDataArray",
     "IndexedVoltageDataArray",
-    "IndexedFieldDataArray", 
+    "IndexedFieldDataArray",
     "IndexedFieldTimeDataArray",
     "IndexedFreqDataArray",
     "IndexedTimeDataArray",

tidy3d/components/data/data_array.py

@@ -1354,9 +1354,9 @@ class IndexedTimeDataArray(DataArray):
 DATA_ARRAY_MAP = {data_array.__name__: data_array for data_array in DATA_ARRAY_TYPES}
 
 IndexedDataArrayTypes = Union[
-    IndexedDataArray, 
-    IndexedVoltageDataArray, 
-    IndexedFieldDataArray, 
+    IndexedDataArray,
+    IndexedVoltageDataArray,
+    IndexedFieldDataArray,
     IndexedFieldTimeDataArray,
     IndexedFreqDataArray,
     IndexedTimeDataArray,

tidy3d/components/data/dataset.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from typing import Any, Callable, Dict, Union, Tuple, Optional
+from typing import Any, Callable, Dict, Optional, Tuple, Union
 
 import numpy as np
 import pydantic.v1 as pd
@@ -316,13 +316,13 @@ def apply_phase(self, phase: float) -> AbstractFieldDataset:
 class ElectromagneticSurfaceFieldDataset(AbstractFieldDataset, ABC):
     """Stores a collection of E and H fields with x, y, z components."""
 
-    E: Tuple[Optional[TriangularSurfaceDataset], Optional[TriangularSurfaceDataset]]  = pd.Field(
+    E: Tuple[Optional[TriangularSurfaceDataset], Optional[TriangularSurfaceDataset]] = pd.Field(
         (None, None),
         title="E",
         description="Spatial distribution of the electric field on the internal and external sides of the surface.",
     )
 
-    H: Tuple[Optional[TriangularSurfaceDataset], Optional[TriangularSurfaceDataset]]  = pd.Field(
+    H: Tuple[Optional[TriangularSurfaceDataset], Optional[TriangularSurfaceDataset]] = pd.Field(
         (None, None),
         title="H",
         description="Spatial distribution of the magnetic field on the internal and external sides of the surface.",
@@ -346,7 +346,7 @@ def field_components(self) -> Dict[str, DataArray]:
     @property
     def current_density(self) -> ElectromagneticSurfaceFieldDataset:
         """Surface current density."""
-        
+
         h_diff = 0
         template = None
         # we assume that is data is None it means field is zero on that side (e.g. PEC)
@@ -358,8 +358,10 @@ def current_density(self) -> ElectromagneticSurfaceFieldDataset:
             template = self.H[1]
 
         if template is None:
-            raise ValueError("Could not calculate current density: the dataset does not contain H field information.")
-            
+            raise ValueError(
+                "Could not calculate current density: the dataset does not contain H field information."
+            )
+
         return template.updated_copy(values=xr.cross(h_diff, self.normal.values, dim="axis"))
 
     @property
@@ -379,7 +381,7 @@ def symmetry_eigenvalues(self) -> Dict[str, Callable[[Axis], float]]:
             Hy=lambda dim: +1 if (dim == 1) else -1,
             Hz=lambda dim: +1 if (dim == 2) else -1,
         )
-    
+
 
 class ModeSolverDataset(ElectromagneticFieldDataset):
     """Dataset storing scalar components of E and H fields as a function of freq. and mode_index.

tidy3d/components/data/monitor_data.py

@@ -89,11 +89,11 @@
     AbstractFieldDataset,
     Dataset,
     ElectromagneticFieldDataset,
+    ElectromagneticSurfaceFieldDataset,
     FieldDataset,
     FieldTimeDataset,
     ModeSolverDataset,
     PermittivityDataset,
-    ElectromagneticSurfaceFieldDataset,
 )
 from .utils import TriangularSurfaceDataset
 
@@ -200,7 +200,14 @@ def get_amplitude(x) -> complex:
 class AbstractFieldData(MonitorData, AbstractFieldDataset, ABC):
     """Collection of scalar fields with some symmetry properties."""
 
-    monitor: Union[FieldMonitor, FieldTimeMonitor, PermittivityMonitor, ModeMonitor, SurfaceFieldMonitor, SurfaceFieldTimeMonitor]
+    monitor: Union[
+        FieldMonitor,
+        FieldTimeMonitor,
+        PermittivityMonitor,
+        ModeMonitor,
+        SurfaceFieldMonitor,
+        SurfaceFieldTimeMonitor,
+    ]
 
     symmetry: Tuple[Symmetry, Symmetry, Symmetry] = pd.Field(
         (0, 0, 0),
@@ -1392,7 +1399,9 @@ def _symmetry_update_dict(self) -> Dict:
         raise Tidy3dNotImplementedError("Surface monitors currently do not support symmetry.")
 
 
-class ElectromagneticSurfaceFieldData(AbstractSurfaceFieldData, ElectromagneticSurfaceFieldDataset, ABC):
+class ElectromagneticSurfaceFieldData(
+    AbstractSurfaceFieldData, ElectromagneticSurfaceFieldDataset, ABC
+):
     """Collection of electromagnetic fields on a surface."""
 
     @property
@@ -1412,12 +1421,12 @@ def poynting(self) -> Tuple[TriangularSurfaceDataset, TriangularSurfaceDataset]:
         poynting = [None, None]
         for ind in range(2):
             if self.E[ind] is not None and self.H[ind] is not None:
-
                 e_field = self.E[ind]
                 h_field = self.H[ind]
 
                 poynting[ind] = e_field.updated_copy(
-                    values=0.5 * np.real(xr.cross(e_field.values, np.conj(h_field.values), dim="axis"))
+                    values=0.5
+                    * np.real(xr.cross(e_field.values, np.conj(h_field.values), dim="axis"))
                 )
 
         return poynting
@@ -1467,7 +1476,9 @@ def normalize(self, source_spectrum_fn: Callable[[float], complex]) -> FieldData
                 if field_data[ind] is not None:
                     src_amps = source_spectrum_fn(field_data[ind].values.f)
                     fields_norm[field_name][ind] = field_data[ind].updated_copy(
-                        values=(field_data[ind].values / src_amps).astype(field_data[ind].values.dtype)
+                        values=(field_data[ind].values / src_amps).astype(
+                            field_data[ind].values.dtype
+                        )
                     )
 
         return self.copy(update=fields_norm)
@@ -1504,7 +1515,6 @@ def poynting(self) -> ScalarFieldTimeDataArray:
         poynting = [None, None]
         for ind in range(2):
             if self.E[ind] is not None and self.H[ind] is not None:
-
                 e_field = self.E[ind]
                 h_field = self.H[ind]
 

tidy3d/components/data/unstructured/base.py

@@ -10,7 +10,7 @@
 import pydantic.v1 as pd
 from xarray import DataArray as XrDataArray
 
-from tidy3d.components.base import cached_property, skip_if_fields_missing, Tidy3dBaseModel
+from tidy3d.components.base import Tidy3dBaseModel, cached_property, skip_if_fields_missing
 from tidy3d.components.data.data_array import (
     DATA_ARRAY_MAP,
     CellDataArray,
@@ -366,9 +366,7 @@ def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
             # Only support operations with a scalar or an unstructured grid dataset of the same spatial dimensionality
             if not (
                 isinstance(x, numbers.Number)
-                or (
-                    isinstance(x, type(self)) and x._point_dims() == self._point_dims()
-                )
+                or (isinstance(x, type(self)) and x._point_dims() == self._point_dims())
             ):
                 raise Tidy3dNotImplementedError(
                     f"Cannot perform arithmetic operations between instances of different classes ({type(self)} and {type(x)})."
@@ -377,9 +375,7 @@ def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
         # Defer to the implementation of the ufunc on unwrapped values.
         inputs = tuple(x.values if isinstance(x, type(self)) else x for x in inputs)
         if out:
-            kwargs["out"] = tuple(
-                x.values if isinstance(x, type(self)) else x for x in out
-            )
+            kwargs["out"] = tuple(x.values if isinstance(x, type(self)) else x for x in out)
         result = getattr(ufunc, method)(*inputs, **kwargs)
 
         if type(result) is tuple:
@@ -410,7 +406,7 @@ def abs(self) -> UnstructuredDataset:
     def conj(self) -> UnstructuredDataset:
         """Complex conjugate value of dataset."""
         return self.updated_copy(values=self.values.conj())
-    
+
     def norm(self, dim) -> UnstructuredDataset:
         """Compute vector norm along a given dimension."""
         return self.updated_copy(values=np.sqrt(self.values.dot(self.values.conj(), dim=dim).real))
@@ -922,7 +918,7 @@ def isel(
             key: value if isinstance(value, list) else [value] for key, value in sel_kwargs.items()
         }
         return self.updated_copy(values=self.values.isel(**sel_kwargs_only_lists))
-    
+
 
 class UnstructuredGridDataset(UnstructuredDataset, np.lib.mixins.NDArrayOperatorsMixin, ABC):
     """Abstract base for datasets that store unstructured grid data."""

tidy3d/components/data/unstructured/surface.py

@@ -9,32 +9,27 @@
 
 try:
     from matplotlib import pyplot as plt
-    from matplotlib.tri import Triangulation
 except ImportError:
     pass
 
+from matplotlib import colormaps
+from matplotlib.colors import Normalize
 from xarray import DataArray as XrDataArray
 
 from tidy3d.components.base import cached_property
 from tidy3d.components.data.data_array import (
     CellDataArray,
-    IndexedDataArray,
+    IndexedDataArrayTypes,
     PointDataArray,
-    SpatialDataArray,
-    IndexedDataArrayTypes
 )
-from tidy3d.components.types import ArrayLike, Ax, Axis, Bound
-from tidy3d.components.viz import add_ax_3d_if_none, equal_aspect, plot_params_grid
-from tidy3d.constants import inf
+from tidy3d.components.types import ArrayLike, Ax, Axis
+from tidy3d.components.viz import add_ax_3d_if_none, equal_aspect
 from tidy3d.exceptions import DataError, Tidy3dNotImplementedError
-from tidy3d.log import log
 from tidy3d.packaging import requires_vtk, vtk
 
 from .base import (
     UnstructuredDataset,
 )
-from matplotlib.colors import Normalize
-from matplotlib import colormaps
 
 
 class TriangularSurfaceDataset(UnstructuredDataset):
@@ -148,8 +143,8 @@ def sel(
         method: Literal["None", "nearest", "pad", "ffill", "backfill", "bfill"] = None,
         **sel_kwargs,
     ) -> Union[TriangularSurfaceDataset, XrDataArray]:
-        """Extract/interpolate data along one or more spatial or non-spatial directions. 
-        Currently works only for non-spatial dimensions through additional arguments. 
+        """Extract/interpolate data along one or more spatial or non-spatial directions.
+        Currently works only for non-spatial dimensions through additional arguments.
         Selection along non-spatial dimensions is forwarded to
         .sel() xarray function. Parameter 'method' applies only to non-spatial dimensions.
 
@@ -173,18 +168,19 @@ def sel(
         """
 
         if any(comp is not None for comp in [x, y, z]):
-            raise Tidy3dNotImplementedError("Surface datasets do not support selection along x, y, or z yet.")
-        
+            raise Tidy3dNotImplementedError(
+                "Surface datasets do not support selection along x, y, or z yet."
+            )
+
         return self._non_spatial_sel(method=method, **sel_kwargs)
-    
+
     def get_cell_volumes(self):
         """Get areas associated to each cell of the grid."""
         v0 = self.points[self.cells.sel(vertex_index=0)]
         e01 = self.points[self.cells.sel(vertex_index=1)] - v0
         e02 = self.points[self.cells.sel(vertex_index=2)] - v0
 
         return 0.5 * np.abs(np.cross(e01, e02))
-        
 
     """ Plotting """
 
@@ -246,7 +242,7 @@ def plot(
                     "Use '.sel()' to select a single field from available dimensions "
                     f"{self._values_coords_dict} before plotting."
                 )
-            
+
         face_colors = None
         face_alpha = 0
         edge_colors = None
@@ -256,16 +252,16 @@ def plot(
             values_avg = np.mean(self.values.data.ravel()[self.cells.data], axis=1)
             face_colors = colormaps[cmap](norm(values_avg))
             face_alpha = 1
-        
+
         if grid:
             edge_colors = "k"
 
         plot_obj = ax.plot_trisurf(
-            self.points.data[:, 0], 
-            self.points.data[:, 1], 
-            self.points.data[:, 2], 
-            triangles=self.cells.data, 
-            fc=face_colors, 
+            self.points.data[:, 0],
+            self.points.data[:, 1],
+            self.points.data[:, 2],
+            triangles=self.cells.data,
+            fc=face_colors,
             ec=edge_colors,
             alpha=face_alpha,
             # cmap=cmap,
@@ -283,7 +279,7 @@ def plot(
         if buffer is not None:
             bounds = np.array(self.bounds)
             size = np.linalg.norm(bounds[1] - bounds[0])
-            
+
             ax.set_xlim(bounds[0][0] - buffer * size, bounds[1][0] + buffer * size)
             ax.set_ylim(bounds[0][1] - buffer * size, bounds[1][1] + buffer * size)
             ax.set_zlim(bounds[0][2] - buffer * size, bounds[1][2] + buffer * size)
@@ -310,7 +306,7 @@ def quiver(
         cbar_kwargs: Dict = None,
         quiver_kwargs: Dict = None,
     ) -> Ax:
-        """Plot the associated data as quiver plot. Field ``values`` must have length 3 along 
+        """Plot the associated data as quiver plot. Field ``values`` must have length 3 along
         the dimension representing x, y, and z components.
 
         Parameters
@@ -352,7 +348,7 @@ def quiver(
                 "Use '.sel()' to select a single field from available dimensions "
                 f"{self._values_coords_dict} before plotting."
             )
-        
+
         # compute max magnitude of vecotr field
         mag = np.sqrt(self.values.dot(self.values.conj(), dim=dim).real)
         mag_max = np.max(mag)
@@ -364,19 +360,19 @@ def quiver(
         u = self.values.sel(**{dim: 0}).real.data[::downsampling] * scale_factor.data
         v = self.values.sel(**{dim: 1}).real.data[::downsampling] * scale_factor.data
         w = self.values.sel(**{dim: 2}).real.data[::downsampling] * scale_factor.data
-        
+
         if color == "magnitude":
-            clr = plt.colormaps[cmap](1 - mag.data[::downsampling].ravel()/mag_max.data)
+            clr = plt.colormaps[cmap](1 - mag.data[::downsampling].ravel() / mag_max.data)
         else:
             clr = color
         plot_obj = ax.quiver(
-            self.points.sel(axis=0).data[::downsampling], 
-            self.points.sel(axis=1).data[::downsampling], 
+            self.points.sel(axis=0).data[::downsampling],
+            self.points.sel(axis=1).data[::downsampling],
             self.points.sel(axis=2).data[::downsampling],
-            u.ravel(), 
-            v.ravel(), 
-            w.ravel(), 
-            color=clr, 
+            u.ravel(),
+            v.ravel(),
+            w.ravel(),
+            color=clr,
             **quiver_kwargs,
         )
 
@@ -390,7 +386,7 @@ def quiver(
         if buffer is not None:
             bounds = np.array(self.bounds)
             size = np.linalg.norm(bounds[1] - bounds[0])
-            
+
             ax.set_xlim(bounds[0][0] - buffer * size, bounds[1][0] + buffer * size)
             ax.set_ylim(bounds[0][1] - buffer * size, bounds[1][1] + buffer * size)
             ax.set_zlim(bounds[0][2] - buffer * size, bounds[1][2] + buffer * size)

tidy3d/components/data/unstructured/tetrahedral.py

@@ -9,11 +9,6 @@
 from xarray import DataArray as XrDataArray
 
 from tidy3d.components.base import cached_property
-from tidy3d.components.data.data_array import (
-    CellDataArray,
-    IndexedDataArray,
-    PointDataArray,
-)
 from tidy3d.components.types import ArrayLike, Axis, Bound, Coordinate
 from tidy3d.exceptions import DataError
 from tidy3d.packaging import requires_vtk, vtk