formatting

Author: dbochkov-flexcompute

tests/test_components/test_grid_spec.py

@@ -541,35 +541,3 @@ def test_uniform_grid_dl_validation(dl, expect_exception):
             grid_spec=td.GridSpec.uniform(dl=dl),
             run_time=1e-12,
         )
-
-def test_dl_min_from_smallest_feature():
-
-    structure = td.Structure(
-        geometry=td.PolySlab(vertices=[[0, 0], [2, 0], [2, 1], [1, 1], [1, 1.1], [2, 1.1], [2, 2], [1, 2], [1, 2.2], [0.7, 2.2], [0.7, 2], [0, 2]], slab_bounds=[-1, 1], axis=2),
-        medium=td.PECMedium(),
-    )
-
-    # check expected dl_min
-    layer_spec = td.LayerRefinementSpec(axis=2, size=(td.inf, td.inf, 2), corner_finder=td.CornerFinderSpec(dl_min_spec=td.SmallestFeatureSpec(convex_resolution=10, concave_resolution=0, mixed_resolution=0)))
-    dl_min = layer_spec._dl_min_from_smallest_feature([structure])
-    assert(np.allclose(0.3 / 10, dl_min))
-
-    layer_spec = td.LayerRefinementSpec(axis=2, size=(td.inf, td.inf, 2), corner_finder=td.CornerFinderSpec(dl_min_spec=td.SmallestFeatureSpec(convex_resolution=0, concave_resolution=0, mixed_resolution=10)))
-    dl_min = layer_spec._dl_min_from_smallest_feature([structure])
-    assert(np.allclose(0.2 / 10, dl_min))
-
-    layer_spec = td.LayerRefinementSpec(axis=2, size=(td.inf, td.inf, 2), corner_finder=td.CornerFinderSpec(dl_min_spec=td.SmallestFeatureSpec(convex_resolution=0, concave_resolution=10, mixed_resolution=0)))
-    dl_min = layer_spec._dl_min_from_smallest_feature([structure])
-    assert(np.allclose(0.1 / 10, dl_min))
-
-
-    # check grid is generated succesfully
-    sim = td.Simulation(
-        size=(5, 5, 5),
-        structures=[structure],
-        grid_spec=td.GridSpec.auto(layer_refinement_specs=[layer_spec], wavelength=100 * td.C_0),
-        run_time=1e-20,
-    )
-
-    _ = sim.grid
-

tests/test_components/test_layerrefinement.py

@@ -339,3 +339,74 @@ def count_grids_within_gap(sim_t):
     layer = layer.updated_copy(refinement_inside_sim_only=False)
     sim = sim.updated_copy(grid_spec=td.GridSpec.auto(wavelength=1, layer_refinement_specs=[layer]))
     assert count_grids_within_gap(sim) > 2
+
+
+def test_dl_min_from_smallest_feature():
+    structure = td.Structure(
+        geometry=td.PolySlab(
+            vertices=[
+                [0, 0],
+                [2, 0],
+                [2, 1],
+                [1, 1],
+                [1, 1.1],
+                [2, 1.1],
+                [2, 2],
+                [1, 2],
+                [1, 2.2],
+                [0.7, 2.2],
+                [0.7, 2],
+                [0, 2],
+            ],
+            slab_bounds=[-1, 1],
+            axis=2,
+        ),
+        medium=td.PECMedium(),
+    )
+
+    # check expected dl_min
+    layer_spec = td.LayerRefinementSpec(
+        axis=2,
+        size=(td.inf, td.inf, 2),
+        corner_finder=td.CornerFinderSpec(
+            dl_min_spec=td.SmallestFeatureSpec(
+                convex_resolution=10, concave_resolution=0, mixed_resolution=0
+            )
+        ),
+    )
+    dl_min = layer_spec._dl_min_from_smallest_feature([structure])
+    assert np.allclose(0.3 / 10, dl_min)
+
+    layer_spec = td.LayerRefinementSpec(
+        axis=2,
+        size=(td.inf, td.inf, 2),
+        corner_finder=td.CornerFinderSpec(
+            dl_min_spec=td.SmallestFeatureSpec(
+                convex_resolution=0, concave_resolution=0, mixed_resolution=10
+            )
+        ),
+    )
+    dl_min = layer_spec._dl_min_from_smallest_feature([structure])
+    assert np.allclose(0.2 / 10, dl_min)
+
+    layer_spec = td.LayerRefinementSpec(
+        axis=2,
+        size=(td.inf, td.inf, 2),
+        corner_finder=td.CornerFinderSpec(
+            dl_min_spec=td.SmallestFeatureSpec(
+                convex_resolution=0, concave_resolution=10, mixed_resolution=0
+            )
+        ),
+    )
+    dl_min = layer_spec._dl_min_from_smallest_feature([structure])
+    assert np.allclose(0.1 / 10, dl_min)
+
+    # check grid is generated succesfully
+    sim = td.Simulation(
+        size=(5, 5, 5),
+        structures=[structure],
+        grid_spec=td.GridSpec.auto(layer_refinement_specs=[layer_spec], wavelength=100 * td.C_0),
+        run_time=1e-20,
+    )
+
+    _ = sim.grid

