Tidy3D Compatibility

Flex RF exposes Tidy3D microwave and RF APIs through the flex_rf.tidy3d compatibility namespace. Use this page to find local Flex RF guides for RF and microwave workflows, plus the generated API symbols for the current compatibility layer.

Start Here

Destination	Best used for
Terminal Component Modeler	Building and analyzing multiport RF components with lumped and wave-port workflows.
Lumped Ports And Elements	Configuring compact current excitations and lumped circuit elements.
Wave Ports	Configuring modal and terminal wave-port excitations.
API Symbol Catalog	Jumping directly to generated flex_rf.tidy3d and flex_rf.web API pages.

Microwave And RF Topics

Microwave and RF simulations share many setup concepts with optical FDTD, but they often need additional attention to ports, S-parameter definitions, impedance extraction, and RF-specific data containers.

Topic	Reference
Terminal Component Modeler	Local Flex RF guide
S-parameter definitions	Local Flex RF guide
RF material models	Local Flex RF guide
RF material library	Local Flex RF guide
Layer-based grid refinement	Local Flex RF guide
Path integrals	Local Flex RF guide
Impedance calculator	Local Flex RF guide
RF mode analysis	Local Flex RF guide
Lumped ports and elements	Local Flex RF guide
Wave ports	Local Flex RF guide
Radiation and scattering	Local Flex RF guide
RF output data	Local Flex RF guide

Quickstart Examples

These examples show two common ways to start working with the current flex_rf compatibility APIs. Existing tidy3d.rf imports can be updated by importing the same RF classes from flex_rf.tidy3d.

Wave Port

import numpy as np
import tidy3d as td
import flex_rf.tidy3d as rft  # flex_rf.tidy3d compatibility wrapper around tidy3d.rf
import flex_rf.web as web

f_min, f_max = (1e9, 70e9)
f0 = (f_max + f_min) / 2
freqs = np.linspace(f_min, f_max, 11)

# Tidy3D lengths are in microns by default.
mil = 25.4
w = 3.2 * mil
t = 0.7 * mil
h = 10.7 * mil
se = 7 * mil
L = 100 * mil
len_inf = 1e6

med_sub = rft.Medium(permittivity=4.4)
med_metal = rft.LossyMetalMedium(
    conductivity=60,
    frequency_range=(f_min, f_max),
    name="Metal",
)

str_sub = rft.Structure(
    geometry=rft.Box(center=(0, 0, 0), size=(len_inf, h, len_inf)),
    medium=med_sub,
)
str_strip_left = rft.Structure(
    geometry=rft.Box(center=(-(se + w) / 2, 0, 0), size=(w, t, len_inf)),
    medium=med_metal,
)
str_strip_right = rft.Structure(
    geometry=rft.Box(center=((se + w) / 2, 0, 0), size=(w, t, len_inf)),
    medium=med_metal,
)
str_gnd_top = rft.Structure(
    geometry=rft.Box(center=(0, h / 2 + t / 2, 0), size=(len_inf, t, len_inf)),
    medium=med_metal,
)
str_gnd_bot = rft.Structure(
    geometry=rft.Box(center=(0, -h / 2 - t / 2, 0), size=(len_inf, t, len_inf)),
    medium=med_metal,
)

lr_spec = rft.LayerRefinementSpec.from_structures(
    structures=[str_strip_left, str_strip_right],
    min_steps_along_axis=1,
    refinement_inside_sim_only=False,
    corner_refinement=td.GridRefinement(dl=t, num_cells=2),
)
lr_spec2 = lr_spec.updated_copy(
    center=(0, h / 2 + t / 2, 0),
    size=(len_inf, t, len_inf),
)
lr_spec3 = lr_spec.updated_copy(
    center=(0, -h / 2 - t / 2, 0),
    size=(len_inf, t, len_inf),
)

grid_spec = rft.GridSpec.auto(
    wavelength=td.C_0 / f_max,
    min_steps_per_wvl=10,
    min_steps_per_sim_size=30,
    layer_refinement_specs=[lr_spec, lr_spec2, lr_spec3],
)

wp1 = rft.WavePort(
    center=(0, 0, -L / 2),
    size=(len_inf, len_inf, 0),
    direction="+",
    name="WP1",
)
wp2 = wp1.updated_copy(name="WP2", center=(0, 0, L / 2), direction="-")

