Bases: `tidy3d.plugins.adjoint.components.geometry.JaxGeometry`, `tidy3d.components.geometry.PolySlab`, `tidy3d.plugins.adjoint.components.base.JaxObject`

A `PolySlab` registered with jax.

Parameters
• axis (Literal[0, 1, 2] = 2) – Specifies dimension of the planar axis (0,1,2) -> (x,y,z).

• sidewall_angle (ConstrainedFloatValue = 0.0) – [units = rad]. Angle of the sidewall. `sidewall_angle=0` (default) specifies a vertical wall; `0<sidewall_angle<np.pi/2` specifies a shrinking cross section along the `axis` direction; and `-np.pi/2<sidewall_angle<0` specifies an expanding cross section along the `axis` direction.

• reference_plane (Literal['bottom', 'middle', 'top'] = middle) – The position of the plane where the supplied cross section are defined. The plane is perpendicular to the `axis`. The plane is located at the `bottom`, `middle`, or `top` of the geometry with respect to the axis. E.g. if `axis=1`, `bottom` refers to the negative side of the y-axis, and `top` refers to the positive side of the y-axis.

• slab_bounds (Tuple[float, float]) – [units = um]. Minimum and maximum positions of the slab along axis dimension.

• dilation (float = 0.0) – [units = um]. Dilation of the supplied polygon by shifting each edge along its normal outwards direction by a distance; a negative value corresponds to erosion.

• vertices (Tuple[Tuple[Union[float, tidy3d.plugins.adjoint.components.types.NumpyArrayType, jax.Array, jax._src.interpreters.ad.JVPTracer], Union[float, tidy3d.plugins.adjoint.components.types.NumpyArrayType, jax.Array, jax._src.interpreters.ad.JVPTracer]], ...]) – [units = um]. List of (d1, d2) defining the 2 dimensional positions of the polygon face vertices at the `reference_plane`. The index of dimension should be in the ascending order: e.g. if the slab normal axis is `axis=y`, the coordinate of the vertices will be in (x, z)

Show JSON schema
```{
"title": "JaxPolySlab",
"description": "A :class:`.PolySlab` registered with jax.\n\nParameters\n----------\naxis : Literal[0, 1, 2] = 2\n    Specifies dimension of the planar axis (0,1,2) -> (x,y,z).\nsidewall_angle : ConstrainedFloatValue = 0.0\n    [units = rad].  Angle of the sidewall. ``sidewall_angle=0`` (default) specifies a vertical wall; ``0<sidewall_angle<np.pi/2`` specifies a shrinking cross section along the ``axis`` direction; and ``-np.pi/2<sidewall_angle<0`` specifies an expanding cross section along the ``axis`` direction.\nreference_plane : Literal['bottom', 'middle', 'top'] = middle\n    The position of the plane where the supplied cross section are defined. The plane is perpendicular to the ``axis``. The plane is located at the ``bottom``, ``middle``, or ``top`` of the geometry with respect to the axis. E.g. if ``axis=1``, ``bottom`` refers to the negative side of the y-axis, and ``top`` refers to the positive side of the y-axis.\nslab_bounds : Tuple[float, float]\n    [units = um].  Minimum and maximum positions of the slab along axis dimension.\ndilation : float = 0.0\n    [units = um].  Dilation of the supplied polygon by shifting each edge along its normal outwards direction by a distance; a negative value corresponds to erosion.\nvertices : Tuple[Tuple[Union[float, tidy3d.plugins.adjoint.components.types.NumpyArrayType, jax.Array, jax._src.interpreters.ad.JVPTracer], Union[float, tidy3d.plugins.adjoint.components.types.NumpyArrayType, jax.Array, jax._src.interpreters.ad.JVPTracer]], ...]\n    [units = um].  List of (d1, d2) defining the 2 dimensional positions of the polygon face vertices at the ``reference_plane``. The index of dimension should be in the ascending order: e.g. if the slab normal axis is ``axis=y``, the coordinate of the vertices will be in (x, z)",
"type": "object",
"properties": {
"type": {
"title": "Type",
"default": "JaxPolySlab",
"enum": [
"JaxPolySlab"
],
"type": "string"
},
"axis": {
"title": "Axis",
"description": "Specifies dimension of the planar axis (0,1,2) -> (x,y,z).",
"default": 2,
"enum": [
0,
1,
2
],
"type": "integer"
},
"sidewall_angle": {
"title": "Sidewall angle",
"description": "Angle of the sidewall. ``sidewall_angle=0`` (default) specifies a vertical wall; ``0<sidewall_angle<np.pi/2`` specifies a shrinking cross section along the ``axis`` direction; and ``-np.pi/2<sidewall_angle<0`` specifies an expanding cross section along the ``axis`` direction.",
"default": 0.0,
"exclusiveMinimum": -1.5707963267948966,
"exclusiveMaximum": 1.5707963267948966,
"type": "number"
},
"reference_plane": {
"title": "Reference plane for cross section",
"description": "The position of the plane where the supplied cross section are defined. The plane is perpendicular to the ``axis``. The plane is located at the ``bottom``, ``middle``, or ``top`` of the geometry with respect to the axis. E.g. if ``axis=1``, ``bottom`` refers to the negative side of the y-axis, and ``top`` refers to the positive side of the y-axis.",
"default": "middle",
"enum": [
"bottom",
"middle",
"top"
],
"type": "string"
},
"slab_bounds": {
"title": "Slab Bounds",
"description": "Minimum and maximum positions of the slab along axis dimension.",
"units": "um",
"type": "array",
"minItems": 2,
"maxItems": 2,
"items": [
{
"type": "number"
},
{
"type": "number"
}
]
},
"dilation": {
"title": "Dilation",
"description": "Dilation of the supplied polygon by shifting each edge along its normal outwards direction by a distance; a negative value corresponds to erosion.",
"default": 0.0,
"units": "um",
"type": "number"
},
"vertices": {
"title": "Vertices",
"description": "List of (d1, d2) defining the 2 dimensional positions of the polygon face vertices at the ``reference_plane``. The index of dimension should be in the ascending order: e.g. if the slab normal axis is ``axis=y``, the coordinate of the vertices will be in (x, z)",
"units": "um",
"jax_field": true,
"type": "array",
"items": {
"type": "array",
"minItems": 2,
"maxItems": 2,
"items": [
{
"anyOf": [
{
"type": "number"
},
{
"title": "npdarray",
"type": "numpy.ndarray"
},
{
"title": "DeviceArray",
"type": "jaxlib.xla_extension.DeviceArray"
},
{
"title": "JVPTracer",
}
]
},
{
"anyOf": [
{
"type": "number"
},
{
"title": "npdarray",
"type": "numpy.ndarray"
},
{
"title": "DeviceArray",
"type": "jaxlib.xla_extension.DeviceArray"
},
{
"title": "JVPTracer",
}
]
}
]
}
}
},
"required": [
"slab_bounds",
"vertices"
],
}
```