tidy3d/components/grid/corner_finder.py

@@ -11,15 +11,14 @@
 from ..geometry.utils import merging_geometries_on_plane
 from ..medium import PEC, LossyMetalMedium
 from ..structure import Structure
-from ..types import ArrayFloat2D, ArrayFloat1D, Axis
+from ..types import ArrayFloat1D, ArrayFloat2D, Axis
 
 CORNER_ANGLE_THRESOLD = 0.1 * np.pi
 
-    
+
 class SmallestFeatureSpec(Tidy3dBaseModel):
     """Specification for automatic detection of smallest geometric features in layered structures."""
 
-
     concave_resolution: pd.NonNegativeInt = pd.Field(
         2,
         title="Concave Region Resolution.",
@@ -42,7 +41,10 @@ class SmallestFeatureSpec(Tidy3dBaseModel):
 
     @cached_property
     def _no_restriction(self):
-        return not any((self.concave_resolution != 0, self.convex_resolution != 0, self.mixed_resolution != 0))
+        return not any(
+            (self.concave_resolution != 0, self.convex_resolution != 0, self.mixed_resolution != 0)
+        )
+
 
 class CornerFinderSpec(Tidy3dBaseModel):
     """Specification for corner detection on a 2D plane."""
@@ -136,16 +138,19 @@ def _corners_and_convexity(
                 poly = poly.normalize().buffer(0)
                 if self.distance_threshold is not None:
                     poly = poly.simplify(self.distance_threshold, preserve_topology=True)
-                corners_xy, corners_convexity = self._filter_collinear_vertices(list(poly.exterior.coords))
+                corners_xy, corners_convexity = self._filter_collinear_vertices(
+                    list(poly.exterior.coords)
+                )
                 corner_list.append(corners_xy)
                 convexity_list.append(corners_convexity)
                 # in case the polygon has holes
                 for poly_inner in poly.interiors:
-                    corners_xy, corners_convexity = self._filter_collinear_vertices(list(poly_inner.coords))
+                    corners_xy, corners_convexity = self._filter_collinear_vertices(
+                        list(poly_inner.coords)
+                    )
                     corner_list.append(corners_xy)
                     convexity_list.append(corners_convexity)
 
-
         if ravel and len(corner_list) > 0:
             corner_list = np.concatenate(corner_list)
             convexity_list = np.concatenate(convexity_list)
@@ -177,10 +182,14 @@ def corners(
             Corner coordinates.
         """
 
-        corner_list, _ = self._corners_and_covexity(normal_axis=normal_axis, coord=coord, structure_list=structure_list, ravel=True)
+        corner_list, _ = self._corners_and_convexity(
+            normal_axis=normal_axis, coord=coord, structure_list=structure_list, ravel=True
+        )
         return corner_list
 
-    def _filter_collinear_vertices(self, vertices: ArrayFloat2D) -> Tuple[ArrayFloat2D, ArrayFloat1D]:
+    def _filter_collinear_vertices(
+        self, vertices: ArrayFloat2D
+    ) -> Tuple[ArrayFloat2D, ArrayFloat1D]:
         """Filter collinear vertices of a polygon, and return corners locations and their convexity.
 
         Parameters
@@ -213,7 +222,11 @@ def normalize(v):
         inner_product = np.where(inner_product < -1, -1, inner_product)
         angle = np.arccos(inner_product)
         num_vs = len(vs_orig)
-        cross_product = np.cross(np.hstack([unit_next, np.zeros((num_vs, 1))]), np.hstack([unit_previous, np.zeros((num_vs, 1))]), axis=-1)
+        cross_product = np.cross(
+            np.hstack([unit_next, np.zeros((num_vs, 1))]),
+            np.hstack([unit_previous, np.zeros((num_vs, 1))]),
+            axis=-1,
+        )
         convexity = cross_product[:, 2] < 0
         ind_filter = angle <= np.pi - self.angle_threshold
         return vs_orig[ind_filter], convexity[ind_filter]

tidy3d/components/grid/grid_spec.py

@@ -1294,7 +1294,7 @@ def suggested_dl_min(self, grid_size_in_vacuum: float, structures: List[Structur
         if self.corner_finder is not None and self.corner_refinement is not None:
             dl_min = min(dl_min, self.corner_refinement._grid_size(grid_size_in_vacuum))
 
-        # min feature size 
+        # min feature size
         if self.corner_finder is not None and not self.corner_finder.dl_min_spec._no_restriction:
             dl_suggested = self._dl_min_from_smallest_feature(structures)
             dl_min = min(dl_min, dl_suggested)
@@ -1335,7 +1335,9 @@ def _inplane_inside(self, point: ArrayFloat2D) -> bool:
         )
         return self.inside(point_3d[0], point_3d[1], point_3d[2])
 
-    def _corners_and_convexity_2d(self, structure_list: List[Structure], ravel: bool) -> List[CoordinateOptional]:
+    def _corners_and_convexity_2d(
+        self, structure_list: List[Structure], ravel: bool
+    ) -> List[CoordinateOptional]:
         """Raw inplane corners and their convexity."""
         if self.corner_finder is None:
             return [], []
@@ -1349,7 +1351,8 @@ def _corners_and_convexity_2d(self, structure_list: List[Structure], ravel: bool
         )
 
         # filter corners outside the inplane bounds
-        if self._is_inplane_bounded:
+        if self._is_inplane_bounded and len(inplane_points) > 0:
+            # flatten temporary list of arrays for faster processing
             if not ravel:
                 split_inds = np.cumsum([len(pts) for pts in inplane_points])[:-1]
                 inplane_points = np.concatenate(inplane_points)
@@ -1362,17 +1365,19 @@ def _corners_and_convexity_2d(self, structure_list: List[Structure], ravel: bool
                 convexity = np.split(convexity, split_inds)
 
         return inplane_points, convexity
-    
+
     def _dl_min_from_smallest_feature(self, structure_list: List[Structure]):
         """Calculate `dl_min` suggestion based on smallest feature size."""
 
-        inplane_points, convexity = self._corners_and_convexity_2d(structure_list=structure_list, ravel=False)
+        inplane_points, convexity = self._corners_and_convexity_2d(
+            structure_list=structure_list, ravel=False
+        )
 
         dl_min = inf
 
         if self.corner_finder is None or self.corner_finder.dl_min_spec._no_restriction:
             return dl_min
-        
+
         dl_min_spec = self.corner_finder.dl_min_spec
 
         for points, conv in zip(inplane_points, convexity):
@@ -1391,7 +1396,6 @@ def _dl_min_from_smallest_feature(self, structure_list: List[Structure]):
                     min_concave_size = np.min(lengths[concave_features])
                     dl_min = min(dl_min, min_concave_size / dl_min_spec.concave_resolution)
 
-            
             if dl_min_spec.mixed_resolution > 0:
                 mixed_features = np.logical_xor(conv, conv_nei)
                 if np.any(mixed_features):
@@ -1402,7 +1406,9 @@ def _dl_min_from_smallest_feature(self, structure_list: List[Structure]):
 
     def _corners(self, structure_list: List[Structure]) -> List[CoordinateOptional]:
         """Inplane corners in 3D coordinate."""
-        inplane_points, _ = self._corners_and_convexity_2d(structure_list=structure_list, ravel=True)
+        inplane_points, _ = self._corners_and_convexity_2d(
+            structure_list=structure_list, ravel=True
+        )
 
         # convert 2d points to 3d
         return [