sim = rft.Simulation(
    size=(50 * mil, h + 2 * t, 1.5 * L),
    grid_spec=grid_spec,
    structures=[str_sub, str_strip_left, str_strip_right, str_gnd_top, str_gnd_bot],
    run_time=2e-9,
    symmetry=(-1, 0, 0),
)

modeler = rft.TerminalComponentModeler(
    simulation=sim,
    ports=[wp1, wp2],
    freqs=freqs,
)
tcm_data = web.run(modeler, task_name="smoke_test_wave_port", verbose=True)

s_matrix = tcm_data.smatrix()
s11 = np.conjugate(s_matrix.data.sel(port_in="WP1@0", port_out="WP1@0"))
s21 = np.conjugate(s_matrix.data.sel(port_in="WP1@0", port_out="WP2@0"))

print(f"S11 max: {float((20 * np.log10(np.abs(s11))).max()):.2f} dB")
print(
    f"S21 at {f0/1e9:.1f} GHz: "
    f"{float((20 * np.log10(np.abs(s21))).sel(f=f0, method='nearest')):.2f} dB"
)

Lumped Port

import numpy as np
import tidy3d as td
import flex_rf.tidy3d as rft  # flex_rf.tidy3d compatibility wrapper around tidy3d.rf
import flex_rf.web as web

freq_start = 5e9
freq_stop = 11e9
freq0 = (freq_start + freq_stop) / 2
wavelength0 = td.C_0 / freq0
freqs = np.linspace(freq_start, freq_stop, 51)

medium_sub = rft.Medium(permittivity=2.2, name="Substrate")
medium_metal = rft.PEC

# Tidy3D lengths are in microns by default.
mm = 1e3
th = 0.05 * mm
sub_x = 23.34 * mm
sub_y = 40 * mm
sub_z = 0.794 * mm
patch_x = 12.45 * mm
patch_y = 16 * mm
feed_x = 2.46 * mm
feed_y = 20 * mm
feed_offset = 2.09 * mm

substrate = rft.Structure(
    geometry=rft.Box(center=[0, 0, 0], size=[sub_x, sub_y, sub_z]),
    medium=medium_sub,
    name="Substrate",
)
ground_plane = rft.Structure(
    geometry=rft.Box(center=[0, 0, -(sub_z + th) / 2], size=[sub_x, sub_y, th]),
    medium=medium_metal,
    name="Ground",
)
feed_line = rft.Structure(
    geometry=rft.Box.from_bounds(
        rmin=[-patch_x / 2 + feed_offset, -sub_y / 2, sub_z / 2],
        rmax=[-patch_x / 2 + feed_offset + feed_x, -sub_y / 2 + feed_y, sub_z / 2 + th],
    ),
    medium=medium_metal,
    name="Feed line",
)
patch = rft.Structure(
    geometry=rft.Box.from_bounds(
        rmin=[-patch_x / 2, -sub_y / 2 + feed_y, sub_z / 2],
        rmax=[patch_x / 2, -sub_y / 2 + feed_y + patch_y, sub_z / 2 + th],
    ),
    medium=medium_metal,
    name="Patch",
)


def _create_lr_spec(structures):
    return rft.LayerRefinementSpec.from_structures(
        structures=structures,
        axis=2,
        bounds_snapping="bounds",
        bounds_refinement=td.GridRefinement(dl=th, num_cells=2),
        corner_refinement=td.GridRefinement(dl=0.2 * mm, num_cells=2),
    )


grid_spec = rft.GridSpec.auto(
    wavelength=wavelength0,
    min_steps_per_wvl=12,
    layer_refinement_specs=[
        _create_lr_spec([ground_plane]),
        _create_lr_spec([feed_line, patch]),
    ],
)

padding = td.C_0 / freq_start / 2
port = rft.LumpedPort(
    name="lumped_port",
    center=[-patch_x / 2 + feed_offset + feed_x / 2, -sub_y / 2, 0],
    size=[feed_x, 0, sub_z],
    voltage_axis=2,
    impedance=50,
)

