tidy3d.plugins.adjoint.JaxSimulationData#

Bases: tidy3d.components.data.sim_data.SimulationData, tidy3d.plugins.adjoint.components.base.JaxObject

A SimulationData registered with jax.

Parameters

simulation (JaxSimulation) – The jax-compatible simulation corresponding to the data.
data (Tuple[Annotated[Union[tidy3d.components.data.monitor_data.FieldData, tidy3d.components.data.monitor_data.FieldTimeData, tidy3d.components.data.monitor_data.PermittivityData, tidy3d.components.data.monitor_data.ModeSolverData, tidy3d.components.data.monitor_data.ModeData, tidy3d.components.data.monitor_data.FluxData, tidy3d.components.data.monitor_data.FluxTimeData, tidy3d.components.data.monitor_data.FieldProjectionKSpaceData, tidy3d.components.data.monitor_data.FieldProjectionCartesianData, tidy3d.components.data.monitor_data.FieldProjectionAngleData, tidy3d.components.data.monitor_data.DiffractionData], FieldInfo(default=PydanticUndefined, discriminator='type', extra={})], ...]) – List of MonitorData instances associated with the monitors of the original Simulation.
log (Optional[str] = None) – A string containing the log information from the simulation run.
diverged (bool = False) – A boolean flag denoting whether the simulation run diverged.
output_data (Tuple[Union[JaxModeData, JaxDiffractionData, JaxFieldData], ...] = ()) – Tuple of Jax-compatible data associated with output monitors.
grad_data (Tuple[FieldData, ...] = ()) – Tuple of monitor data storing fields associated with the input structures.
grad_eps_data (Tuple[PermittivityData, ...] = ()) – Tuple of monitor data storing epsilon associated with the input structures.
task_id (Optional[str] = None) – Optional field storing the task_id for the original JaxSimulation.

__init__(**kwargs)#: Init method, includes post-init validators.

Methods