attribute axis: Axis = 2#

Specifies dimension of the planar axis (0,1,2) -> (x,y,z).

attribute dilation: float = 0.0#

Dilation of the supplied polygon by shifting each edge along its normal outwards direction by a distance; a negative value corresponds to erosion.

Validated by
• `no_dilation`

attribute reference_plane: PlanePosition = 'middle'#

The position of the plane where the supplied cross section are defined. The plane is perpendicular to the `axis`. The plane is located at the `bottom`, `middle`, or `top` of the geometry with respect to the axis. E.g. if `axis=1`, `bottom` refers to the negative side of the y-axis, and `top` refers to the positive side of the y-axis.

attribute sidewall_angle: float = 0.0#

Angle of the sidewall. `sidewall_angle=0` (default) specifies a vertical wall; `0<sidewall_angle<np.pi/2` specifies a shrinking cross section along the `axis` direction; and `-np.pi/2<sidewall_angle<0` specifies an expanding cross section along the `axis` direction.

Constraints
• exclusiveMinimum = -1.5707963267948966

• exclusiveMaximum = 1.5707963267948966

Validated by
• `no_sidewall`

attribute slab_bounds: Tuple[float, float] [Required]#

Minimum and maximum positions of the slab along axis dimension.

Validated by
• `slab_bounds_order`

attribute vertices: Tuple[Tuple[JaxFloat, JaxFloat], ...] [Required]#

List of (d1, d2) defining the 2 dimensional positions of the polygon face vertices at the `reference_plane`. The index of dimension should be in the ascending order: e.g. if the slab normal axis is `axis=y`, the coordinate of the vertices will be in (x, z)

Validated by
• `convert_to_numpy`

• `convert_to_numpy`

• `correct_shape`

• `correct_shape`

• `limit_number_of_vertices`

• `no_complex_self_intersecting_polygon_at_reference_plane`

• `no_complex_self_intersecting_polygon_at_reference_plane`

• `no_self_intersecting_polygon_during_extrusion`

• `no_self_intersecting_polygon_during_extrusion`

