tidy3d.ModeSolverData
tidy3d.ModeSolverData#
- class tidy3d.ModeSolverData#
Bases:
tidy3d.components.data.dataset.ModeSolverDataset,tidy3d.components.data.monitor_data.ElectromagneticFieldDataData associated with a
ModeSolverMonitor: scalar components of E and H fields.- Parameters
Ex (ScalarModeFieldDataArray) – Spatial distribution of the x-component of the electric field of the mode.
Ey (ScalarModeFieldDataArray) – Spatial distribution of the y-component of the electric field of the mode.
Ez (ScalarModeFieldDataArray) – Spatial distribution of the z-component of the electric field of the mode.
Hx (ScalarModeFieldDataArray) – Spatial distribution of the x-component of the magnetic field of the mode.
Hy (ScalarModeFieldDataArray) – Spatial distribution of the y-component of the magnetic field of the mode.
Hz (ScalarModeFieldDataArray) – Spatial distribution of the z-component of the magnetic field of the mode.
monitor (ModeSolverMonitor) – symmetry : Tuple[Literal[0, -1, 1], Literal[0, -1, 1], Literal[0, -1, 1]] = (0, 0, 0) Symmetry eigenvalues of the original simulation in x, y, and z.
symmetry_center (Optional[Tuple[float, float, float]] = None) – Center of the symmetry planes of the original simulation in x, y, and z. Required only if any of the
symmetryfield are non-zero.grid_expanded (Optional[Grid] = None) –
Gridon which the symmetry will be expanded. Required only if any of thesymmetryfield are non-zero.grid_primal_correction (Union[float, FreqDataArray, TimeDataArray, FreqModeDataArray] = 1.0) – Correction factor that needs to be applied for data corresponding to a 2D monitor to take into account the finite grid in the normal direction in the simulation in which the data was computed. The factor is applied to fields defined on the primal grid locations along the normal direction.
grid_dual_correction (Union[float, FreqDataArray, TimeDataArray, FreqModeDataArray] = 1.0) – Correction factor that needs to be applied for data corresponding to a 2D monitor to take into account the finite grid in the normal direction in the simulation in which the data was computed. The factor is applied to fields defined on the dual grid locations along the normal direction.
n_complex (ModeIndexDataArray) – Complex-valued effective propagation constants associated with the mode.
Example
>>> from tidy3d import ModeSpec >>> from tidy3d import ScalarModeFieldDataArray, ModeIndexDataArray >>> x = [-1,1] >>> y = [0] >>> z = [-3,-1,1,3] >>> f = [2e14, 3e14] >>> mode_index = np.arange(5) >>> field_coords = dict(x=x, y=y, z=z, f=f, mode_index=mode_index) >>> field = ScalarModeFieldDataArray((1+1j)*np.random.random((2,1,4,2,5)), coords=field_coords) >>> index_coords = dict(f=f, mode_index=mode_index) >>> index_data = ModeIndexDataArray((1+1j) * np.random.random((2,5)), coords=index_coords) >>> monitor = ModeSolverMonitor( ... size=(2,0,6), ... freqs=[2e14, 3e14], ... mode_spec=ModeSpec(num_modes=5), ... name='mode_solver', ... ) >>> data = ModeSolverData( ... monitor=monitor, ... Ex=field, ... Ey=field, ... Ez=field, ... Hx=field, ... Hy=field, ... Hz=field, ... n_complex=index_data ... )
Show JSON schema
{ "title": "ModeSolverData", "description": "Data associated with a :class:`.ModeSolverMonitor`: scalar components of E and H fields.\n\nParameters\n----------\nEx : ScalarModeFieldDataArray\n Spatial distribution of the x-component of the electric field of the mode.\nEy : ScalarModeFieldDataArray\n Spatial distribution of the y-component of the electric field of the mode.\nEz : ScalarModeFieldDataArray\n Spatial distribution of the z-component of the electric field of the mode.\nHx : ScalarModeFieldDataArray\n Spatial distribution of the x-component of the magnetic field of the mode.\nHy : ScalarModeFieldDataArray\n Spatial distribution of the y-component of the magnetic field of the mode.\nHz : ScalarModeFieldDataArray\n Spatial distribution of the z-component of the magnetic field of the mode.\nmonitor : ModeSolverMonitor\n symmetry : Tuple[Literal[0, -1, 1], Literal[0, -1, 1], Literal[0, -1, 1]] = (0, 0, 0)\n Symmetry eigenvalues of the original simulation in x, y, and z.\nsymmetry_center : Optional[Tuple[float, float, float]] = None\n Center of the symmetry planes of the original simulation in x, y, and z. Required only if any of the ``symmetry`` field are non-zero.\ngrid_expanded : Optional[Grid] = None\n :class:`.Grid` on which the symmetry will be expanded. Required only if any of the ``symmetry`` field are non-zero.\ngrid_primal_correction : Union[float, FreqDataArray, TimeDataArray, FreqModeDataArray] = 1.0\n Correction factor that needs to be applied for data corresponding to a 2D monitor to take into account the finite grid in the normal direction in the simulation in which the data was computed. The factor is applied to fields defined on the primal grid locations along the normal direction.\ngrid_dual_correction : Union[float, FreqDataArray, TimeDataArray, FreqModeDataArray] = 1.0\n Correction factor that needs to be applied for data corresponding to a 2D monitor to take into account the finite grid in the normal direction in the simulation in which the data was computed. The factor is applied to fields defined on the dual grid locations along the normal direction.\nn_complex : ModeIndexDataArray\n Complex-valued effective propagation constants associated with the mode.\n\nExample\n-------\n>>> from tidy3d import ModeSpec\n>>> from tidy3d import ScalarModeFieldDataArray, ModeIndexDataArray\n>>> x = [-1,1]\n>>> y = [0]\n>>> z = [-3,-1,1,3]\n>>> f = [2e14, 3e14]\n>>> mode_index = np.arange(5)\n>>> field_coords = dict(x=x, y=y, z=z, f=f, mode_index=mode_index)\n>>> field = ScalarModeFieldDataArray((1+1j)*np.random.random((2,1,4,2,5)), coords=field_coords)\n>>> index_coords = dict(f=f, mode_index=mode_index)\n>>> index_data = ModeIndexDataArray((1+1j) * np.random.random((2,5)), coords=index_coords)\n>>> monitor = ModeSolverMonitor(\n... size=(2,0,6),\n... freqs=[2e14, 3e14],\n... mode_spec=ModeSpec(num_modes=5),\n... name='mode_solver',\n... )\n>>> data = ModeSolverData(\n... monitor=monitor,\n... Ex=field,\n... Ey=field,\n... Ez=field,\n... Hx=field,\n... Hy=field,\n... Hz=field,\n... n_complex=index_data\n... )", "type": "object", "properties": { "type": { "title": "Type", "default": "ModeSolverData", "enum": [ "ModeSolverData" ], "type": "string" }, "Ex": { "title": "DataArray", "description": "Spatial distribution of the x-component of the electric field of the mode.", "type": "xr.DataArray", "properties": { "_dims": { "title": "_dims", "type": "Tuple[str, ...]" } }, "required": [ "_dims" ] }, "Ey": { "title": "DataArray", "description": "Spatial distribution of the y-component of the electric field of the mode.", "type": "xr.DataArray", "properties": { "_dims": { "title": "_dims", "type": "Tuple[str, ...]" } }, "required": [ "_dims" ] }, "Ez": { "title": "DataArray", "description": "Spatial distribution of the z-component of the electric field of the mode.", "type": "xr.DataArray", "properties": { "_dims": { "title": "_dims", "type": "Tuple[str, ...]" } }, "required": [ "_dims" ] }, "Hx": { "title": "DataArray", "description": "Spatial distribution of the x-component of the magnetic field of the mode.", "type": "xr.DataArray", "properties": { "_dims": { "title": "_dims", "type": "Tuple[str, ...]" } }, "required": [ "_dims" ] }, "Hy": { "title": "DataArray", "description": "Spatial distribution of the y-component of the magnetic field of the mode.", "type": "xr.DataArray", "properties": { "_dims": { "title": "_dims", "type": "Tuple[str, ...]" } }, "required": [ "_dims" ] }, "Hz": { "title": "DataArray", "description": "Spatial distribution of the z-component of the magnetic field of the mode.", "type": "xr.DataArray", "properties": { "_dims": { "title": "_dims", "type": "Tuple[str, ...]" } }, "required": [ "_dims" ] }, "monitor": { "$ref": "#/definitions/ModeSolverMonitor" }, "symmetry": { "title": "Symmetry", "description": "Symmetry eigenvalues of the original simulation in x, y, and z.", "default": [ 0, 0, 0 ], "type": "array", "minItems": 3, "maxItems": 3, "items": [ { "enum": [ 0, -1, 1 ], "type": "integer" }, { "enum": [ 0, -1, 1 ], "type": "integer" }, { "enum": [ 0, -1, 1 ], "type": "integer" } ] }, "symmetry_center": { "title": "Symmetry Center", "description": "Center of the symmetry planes of the original simulation in x, y, and z. Required only if any of the ``symmetry`` field are non-zero.", "type": "array", "minItems": 3, "maxItems": 3, "items": [ { "type": "number" }, { "type": "number" }, { "type": "number" } ] }, "grid_expanded": { "title": "Expanded Grid", "description": ":class:`.Grid` on which the symmetry will be expanded. Required only if any of the ``symmetry`` field are non-zero.", "allOf": [ { "$ref": "#/definitions/Grid" } ] }, "grid_primal_correction": { "title": "Field correction factor", "description": "Correction factor that needs to be applied for data corresponding to a 2D monitor to take into account the finite grid in the normal direction in the simulation in which the data was computed. The factor is applied to fields defined on the primal grid locations along the normal direction.", "default": 1.0, "anyOf": [ { "type": "number" }, { "title": "DataArray", "type": "xr.DataArray", "properties": { "_dims": { "title": "_dims", "type": "Tuple[str, ...]" } }, "required": [ "_dims" ] }, { "title": "DataArray", "type": "xr.DataArray", "properties": { "_dims": { "title": "_dims", "type": "Tuple[str, ...]" } }, "required": [ "_dims" ] }, { "title": "DataArray", "type": "xr.DataArray", "properties": { "_dims": { "title": "_dims", "type": "Tuple[str, ...]" } }, "required": [ "_dims" ] } ] }, "grid_dual_correction": { "title": "Field correction factor", "description": "Correction factor that needs to be applied for data corresponding to a 2D monitor to take into account the finite grid in the normal direction in the simulation in which the data was computed. The factor is applied to fields defined on the dual grid locations along the normal direction.", "default": 1.0, "anyOf": [ { "type": "number" }, { "title": "DataArray", "type": "xr.DataArray", "properties": { "_dims": { "title": "_dims", "type": "Tuple[str, ...]" } }, "required": [ "_dims" ] }, { "title": "DataArray", "type": "xr.DataArray", "properties": { "_dims": { "title": "_dims", "type": "Tuple[str, ...]" } }, "required": [ "_dims" ] }, { "title": "DataArray", "type": "xr.DataArray", "properties": { "_dims": { "title": "_dims", "type": "Tuple[str, ...]" } }, "required": [ "_dims" ] } ] }, "n_complex": { "title": "DataArray", "description": "Complex-valued effective propagation constants associated with the mode.", "type": "xr.DataArray", "properties": { "_dims": { "title": "_dims", "type": "Tuple[str, ...]" } }, "required": [ "_dims" ] } }, "required": [ "Ex", "Ey", "Ez", "Hx", "Hy", "Hz", "monitor", "n_complex" ], "additionalProperties": false, "definitions": { "ApodizationSpec": { "title": "ApodizationSpec", "description": "Stores specifications for the apodizaton of frequency-domain monitors.\n\nParameters\n----------\nstart : Optional[NonNegativeFloat] = None\n [units = sec]. Defines the time at which the start apodization ends.\nend : Optional[NonNegativeFloat] = None\n [units = sec]. Defines the time at which the end apodization begins.\nwidth : Optional[PositiveFloat] = None\n [units = sec]. Characteristic decay length of the apodization function.\n\nExample\n-------\n>>> apod_spec = ApodizationSpec(start=1, end=2, width=0.5)", "type": "object", "properties": { "start": { "title": "Start Interval", "description": "Defines the time at which the start apodization ends.", "units": "sec", "minimum": 0, "type": "number" }, "end": { "title": "End Interval", "description": "Defines the time at which the end apodization begins.", "units": "sec", "minimum": 0, "type": "number" }, "width": { "title": "Apodization Width", "description": "Characteristic decay length of the apodization function.", "units": "sec", "exclusiveMinimum": 0, "type": "number" }, "type": { "title": "Type", "default": "ApodizationSpec", "enum": [ "ApodizationSpec" ], "type": "string" } }, "additionalProperties": false }, "ModeSpec": { "title": "ModeSpec", "description": "Stores specifications for the mode solver to find an electromagntic mode.\nNote, the planar axes are found by popping the injection axis from {x,y,z}.\nFor example, if injection axis is y, the planar axes are ordered {x,z}.\n\nParameters\n----------\nnum_modes : PositiveInt = 1\n Number of modes returned by mode solver.\ntarget_neff : Optional[PositiveFloat] = None\n Guess for effective index of the mode.\nnum_pml : Tuple[NonNegativeInt, NonNegativeInt] = (0, 0)\n Number of standard pml layers to add in the two tangential axes.\nfilter_pol : Optional[Literal['te', 'tm']] = None\n The solver always computes the ``num_modes`` modes closest to the given ``target_neff``. If ``filter_pol==None``, they are simply sorted in order of decresing effective index. If a polarization filter is selected, the modes are rearranged such that the first ``n_pol`` modes in the list are the ones with the selected polarization fraction larger than or equal to 0.5, while the next ``num_modes - n_pol`` modes are the ones where it is smaller than 0.5 (i.e. the opposite polarization fraction is larger than 0.5). Within each polarization subset, the modes are still ordered by decreasing effective index. ``te``-fraction is defined as the integrated intensity of the E-field component parallel to the first plane axis, normalized to the total in-plane E-field intensity. Conversely, ``tm``-fraction uses the E field component parallel to the second plane axis.\nangle_theta : float = 0.0\n [units = rad]. Polar angle of the propagation axis from the injection axis.\nangle_phi : float = 0.0\n [units = rad]. Azimuth angle of the propagation axis in the plane orthogonal to the injection axis.\nprecision : Literal['single', 'double'] = single\n The solver will be faster and using less memory under single precision, but more accurate under double precision.\nbend_radius : Optional[float] = None\n [units = um]. A curvature radius for simulation of waveguide bends. Can be negative, in which case the mode plane center has a smaller value than the curvature center along the tangential axis perpendicular to the bend axis.\nbend_axis : Optional[Literal[0, 1]] = None\n Index into the two tangential axes defining the normal to the plane in which the bend lies. This must be provided if ``bend_radius`` is not ``None``. For example, for a ring in the global xy-plane, and a mode plane in either the xz or the yz plane, the ``bend_axis`` is always 1 (the global z axis).\ntrack_freq : Optional[Literal['central', 'lowest', 'highest']] = central\n Parameter that turns on/off mode tracking based on their similarity. Can take values ``'lowest'``, ``'central'``, or ``'highest'``, which correspond to mode tracking based on the lowest, central, or highest frequency. If ``None`` no mode tracking is performed.\n\nExample\n-------\n>>> mode_spec = ModeSpec(num_modes=3, target_neff=1.5)", "type": "object", "properties": { "num_modes": { "title": "Number of modes", "description": "Number of modes returned by mode solver.", "default": 1, "exclusiveMinimum": 0, "type": "integer" }, "target_neff": { "title": "Target effective index", "description": "Guess for effective index of the mode.", "exclusiveMinimum": 0, "type": "number" }, "num_pml": { "title": "Number of PML layers", "description": "Number of standard pml layers to add in the two tangential axes.", "default": [ 0, 0 ], "type": "array", "minItems": 2, "maxItems": 2, "items": [ { "type": "integer", "minimum": 0 }, { "type": "integer", "minimum": 0 } ] }, "filter_pol": { "title": "Polarization filtering", "description": "The solver always computes the ``num_modes`` modes closest to the given ``target_neff``. If ``filter_pol==None``, they are simply sorted in order of decresing effective index. If a polarization filter is selected, the modes are rearranged such that the first ``n_pol`` modes in the list are the ones with the selected polarization fraction larger than or equal to 0.5, while the next ``num_modes - n_pol`` modes are the ones where it is smaller than 0.5 (i.e. the opposite polarization fraction is larger than 0.5). Within each polarization subset, the modes are still ordered by decreasing effective index. ``te``-fraction is defined as the integrated intensity of the E-field component parallel to the first plane axis, normalized to the total in-plane E-field intensity. Conversely, ``tm``-fraction uses the E field component parallel to the second plane axis.", "enum": [ "te", "tm" ], "type": "string" }, "angle_theta": { "title": "Polar Angle", "description": "Polar angle of the propagation axis from the injection axis.", "default": 0.0, "units": "rad", "type": "number" }, "angle_phi": { "title": "Azimuth Angle", "description": "Azimuth angle of the propagation axis in the plane orthogonal to the injection axis.", "default": 0.0, "units": "rad", "type": "number" }, "precision": { "title": "single or double precision in mode solver", "description": "The solver will be faster and using less memory under single precision, but more accurate under double precision.", "default": "single", "enum": [ "single", "double" ], "type": "string" }, "bend_radius": { "title": "Bend radius", "description": "A curvature radius for simulation of waveguide bends. Can be negative, in which case the mode plane center has a smaller value than the curvature center along the tangential axis perpendicular to the bend axis.", "units": "um", "type": "number" }, "bend_axis": { "title": "Bend axis", "description": "Index into the two tangential axes defining the normal to the plane in which the bend lies. This must be provided if ``bend_radius`` is not ``None``. For example, for a ring in the global xy-plane, and a mode plane in either the xz or the yz plane, the ``bend_axis`` is always 1 (the global z axis).", "enum": [ 0, 1 ], "type": "integer" }, "track_freq": { "title": "Mode Tracking Frequency", "description": "Parameter that turns on/off mode tracking based on their similarity. Can take values ``'lowest'``, ``'central'``, or ``'highest'``, which correspond to mode tracking based on the lowest, central, or highest frequency. If ``None`` no mode tracking is performed.", "default": "central", "enum": [ "central", "lowest", "highest" ], "type": "string" }, "type": { "title": "Type", "default": "ModeSpec", "enum": [ "ModeSpec" ], "type": "string" } }, "additionalProperties": false }, "ModeSolverMonitor": { "title": "ModeSolverMonitor", "description": ":class:`Monitor` that stores the mode field profiles returned by the mode solver in the\nmonitor plane.\n\nParameters\n----------\ncenter : Tuple[float, float, float] = (0.0, 0.0, 0.0)\n [units = um]. Center of object in x, y, and z.\nsize : Tuple[NonNegativeFloat, NonNegativeFloat, NonNegativeFloat]\n [units = um]. Size in x, y, and z directions.\nname : ConstrainedStrValue\n Unique name for monitor.\nfreqs : Union[Tuple[float, ...], Array]\n [units = Hz]. Array or list of frequencies stored by the field monitor.\napodization : ApodizationSpec = ApodizationSpec(start=None, end=None, width=None, type='ApodizationSpec')\n Sets parameters of (optional) apodization. Apodization applies a windowing function to the Fourier transform of the time-domain fields into frequency-domain ones, and can be used to truncate the beginning and/or end of the time signal, for example to eliminate the source pulse when studying the eigenmodes of a system. Note: apodization affects the normalization of the frequency-domain fields.\nmode_spec : ModeSpec\n Parameters to feed to mode solver which determine modes measured by monitor.\n\nExample\n-------\n>>> mode_spec = ModeSpec(num_modes=3)\n>>> monitor = ModeSolverMonitor(\n... center=(1,2,3),\n... size=(2,2,0),\n... freqs=[200e12, 210e12],\n... mode_spec=mode_spec,\n... name='mode_monitor')", "type": "object", "properties": { "type": { "title": "Type", "default": "ModeSolverMonitor", "enum": [ "ModeSolverMonitor" ], "type": "string" }, "center": { "title": "Center", "description": "Center of object in x, y, and z.", "default": [ 0.0, 0.0, 0.0 ], "units": "um", "type": "array", "minItems": 3, "maxItems": 3, "items": [ { "type": "number" }, { "type": "number" }, { "type": "number" } ] }, "size": { "title": "Size", "description": "Size in x, y, and z directions.", "units": "um", "type": "array", "minItems": 3, "maxItems": 3, "items": [ { "type": "number", "minimum": 0 }, { "type": "number", "minimum": 0 }, { "type": "number", "minimum": 0 } ] }, "name": { "title": "Name", "description": "Unique name for monitor.", "minLength": 1, "type": "string" }, "freqs": { "title": "Frequencies", "description": "Array or list of frequencies stored by the field monitor.", "units": "Hz", "anyOf": [ { "type": "array", "items": { "type": "number" } }, { "title": "Array Like", "description": "Accepts sequence (tuple, list, numpy array) and converts to tuple.", "type": "tuple", "properties": {}, "required": [] } ] }, "apodization": { "title": "Apodization Specification", "description": "Sets parameters of (optional) apodization. Apodization applies a windowing function to the Fourier transform of the time-domain fields into frequency-domain ones, and can be used to truncate the beginning and/or end of the time signal, for example to eliminate the source pulse when studying the eigenmodes of a system. Note: apodization affects the normalization of the frequency-domain fields.", "default": { "start": null, "end": null, "width": null, "type": "ApodizationSpec" }, "allOf": [ { "$ref": "#/definitions/ApodizationSpec" } ] }, "mode_spec": { "title": "Mode Specification", "description": "Parameters to feed to mode solver which determine modes measured by monitor.", "allOf": [ { "$ref": "#/definitions/ModeSpec" } ] } }, "required": [ "size", "name", "freqs", "mode_spec" ], "additionalProperties": false }, "Coords": { "title": "Coords", "description": "Holds data about a set of x,y,z positions on a grid.\n\nParameters\n----------\nx : Array\n 1-dimensional array of x coordinates.\ny : Array\n 1-dimensional array of y coordinates.\nz : Array\n 1-dimensional array of z coordinates.\n\nExample\n-------\n>>> x = np.linspace(-1, 1, 10)\n>>> y = np.linspace(-1, 1, 11)\n>>> z = np.linspace(-1, 1, 12)\n>>> coords = Coords(x=x, y=y, z=z)", "type": "object", "properties": { "x": { "title": "Array Like", "description": "Accepts sequence (tuple, list, numpy array) and converts to tuple.", "type": "tuple", "properties": {}, "required": [] }, "y": { "title": "Array Like", "description": "Accepts sequence (tuple, list, numpy array) and converts to tuple.", "type": "tuple", "properties": {}, "required": [] }, "z": { "title": "Array Like", "description": "Accepts sequence (tuple, list, numpy array) and converts to tuple.", "type": "tuple", "properties": {}, "required": [] }, "type": { "title": "Type", "default": "Coords", "enum": [ "Coords" ], "type": "string" } }, "required": [ "x", "y", "z" ], "additionalProperties": false }, "Grid": { "title": "Grid", "description": "Contains all information about the spatial positions of the FDTD grid.\n\nParameters\n----------\nboundaries : Coords\n x,y,z coordinates of the boundaries between cells, defining the FDTD grid.\n\nExample\n-------\n>>> x = np.linspace(-1, 1, 10)\n>>> y = np.linspace(-1, 1, 11)\n>>> z = np.linspace(-1, 1, 12)\n>>> coords = Coords(x=x, y=y, z=z)\n>>> grid = Grid(boundaries=coords)\n>>> centers = grid.centers\n>>> sizes = grid.sizes\n>>> yee_grid = grid.yee", "type": "object", "properties": { "boundaries": { "title": "Boundary Coordinates", "description": "x,y,z coordinates of the boundaries between cells, defining the FDTD grid.", "allOf": [ { "$ref": "#/definitions/Coords" } ] }, "type": { "title": "Type", "default": "Grid", "enum": [ "Grid" ], "type": "string" } }, "required": [ "boundaries" ], "additionalProperties": false } } }
- attribute Ex: ScalarModeFieldDataArray [Required]#
Spatial distribution of the x-component of the electric field of the mode.
- Constraints
title = DataArray
type = xr.DataArray
properties = {‘_dims’: {‘title’: ‘_dims’, ‘type’: ‘Tuple[str, …]’}}
required = [‘_dims’]
- attribute Ey: ScalarModeFieldDataArray [Required]#
Spatial distribution of the y-component of the electric field of the mode.
- Constraints
title = DataArray
type = xr.DataArray
properties = {‘_dims’: {‘title’: ‘_dims’, ‘type’: ‘Tuple[str, …]’}}
required = [‘_dims’]
- attribute Ez: ScalarModeFieldDataArray [Required]#
Spatial distribution of the z-component of the electric field of the mode.
- Constraints
title = DataArray
type = xr.DataArray
properties = {‘_dims’: {‘title’: ‘_dims’, ‘type’: ‘Tuple[str, …]’}}
required = [‘_dims’]
- attribute Hx: ScalarModeFieldDataArray [Required]#
Spatial distribution of the x-component of the magnetic field of the mode.
- Constraints
title = DataArray
type = xr.DataArray
properties = {‘_dims’: {‘title’: ‘_dims’, ‘type’: ‘Tuple[str, …]’}}
required = [‘_dims’]
- attribute Hy: ScalarModeFieldDataArray [Required]#
Spatial distribution of the y-component of the magnetic field of the mode.
- Constraints
title = DataArray
type = xr.DataArray
properties = {‘_dims’: {‘title’: ‘_dims’, ‘type’: ‘Tuple[str, …]’}}
required = [‘_dims’]
- attribute Hz: ScalarModeFieldDataArray [Required]#
Spatial distribution of the z-component of the magnetic field of the mode.
- Constraints
title = DataArray
type = xr.DataArray
properties = {‘_dims’: {‘title’: ‘_dims’, ‘type’: ‘Tuple[str, …]’}}
required = [‘_dims’]
- attribute grid_dual_correction: Union[float, FreqDataArray, TimeDataArray, FreqModeDataArray] = 1.0#
Correction factor that needs to be applied for data corresponding to a 2D monitor to take into account the finite grid in the normal direction in the simulation in which the data was computed. The factor is applied to fields defined on the dual grid locations along the normal direction.
- attribute grid_expanded: Grid = None#
Gridon which the symmetry will be expanded. Required only if any of thesymmetryfield are non-zero.- Validated by
_make_required
- attribute grid_primal_correction: Union[float, FreqDataArray, TimeDataArray, FreqModeDataArray] = 1.0#
Correction factor that needs to be applied for data corresponding to a 2D monitor to take into account the finite grid in the normal direction in the simulation in which the data was computed. The factor is applied to fields defined on the primal grid locations along the normal direction.
- attribute monitor: ModeSolverMonitor [Required]#
- attribute n_complex: ModeIndexDataArray [Required]#
Complex-valued effective propagation constants associated with the mode.
- Constraints
title = DataArray
type = xr.DataArray
properties = {‘_dims’: {‘title’: ‘_dims’, ‘type’: ‘Tuple[str, …]’}}
required = [‘_dims’]
- attribute symmetry: Tuple[Symmetry, Symmetry, Symmetry] = (0, 0, 0)#
Symmetry eigenvalues of the original simulation in x, y, and z.
- attribute symmetry_center: Coordinate = None#
Center of the symmetry planes of the original simulation in x, y, and z. Required only if any of the
symmetryfield are non-zero.- Validated by
_make_required
- classmethod add_type_field() None#
Automatically place “type” field with model name in the model field dictionary.
- colocate(x=None, y=None, z=None) xarray.core.dataset.Dataset#
colocate all of the data at a set of x, y, z coordinates.
- Parameters
x (Optional[array-like] = None) – x coordinates of locations. If not supplied, does not try to colocate on this dimension.
y (Optional[array-like] = None) – y coordinates of locations. If not supplied, does not try to colocate on this dimension.
z (Optional[array-like] = None) – z coordinates of locations. If not supplied, does not try to colocate on this dimension.
- Returns
Dataset containing all fields at the same spatial locations. For more details refer to xarray’s Documentaton.
- Return type
xr.Dataset
Note
For many operations (such as flux calculations and plotting), it is important that the fields are colocated at the same spatial locations. Be sure to apply this method to your field data in those cases.
- 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) tidy3d.components.base.Tidy3dBaseModel#
Copy a Tidy3dBaseModel. With
deep=Trueas 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
Tidy3dBaseModelfrom.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
Tidy3dBaseModelfrom.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
Tidy3dBaseModelfrom.- 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
Tidy3dBaseModelfrom.- Returns
A dictionary containing the model.
- Return type
dict
Example
>>> sim_dict = Simulation.dict_from_yaml(fname='folder/sim.yaml')
- dot(field_data: Union[tidy3d.components.data.monitor_data.FieldData, tidy3d.components.data.monitor_data.ModeSolverData], conjugate: bool = True) tidy3d.components.data.data_array.ModeAmpsDataArray#
Dot product (modal overlap) with another
FieldDataobject. Both datasets have to be frequency-domain data associated with a 2D monitor. Along the tangential directions, the datasets have to have the same discretization. Along the normal direction, the monitor position may differ and is ignored. Other coordinates (frequency,mode_index) have to be either identical or broadcastable. Broadcasting is also supported in the case in which the otherfield_datahas a dimension of size1whose coordinate is not in the list of coordinates in theselfdataset along the corresponding dimension. In that case, the coordinates of theselfdataset are used in the output.- Parameters
field_data (
ElectromagneticFieldData) – A data instance to compute the dot product with.conjugate (bool, optional) – If
True(default), the dot product is defined as1 / 4times the integral ofE_self* x H_other - H_self* x E_other, wherexis the cross product and*is complex conjugation. IfFalse, the complex conjugation is skipped.
Note
The dot product with and without conjugation is equivalent (up to a phase) for modes in lossless waveguides but differs for modes in lossy materials. In that case, the conjugated dot product can be interpreted as the fraction of the power of the first mode carried by the second, but modes are not orthogonal with respect to that product and the sum of carried power fractions exceed 1. In the non-conjugated definition, orthogonal modes can be defined, but the interpretation of modal overlap as power carried by a given mode is no longer valid.
- classmethod from_file(fname: str, group_path: Optional[str] = None, **parse_obj_kwargs) tidy3d.components.base.Tidy3dBaseModel#
Loads a
Tidy3dBaseModelfrom .yaml, .json, or .hdf5 file.- Parameters
fname (str) – Full path to the .yaml or .json file to load the
Tidy3dBaseModelfrom.group_path (str, optional) – Path to a group inside the file to use as the base level. Only for
.hdf5files. Starting / is optional.**parse_obj_kwargs – Keyword arguments passed to either pydantic’s
parse_objfunction 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_hdf5(fname: str, group_path: str = '', **parse_obj_kwargs) tidy3d.components.base.Tidy3dBaseModel#
Loads
Tidy3dBaseModelinstance to .hdf5 file.- Parameters
fname (str) – Full path to the .hdf5 file to load the
Tidy3dBaseModelfrom.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_objmethod.
Example
>>> simulation.to_hdf5(fname='folder/sim.hdf5')
- classmethod from_json(fname: str, **parse_obj_kwargs) tidy3d.components.base.Tidy3dBaseModel#
Load a
Tidy3dBaseModelfrom .json file.- Parameters
fname (str) – Full path to the .json file to load the
Tidy3dBaseModelfrom.- Returns
Tidy3dBaseModel– An instance of the component class calling load.**parse_obj_kwargs – Keyword arguments passed to pydantic’s
parse_objmethod.
Example
>>> simulation = Simulation.from_json(fname='folder/sim.json')
- classmethod from_orm(obj: Any) Model#
- classmethod from_yaml(fname: str, **parse_obj_kwargs) tidy3d.components.base.Tidy3dBaseModel#
Loads
Tidy3dBaseModelfrom .yaml file.- Parameters
fname (str) – Full path to the .yaml file to load the
Tidy3dBaseModelfrom.**parse_obj_kwargs – Keyword arguments passed to pydantic’s
parse_objmethod.
- 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_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)
- 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().
- normalize(source_spectrum_fn: Callable[[float], complex]) tidy3d.components.data.dataset.Dataset#
Return copy of self after normalization is applied using source spectrum function.
- overlap_sort(track_freq: Literal['central', 'lowest', 'highest'], overlap_thresh: float = 0.9) tidy3d.components.data.monitor_data.ModeSolverData#
Starting from the base frequency defined by parameter
track_freq, sort modes at each frequency according to their overlap values with the modes at the previous frequency. That is, it attempts to rearrange modes in such a way that a givenmode_indexcorresponds to physically the same mode at all frequencies. Modes with overlap values overoverlap_treshare considered matching and not rearranged.- Parameters
track_freq (Literal["central", "lowest", "highest"]) – Parameter that specifies which frequency will serve as a starting point in the reordering process.
overlap_thresh (float = 0.9) – Modal overlap threshold above which two modes are considered to be the same and are not rearranged. If after the sorting procedure the overlap value between two corresponding modes is less than this threshold, a warning about a possible discontinuity is displayed.
- 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#
- plot_field(*args, **kwargs)#
Warn user to use the
ModeSolverplot_fieldfunction now.
- 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#
- to_file(fname: str) None#
Exports
Tidy3dBaseModelinstance to .yaml, .json, or .hdf5 file- Parameters
fname (str) – Full path to the .yaml or .json file to save the
Tidy3dBaseModelto.
Example
>>> simulation.to_file(fname='folder/sim.json')
- to_hdf5(fname: str) None#
Exports
Tidy3dBaseModelinstance to .hdf5 file.- Parameters
fname (str) – Full path to the .hdf5 file to save the
Tidy3dBaseModelto.
Example
>>> simulation.to_hdf5(fname='folder/sim.hdf5')
- to_json(fname: str) None#
Exports
Tidy3dBaseModelinstance to .json file- Parameters
fname (str) – Full path to the .json file to save the
Tidy3dBaseModelto.
Example
>>> simulation.to_json(fname='folder/sim.json')
- to_yaml(fname: str) None#
Exports
Tidy3dBaseModelinstance to .yaml file.- Parameters
fname (str) – Full path to the .yaml file to save the
Tidy3dBaseModelto.
Example
>>> simulation.to_yaml(fname='folder/sim.yaml')
- classmethod tuple_to_dict(tuple_values: tuple) dict#
How we generate a dictionary mapping new keys to tuple values for hdf5.
- classmethod update_forward_refs(**localns: Any) None#
Try to update ForwardRefs on fields based on this Model, globalns and localns.
- updated_copy(**kwargs) tidy3d.components.base.Tidy3dBaseModel#
Make copy of a component instance with
**kwargsindicating updated field values.
- classmethod validate(value: Any) Model#
- property field_components: Dict[str, tidy3d.components.data.data_array.DataArray]#
Maps the field components to thier associated data.
- property flux: tidy3d.components.data.data_array.FluxDataArray#
Flux for data corresponding to a 2D monitor.
- property grid_locations: Dict[str, str]#
Maps field components to the string key of their grid locations on the yee lattice.
- property k_eff#
Imaginary part of the propagation index.
- property n_eff#
Real part of the propagation index.
- property poynting: tidy3d.components.data.data_array.ScalarFieldDataArray#
Time-averaged Poynting vector for frequency-domain data associated to a 2D monitor, projected to the direction normal to the monitor plane.
- property symmetry_eigenvalues: Dict[str, Callable[[Literal[0, 1, 2]], float]]#
Maps field components to their (positive) symmetry eigenvalues.
- property symmetry_expanded_copy: tidy3d.components.data.monitor_data.AbstractFieldData#
Create a copy of the
AbstractFieldDatawith fields expanded based on symmetry.- Returns
A data object with the symmetry expanded fields.
- Return type
AbstractFieldData
- property time_reversed_copy: tidy3d.components.data.monitor_data.FieldData#
Make a copy of the data with time-reversed fields.