`__init__`(**kwargs)	Init method, includes post-init validators.
`add_type_field`()	Automatically place "type" field with model name in the model field dictionary.
`apply_phase`(data[, phase])	Apply a phase to xarray data.
`at_boundaries`(field_monitor_name)	Return xarray.Dataset representation of field monitor data colocated at Yee cell boundaries.
`at_centers`(field_monitor_name)	Return xarray.Dataset representation of field monitor data colocated at Yee cell centers.
`construct`([_fields_set])	Creates a new model setting __dict__ and __fields_set__ from trusted or pre-validated data.
`copy`(**kwargs)	Copy a Tidy3dBaseModel.
`data_monitors_match_sim`(val, values)	Ensure each `AbstractMonitorData` in `.data` corresponds to a monitor in `.simulation`.
`dict`(*[, include, exclude, by_alias, ...])	Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
`dict_from_file`(fname[, group_path])	Loads a dictionary containing the model from a .yaml, .json, .hdf5, or .hdf5.gz file.
`dict_from_hdf5`(fname[, group_path, ...])	Loads a dictionary containing the model contents from a .hdf5 file.
`dict_from_hdf5_gz`(fname[, group_path, ...])	Loads a dictionary containing the model contents from a .hdf5.gz file.
`dict_from_json`(fname)	Load dictionary of the model from a .json file.
`dict_from_yaml`(fname)	Load dictionary of the model from a .yaml file.
`from_file`(fname[, group_path])	Loads a `Tidy3dBaseModel` from .yaml, .json, .hdf5, or .hdf5.gz file.
`from_hdf5`(fname[, group_path, custom_decoders])	Loads `Tidy3dBaseModel` instance to .hdf5 file.
`from_hdf5_gz`(fname[, group_path, ...])	Loads `Tidy3dBaseModel` instance to .hdf5.gz file.
`from_json`(fname, **parse_obj_kwargs)	Load a `Tidy3dBaseModel` from .json file.
`from_orm`(obj)
`from_sim_data`(sim_data, jax_info[, task_id])	Construct a `JaxSimulationData` instance from a `SimulationData`.
`from_tidy3d`(tidy3d_obj)	Convert `Tidy3dBaseModel` instance to `JaxObject`.
`from_yaml`(fname, **parse_obj_kwargs)	Loads `Tidy3dBaseModel` from .yaml file.
`generate_docstring`()	Generates a docstring for a Tidy3D mode and saves it to the __doc__ of the class.
`get_intensity`(field_monitor_name)	return xarray.DataArray of the intensity of a field monitor at Yee cell centers.
`get_jax_field_names`()	Returns list of field names that have a `jax_field_type`.
`get_poynting_vector`(field_monitor_name)	return `xarray.Dataset` of the Poynting vector at Yee cell centers.
`get_sub_model`(group_path, model_dict)	Get the sub model for a given group path.
`get_submodels_by_hash`()	Return a dictionary of this object's sub-models indexed by their hash values.
`get_tuple_group_name`(index)	Get the group name of a tuple element.
`get_tuple_index`(key_name)	Get the index into the tuple based on its group name.
`help`([methods])	Prints message describing the fields and methods of a `Tidy3dBaseModel`.
`json`(*[, include, exclude, by_alias, ...])	Generate a JSON representation of the model, include and exclude arguments as per dict().
`load_field_monitor`(monitor_name)	Load monitor and raise exception if not a field monitor.
`make_adjoint_simulation`(fwidth, run_time)	Make an adjoint simulation out of the data provided (generally, the vjp sim data).
`mnt_data_from_file`(fname, mnt_name, ...)	Loads data for a specific monitor from a .hdf5 file with data for a `SimulationData`.
`normalize_adjoint_fields`()	Make copy of jax_sim_data with grad_data (fields) normalized by adjoint sources.
`parse_file`(path, *[, content_type, ...])
`parse_obj`(obj)
`parse_raw`(b, *[, content_type, encoding, ...])
`plot_field`(field_monitor_name, field_name[, ...])	Plot the field data for a monitor with simulation plot overlayed.
`plot_scalar_array`(field_data, axis, position)	Plot the field data for a monitor with simulation plot overlayed.
`renormalize`(normalize_index)	Return a copy of the `SimulationData` with a different source used for the normalization.
`schema`([by_alias, ref_template])
`schema_json`(*[, by_alias, ref_template])
`source_spectrum`(source_index)	Get a spectrum normalization function for a given source index.
`split_data`(mnt_data, jax_info)	Split list of monitor data into data, output_data, grad_data, and grad_eps_data.
`split_fwd_sim_data`(sim_data, jax_info)	Split a `SimulationData` into two parts, containing user and gradient data.
`to_file`(fname)	Exports `Tidy3dBaseModel` instance to .yaml, .json, or .hdf5 file
`to_hdf5`(fname[, custom_encoders])	Exports `JaxObject` instance to .hdf5 file.
`to_hdf5_gz`(fname[, custom_encoders])	Exports `Tidy3dBaseModel` instance to .hdf5.gz file.
`to_json`(fname)	Exports `Tidy3dBaseModel` instance to .json file
`to_yaml`(fname)	Exports `Tidy3dBaseModel` instance to .yaml file.
`tree_flatten`()	How to flatten a `JaxObject` instance into a pytree.
`tree_unflatten`(aux_data, children)	How to unflatten a pytree into a `JaxObject` instance.
`tuple_to_dict`(tuple_values)	How we generate a dictionary mapping new keys to tuple values for hdf5.
`update_forward_refs`(**localns)	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.
`validate`(value)
`validate_no_ambiguity`(val, values)	Ensure all `AbstractMonitorData` entries in `.data` correspond to different monitors in `.simulation`.

Attributes

`final_decay_value`	Returns value of the field decay at the final time step.
`grad_data_symmetry`	`self.grad_data` but with `symmetry_expanded_copy` applied.
`grad_eps_data_symmetry`	`self.grad_eps_data` but with `symmetry_expanded_copy` applied.
`monitor_data`	Dictionary of `.output_data` monitor `.name` to the corresponding data.
`output_monitor_data`	Dictionary of `.output_data` monitor `.name` to the corresponding data.
`output_data`
`grad_data`
`grad_eps_data`
`simulation`
`task_id`

class Config#

Bases: object

Sets config for all Tidy3dBaseModel objects.

allow_population_by_field_namebool = True: Allow properties to stand in for fields(?).
arbitrary_types_allowedbool = True: Allow types like numpy arrays.
extrastr = ‘forbid’: Forbid extra kwargs not specified in model.
json_encodersDict[type, Callable]: Defines how to encode type in json file.
validate_allbool = True: Validate default values just to be safe.
validate_assignmentbool: Re-validate after re-assignment of field in model.

__eq__(other)#: Define == for two Tidy3DBaseModels.