• `to_list`

• `validator`

add_ax_labels_lims(axis: Literal[0, 1, 2], ax: matplotlib.axes._axes.Axes, buffer: float = 0.3) matplotlib.axes._axes.Axes#

Sets the x,y labels based on `axis` and the extends based on `self.bounds`.

Parameters
• axis (int) – Integer index into ‘xyz’ (0,1,2).

• ax (matplotlib.axes._subplots.Axes) – Matplotlib axes to add labels and limits on.

• buffer (float = 0.3) – Amount of space to place around the limits on the + and - sides.

Returns

The supplied or created matplotlib axes.

Return type

matplotlib.axes._subplots.Axes

Automatically place “type” field with model name in the model field dictionary.

static array_to_vertices(arr_vertices: numpy.ndarray) tidy3d.components.types.ArrayLike_dtype=<class 'float'>_ndim=2#

Converts a numpy array of vertices to a list of tuples.

static bounds_intersection(bounds1: Tuple[Tuple[float, float, float], Tuple[float, float, float]], bounds2: Tuple[Tuple[float, float, float], Tuple[float, float, float]]) Tuple[Tuple[float, float, float], Tuple[float, float, float]]#

Return the bounds that are the intersection of two bounds.

static car_2_sph(x: float, y: float, z: float) Tuple[float, float, float]#

Convert Cartesian to spherical coordinates.

Parameters
• x (float) – x coordinate relative to `local_origin`.

• y (float) – y coordinate relative to `local_origin`.

• z (float) – z coordinate relative to `local_origin`.

Returns

r, theta, and phi coordinates relative to `local_origin`.

Return type

Tuple[float, float, float]

static car_2_sph_field(f_x: float, f_y: float, f_z: float, theta: float, phi: float) Tuple[complex, complex, complex]#

Convert vector field components in cartesian coordinates to spherical.

Parameters
• f_x (float) – x component of the vector field.

• f_y (float) – y component of the vector fielf.

• f_z (float) – z component of the vector field.

• theta (float) – polar angle (rad) of location of the vector field.

• phi (float) – azimuthal angle (rad) of location of the vector field.

Returns

radial (s), elevation (theta), and azimuthal (phi) components of the vector field in spherical coordinates.

Return type

Tuple[float, float, float]

Get the (x,y,z) components of E_fwd * E_adj and D_fwd * D_adj fields in the domain.

classmethod construct(_fields_set: Optional[SetStr] = None, **values: Any) Model#

Creates a new model setting __dict__ and __fields_set__ from trusted or pre-validated data. Default values are respected, but no other validation is performed. Behaves as if Config.extra = ‘allow’ was set since it adds all passed values

copy(**kwargs) #

Copy a Tidy3dBaseModel. With `deep=True` as default.

dict(*, include: Optional[Union[AbstractSetIntStr, MappingIntStrAny]] = None, exclude: Optional[Union[AbstractSetIntStr, MappingIntStrAny]] = None, by_alias: bool = False, skip_defaults: Optional[bool] = None, exclude_unset: bool = False, exclude_defaults: bool = False, exclude_none: bool = False) DictStrAny#

Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.

classmethod dict_from_file(fname: str, group_path: Optional[str] = None) dict#

Loads a dictionary containing the model from a .yaml, .json, or .hdf5 file.

Parameters
• fname (str) – Full path to the .yaml or .json file to load the `Tidy3dBaseModel` from.

• group_path (str, optional) – Path to a group inside the file to use as the base level.

Returns

A dictionary containing the model.

Return type

dict

Example

```>>> simulation = Simulation.from_file(fname='folder/sim.json')
```
classmethod dict_from_hdf5(fname: str, group_path: str = '') dict#

Loads a dictionary containing the model contents from a .hdf5 file.

Parameters
• fname (str) – Full path to the .hdf5 file to load the `Tidy3dBaseModel` from.

• group_path (str, optional) – Path to a group inside the file to selectively load a sub-element of the model only.

Returns

Dictionary containing the model.

Return type

dict

Example

```>>> sim_dict = Simulation.dict_from_hdf5(fname='folder/sim.hdf5')
```
classmethod dict_from_json(fname: str) dict#

Load dictionary of the model from a .json file.

Parameters

fname (str) – Full path to the .json file to load the `Tidy3dBaseModel` from.

Returns

A dictionary containing the model.

Return type

dict

Example

```>>> sim_dict = Simulation.dict_from_json(fname='folder/sim.json')
```
classmethod dict_from_yaml(fname: str) dict#

