tidy3d.components.geometry.Geometry#

class tidy3d.components.geometry.Geometry#

Abstract base class, defines where something exists in space.

Show JSON schema

{
   "title": "Geometry",
   "description": "Abstract base class, defines where something exists in space.\n\nParameters\n----------",
   "type": "object",
   "properties": {
      "type": {
         "title": "Type",
         "default": "Geometry",
         "enum": [
            "Geometry"
         ],
         "type": "string"
      }
   },
   "additionalProperties": false
}

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

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]

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.

inside(x, y, z) → bool#

Returns True if point (x,y,z) is inside volume of Geometry.

Parameters

x (float) – Position of point in x direction.
y (float) – Position of point in y direction.
z (float) – Position of point in z direction.

Returns

True if point (x,y,z) is inside geometry.

Return type

bool

abstract intersections(x: Optional[float] = None, y: Optional[float] = None, z: Optional[float] = None) → List[shapely.geometry.base.BaseGeometry]#

Returns list of shapely geoemtries at 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

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

Return type

List[shapely.geometry.base.BaseGeometry]

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_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

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]

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

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.Array, polar_axis: Literal[0, 1, 2], angle_theta: float, angle_phi: float) → tidy3d.components.types.Array#

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.Array, axis: Tuple[float, float, float], angle: float) → tidy3d.components.types.Array#

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).

static sph_2_car(r: float, theta: float, phi: float) → Tuple[float, float, float]#

Convert spherical to Cartesian coordinates.

Parameters

r (float) – radius.
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]

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.
Return type: float

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]

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.
Return type: float

property bounding_box#

Returns Box representation of the bounding box of a Geometry.

Returns: Geometric object representing bounding box.
Return type: Box

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

Returns bounding box min and max coordinates..

Returns: Min and max bounds packaged as (minx, miny, minz), (maxx, maxy, maxz).
Return type: Tuple[float, float, float], Tuple[float, float float]

property plot_params#: Default parameters for plotting a Geometry object.