__ge__(other)#: define >= for getting unique indices based on hash.

__getitem__(monitor_name: str) → tidy3d.components.base_sim.data.monitor_data.AbstractMonitorData#: Get a AbstractMonitorData by name. Apply symmetry if applicable.

__gt__(other)#: define > for getting unique indices based on hash.

__hash__() → int#: Hash method.

classmethod __init_subclass__() → None#: Things that are done to each of the models.

__iter__() → TupleGenerator#: so dict(model) works

__le__(other)#: define <= for getting unique indices based on hash.

__lt__(other)#: define < for getting unique indices based on hash.

__pretty__(fmt: Callable[[Any], Any], **kwargs: Any) → Generator[Any, None, None]#: Used by devtools (https://python-devtools.helpmanual.io/) to provide a human readable representations of objects

__repr_name__() → str#: Name of the instance’s class, used in __repr__.

__rich_repr__() → RichReprResult#: Get fields for Rich library

classmethod __try_update_forward_refs__(**localns: Any) → None#: Same as update_forward_refs but will not raise exception when forward references are not defined.

classmethod add_type_field() → None#: Automatically place “type” field with model name in the model field dictionary.

static apply_phase(data: Union[xarray.core.dataarray.DataArray, xarray.core.dataset.Dataset], phase: float = 0.0) → xarray.core.dataarray.DataArray#: Apply a phase to xarray data.

at_boundaries(field_monitor_name: str) → xarray.core.dataset.Dataset#

Return xarray.Dataset representation of field monitor data colocated at Yee cell boundaries.

Parameters: field_monitor_name (str) – Name of field monitor used in the original Simulation.
Returns: Dataset containing all of the fields in the data interpolated to boundary locations on the Yee grid.
Return type: xarray.Dataset

at_centers(field_monitor_name: str) → xarray.core.dataset.Dataset#

Return xarray.Dataset representation of field monitor data colocated at Yee cell centers.

Parameters: field_monitor_name (str) – Name of field monitor used in the original Simulation.
Returns: Dataset containing all of the fields in the data interpolated to center locations on the Yee grid.
Return type: xarray.Dataset

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=True as default.

classmethod data_monitors_match_sim(val, values)#: Ensure each AbstractMonitorData in .data corresponds to a monitor in .simulation.

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, .hdf5, or .hdf5.gz file.

Parameters

fname (str) – Full path to the 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 = '', custom_decoders: Optional[List[Callable]] = None) → dict#

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

Parameters

fname (str) – Full path to the .hdf5 file to load the JaxObject from.
group_path (str, optional) – Path to a group inside the file to selectively load a sub-element of the model only.
custom_decoders (List[Callable]) – List of functions accepting (fname: str, group_path: str, model_dict: dict, key: str, value: Any) that store the value in the model dict after a custom decoding.

Returns

Dictionary containing the model.

Return type

dict

Example

>>> sim_dict = Simulation.dict_from_hdf5(fname='folder/sim.hdf5') 

classmethod dict_from_hdf5_gz(fname: str, group_path: str = '', custom_decoders: Optional[List[Callable]] = None) → dict#

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

Parameters

fname (str) – Full path to the .hdf5.gz 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.
custom_decoders (List[Callable]) – List of functions accepting (fname: str, group_path: str, model_dict: dict, key: str, value: Any) that store the value in the model dict after a custom decoding.

Returns

Dictionary containing the model.

Return type

dict

Example

>>> sim_dict = Simulation.dict_from_hdf5(fname='folder/sim.hdf5.gz') 

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

property final_decay_value: float#: Returns value of the field decay at the final time step.

classmethod from_file(fname: str, group_path: Optional[str] = None, **parse_obj_kwargs) → tidy3d.components.base.Tidy3dBaseModel#

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

Parameters

fname (str) – Full path to the 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_hdf5(fname: str, group_path: str = '', custom_decoders: Optional[List[Callable]] = None, **parse_obj_kwargs) → tidy3d.components.base.Tidy3dBaseModel#

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.
custom_decoders (List[Callable]) – List of functions accepting (fname: str, group_path: str, model_dict: dict, key: str, value: Any) that store the value in the model dict after a custom decoding.
**parse_obj_kwargs – Keyword arguments passed to pydantic’s parse_obj method.

Example

>>> simulation = Simulation.from_hdf5(fname='folder/sim.hdf5') 