Load dictionary of the model from a .yaml file.

Parameters

fname (str) – Full path to the .yaml file to load the `Tidy3dBaseModel` from.

Returns

A dictionary containing the model.

Return type

dict

Example

```>>> sim_dict = Simulation.dict_from_yaml(fname='folder/sim.yaml')
```
edge_contrib(vertex_grad: Tuple[float, float], vertex_stat: Tuple[float, float], is_next: bool, e_mult_xyz: Tuple[Dict[str, tidy3d.components.data.data_array.ScalarFieldDataArray]], d_mult_xyz: Tuple[Dict[str, tidy3d.components.data.data_array.ScalarFieldDataArray]], sim_bounds: Tuple[Tuple[float, float, float], Tuple[float, float, float]], wvl_mat: float, eps_out: complex, eps_in: complex) Tuple[float, float]#

classmethod evaluate_inf_shape(shape: shapely.geometry.base.BaseGeometry) shapely.geometry.base.BaseGeometry#

Returns a copy of shape with inf vertices replaced by large numbers if polygon.

classmethod from_file(fname: str, group_path: Optional[str] = None, **parse_obj_kwargs) #

Loads a `Tidy3dBaseModel` from .yaml, .json, or .hdf5 file.

Parameters
• fname (str) – Full path to the .yaml or .json file to load the `Tidy3dBaseModel` from.

• group_path (str, optional) – Path to a group inside the file to use as the base level. Only for `.hdf5` files. Starting / is optional.

• **parse_obj_kwargs – Keyword arguments passed to either pydantic’s `parse_obj` function when loading model.

Returns

An instance of the component class calling load.

Return type

`Tidy3dBaseModel`

Example

```>>> simulation = Simulation.from_file(fname='folder/sim.json')
```
classmethod from_gds(gds_cell, axis: Literal[0, 1, 2], slab_bounds: Tuple[float, float], gds_layer: int, gds_dtype: Optional[int] = None, gds_scale: pydantic.types.PositiveFloat = 1.0, dilation: float = 0.0, sidewall_angle: float = 0, reference_plane: Literal['bottom', 'middle', 'top'] = 'middle') #

Import `PolySlab` from a `gdstk.Cell` or a `gdspy.Cell`.

Parameters
• gds_cell (Union[gdstk.Cell, gdspy.Cell]) – `gdstk.Cell` or `gdspy.Cell` containing 2D geometric data.

• axis (int) – Integer index into the polygon’s slab axis. (0,1,2) -> (x,y,z).

• slab_bounds (Tuple[float, float]) – Minimum and maximum positions of the slab along `axis`.

• gds_layer (int) – Layer index in the `gds_cell`.

• gds_dtype (int = None) – Data-type index in the `gds_cell`. If `None`, imports all data for this layer into the returned list.

• gds_scale (float = 1.0) – Length scale used in GDS file in units of MICROMETER. For example, if gds file uses nanometers, set `gds_scale=1e-3`. Must be positive.

• dilation (float = 0.0) – Dilation of the polygon in the base by shifting each edge along its normal outwards direction by a distance; a negative value corresponds to erosion.

• sidewall_angle (float = 0) – Angle of the sidewall. `sidewall_angle=0` (default) specifies vertical wall, while `0<sidewall_angle<np.pi/2` for the base to be larger than the top.

• reference_plane (PlanePosition = "middle") – The position of the GDS layer. It can be at the `bottom`, `middle`, or `top` of the PolySlab. E.g. if `axis=1`, `bottom` refers to the negative side of y-axis, and `top` refers to the positive side of y-axis.

Returns

List of `PolySlab` objects sharing `axis` and slab bound properties.

Return type

List[`PolySlab`]

classmethod from_hdf5(fname: str, group_path: str = '', **parse_obj_kwargs) #

Loads `Tidy3dBaseModel` instance to .hdf5 file.

Parameters
• fname (str) – Full path to the .hdf5 file to load the `Tidy3dBaseModel` from.

• group_path (str, optional) – Path to a group inside the file to selectively load a sub-element of the model only. Starting / is optional.

• **parse_obj_kwargs – Keyword arguments passed to pydantic’s `parse_obj` method.

Example

```>>> simulation = Simulation.from_file(fname='folder/sim.hdf5')
```
classmethod from_json(fname: str, **parse_obj_kwargs) #

Load a `Tidy3dBaseModel` from .json file.

Parameters

fname (str) – Full path to the .json file to load the `Tidy3dBaseModel` from.

Returns

• `Tidy3dBaseModel` – An instance of the component class calling load.

