Automatic mesh refinement in layered structures#

This tutorial demonstrates how to use LayerRefinementSpec to automatically refine mesh in layered structures in Tidy3D. Those layered structures are commonly found in devices fabricated with printed circuit boards. This tool can identify geometric corners on the layer cross-section, and automatically refine and snap the grids around these critical points. It can also automatically adjust mesh density along the layer thickness direction. This capability is especially valuable for improving simulation accuracy and convergence in cases involving metallic structures, where electromagnetic fields can change dramatically near metal interfaces and even exhibit singular behavior at corners. For background on meshing in FDTD, we recommend first reviewing our automatic nonuniform meshing tutorial.

To demonstrate the key features of LayerRefinementSpec, we’ll walk through a practical example on a simple patch antenna structure.

If you are new to the finite-difference time-domain (FDTD) method, we highly recommend going through our FDTD101 tutorials.

[1]:

# basic imports
import numpy as np
import pprint
import matplotlib.pylab as plt

# tidy3d imports
import tidy3d as td

Simple rectangular patch antenna but with a cutout in the top.

[2]:

mm = 1e3  # millimeters

# patch antenna dimensions
patch_length = 30 * mm
patch_width = 30 * mm
patch_thickness = 0.02 * mm

# transmission line dimensions
transmission_width = 2 * mm
transmission_length = 90 * mm

# slot dimensions
slot_width = 5 * mm
slot_length = 3 * mm

# cutout dimensions
cutout_radius = 10 * mm

# substrate dimensions
sub_length = 50 * mm
sub_width = 50 * mm
sub_thickness = 1 * mm

Let’s define the geometry of the patch antenna consisting of a patch, a substrate, and a ground plane.

[3]:

# define patch geometry
patch_geometry_original = td.Box(
    center=(0, 0, 0),
    size=(patch_width, patch_length, patch_thickness),
)

tranmission_line_geometry = td.Box(
    center=(0, -transmission_length / 2, 0),
    size=(transmission_width, transmission_length, patch_thickness),
)

slot_geometry = td.Box(
    center=(0, -patch_length / 2 + slot_length / 2, 0),
    size=(slot_width, slot_length, patch_thickness),
)

cutout_geometry = td.Cylinder(
    center=(0, patch_length / 2, 0),
    axis=2,
    radius=cutout_radius,
    length=patch_thickness,
)

patch_geometry = patch_geometry_original - slot_geometry + tranmission_line_geometry - cutout_geometry

# define ground plane geometry
ground_geometry = td.Box(
    center=(0, 0, -sub_thickness),
    size=(sub_width, sub_length, patch_thickness),
)

# define substrate geometry
sub_geometry = td.Box(
    center=(0, 0, -sub_thickness / 2),
    size=(sub_width, sub_length, sub_thickness),
)

Now let’s setup the patch and ground plane structures that are made of PEC, and the substrate structure made of a dielectric material.

[4]:

patch = td.Structure(geometry=patch_geometry, medium=td.PEC)
ground = td.Structure(geometry=ground_geometry, medium=td.PEC)
substrate = td.Structure(geometry=sub_geometry, medium=td.Medium(permittivity=4.4))

Let’s define the structure list. In Tidy3D, when two structures overlap, the overlapping region is considered inside the structure that is added latter in the structure list. Thus, we place substrate at the beginning of the structure list to make sure that the thin metal layer is not overridden by the substrate layer under machine precision error.

[5]:

structures = [substrate, patch, ground]

The rest of simulation setup with the default non-uniform grid.

[6]:

freq0 = 10e9  # 10 GHz
wavelength = td.C_0 / freq0
resolution = 10
grid_spec = td.GridSpec.auto(wavelength=wavelength, min_steps_per_wvl=resolution)

sim = td.Simulation(
    size=[60 * mm, 60 * mm, 20 * mm],
    grid_spec=grid_spec,
    structures=structures,
    run_time=td.RunTimeSpec(quality_factor=10),
    boundary_spec=td.BoundarySpec.pml(),
    plot_length_units="mm",
)

16:54:12 PST WARNING: A structure has a nonzero dimension along axis z, which is
             however too small compared to the generated mesh step along that   
             direction. This could produce unpredictable results. We recommend  
             increasing the resolution, or adding a mesh override structure to  
             ensure that all geometries are at least one pixel thick along all  
             dimensions.

             WARNING: Suppressed 2 WARNING messages.

Note: Tidy3D is warning us that the thickness of our metallic structures is too small. They are not resolved by the generated grids. In other words, the grid size is much larger than the structure thickness. However, we may safely ignore this warning throughout this notebook, as we have special subpixel averaging scheme (also known as conformal meshing) for PEC and LossyMetalMedium, with which the simulation is still accurate enough.

Finally, define a helper function to show us the various grids as we go along this example.

[7]:

# Plot simulation and overlay grid in the yz and xy planes
def plot_sim_grid(sim):
    fig, ax = plt.subplots(1, 2, figsize=(12, 6))

    sim.plot(z=0, ax=ax[0])
    sim.plot_grid(z=0, ax=ax[0])
    ax[0].set_xlim(-20 * mm, 20 * mm)
    ax[0].set_ylim(-20 * mm, 20 * mm)

    sim.plot(y=0, ax=ax[1])
    sim.plot_grid(y=0, ax=ax[1], override_structures_alpha=0)
    ax[1].set_xlim(-5 * mm, 5 * mm)
    ax[1].set_ylim(-5 * mm, 5 * mm)

    pprint.pp(sim.grid_info)

Default Automatic Non-uniform Grid#

By default, Tidy3D automatically generates nonuniform grids, as detailed in this tutorial. The grid size is modulated by material properties: denser grid points inside materials of higher index of refraction. This scheme is very effective in many cases where the main source of error is numerical dispersion, e.g. photonic simulations where the electromagnetic field behavior is largely dictated by dielectric materials.

The figure below shows the default non-uniform grid for this patch antenna example. From the front view (right figure), the mesh is indeed finer in the dielectric substrate compared to the air region. However, from the top view (left figure), we observe that the mesh is not refined around metal interfaces, and the grid point is not snapped to the corners of metallic structures. This can lead to slow convergence for simulations at microwave frequencies, where the main source of error comes from the rapid field variations around metallic interfaces.

[8]:

plot_sim_grid(sim)

{'Nx': 41,
 'Ny': 41,
 'Nz': 7,
 'grid_points': 11767,
 'min_grid_size': 1428.5714285714275,
 'max_grid_size': 2996.666666666667,
 'computational_complexity': 8.236900000000006}

../_images/notebooks_LayerRefinement_16_1.png

Automatic mesh refinement in layered structures

Contents

Automatic mesh refinement in layered structures#

Default Automatic Non-uniform Grid#

Basic Layer Refinement Specification#

Advanced Layer Refinement Specification#

In-plane Mesh Refinement Around Corners#

Mesh Refinement Along Layer Thickness#