classmethod from_hdf5_gz(fname: str, group_path: str = '', custom_decoders: Optional[List[Callable]] = None, **parse_obj_kwargs) → tidy3d.components.base.Tidy3dBaseModel#

Loads Tidy3dBaseModel instance to .hdf5.gz file.

Parameters

fname (str) – Full path to the .hdf5.gz 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.
custom_decoders (List[Callable]) – List of functions accepting (fname: str, group_path: str, model_dict: dict, key: str, value: Any) that store the value in the model dict after a custom decoding.
**parse_obj_kwargs – Keyword arguments passed to pydantic’s parse_obj method.

Example

>>> simulation = Simulation.from_hdf5_gz(fname='folder/sim.hdf5.gz') 

classmethod from_json(fname: str, **parse_obj_kwargs) → tidy3d.components.base.Tidy3dBaseModel#

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_sim_data(sim_data: tidy3d.components.data.sim_data.SimulationData, jax_info: tidy3d.plugins.adjoint.components.simulation.JaxInfo, task_id: Optional[str] = None) → tidy3d.plugins.adjoint.components.data.sim_data.JaxSimulationData#: Construct a JaxSimulationData instance from a SimulationData.

classmethod from_tidy3d(tidy3d_obj: tidy3d.components.base.Tidy3dBaseModel) → tidy3d.plugins.adjoint.components.base.JaxObject#: Convert Tidy3dBaseModel instance to JaxObject.

classmethod from_yaml(fname: str, **parse_obj_kwargs) → tidy3d.components.base.Tidy3dBaseModel#

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.

get_intensity(field_monitor_name: str) → xarray.core.dataarray.DataArray#

return xarray.DataArray of the intensity of a field monitor at Yee cell centers.

Parameters: field_monitor_name (str) – Name of field monitor used in the original Simulation.
Returns: DataArray containing the electric intensity of the field-like monitor. Data is interpolated to the center locations on Yee grid.
Return type: xarray.DataArray

classmethod get_jax_field_names() → List[str]#: Returns list of field names that have a jax_field_type.

get_poynting_vector(field_monitor_name: str) → xarray.core.dataset.Dataset#

return xarray.Dataset of the Poynting vector at Yee cell centers.

Calculated values represent the instantaneous Poynting vector for time-domain fields and the complex vector for frequency-domain: S = 1/2 E × conj(H).

Only the available components are returned, e.g., if the indicated monitor doesn’t include field component “Ex”, then “Sy” and “Sz” will not be calculated.

Parameters: field_monitor_name (str) – Name of field monitor used in the original Simulation.
Returns: DataArray containing the Poynting vector calculated based on the field components colocated at the center locations of the Yee grid.
Return type: xarray.DataArray

classmethod get_sub_model(group_path: str, model_dict: dict | list) → dict#: Get the sub model for a given group path.

get_submodels_by_hash() → Dict[int, List[Union[str, Tuple[str, int]]]]#: Return a dictionary of this object’s sub-models indexed by their hash values.

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.

property grad_data_symmetry: Tuple[tidy3d.components.data.monitor_data.FieldData, ...]#: self.grad_data but with symmetry_expanded_copy applied.

property grad_eps_data_symmetry: Tuple[tidy3d.components.data.monitor_data.FieldData, ...]#: self.grad_eps_data but with symmetry_expanded_copy applied.

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) → str#

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

load_field_monitor(monitor_name: str) → tidy3d.components.data.monitor_data.AbstractFieldData#: Load monitor and raise exception if not a field monitor.

make_adjoint_simulation(fwidth: float, run_time: float) → tidy3d.plugins.adjoint.components.simulation.JaxSimulation#: Make an adjoint simulation out of the data provided (generally, the vjp sim data).

Loads data for a specific monitor from a .hdf5 file with data for a SimulationData.

Parameters

fname (str) – Full path to an hdf5 file containing SimulationData data.
mnt_name (str, optional) – .name of the monitor to load the data from.
**parse_obj_kwargs – Keyword arguments passed to either pydantic’s parse_obj function when loading model.

Returns

Monitor data corresponding to the mnt_name type.

Return type

MonitorData

Example

>>> field_data = SimulationData.from_file(fname='folder/data.hdf5', mnt_name="field") 