• **parse_obj_kwargs – Keyword arguments passed to pydantic’s `parse_obj` method.

Example

```>>> simulation = Simulation.from_json(fname='folder/sim.json')
```
classmethod from_orm(obj: Any) Model#

Convert `Tidy3dBaseModel` instance to `JaxObject`.

classmethod from_yaml(fname: str, **parse_obj_kwargs) #

Loads `Tidy3dBaseModel` from .yaml file.

Parameters
• fname (str) – Full path to the .yaml file to load the `Tidy3dBaseModel` from.

• **parse_obj_kwargs – Keyword arguments passed to pydantic’s `parse_obj` method.

Returns

An instance of the component class calling from_yaml.

Return type

`Tidy3dBaseModel`

Example

```>>> simulation = Simulation.from_yaml(fname='folder/sim.yaml')
```
classmethod generate_docstring() str#

Generates a docstring for a Tidy3D mode and saves it to the __doc__ of the class.

classmethod get_jax_field_names() List[str]#

Returns list of field names that have a `jax_field_type`.

classmethod get_sub_model(group_path: str, model_dict: dict | list) dict#

Get the sub model for a given group path.

static get_tuple_group_name(index: int) str#

Get the group name of a tuple element.

static get_tuple_index(key_name: str) int#

Get the index into the tuple based on its group name.

help(methods: bool = False) None#

Prints message describing the fields and methods of a `Tidy3dBaseModel`.

Parameters

methods (bool = False) – Whether to also print out information about object’s methods.

Example

```>>> simulation.help(methods=True)
```
inside(x: numpy.ndarray[float], y: numpy.ndarray[float], z: numpy.ndarray[float]) numpy.ndarray[bool]#

For input arrays `x`, `y`, `z` of arbitrary but identical shape, return an array with the same shape which is `True` for every point in zip(x, y, z) that is inside the volume of the `Geometry`, and `False` otherwise.

Parameters
• x (np.ndarray[float]) – Array of point positions in x direction.

• y (np.ndarray[float]) – Array of point positions in y direction.

• z (np.ndarray[float]) – Array of point positions in z direction.

Returns

`True` for every point that is inside the geometry.

Return type

np.ndarray[bool]

inside_meshgrid(x: numpy.ndarray[float], y: numpy.ndarray[float], z: numpy.ndarray[float]) numpy.ndarray[bool]#

Perform `self.inside` on a set of sorted 1D coordinates. Applies meshgrid to the supplied coordinates before checking inside.

Parameters
• x (np.ndarray[float]) – 1D array of point positions in x direction.

• y (np.ndarray[float]) – 1D array of point positions in y direction.

• z (np.ndarray[float]) – 1D array of point positions in z direction.

Returns

Array with shape `(x.size, y.size, z.size)`, which is `True` for every point that is inside the geometry.

Return type

np.ndarray[bool]

intersections_2dbox(plane: tidy3d.components.geometry.Box) List[shapely.geometry.base.BaseGeometry]#

Returns list of shapely geomtries representing the intersections of the geometry with a 2D box.

Returns

List of 2D shapes that intersect plane. For more details refer to Shapely’s Documentaton.

Return type

List[shapely.geometry.base.BaseGeometry]

intersections_plane(x: Optional[float] = None, y: Optional[float] = None, z: Optional[float] = None)#

Returns shapely geometry at plane specified by one non None value of x,y,z.

Parameters
• x (float) – Position of plane in x direction, only one of x,y,z can be specified to define plane.

• y (float) – Position of plane in y direction, only one of x,y,z can be specified to define plane.

• z (float) – Position of plane in z direction, only one of x,y,z can be specified to define plane.

Returns

• List[shapely.geometry.base.BaseGeometry] – List of 2D shapes that intersect plane. For more details refer to

intersects(other) bool#

Returns `True` if two `Geometry` have intersecting .bounds.

Parameters

other (`Geometry`) – Geometry to check intersection with.

Returns

Whether the rectangular bounding boxes of the two geometries intersect.

Return type

bool

intersects_axis_position(axis: int, position: float) bool#

Whether self intersects plane specified by a given position along a normal axis.

Parameters
• axis (int = None) – Axis nomral to the plane.

• position (float = None) – Position of plane along the normal axis.

Returns

Whether this geometry intersects the plane.

Return type

bool

intersects_plane(x: Optional[float] = None, y: Optional[float] = None, z: Optional[float] = None) bool#

Whether self intersects plane specified by one non-None value of x,y,z.

