chore: improve TCAD mesher logging and fix unstructured data plotting (#3729)

Flex-RevId: 59d167cf0099796aa9c4a74821863c78804a927d

Author: momchil-flex

tests/test_components/test_heat_charge.py

@@ -1291,17 +1291,6 @@ def test_heat_charge_mnt_data(
                     _ = mnt_data.updated_copy(J=tri_grid)
 
 
-def test_heat_charge_monitor_data_warns_for_missing_fields(monitors):
-    """Ensure monitor-data missing-field warnings are emitted at initialization."""
-    temp_monitor_empty = monitors[3]
-    with AssertLogLevel("WARNING", contains_str="field 'temperature'"):
-        _ = td.TemperatureData(monitor=temp_monitor_empty, temperature=None)
-
-    potential_monitor_empty = monitors[7]
-    with AssertLogLevel("WARNING", contains_str="field 'potential'"):
-        _ = td.SteadyPotentialData(monitor=potential_monitor_empty, potential=None)
-
-
 def test_grid_spec_validation(grid_specs):
     """Tests whether unstructured grids can be created and different validators for them."""
     # Test UniformUnstructuredGrid
@@ -1460,6 +1449,7 @@ def test_mesh_plotting(simulation_data):
 
     # Plotting mesh from unstructured temperature data
     heat_sim_data.plot_mesh("tri")
+    heat_sim_data.plot_mesh("tri", y=0)  # redundant normal-axis sel should be a no-op
     heat_sim_data.plot_mesh("tet", y=0.5)
 
     # Plotting mesh from unstructured voltage data
@@ -1492,6 +1482,87 @@ def test_mesh_plotting(simulation_data):
         mesh_data.plot_mesh("mesh_test", z=0, field_name="wrong")
 
 
+def test_plot_mesh_2d_auto_sel():
+    """Test that plot_mesh auto-selects the collapsed dimension for 2D simulations."""
+
+    solid_medium = td.Medium(
+        permittivity=2.0,
+        heat_spec=td.SolidSpec(conductivity=1, capacity=1),
+        name="solid",
+    )
+    fluid_medium = td.Medium(permittivity=3.0, heat_spec=td.FluidSpec(), name="fluid")
+    structure = td.Structure(
+        geometry=td.Box(size=(0.5, 0.5, 0.5), center=(0, 0, 0)),
+        medium=solid_medium,
+        name="box",
+    )
+
+    temp_mnt_2d = td.TemperatureMonitor(
+        center=(0, 0, 0), size=(0.8, 0, 0.8), name="temp_2d", unstructured=True
+    )
+    mesh_mnt_2d = td.VolumeMeshMonitor(center=(0, 0, 0), size=(0.8, 0, 0.8), name="mesh_2d")
+
+    heat_sim_2d = td.HeatChargeSimulation(
+        medium=fluid_medium,
+        structures=[structure],
+        center=(0, 0, 0),
+        size=(1, 0, 1),
+        grid_spec=td.UniformUnstructuredGrid(dl=0.1),
+        sources=[td.HeatSource(rate=1, structures=["box"])],
+        boundary_spec=[
+            td.HeatChargeBoundarySpec(
+                placement=td.StructureBoundary(structure="box"),
+                condition=td.TemperatureBC(temperature=500),
+            )
+        ],
+        monitors=[temp_mnt_2d],
+    )
+
+    tet_grid_points = td.PointDataArray(
+        [
+            [0.0, -0.01, 0.0],
+            [0.4, -0.01, 0.0],
+            [0.0, -0.01, 0.4],
+            [0.4, -0.01, 0.4],
+            [0.2, 0.01, 0.2],
+        ],
+        dims=("index", "axis"),
+    )
+    tet_grid_cells = td.CellDataArray(
+        [[0, 1, 2, 4], [1, 2, 3, 4]],
+        dims=("cell_index", "vertex_index"),
+    )
+    tet_grid_values = td.IndexedDataArray(
+        [300.0, 310.0, 320.0, 330.0, 340.0],
+        dims=("index",),
+        name="T",
+    )
+    tet_grid = td.TetrahedralGridDataset(
+        points=tet_grid_points, cells=tet_grid_cells, values=tet_grid_values
+    )
+
+    sim_data_2d = td.HeatChargeSimulationData(
+        simulation=heat_sim_2d,
+        data=[td.TemperatureData(monitor=temp_mnt_2d, temperature=tet_grid)],
+    )
+
+    # Should auto-detect the zero-size y dimension and slice without needing y=0
+    sim_data_2d.plot_mesh("temp_2d")
+    plt.close()
+
+    # Also test plot_field auto-selection
+    sim_data_2d.plot_field("temp_2d")
+    plt.close()
+
+    # VolumeMesherData case
+    mesh_mnt_data = td.VolumeMeshData(monitor=mesh_mnt_2d, mesh=tet_grid)
+    mesher_data_2d = td.VolumeMesherData(
+        simulation=heat_sim_2d, data=[mesh_mnt_data], monitors=[mesh_mnt_2d]
+    )
+    mesher_data_2d.plot_mesh("mesh_2d")
+    plt.close()
+
+
 def test_conduction_simulation_has_conductors(conduction_simulation, structures):
     """Test whether error is raised if conduction simulation has no conductors."""
 

tests/test_data/test_datasets.py

@@ -294,6 +294,10 @@ def test_triangular_dataset(tmp_path, ds_name, dataset_type_ind, no_vtk=False):
         result = tri_grid.sel(x=np.linspace(0, 1, 3), y=tri_grid.normal_pos, z=[0.3, 0.4, 0.5])
         assert result.name == ds_name
 
+        # selecting only along the normal axis is a no-op and should return self
+        result_normal_only = tri_grid.sel(y=tri_grid.normal_pos)
+        assert result_normal_only == tri_grid
+
         # can't select out of plane
         with pytest.raises(DataError):
             _ = tri_grid.sel(x=np.linspace(0, 1, 3), y=1.2, z=[0.3, 0.4, 0.5])
@@ -779,105 +783,6 @@ def test_from_vtk():
         _ = td.TriangularGridDataset.from_vtk("tests/data/gmsh_2d.vtk")
 
 
-def test_triangular_from_vtu_near_planar_large_coordinates(tmp_path):
-    """Regression for large-coordinate planar slices with small normal-axis jitter."""
-    pytest.importorskip("vtk")
-    import vtk
-
-    import tidy3d as td
-
-    tri_grid = td.TriangularGridDataset(
-        normal_axis=1,
-        normal_pos=0.0,
-        points=td.PointDataArray(
-            [
-                [100000.0, 0.0],
-                [101000.0, 0.0],
-                [100000.0, 690.0],
-                [101000.0, 690.0],
-            ],
-            dims=("index", "axis"),
-        ),
-        cells=td.CellDataArray([[0, 1, 2], [1, 2, 3]], dims=("cell_index", "vertex_index")),
-        values=td.IndexedDataArray(
-            [1.0, 2.0, 3.0, 4.0], coords={"index": np.arange(4)}, name="temp"
-        ),
-    )
-
-    vtu_path = tmp_path / "near_planar_large_coords.vtu"
-    tri_grid.to_vtu(vtu_path)
-
-    # Inject tiny jitter in the nominally planar normal direction.
-    reader = vtk.vtkXMLUnstructuredGridReader()
-    reader.SetFileName(str(vtu_path))
-    reader.Update()
-    grid = reader.GetOutput()
-    points = grid.GetPoints()
-    for ind in range(points.GetNumberOfPoints()):
-        x, _, z = points.GetPoint(ind)
-        points.SetPoint(ind, x, 6e-6 if (ind % 2) == 0 else -6e-6, z)
-    points.Modified()
-
-    writer = vtk.vtkXMLUnstructuredGridWriter()
-    writer.SetFileName(str(vtu_path))
-    writer.SetInputData(grid)
-    writer.Write()
-
-    loaded = td.TriangularGridDataset.from_vtu(vtu_path, field="temp")
-    assert loaded.normal_axis == 1
-    assert abs(float(loaded.normal_pos)) < 1e-4
-    assert loaded.points.sizes["index"] == 4
-
-
-def test_triangular_from_vtu_far_from_origin_small_extent(tmp_path):
-    """Regression: tolerance must depend on extent, not absolute position."""
-    pytest.importorskip("vtk")
-    import vtk
-
-    import tidy3d as td
-
-    tri_grid = td.TriangularGridDataset(
-        normal_axis=1,
-        normal_pos=0.0,
-        points=td.PointDataArray(
-            [
-                [1e9, -2e9],
-                [1e9 + 2.0, -2e9],
-                [1e9, -2e9 + 1.0],
-                [1e9 + 2.0, -2e9 + 1.0],
-            ],
-            dims=("index", "axis"),
-        ),
-        cells=td.CellDataArray([[0, 1, 2], [1, 2, 3]], dims=("cell_index", "vertex_index")),
-        values=td.IndexedDataArray(
-            [1.0, 2.0, 3.0, 4.0], coords={"index": np.arange(4)}, name="temp"
-        ),
-    )
-
-    vtu_path = tmp_path / "far_origin_small_extent.vtu"
-    tri_grid.to_vtu(vtu_path)
-
-    reader = vtk.vtkXMLUnstructuredGridReader()
-    reader.SetFileName(str(vtu_path))
-    reader.Update()
-    grid = reader.GetOutput()
-    points = grid.GetPoints()
-    for ind in range(points.GetNumberOfPoints()):
-        x, _, z = points.GetPoint(ind)
-        points.SetPoint(ind, x, 2e-7 if (ind % 2) == 0 else -2e-7, z)
-    points.Modified()
-
-    writer = vtk.vtkXMLUnstructuredGridWriter()
-    writer.SetFileName(str(vtu_path))
-    writer.SetInputData(grid)
-    writer.Write()
-
-    loaded = td.TriangularGridDataset.from_vtu(vtu_path, field="temp")
-    assert loaded.normal_axis == 1
-    assert abs(float(loaded.normal_pos)) < 1e-5
-    assert loaded.points.sizes["index"] == 4
-
-
 def test_tetrahedral_from_vtk_obj_without_cell_types_array():
     """Regression test for VTK objects with missing ``GetCellTypesArray`` output."""
     pytest.importorskip("vtk")

tidy3d/components/data/unstructured/triangular.py

@@ -175,12 +175,7 @@ def _from_vtk_obj(
 
         # detect zero size dimension
         bounds = np.max(points_numpy, axis=0) - np.min(points_numpy, axis=0)
-        # VTU slices can accumulate small floating-point jitter in the nominally
-        # zero-thickness direction. Scale tolerance with geometry extent (rather than
-        # absolute coordinate value) to avoid origin-dependent behavior.
-        size_scale = float(np.max(bounds)) if bounds.size > 0 else 0.0
-        zero_dim_tol = max(1e-6, 2e-8 * size_scale)
-        zero_dims = np.where(np.isclose(bounds, 0, atol=zero_dim_tol))[0]
+        zero_dims = np.where(np.isclose(bounds, 0, atol=1e-6))[0]
 
         if len(zero_dims) != 1:
             raise DataError(
@@ -496,6 +491,9 @@ def sel(
         axes = [ind for ind, comp in enumerate(xyz) if comp is not None]
         num_provided = len(axes)
 
+        if num_provided == 0 and len(sel_kwargs) == 0:
+            raise DataError("At least one dimension for selection must be provided.")
+
         if self.normal_axis in axes:
             if xyz[self.normal_axis] != self.normal_pos:
                 raise DataError(
@@ -507,9 +505,6 @@ def sel(
                 num_provided -= 1
                 axes.remove(self.normal_axis)
 
-        if num_provided == 0 and len(sel_kwargs) == 0:
-            raise DataError("At least one dimension for selection must be provided.")
-
         self_after_non_spatial_sel = self._non_spatial_sel(method=method, **sel_kwargs)
 
         if num_provided == 1:

tidy3d/components/tcad/data/sim_data.py

@@ -45,6 +45,28 @@
     from tidy3d.components.types import Ax, RealFieldVal
 
 
+def _auto_sel_kwargs_for_zero_size_dims(
+    monitor: Any,
+    simulation: Any,
+    sel_kwargs: dict,
+) -> dict:
+    """Find the first zero-size spatial dimension to auto-select on.
+
+    For 2D simulations or 2D monitors producing 3D unstructured data, this detects
+    which spatial dimension is collapsed and returns the appropriate sel kwarg
+    so that a TetrahedralGridDataset can be sliced to a TriangularGridDataset.
+    """
+    for dim in range(3):
+        dim_name = "xyz"[dim]
+        if dim_name in sel_kwargs:
+            continue
+        if monitor.size[dim] == 0:
+            return {dim_name: monitor.center[dim]}
+        if simulation.size[dim] == 0:
+            return {dim_name: simulation.center[dim]}
+    return {}
+
+
 def _compute_monitor_axis_limits(
     monitor: Any,
     sim_bounds: tuple,
@@ -235,6 +257,13 @@ def plot_mesh(
         if len(sel_kwargs) > 0:
             field_data = field_data.sel(**sel_kwargs)
 
+        if isinstance(field_data, TetrahedralGridDataset):
+            auto_sel = _auto_sel_kwargs_for_zero_size_dims(
+                monitor_data.monitor, self.simulation, sel_kwargs
+            )
+            if auto_sel:
+                field_data = field_data.sel(**auto_sel)
+
         if isinstance(field_data, TetrahedralGridDataset):
             raise DataError(
                 "Must select a two-dimensional slice of unstructured dataset for plotting"
@@ -422,6 +451,13 @@ def plot_field(
         if isinstance(field_data, UnstructuredGridDataset) and len(sel_kwargs) > 0:
             field_data = field_data.sel(**sel_kwargs)
 
+        if isinstance(field_data, TetrahedralGridDataset):
+            auto_sel = _auto_sel_kwargs_for_zero_size_dims(
+                monitor_data.monitor, self.simulation, sel_kwargs
+            )
+            if auto_sel:
+                field_data = field_data.sel(**auto_sel)
+
         if isinstance(field_data, TetrahedralGridDataset):
             raise DataError(
                 "Must select a two-dimensional slice of unstructured dataset for plotting"