property monitor_data: Dict[str, Union[tidy3d.plugins.adjoint.components.data.monitor_data.JaxModeData, tidy3d.plugins.adjoint.components.data.monitor_data.JaxDiffractionData, tidy3d.plugins.adjoint.components.data.monitor_data.JaxFieldData, tidy3d.components.data.monitor_data.FieldData, tidy3d.components.data.monitor_data.FieldTimeData, tidy3d.components.data.monitor_data.PermittivityData, tidy3d.components.data.monitor_data.ModeSolverData, tidy3d.components.data.monitor_data.ModeData, tidy3d.components.data.monitor_data.FluxData, tidy3d.components.data.monitor_data.FluxTimeData, tidy3d.components.data.monitor_data.FieldProjectionKSpaceData, tidy3d.components.data.monitor_data.FieldProjectionCartesianData, tidy3d.components.data.monitor_data.FieldProjectionAngleData, tidy3d.components.data.monitor_data.DiffractionData]]#: Dictionary of .output_data monitor .name to the corresponding data.

normalize_adjoint_fields() → tidy3d.plugins.adjoint.components.data.sim_data.JaxSimulationData#: Make copy of jax_sim_data with grad_data (fields) normalized by adjoint sources.

property output_monitor_data: Dict[str, Union[tidy3d.plugins.adjoint.components.data.monitor_data.JaxModeData, tidy3d.plugins.adjoint.components.data.monitor_data.JaxDiffractionData, tidy3d.plugins.adjoint.components.data.monitor_data.JaxFieldData]]#: Dictionary of .output_data monitor .name to the corresponding data.

plot_field(field_monitor_name: str, field_name: str, val: Literal['real', 'imag', 'abs', 'abs^2', 'phase'] = 'real', scale: Literal['lin', 'dB'] = 'lin', eps_alpha: float = 0.2, phase: float = 0.0, robust: bool = True, vmin: Optional[float] = None, vmax: Optional[float] = None, ax: Optional[matplotlib.axes._axes.Axes] = None, **sel_kwargs) → matplotlib.axes._axes.Axes#

Plot the field data for a monitor with simulation plot overlayed.

Parameters

field_monitor_name (str) – Name of FieldMonitor, FieldTimeData, or ModeSolverData to plot.
field_name (str) – Name of field component to plot (eg. ‘Ex’). Also accepts ‘E’ and ‘H’ to plot the vector magnitudes of the electric and magnetic fields, and ‘S’ for the Poynting vector.
val (Literal['real', 'imag', 'abs', 'abs^2', 'phase'] = 'real') – Which part of the field to plot.
scale (Literal['lin', 'dB']) – Plot in linear or logarithmic (dB) scale.
eps_alpha (float = 0.2) – Opacity of the structure permittivity. Must be between 0 and 1 (inclusive).
phase (float = 0.0) – Optional phase (radians) to apply to the fields. Only has an effect on frequency-domain fields.
robust (bool = True) – If True and vmin or vmax are absent, uses the 2nd and 98th percentiles of the data to compute the color limits. This helps in visualizing the field patterns especially in the presence of a source.
vmin (float = None) – The lower bound of data range that the colormap covers. If None, they are inferred from the data and other keyword arguments.
vmax (float = None) – The upper bound of data range that the colormap covers. If None, they are inferred from the data and other keyword arguments.
ax (matplotlib.axes._subplots.Axes = None) – matplotlib axes to plot on, if not specified, one is created.
sel_kwargs (keyword arguments used to perform .sel() selection in the monitor data.) – These kwargs can select over the spatial dimensions (x, y, z), frequency or time dimensions (f, t) or mode_index, if applicable. For the plotting to work appropriately, the resulting data after selection must contain only two coordinates with len > 1. Furthermore, these should be spatial coordinates (x, y, or z).

Returns

The supplied or created matplotlib axes.

Return type

matplotlib.axes._subplots.Axes

plot_scalar_array(field_data: xarray.core.dataarray.DataArray, axis: Literal[0, 1, 2], position: float, freq: float = None, eps_alpha: float = 0.2, robust: bool = True, vmin: float = None, vmax: float = None, cmap_type: Literal['divergent', 'sequential', 'cyclic'] = 'divergent', ax: matplotlib.axes._axes.Axes = None) → matplotlib.axes._axes.Axes#

Plot the field data for a monitor with simulation plot overlayed.

Parameters