Parameters
• x (float = None) – Position of plane in x direction, only one of x,y,z can be specified to define plane.

• y (float = None) – Position of plane in y direction, only one of x,y,z can be specified to define plane.

• z (float = None) – Position of plane in z direction, only one of x,y,z can be specified to define plane.

Returns

Whether this geometry intersects the plane.

Return type

bool

json(*, include: Optional[Union[AbstractSetIntStr, MappingIntStrAny]] = None, exclude: Optional[Union[AbstractSetIntStr, MappingIntStrAny]] = None, by_alias: bool = False, skip_defaults: Optional[bool] = None, exclude_unset: bool = False, exclude_defaults: bool = False, exclude_none: bool = False, encoder: Optional[Callable[[Any], Any]] = None, models_as_dict: bool = True, **dumps_kwargs: Any) unicode#

Generate a JSON representation of the model, include and exclude arguments as per dict().

encoder is an optional function to supply as default to json.dumps(), other arguments as per json.dumps().

static kspace_2_sph(ux: float, uy: float, axis: Literal[0, 1, 2]) Tuple[float, float]#

Convert normalized k-space coordinates to angles.

Parameters
• ux (float) – normalized kx coordinate.

• uy (float) – normalized ky coordinate.

• axis (int) – axis along which the observation plane is oriented.

Returns

theta and phi coordinates relative to `local_origin`.

Return type

Tuple[float, float]

Return gradient monitor associated with this object.

classmethod map_to_coords(func: Callable[[float], float], shape: shapely.geometry.base.BaseGeometry) shapely.geometry.base.BaseGeometry#

Maps a function to each coordinate in shape.

Parameters
• func (Callable[[float], float]) – Takes old coordinate and returns new coordinate.

• shape (shapely.geometry.base.BaseGeometry) – The shape to map this function to.

Returns

A new copy of the input shape with the mapping applied to the coordinates.

Return type

shapely.geometry.base.BaseGeometry

classmethod parse_file(path: Union[str, pathlib.Path], *, content_type: unicode = None, encoding: unicode = 'utf8', proto: pydantic.parse.Protocol = None, allow_pickle: bool = False) Model#
classmethod parse_obj(obj: Any) Model#
classmethod parse_raw(b: Union[str, bytes], *, content_type: unicode = None, encoding: unicode = 'utf8', proto: pydantic.parse.Protocol = None, allow_pickle: bool = False) Model#
static parse_xyz_kwargs(**xyz) Tuple[Literal[0, 1, 2], float]#

Turns x,y,z kwargs into index of the normal axis and position along that axis.

Parameters
• x (float = None) – Position of plane in x direction, only one of x,y,z can be specified to define plane.

• y (float = None) – Position of plane in y direction, only one of x,y,z can be specified to define plane.

• z (float = None) – Position of plane in z direction, only one of x,y,z can be specified to define plane.

Returns

Index into xyz axis (0,1,2) and position along that axis.

Return type

int, float

plot(x: float = None, y: float = None, z: float = None, ax: matplotlib.axes._axes.Axes = None, **patch_kwargs) matplotlib.axes._axes.Axes#

Plot geometry cross section at single (x,y,z) coordinate.

Parameters
• x (float = None) – Position of plane in x direction, only one of x,y,z can be specified to define plane.

• y (float = None) – Position of plane in y direction, only one of x,y,z can be specified to define plane.

• z (float = None) – Position of plane in z direction, only one of x,y,z can be specified to define plane.

• ax (matplotlib.axes._subplots.Axes = None) – Matplotlib axes to plot on, if not specified, one is created.

• **patch_kwargs – Optional keyword arguments passed to the matplotlib patch plotting of structure. For details on accepted values, refer to Matplotlib’s documentation.

Returns

The supplied or created matplotlib axes.

Return type

matplotlib.axes._subplots.Axes

plot_shape(shape: shapely.geometry.base.BaseGeometry, plot_params: tidy3d.components.viz.PlotParams, ax: matplotlib.axes._axes.Axes) matplotlib.axes._axes.Axes#

Defines how a shape is plotted on a matplotlib axes.

static pop_axis(coord: Tuple[Any, Any, Any], axis: int) Tuple[Any, Tuple[Any, Any]]#

Separates coordinate at `axis` index from coordinates on the plane tangent to `axis`.

Parameters
• coord (Tuple[Any, Any, Any]) – Tuple of three values in original coordinate system.

• axis (int) – Integer index into ‘xyz’ (0,1,2).

Returns