sim = rft.Simulation(
    size=[sub_x + 2 * padding, sub_y + 2 * padding, sub_z + 2 * padding],
    structures=[substrate, ground_plane, feed_line, patch],
    grid_spec=grid_spec,
    run_time=5e-9,
)

modeler = rft.TerminalComponentModeler(
    simulation=sim,
    freqs=freqs,
    ports=[port],
)
tcm_data = web.run(modeler, task_name="smoke_test_lumped_port", verbose=True)

s_matrix = tcm_data.smatrix()
s11 = np.conjugate(s_matrix.data.isel(port_out=0, port_in=0))
print(f"S11 min: {float((20 * np.log10(np.abs(s11))).min()):.2f} dB")
print(
    f"S11 at {freq0/1e9:.1f} GHz: "
    f"{float((20 * np.log10(np.abs(s11))).sel(f=freq0, method='nearest')):.2f} dB"
)

API Symbol Catalog

This catalog is generated from the current flex_rf compatibility exports. Use it to jump from the compatibility guide to the detailed API pages.

flex_rf.tidy3d

Symbol	Kind	Summary
flex_rf.tidy3d.Absorber	class	Specifies an adiabatic absorber along a single dimension.
flex_rf.tidy3d.AbsorberParams	class	Specifies parameters common to Absorbers and PMLs.
flex_rf.tidy3d.AbstractComponentModeler	class	Tool for modeling devices and computing port parameters.
flex_rf.tidy3d.AdmittanceNetwork	class	Class for representing a network consisting of an arbitrary number of resistors, capacitors, and inductors. The network is represented in the Laplace domain as an admittance function. Provides additional functionality for representing the network as an equivalent medium.
flex_rf.tidy3d.AnisotropicMedium	class	Diagonally anisotropic medium.
flex_rf.tidy3d.AntennaMetricsData	class	Data representing the main parameters and figures of merit for antennas.
flex_rf.tidy3d.AutoGrid	class	Specification for non-uniform grid along a given dimension.
flex_rf.tidy3d.AutoImpedanceSpec	class	Specification for fully automatic transmission line impedance computation.
flex_rf.tidy3d.AxisAlignedCurrentIntegral	class	Class for computing conduction current via Ampère’s circuital law on an axis-aligned loop.
flex_rf.tidy3d.AxisAlignedCurrentIntegralSpec	class	Class for specifying the computation of conduction current via Ampère’s circuital law on an axis-aligned loop.
flex_rf.tidy3d.AxisAlignedPathIntegral	class	Class for defining the simplest type of path integral, which is aligned with Cartesian axes.
flex_rf.tidy3d.AxisAlignedVoltageIntegral	class	Class for computing the voltage between two points defined by an axis-aligned line.
flex_rf.tidy3d.AxisAlignedVoltageIntegralSpec	class	Class for specifying the voltage calculation between two points defined by an axis-aligned line.
flex_rf.tidy3d.BasebandCustomSourceTime	class	Custom baseband source time profile from a user-provided time-domain dataset.
flex_rf.tidy3d.BasebandGaussianPulse	class	Unmodulated Gaussian pulse source time profile.
flex_rf.tidy3d.BasebandRectangularPulse	class	Smoothed rectangular pulse source time profile.
flex_rf.tidy3d.BasebandStep	class	Step function source time profile using an error function (erf).
flex_rf.tidy3d.BlackmanHarrisWindow	class	Standard Blackman-Harris window for tapering or spectral shaping.
flex_rf.tidy3d.BlackmanWindow	class	Standard Blackman window for tapering or spectral shaping.
flex_rf.tidy3d.BlochBoundary	class	Specifies a Bloch boundary condition along a single dimension.
flex_rf.tidy3d.Boundary	class	Boundary conditions at the minus and plus extents along a dimension.
flex_rf.tidy3d.BoundarySpec	class	Specifies boundary conditions on each side of the domain and along each dimension.
flex_rf.tidy3d.Box	class	Rectangular prism. Also base class for Simulation, Monitor, and Source.
flex_rf.tidy3d.C_0	attribute	Speed of light in vacuum [um/s]
flex_rf.tidy3d.ChebWindow	class	Standard Chebyshev window for tapering with configurable sidelobe attenuation.
flex_rf.tidy3d.CircuitImpedanceModel	class	Circuit model storing R/L/C components and port nodes; fits admittance on demand.
flex_rf.tidy3d.ClipOperation	class	Class representing the result of a set operation between geometries.
flex_rf.tidy3d.CoaxialLumpedPort	class	Class representing a single coaxial lumped port.
flex_rf.tidy3d.CoaxialLumpedResistor	class	Class representing a coaxial lumped resistor. Lumped resistors are appended to the list of structures in the simulation as Medium2D with the appropriate conductivity given their size and geometry.
flex_rf.tidy3d.ComponentModelerDataType	attribute
flex_rf.tidy3d.ComponentModelerType	attribute
flex_rf.tidy3d.CompositeCurrentIntegral	class	Current integral comprising one or more disjoint paths
flex_rf.tidy3d.CompositeCurrentIntegralSpec	class	Specification for a composite current integral.
flex_rf.tidy3d.constant_loss_tangent_model	function	Fit a constant loss tangent material model.
flex_rf.tidy3d.ContourPathAveraging	class	Apply a contour-path subpixel averaging method to dielectric boundaries.
flex_rf.tidy3d.Coords	class	Holds data about a set of x,y,z positions on a grid.
flex_rf.tidy3d.CornerFinderSpec	class	Specification for corner detection on a 2D plane.
flex_rf.tidy3d.CurrentIntegralTypes	attribute
flex_rf.tidy3d.Custom2DCurrentIntegral	class	Class for computing conduction current via Ampère’s circuital law on a custom path. To compute the current flowing in the positive axis direction, the vertices should be ordered in a counterclockwise direction.
flex_rf.tidy3d.Custom2DCurrentIntegralSpec	class	Class for specifying the computation of conduction current via Ampère’s circuital law on a custom path. To compute the current flowing in the positive axis direction, the vertices should be ordered in a counterclockwise direction.
flex_rf.tidy3d.Custom2DPathIntegral	class	Class for defining a custom path integral defined as a curve on an axis-aligned plane.
flex_rf.tidy3d.Custom2DVoltageIntegral	class	Class for computing the voltage between two points defined by a custom path. Computed voltage is :math:V=V_b-V_a, where position b is the final vertex in the supplied path.
flex_rf.tidy3d.Custom2DVoltageIntegralSpec	class	Class for specifying the computation of voltage between two points defined by a custom path. Computed voltage is :math:V=V_b-V_a, where position b is the final vertex in the supplied path.
flex_rf.tidy3d.CustomAnisotropicMedium	class	Diagonally anisotropic medium with spatially varying permittivity in each component.
flex_rf.tidy3d.CustomGrid	class	Custom 1D grid supplied as a list of grid cell sizes centered on the simulation center.
flex_rf.tidy3d.CustomGridBoundaries	class	Custom 1D grid supplied as a list of grid cell boundary coordinates.
flex_rf.tidy3d.CustomImpedanceSpec	class	Specification for custom transmission line voltages and currents in mode solvers.
flex_rf.tidy3d.CustomMedium	class	Medium with user-supplied permittivity distribution.
flex_rf.tidy3d.CustomPoleResidue	class	A spatially varying dispersive medium described by the pole-residue pair model.
flex_rf.tidy3d.CustomSourceTime	class	Custom source time dependence consisting of a real or complex envelope modulated at a central frequency, as shown below.
flex_rf.tidy3d.Cylinder	class	Cylindrical geometry with optional sidewall angle along axis direction. When sidewall_angle is nonzero, the shape is a conical frustum or a cone.
flex_rf.tidy3d.DiffractionData	class	Data for a DiffractionMonitor: complex components of diffracted far fields.
flex_rf.tidy3d.DiffractionMonitor	class	Monitor that uses a 2D Fourier transform to compute the diffraction amplitudes and efficiency for allowed diffraction orders.
flex_rf.tidy3d.DirectivityData	class	Data associated with a DirectivityMonitor.
flex_rf.tidy3d.DirectivityMonitor	class	Monitor that records the radiation characteristics of antennas in the frequency domain at specified observation angles.
flex_rf.tidy3d.DirectivityMonitorSpec	class	Specification for automatically generating a DirectivityMonitor.
flex_rf.tidy3d.EPSILON_0	attribute	Vacuum permittivity [F/um]
flex_rf.tidy3d.ETA_0	attribute	Vacuum impedance in Ohms
flex_rf.tidy3d.FastDispersionFitter	class	Tool for fitting refractive index data to get a dispersive medium described by PoleResidue model.
flex_rf.tidy3d.FieldData	class	Data associated with a FieldMonitor: scalar components of E and H fields.
flex_rf.tidy3d.FieldGrid	class	Holds the grid data for a single field.
flex_rf.tidy3d.FieldMonitor	class	Monitor that records electromagnetic fields in the frequency domain.
flex_rf.tidy3d.FieldTimeData	class	Data associated with a FieldTimeMonitor: scalar components of E and H fields.
flex_rf.tidy3d.FieldTimeMonitor	class	Monitor that records electromagnetic fields in the time domain.
flex_rf.tidy3d.FluxData	class	Data associated with a FluxMonitor: flux data in the frequency-domain.
flex_rf.tidy3d.FluxMonitor	class	Monitor that records power flux in the frequency domain.
flex_rf.tidy3d.FluxTimeData	class	Data associated with a FluxTimeMonitor: flux data in the time-domain.
flex_rf.tidy3d.FluxTimeMonitor	class	Monitor that records power flux in the time domain.
flex_rf.tidy3d.FreqRange	class	Convenience class for handling frequency/wavelength conversion; it simplifies specification of frequency ranges and sample points for sources and monitors.
flex_rf.tidy3d.FrequencyUtils	class	Utilities for classifying frequencies/wavelengths and generating samples for standard optical bands.
flex_rf.tidy3d.FullyAnisotropicMedium	class	Fully anisotropic medium including all 9 components of the permittivity and conductivity tensors.
flex_rf.tidy3d.GaussianPulse	class	Source time dependence that describes a Gaussian pulse.
flex_rf.tidy3d.Geometry	class	Abstract base class, defines where something exists in space.
flex_rf.tidy3d.GeometryGroup	class	A collection of Geometry objects that can be called as a single geometry object.
flex_rf.tidy3d.Grid	class	Contains all information about the spatial positions of the FDTD grid.
flex_rf.tidy3d.GridRefinement	class	Specification for local mesh refinement that defines the grid step size and the number of grid cells in the refinement region.
flex_rf.tidy3d.GridSpec	class	Collective grid specification for all three dimensions.
flex_rf.tidy3d.HammerstadSurfaceRoughness	class	Modified Hammerstad surface roughness model. It’s a popular model that works well under 5 GHz for surface roughness below 2 micrometer RMS.
flex_rf.tidy3d.HammingWindow	class	Standard Hamming window for tapering or spectral shaping.
flex_rf.tidy3d.HannWindow	class	Hann window with configurable sidelobe suppression and sidelobe count.
flex_rf.tidy3d.HeuristicPECStaircasing	class	Apply a variant of staircasing scheme to PEC boundaries: the electric field grid is set to PEC if the field is substantially parallel to the interface.
flex_rf.tidy3d.HuraySurfaceRoughness	class	Huray surface roughness model.
flex_rf.tidy3d.ImpedanceCalculator	class	Tool for computing the characteristic impedance of a transmission line.
flex_rf.tidy3d.inf	attribute	Representation of infinity used within tidy3d.
flex_rf.tidy3d.InternalAbsorber	class	Internally placed plane with one-way wave equation boundary conditions for absorption of electromagnetic waves. Note that internal absorbers are automatically wrapped in a PEC frame with a backing PEC plate on the non-absorbing side.
flex_rf.tidy3d.KaiserWindow	class	Class for Kaiser window.
flex_rf.tidy3d.LayerRefinementSpec	class	Specification for automatic mesh refinement and snapping in layered structures. Structure corners on the cross section perpendicular to layer thickness direction can be automatically identified. Subsequently, mesh is snapped and refined around the corners. Mesh can also be refined and snapped around the bounds along the layer thickness direction.
flex_rf.tidy3d.LinearLumpedElement	class	Lumped element representing a network consisting of resistors, capacitors, and inductors.
flex_rf.tidy3d.LobeMeasurer	class	Tool for detecting and analyzing lobes in antenna radiation patterns, along with their characteristics such as direction and beamwidth.
flex_rf.tidy3d.log	module	Logging Configuration for Tidy3d.
flex_rf.tidy3d.LossyMetalMedium	class	Lossy metal that can be modeled with a surface impedance boundary condition (SIBC).
flex_rf.tidy3d.LowFrequencySmoothingSpec	class	Specifies the low frequency smoothing parameters for the simulation. This specification affects only results recorded in mode monitors. Specifically, the mode decomposition data for frequencies for which the total simulation time in units of the corresponding period (T = 1/f) is less than the specified minimum sampling time will be overridden by extrapolation from the data in the trusted frequency range. The trusted frequency range is defined in terms of minimum and maximum sampling times (the total simulation time divided by the corresponding period). Example ------- >>> low_freq_smoothing = LowFrequencySmoothingSpec( … min_sampling_time=3, … max_sampling_time=6, … order=1, … max_deviation=0.5, … monitors=(“monitor1”, “monitor2”), … )
flex_rf.tidy3d.LumpedCircuitComponent	class	Single R, L, or C branch between two nodes.
flex_rf.tidy3d.LumpedPort	class	Class representing a single rectangular lumped port.
flex_rf.tidy3d.LumpedResistor	class	Class representing a rectangular lumped resistor. Lumped resistors are appended to the list of structures in the simulation as Medium2D with the appropriate conductivity given their size and voltage axis.
flex_rf.tidy3d.material_library	module
flex_rf.tidy3d.Medium	class	Dispersionless medium. Mediums define the optical properties of the materials within the simulation.
flex_rf.tidy3d.Medium2D	class	2D diagonally anisotropic medium.
flex_rf.tidy3d.MeshOverrideStructure	class	Defines an object that is only used in the process of generating the mesh.
flex_rf.tidy3d.MicrowaveModeData	class	Data associated with a ModeMonitor for microwave and RF applications: modal amplitudes, propagation indices, mode profiles, and transmission line data.
flex_rf.tidy3d.MicrowaveModeMonitor	class	Monitor that records amplitudes from modal decomposition of fields on plane.
flex_rf.tidy3d.MicrowaveModeSolverData	class	Data associated with a ModeSolverMonitor for microwave and RF applications: scalar components of E and H fields plus characteristic impedance data.
flex_rf.tidy3d.MicrowaveModeSolverMonitor	class	Monitor that stores the mode field profiles returned by the mode solver in the monitor plane.
flex_rf.tidy3d.MicrowaveModeSpec	class	Specification for transmission line modes and microwave waveguides.
flex_rf.tidy3d.MicrowaveSMatrixData	class	Stores the computed S-matrix and reference impedances for the terminal ports.
flex_rf.tidy3d.MicrowaveTerminalSource	class	Injects current source to excite a specific terminal mode.
flex_rf.tidy3d.ModeData	class	Data associated with a ModeMonitor: modal amplitudes, propagation indices and mode profiles.
flex_rf.tidy3d.ModelerLowFrequencySmoothingSpec	class	Specifies the low frequency smoothing parameters for the terminal component simulation. This specification affects only results at wave ports. Specifically, the mode decomposition data for frequencies for which the total simulation time in units of the corresponding period (T = 1/f) is less than the specified minimum sampling time will be overridden by extrapolation from the data in the trusted frequency range. The trusted frequency range is defined in terms of minimum and maximum sampling times (the total simulation time divided by the corresponding period).
flex_rf.tidy3d.models	module	Imports for transmission line models.
flex_rf.tidy3d.ModeMonitor	class	Monitor that records amplitudes from modal decomposition of fields on plane.
flex_rf.tidy3d.ModeSolver	class	Interface for solving electromagnetic eigenmodes in a 2D plane with translational invariance in the third dimension.
flex_rf.tidy3d.ModeSolverData	class	Data associated with a ModeSolverMonitor: scalar components of E and H fields.
flex_rf.tidy3d.ModeSolverMonitor	class	Monitor that stores the mode field profiles returned by the mode solver in the monitor plane.
flex_rf.tidy3d.ModeSpec	class	Stores specifications for the mode solver to find an electromagnetic mode.
flex_rf.tidy3d.MU_0	attribute	Vacuum permeability [H/um]
flex_rf.tidy3d.path_integrals_from_lumped_element	function	Helper to create a AxisAlignedVoltageIntegral and AxisAlignedCurrentIntegral from a supplied LinearLumpedElement. Takes into account any snapping the lumped element undergoes using the supplied Grid.
flex_rf.tidy3d.PEC	attribute
flex_rf.tidy3d.PECBoundary	class	Perfect electric conductor boundary condition class.
flex_rf.tidy3d.PECConformal	class	Apply a subpixel averaging method known as conformal mesh scheme to PEC boundaries.
flex_rf.tidy3d.PECFrame	class	PEC source frame.
flex_rf.tidy3d.PECMedium	class	Perfect electrical conductor class.
flex_rf.tidy3d.Periodic	class	Periodic boundary condition class.
flex_rf.tidy3d.PermittivityData	class	Data for a PermittivityMonitor: diagonal components of the permittivity tensor.
flex_rf.tidy3d.PermittivityMonitor	class	Monitor that records the diagonal components of the complex-valued relative permittivity tensor in the frequency domain. The recorded data has the same shape as a FieldMonitor of the same geometry: the permittivity values are saved at the Yee grid locations, and can be interpolated to any point inside the monitor.
flex_rf.tidy3d.PlaneWave	class	Uniform current distribution on an infinite extent plane. One element of size must be zero.
flex_rf.tidy3d.PMCBoundary	class	Perfect magnetic conductor boundary condition class.
flex_rf.tidy3d.PMCMedium	class	Perfect magnetic conductor class.
flex_rf.tidy3d.PML	class	Specifies a standard PML along a single dimension.
flex_rf.tidy3d.PMLParams	class	Specifies full set of parameters needed for complex, frequency-shifted PML.
flex_rf.tidy3d.PointDipole	class	Uniform current source with a zero size. The source corresponds to an infinitesimal antenna with a fixed current density, and is slightly different from a related definition that is used in some contexts, namely an oscillating electric or magnetic dipole. The two are related through a factor of omega ** 2 in the power normalization, where omega is the angular frequency of the oscillation. This is discussed further in our source normalization <https://docs.flexcompute.com/projects/tidy3d/en/latest/faq/docs/faq/How-are-results-normalized.html>_ FAQ page.
flex_rf.tidy3d.PolarizedAveraging	class	Apply a polarized subpixel averaging method to dielectric boundaries, which is a phenomenological approximation of ContourPathAveraging.
flex_rf.tidy3d.PoleResidue	class	A dispersive medium described by the pole-residue pair model.
flex_rf.tidy3d.PolySlab	class	Polygon extruded with optional sidewall angle along axis direction.
flex_rf.tidy3d.PortDataArray	class	Array of values over dimensions of frequency and port name.
flex_rf.tidy3d.QuasiUniformGrid	class	Similar to UniformGrid that generates uniform 1D grid, but grid positions are locally fine tuned to be snaped to snapping points and the edges of structure bounding boxes. Internally, it is using the same meshing method as AutoGrid, but it ignores material information in favor for a user-defined grid size.
flex_rf.tidy3d.RadialTaper	class	Class for Radial Taper.
flex_rf.tidy3d.RectangularAntennaArrayCalculator	class	This class provides methods to calculate the array factor and far-field radiation patterns for rectangular phased antenna arrays. It handles arrays with arbitrary size, spacing, phase shifts, and amplitude tapering in x, y, and z directions.
flex_rf.tidy3d.RectangularLumpedElement	class	Class representing a rectangular planar element with zero thickness along its normal axis. A RectangularLumpedElement is appended to the list of structures in the simulation as a Medium2D with the appropriate material properties given their size, voltage axis, and the network they represent.
flex_rf.tidy3d.RectangularTaper	class	Class for rectangular taper.
flex_rf.tidy3d.rf_material_library	attribute
flex_rf.tidy3d.RLCNetwork	class	Class for representing a simple network consisting of a resistor, capacitor, and inductor. Provides additional functionality for representing the network as an equivalent medium.
flex_rf.tidy3d.RotationAroundAxis	class	Rotation of vectors and tensors around a given vector.
flex_rf.tidy3d.RunTimeSpec	class	Defines specification for how long to run a simulation when added to Simulation.run_time.
flex_rf.tidy3d.Scene	class	Contains generic information about the geometry and medium properties common to all types of simulations.
flex_rf.tidy3d.set_logging_file	function	Set a file to write log to, independently from the stdout and stderr output chosen using set_logging_level.
flex_rf.tidy3d.set_logging_level	function	Raise a warning here instead of setting the logging level.
flex_rf.tidy3d.Simulation	class	Custom implementation of Maxwell’s equations which represents the physical model to be solved using the FDTD method.
flex_rf.tidy3d.SimulationData	class	Stores data from a collection of Monitor objects in a Simulation.
flex_rf.tidy3d.SourceTime	class	Base class describing the time dependence of a source.
flex_rf.tidy3d.SpatialDataArray	class	Spatial distribution.
flex_rf.tidy3d.Sphere	class	Spherical geometry.
flex_rf.tidy3d.StablePML	class	Specifies a ‘stable’ PML along a single dimension. This PML deals handles possibly divergent simulations better, but at the expense of more layers.
flex_rf.tidy3d.Staircasing	class	Apply staircasing scheme to material assignment of Yee grids on structure boundaries.
flex_rf.tidy3d.Structure	class	Defines a physical object that interacts with the electromagnetic fields. A Structure is a combination of a material property (AbstractMedium) and a Geometry.
flex_rf.tidy3d.SubpixelSpec	class	Defines specification for subpixel averaging schemes when added to Simulation.subpixel.
flex_rf.tidy3d.SurfaceImpedance	class	Apply 1st order (Leontovich) surface impedance boundary condition to structure made of LossyMetalMedium.
flex_rf.tidy3d.SurfaceImpedanceFitterParam	class	Advanced parameters for fitting surface impedance of a LossyMetalMedium. Internally, the quantity to be fitted is surface impedance divided by -1j * \omega.
flex_rf.tidy3d.TaylorWindow	class	Taylor window with configurable sidelobe suppression and sidelobe count.
flex_rf.tidy3d.TerminalComponentModeler	class	Tool for modeling two-terminal multiport devices and computing port parameters with lumped and wave ports.
flex_rf.tidy3d.TerminalComponentModelerData	class	Data associated with a TerminalComponentModeler simulation run.
flex_rf.tidy3d.TerminalPortDataArray	class	Port parameter matrix elements for terminal-based ports.
flex_rf.tidy3d.TerminalWavePort	class	Class representing a single terminal-driven wave port.
flex_rf.tidy3d.Transformed	class	Class representing a transformed geometry.
flex_rf.tidy3d.TriangleMesh	class	Custom surface geometry given by a triangle mesh, as in the STL file format.
flex_rf.tidy3d.UniformCurrentSource	class	Source in a rectangular volume with uniform time dependence.
flex_rf.tidy3d.UniformGrid	class	Uniform 1D grid. The most standard way to define a simulation is to use a constant grid size in each of the three directions.
flex_rf.tidy3d.VisualizationSpec	class	Defines specification for visualization when used with plotting functions.
flex_rf.tidy3d.VoltageIntegralTypes	attribute
flex_rf.tidy3d.VolumetricAveraging	class	Apply volumetric averaging scheme to material properties of Yee grids on structure boundaries. The material property is averaged in the volume surrounding the Yee grid.
flex_rf.tidy3d.WavePort	class	Class representing a single modal-driven wave port.
flex_rf.tidy3d.YeeGrid	class	Holds the yee grid coordinates for each of the E and H positions.

flex_rf.web

Symbol	Kind	Summary
flex_rf.web.Batch	class	Interface for submitting several Simulation objects to sever.
flex_rf.web.BatchData	class	Holds a collection of SimulationData returned by Batch.
flex_rf.web.Job	class	Interface for managing the running of a Simulation on server.
flex_rf.web.load	function	Download and Load simulation results into SimulationData object.
flex_rf.web.monitor	function	Print the real time task progress until completion.
flex_rf.web.real_cost	function	Get the billed cost for given task after it has been run.
flex_rf.web.run	function	Delegate wrapped execution to tidy3d.web.run lazily.
flex_rf.web.start	function	Start running the simulation associated with task.
flex_rf.web.upload	function	Upload simulation to server, but do not start running Simulation.