field_data (xr.DataArray) – DataArray with the field data to plot. Must be a scalar field.
axis (Axis) – Axis normal to the plotting plane.
position (float) – Position along the axis.
freq (float = None) – Frequency at which the permittivity is evaluated at (if dispersive). By default, chooses permittivity as frequency goes to infinity.
eps_alpha (float = 0.2) – Opacity of the structure permittivity. Must be between 0 and 1 (inclusive).
robust (bool = True) – If True and vmin or vmax are absent, uses the 2nd and 98th percentiles of the data to compute the color limits. This helps in visualizing the field patterns especially in the presence of a source.
vmin (float = None) – The lower bound of data range that the colormap covers. If None, they are inferred from the data and other keyword arguments.
vmax (float = None) – The upper bound of data range that the colormap covers. If None, they are inferred from the data and other keyword arguments.
cmap_type (Literal["divergent", "sequential", "cyclic"] = "divergent") – Type of color map to use for plotting.
ax (matplotlib.axes._subplots.Axes = None) – matplotlib axes to plot on, if not specified, one is created.

Returns

The supplied or created matplotlib axes.

Return type

matplotlib.axes._subplots.Axes

renormalize(normalize_index: int) → tidy3d.components.data.sim_data.SimulationData#: Return a copy of the SimulationData with a different source used for the normalization.

source_spectrum(source_index: int) → Callable#: Get a spectrum normalization function for a given source index.

static split_data(mnt_data: List[Union[tidy3d.components.data.monitor_data.FieldData, tidy3d.components.data.monitor_data.FieldTimeData, tidy3d.components.data.monitor_data.PermittivityData, tidy3d.components.data.monitor_data.ModeSolverData, tidy3d.components.data.monitor_data.ModeData, tidy3d.components.data.monitor_data.FluxData, tidy3d.components.data.monitor_data.FluxTimeData, tidy3d.components.data.monitor_data.FieldProjectionKSpaceData, tidy3d.components.data.monitor_data.FieldProjectionCartesianData, tidy3d.components.data.monitor_data.FieldProjectionAngleData, tidy3d.components.data.monitor_data.DiffractionData]], jax_info: tidy3d.plugins.adjoint.components.simulation.JaxInfo) → Dict[str, List[Union[tidy3d.components.data.monitor_data.FieldData, tidy3d.components.data.monitor_data.FieldTimeData, tidy3d.components.data.monitor_data.PermittivityData, tidy3d.components.data.monitor_data.ModeSolverData, tidy3d.components.data.monitor_data.ModeData, tidy3d.components.data.monitor_data.FluxData, tidy3d.components.data.monitor_data.FluxTimeData, tidy3d.components.data.monitor_data.FieldProjectionKSpaceData, tidy3d.components.data.monitor_data.FieldProjectionCartesianData, tidy3d.components.data.monitor_data.FieldProjectionAngleData, tidy3d.components.data.monitor_data.DiffractionData]]]#: Split list of monitor data into data, output_data, grad_data, and grad_eps_data.

classmethod split_fwd_sim_data(sim_data: tidy3d.components.data.sim_data.SimulationData, jax_info: tidy3d.plugins.adjoint.components.simulation.JaxInfo) → Tuple[tidy3d.components.data.sim_data.SimulationData, tidy3d.components.data.sim_data.SimulationData]#: Split a SimulationData into two parts, containing user and gradient data.

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, custom_encoders: Optional[List[Callable]] = None) → None#

Exports JaxObject instance to .hdf5 file.

Parameters

fname (str) – Full path to the .hdf5 file to save the JaxObject to.
custom_encoders (List[Callable]) – List of functions accepting (fname: str, group_path: str, value: Any) that take the value supplied and write it to the hdf5 fname at group_path.

Example

>>> simulation.to_hdf5(fname='folder/sim.hdf5') 

to_hdf5_gz(fname: str, custom_encoders: Optional[List[Callable]] = None) → None#

Exports Tidy3dBaseModel instance to .hdf5.gz file.

Parameters

fname (str) – Full path to the .hdf5.gz file to save the Tidy3dBaseModel to.
custom_encoders (List[Callable]) – List of functions accepting (fname: str, group_path: str, value: Any) that take the value supplied and write it to the hdf5 fname at group_path.

Example

>>> simulation.to_hdf5_gz(fname='folder/sim.hdf5.gz') 

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

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 **kwargs indicating updated field values.

classmethod validate_no_ambiguity(val, values)#: Ensure all AbstractMonitorData entries in .data correspond to different monitors in .simulation.