The input coordinates are separated into the one along the axis provided and the two on the planar coordinates, like `axis_coord, (planar_coord1, planar_coord2)`.

Return type

Any, Tuple[Any, Any]

reflect_points(points: tidy3d.components.types.ArrayLike_dtype=<class 'float'>_ndim=3, polar_axis: typing.Literal[0, 1, 2], angle_theta: float, angle_phi: float) tidy3d.components.types.ArrayLike_dtype=<class 'float'>_ndim=3#

Reflect a set of points in 3D at a plane passing through the coordinate origin defined and normal to a given axis defined in polar coordinates (theta, phi) w.r.t. the `polar_axis` which can be 0, 1, or 2.

Parameters
• points (ArrayLike[float]) – Array of shape `(3, ...)`.

• polar_axis (Axis) – Cartesian axis w.r.t. which the normal axis angles are defined.

• angle_theta (float) – Polar angle w.r.t. the polar axis.

• angle_phi (float) – Azimuth angle around the polar axis.

static rotate_points(points: tidy3d.components.types.ArrayLike_dtype=<class 'float'>_ndim=3, axis: typing.Tuple[float, float, float], angle: float) tidy3d.components.types.ArrayLike_dtype=<class 'float'>_ndim=3#

Rotate a set of points in 3D.

Parameters
• points (ArrayLike[float]) – Array of shape `(3, ...)`.

• axis (Coordinate) – Axis of rotation

• angle (float) – Angle of rotation counter-clockwise around the axis (rad).

classmethod schema(by_alias: bool = True, ref_template: unicode = '#/definitions/{model}') DictStrAny#
classmethod schema_json(*, by_alias: bool = True, ref_template: unicode = '#/definitions/{model}', **dumps_kwargs: Any) unicode#
static sph_2_car(r: float, theta: float, phi: float) Tuple[float, float, float]#

Convert spherical to Cartesian coordinates.

Parameters

• theta (float) – polar angle (rad) downward from x=y=0 line.

• phi (float) – azimuthal (rad) angle from y=z=0 line.

Returns

x, y, and z coordinates relative to `local_origin`.

Return type

Tuple[float, float, float]

static sph_2_car_field(f_r: float, f_theta: float, f_phi: float, theta: float, phi: float) Tuple[complex, complex, complex]#

Convert vector field components in spherical coordinates to cartesian.

Parameters
• f_r (float) – radial component of the vector field.

• f_theta (float) – polar angle component of the vector fielf.

• f_phi (float) – azimuthal angle component of the vector field.

• theta (float) – polar angle (rad) of location of the vector field.

• phi (float) – azimuthal angle (rad) of location of the vector field.

Returns

x, y, and z components of the vector field in cartesian coordinates.

Return type

Tuple[float, float, float]

Stores the gradient of the vertices given forward and adjoint field data.

classmethod strip_coords(shape: shapely.geometry.base.BaseGeometry) Tuple[List[float], List[float], Tuple[List[float], List[float]]]#

Get the exterior and list of interior xy coords for a shape.

Parameters

shape (shapely.geometry.base.BaseGeometry) – The shape that you want to strip coordinates from.

Returns

List of exterior xy coordinates and a list of lists of the interior xy coordinates of the “holes” in the shape.

Return type

Tuple[List[float], List[float], Tuple[List[float], List[float]]]

surface_area(bounds: Optional[Tuple[Tuple[float, float, float], Tuple[float, float, float]]] = None)#

Returns object’s surface area with optional bounds.

Parameters

bounds (Tuple[Tuple[float, float, float], Tuple[float, float, float]] = None) – Min and max bounds packaged as `(minx, miny, minz), (maxx, maxy, maxz)`.

Returns

Surface area in um^2.

Return type

float

to_file(fname: str) None#

Exports `Tidy3dBaseModel` instance to .yaml, .json, or .hdf5 file

Parameters

fname (str) – Full path to the .yaml or .json file to save the `Tidy3dBaseModel` to.

Example

```>>> simulation.to_file(fname='folder/sim.json')
```
to_hdf5(fname: str) None#

Exports `Tidy3dBaseModel` instance to .hdf5 file.

Parameters

fname (str) – Full path to the .hdf5 file to save the `Tidy3dBaseModel` to.

Example

```>>> simulation.to_hdf5(fname='folder/sim.hdf5')
```
to_json(fname: str) None#

Exports `Tidy3dBaseModel` instance to .json file

Parameters

fname (str) – Full path to the .json file to save the `Tidy3dBaseModel` to.

Example

```>>> simulation.to_json(fname='folder/sim.json')
```
to_tidy3d() #

Convert `JaxGeometry` instance to `Geometry`

to_yaml(fname: str) None#

Exports `Tidy3dBaseModel` instance to .yaml file.

Parameters

fname (str) – Full path to the .yaml file to save the `Tidy3dBaseModel` to.

Example

```>>> simulation.to_yaml(fname='folder/sim.yaml')
```
tree_flatten() Tuple[list, dict]#

How to flatten a `JaxObject` instance into a pytree.

classmethod tree_unflatten(aux_data: dict, children: list) tidy3d.plugins.adjoint.components.base.JaxObject#

How to unflatten a pytree into a `JaxObject` instance.

classmethod tuple_to_dict(tuple_values: tuple) dict#

How we generate a dictionary mapping new keys to tuple values for hdf5.

static unpop_axis(ax_coord: Any, plane_coords: Tuple[Any, Any], axis: int) Tuple[Any, Any, Any]#

Combine coordinate along axis with coordinates on the plane tangent to the axis.

Parameters
• ax_coord (Any) – Value along axis direction.

• plane_coords (Tuple[Any, Any]) – Values along ordered planar directions.

• axis (int) – Integer index into ‘xyz’ (0,1,2).

Returns

The three values in the xyz coordinate system.

Return type

Tuple[Any, Any, Any]

classmethod update_forward_refs(**localns: Any) None#

Try to update ForwardRefs on fields based on this Model, globalns and localns.

updated_copy(**kwargs) #

Make copy of a component instance with `**kwargs` indicating updated field values.

classmethod validate(value: Any) Model#
vertex_vjp(i_vertex, e_mult_xyz: Tuple[Dict[str, tidy3d.components.data.data_array.ScalarFieldDataArray]], d_mult_xyz: Tuple[Dict[str, tidy3d.components.data.data_array.ScalarFieldDataArray]], sim_bounds: Tuple[Tuple[float, float, float], Tuple[float, float, float]], wvl_mat: float, eps_out: complex, eps_in: complex)#

Compute the vjp for every vertex.

static vertices_to_array(vertices_tuple: tidy3d.components.types.ArrayLike_dtype=<class 'float'>_ndim=2) numpy.ndarray#

Converts a list of tuples (vertices) to a numpy array.

volume(bounds: Optional[Tuple[Tuple[float, float, float], Tuple[float, float, float]]] = None)#

Returns object’s volume with optional bounds.

Parameters

bounds (Tuple[Tuple[float, float, float], Tuple[float, float, float]] = None) – Min and max bounds packaged as `(minx, miny, minz), (maxx, maxy, maxz)`.

Returns

Volume in um^3.

Return type

float

property base_polygon: numpy.ndarray#

The polygon at the base, derived from the `middle_polygon`.

Returns

The vertices of the polygon at the base.

Return type

ArrayLike[float, float]

property bound_center: Tuple[float, float, float]#

Size of the bounding box of this geometry.

property bound_size: Tuple[float, float, float]#

Size of the bounding box of this geometry.

property bounding_box#

Returns `Box` representation of the bounding box of a `Geometry`.

Returns

Geometric object representing bounding box.

Return type

`Box`

property bounds: Tuple[Tuple[float, float, float], Tuple[float, float, float]]#

Returns bounding box min and max coordinates. The dilation and slant angle are not taken into account exactly for speed. Instead, the polygon may be slightly smaller than the returned bounds, but it should always be fully contained.

Returns

Min and max bounds packaged as `(minx, miny, minz), (maxx, maxy, maxz)`.

Return type

Tuple[float, float, float], Tuple[float, float float]

property center_axis: float#

Gets the position of the center of the geometry in the out of plane dimension.

property finite_length_axis: float#

Gets the length of the geometry along the out of plane dimension. If the length is td.inf, return `LARGE_NUMBER`

property is_ccw: bool#

Is this PolySlab CCW oriented?

property length_axis: float#

Gets the length of the geometry along the out of plane dimension.

property middle_polygon: numpy.ndarray#

The polygon at the middle.

Returns

The vertices of the polygon at the middle.

Return type

ArrayLike[float, float]

property plot_params#

Default parameters for plotting a Geometry object.

property reference_polygon: numpy.ndarray#

The polygon at the reference plane.

Returns

The vertices of the polygon at the reference plane.

Return type

ArrayLike[float, float]

property top_polygon: numpy.ndarray#

The polygon at the top, derived from the `middle_polygon`.

Returns

The vertices of the polygon at the top.

Return type

ArrayLike[float, float]