tidy3d.plugins.adjoint.JaxCustomMedium#

class tidy3d.plugins.adjoint.JaxCustomMedium(*, type: Literal['JaxCustomMedium'] = 'JaxCustomMedium', name: str = None, frequency_range: Tuple[float, float] = None, allow_gain: bool = False, nonlinear_spec: Union[tidy3d.components.medium.NonlinearSpec, tidy3d.components.medium.NonlinearSusceptibility] = None, modulation_spec: tidy3d.components.time_modulation.ModulationSpec = None, heat_spec: Optional[Union[tidy3d.components.heat_spec.FluidSpec, tidy3d.components.heat_spec.SolidSpec]] = None, interp_method: Literal['nearest', 'linear'] = 'nearest', subpixel: bool = False, eps_dataset: Optional[tidy3d.plugins.adjoint.components.data.dataset.JaxPermittivityDataset] = None, permittivity: Optional[tidy3d.plugins.adjoint.components.data.data_array.JaxDataArray] = None, conductivity: Optional[tidy3d.plugins.adjoint.components.data.data_array.JaxDataArray] = None)#

Bases: tidy3d.components.medium.CustomMedium, tidy3d.plugins.adjoint.components.medium.AbstractJaxMedium

A CustomMedium registered with jax. Note: The gradient calculation assumes uniform field across the pixel. Therefore, the accuracy degrades as the pixel size becomes large with respect to the field variation.

Parameters

name (Optional[str] = None) – Optional unique name for medium.
frequency_range (Optional[Tuple[float, float]] = None) – [units = (Hz, Hz)]. Optional range of validity for the medium.
allow_gain (bool = False) – Allow the medium to be active. Caution: simulations with a gain medium are unstable, and are likely to diverge.Simulations where ‘allow_gain’ is set to ‘True’ will still be charged even if diverged. Monitor data up to the divergence point will still be returned and can be useful in some cases.
nonlinear_spec (Union[NonlinearSpec, NonlinearSusceptibility] = None) – Nonlinear spec applied on top of the base medium properties.
modulation_spec (Optional[ModulationSpec] = None) – Modulation spec applied on top of the base medium properties.
heat_spec (Union[FluidSpec, SolidSpec, NoneType] = None) – Specification of the medium heat properties. They are used for solving the heat equation via the HeatSimulation interface. Such simulations can be used for investigating the influence of heat propagation on the properties of optical systems. Once the temperature distribution in the system is found using HeatSimulation object, Simulation.perturbed_mediums_copy() can be used to convert mediums with perturbation models defined into spatially dependent custom mediums. Otherwise, the heat_spec does not directly affect the running of an optical Simulation.
interp_method (Literal['nearest', 'linear'] = nearest) – Interpolation method to obtain permittivity values that are not supplied at the Yee grids; For grids outside the range of the supplied data, extrapolation will be applied. When the extrapolated value is smaller (greater) than the minimal (maximal) of the supplied data, the extrapolated value will take the minimal (maximal) of the supplied data.
subpixel (bool = False) – If True and simulation’s subpixel is also True, applies subpixel averaging of the permittivity on the interface of the structure, including exterior boundary and intersection interfaces with other structures.
eps_dataset (Optional[JaxPermittivityDataset] = None) – User-supplied dataset containing complex-valued permittivity as a function of space. Permittivity distribution over the Yee-grid will be interpolated based on the data nearest to the grid location.
permittivity (Optional[JaxDataArray] = None) – Spatial profile of relative permittivity.
conductivity (Optional[JaxDataArray] = None) – Spatial profile Electric conductivity. Defined such that the imaginary part of the complex permittivity at angular frequency omega is given by conductivity/omega.

__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.
`construct`([_fields_set])	Creates a new model setting __dict__ and __fields_set__ from trusted or pre-validated data.
`copy`(**kwargs)	Copy a Tidy3dBaseModel.
`d_eps_map`(grad_data_fwd, grad_data_adj, ...)	Mapping of gradient w.r.t.
`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.
`e_mult_volume`(field, grad_data_fwd, ...)	Get the E_fwd * E_adj * dV field distribution inside of the discretized volume.
`eps_comp`(row, col, frequency)	Single component of the complex-valued permittivity tensor as a function of frequency.
`eps_comp_on_grid`(row, col, frequency, coords)	Spatial profile of a single component of the complex-valued permittivity tensor at `frequency` interpolated at the supplied coordinates.
`eps_complex_to_eps_sigma`(eps_complex, freq)	Convert complex permittivity at frequency `freq` to permittivity and conductivity values.
`eps_complex_to_nk`(eps_c)	Convert complex permittivity to n, k values.
`eps_dataarray_freq`(frequency)	"Permittivity array at `frequency`
`eps_diagonal`(frequency)	Main diagonal of the complex-valued permittivity tensor at `frequency`.
`eps_diagonal_on_grid`(frequency, coords)	Spatial profile of main diagonal of the complex-valued permittivity at `frequency` interpolated at the supplied coordinates.
`eps_model`(frequency)	Spatial and polarizaiton average of complex-valued permittivity as a function of frequency.
`eps_sigma_to_eps_complex`(eps_real, sigma, freq)	convert permittivity and conductivity to complex permittivity at freq
`from_eps_raw`(eps[, freq, interp_method])	Construct a `CustomMedium` from datasets containing raw permittivity values.
`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_nk`(n[, k, freq, interp_method])	Construct a `CustomMedium` from datasets containing n and k values.
`from_orm`(obj)
`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_jax_field_names`()	Returns list of field names that have a `jax_field_type`.
`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.
`grids`(bounds)	Make a `Grid` corresponding to the data in each `eps_ii` component.
`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().
`make_inside_mask`(vol_coords, inside_fn)	Make a 3D mask of where the volume coordinates are inside a supplied function.
`nk_model`(frequency)	Real and imaginary parts of the refactive index as a function of frequency.
`nk_to_eps_complex`(n[, k])	Convert n, k to complex permittivity.
`nk_to_eps_sigma`(n, k, freq)	Convert `n`, `k` at frequency `freq` to permittivity and conductivity values.
`parse_file`(path, *[, content_type, ...])
`parse_obj`(obj)
`parse_raw`(b, *[, content_type, encoding, ...])
`plot`(freqs[, ax])	Plot n, k of a `Medium` as a function of frequency.
`schema`([by_alias, ref_template])
`schema_json`(*[, by_alias, ref_template])
`sigma_model`(freq)	Complex-valued conductivity as a function of frequency.
`store_vjp`(grad_data_fwd, grad_data_adj, ...)	Returns the gradient of the medium parameters given forward and adjoint field 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_medium`()	Convert `JaxMedium` instance to `Medium`
`to_tidy3d`()	Convert self to tidy3d component.
`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)

Attributes

`freqs`	float array of frequencies.
`is_isotropic`	Check if the medium is isotropic or anisotropic.
`is_pec`	Whether the medium is a PEC.
`n_cfl`	This property computes the index of refraction related to CFL condition, so that the FDTD with this medium is stable when the time step size that doesn't take material factor into account is multiplied by n_cfl`.
`time_modulated`	Whether any component of the medium is time modulated.
`permittivity`
`conductivity`
`eps_dataset`

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.

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

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.

d_eps_map(grad_data_fwd: tidy3d.components.data.monitor_data.FieldData, grad_data_adj: tidy3d.components.data.monitor_data.FieldData, sim_bounds: Tuple[Tuple[float, float, float], Tuple[float, float, float]], wvl_mat: float, inside_fn: Callable) → xarray.core.dataarray.DataArray#: Mapping of gradient w.r.t. permittivity at each point in discretized volume.

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

e_mult_volume(field: Literal['Ex', 'Ey', 'Ez'], grad_data_fwd: tidy3d.components.data.monitor_data.FieldData, grad_data_adj: tidy3d.components.data.monitor_data.FieldData, vol_coords: Dict[str, numpy.ndarray], d_vol: float, inside_fn: Callable) → xarray.core.dataarray.DataArray#: Get the E_fwd * E_adj * dV field distribution inside of the discretized volume.

eps_comp(row: Literal[0, 1, 2], col: Literal[0, 1, 2], frequency: float) → complex#

Single component of the complex-valued permittivity tensor as a function of frequency.

Parameters

row (int) – Component’s row in the permittivity tensor (0, 1, or 2 for x, y, or z respectively).
col (int) – Component’s column in the permittivity tensor (0, 1, or 2 for x, y, or z respectively).
frequency (float) – Frequency to evaluate permittivity at (Hz).

Returns

Element of the relative permittivity tensor evaluated at frequency.

Return type

complex

eps_comp_on_grid(row: Literal[0, 1, 2], col: Literal[0, 1, 2], frequency: float, coords: tidy3d.components.grid.grid.Coords) → tidy3d.components.types.ArrayLike[dtype=complex, ndim=3]#

Spatial profile of a single component of the complex-valued permittivity tensor at frequency interpolated at the supplied coordinates.

Parameters

row (int) – Component’s row in the permittivity tensor (0, 1, or 2 for x, y, or z respectively).
col (int) – Component’s column in the permittivity tensor (0, 1, or 2 for x, y, or z respectively).
frequency (float) – Frequency to evaluate permittivity at (Hz).
coords (Coords) – The grid point coordinates over which interpolation is performed.

Returns

Single component of the complex-valued permittivity tensor at frequency interpolated at the supplied coordinates.

Return type

ArrayComplex3D

static eps_complex_to_eps_sigma(eps_complex: complex, freq: float) → Tuple[float, float]#

Convert complex permittivity at frequency freq to permittivity and conductivity values.

Parameters

eps_complex (complex) – Complex-valued relative permittivity.
freq (float) – Frequency to evaluate permittivity at (Hz).

Returns

Real part of relative permittivity & electric conductivity.

Return type

Tuple[float, float]

static eps_complex_to_nk(eps_c: complex) → Tuple[float, float]#

Convert complex permittivity to n, k values.

Parameters: eps_c (complex) – Complex-valued relative permittivity.
Returns: Real and imaginary parts of refractive index (n & k).
Return type: Tuple[float, float]

eps_dataarray_freq(frequency: float)#: “Permittivity array at frequency

eps_diagonal(frequency: float) → Tuple[complex, complex, complex]#: Main diagonal of the complex-valued permittivity tensor at frequency. Spatially, we take max{|eps|}, so that autoMesh generation works appropriately.

eps_diagonal_on_grid(frequency: float, coords: tidy3d.components.grid.grid.Coords) → Tuple[tidy3d.components.types.ArrayLike[dtype=complex, ndim=3], tidy3d.components.types.ArrayLike[dtype=complex, ndim=3], tidy3d.components.types.ArrayLike[dtype=complex, ndim=3]]#

Spatial profile of main diagonal of the complex-valued permittivity at frequency interpolated at the supplied coordinates.

Parameters

frequency (float) – Frequency to evaluate permittivity at (Hz).
coords (Coords) – The grid point coordinates over which interpolation is performed.

Returns

The complex-valued permittivity tensor at frequency interpolated at the supplied coordinate.

Return type

Tuple[ArrayComplex3D, ArrayComplex3D, ArrayComplex3D]

eps_model(frequency: float) → complex#: Spatial and polarizaiton average of complex-valued permittivity as a function of frequency.

static eps_sigma_to_eps_complex(eps_real: float, sigma: float, freq: float) → complex#

convert permittivity and conductivity to complex permittivity at freq

Parameters

eps_real (float) – Real-valued relative permittivity.
sigma (float) – Conductivity.
freq (float) – Frequency to evaluate permittivity at (Hz). If not supplied, returns real part of permittivity (limit as frequency -> infinity.)

Returns

Complex-valued relative permittivity.

Return type

complex

property freqs: numpy.ndarray#: float array of frequencies. This field is to be deprecated in v3.0.

classmethod from_eps_raw(eps: Union[tidy3d.components.data.data_array.ScalarFieldDataArray, tidy3d.components.data.data_array.SpatialDataArray], freq: Optional[float] = None, interp_method: Literal['nearest', 'linear'] = 'nearest', **kwargs) → tidy3d.components.medium.CustomMedium#

Construct a CustomMedium from datasets containing raw permittivity values.

Parameters

eps (Union[SpatialDataArray, ScalarFieldDataArray]) – Dataset containing complex-valued permittivity as a function of space.
freq (float, optional) – Frequency at which eps are defined.
interp_method (InterpMethod, optional) – Interpolation method to obtain permittivity values that are not supplied at the Yee grids.

Note

For lossy medium that has a complex-valued eps, if eps is supplied through SpatialDataArray, which doesn’t contain frequency information, the freq kwarg will be used to evaluate the permittivity and conductivity. Alternatively, eps can be supplied through ScalarFieldDataArray, which contains a frequency coordinate. In this case, leave freq kwarg as the default of None.

Returns: Medium containing the spatially varying permittivity data.
Return type: CustomMedium

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_nk(n: Union[tidy3d.components.data.data_array.ScalarFieldDataArray, tidy3d.components.data.data_array.SpatialDataArray], k: Optional[Union[tidy3d.components.data.data_array.ScalarFieldDataArray, tidy3d.components.data.data_array.SpatialDataArray]] = None, freq: Optional[float] = None, interp_method: Literal['nearest', 'linear'] = 'nearest', **kwargs) → tidy3d.components.medium.CustomMedium#

Construct a CustomMedium from datasets containing n and k values.

Parameters

n (Union[SpatialDataArray, ScalarFieldDataArray]) – Real part of refractive index.
k (Union[SpatialDataArray, ScalarFieldDataArray], optional) – Imaginary part of refrative index for lossy medium.
freq (float, optional) – Frequency at which n and k are defined.
interp_method (InterpMethod, optional) – Interpolation method to obtain permittivity values that are not supplied at the Yee grids.

Note

For lossy medium, if both n and k are supplied through SpatialDataArray, which doesn’t contain frequency information, the freq kwarg will be used to evaluate the permittivity and conductivity. Alternatively, n and k can be supplied through ScalarFieldDataArray, which contains a frequency coordinate. In this case, leave freq kwarg as the default of None.

Returns: Medium containing the spatially varying permittivity data.
Return type: CustomMedium

classmethod from_tidy3d(tidy3d_obj: tidy3d.components.medium.CustomMedium) → tidy3d.plugins.adjoint.components.medium.JaxCustomMedium#: 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.

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.

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.

grids(bounds: Tuple[Tuple[float, float, float], Tuple[float, float, float]]) → Dict[str, tidy3d.components.grid.grid.Grid]#: Make a Grid corresponding to the data in each eps_ii component. The min and max coordinates along each dimension are bounded by bounds.

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) 

property is_isotropic: bool#: Check if the medium is isotropic or anisotropic.

property is_pec#: Whether the medium is a PEC.

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

static make_inside_mask(vol_coords: Dict[str, numpy.ndarray], inside_fn: Callable) → xarray.core.dataarray.DataArray#: Make a 3D mask of where the volume coordinates are inside a supplied function.

property n_cfl#

This property computes the index of refraction related to CFL condition, so that the FDTD with this medium is stable when the time step size that doesn’t take material factor into account is multiplied by n_cfl`.

For dispersiveless custom medium, it equals min[sqrt(eps_inf)], where min is performed over all components and spatial points.

nk_model(frequency: float) → Tuple[float, float]#

Real and imaginary parts of the refactive index as a function of frequency.

Parameters: frequency (float) – Frequency to evaluate permittivity at (Hz).
Returns: Real part (n) and imaginary part (k) of refractive index of medium.
Return type: Tuple[float, float]

static nk_to_eps_complex(n: float, k: float = 0.0) → complex#

Convert n, k to complex permittivity.

Parameters

n (float) – Real part of refractive index.
k (float = 0.0) – Imaginary part of refrative index.

Returns

Complex-valued relative permittivity.

Return type

complex

static nk_to_eps_sigma(n: float, k: float, freq: float) → Tuple[float, float]#

Convert n, k at frequency freq to permittivity and conductivity values.

Parameters

n (float) – Real part of refractive index.
k (float = 0.0) – Imaginary part of refrative index.
frequency (float) – Frequency to evaluate permittivity at (Hz).

Returns

Real part of relative permittivity & electric conductivity.

Return type

Tuple[float, float]

plot(freqs: float, ax: matplotlib.axes._axes.Axes = None) → matplotlib.axes._axes.Axes#

Plot n, k of a Medium as a function of frequency.

Parameters

freqs (float) – Frequencies (Hz) to evaluate the medium properties at.
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

sigma_model(freq: float) → complex#

Complex-valued conductivity as a function of frequency.

Parameters: freq (float) – Frequency to evaluate conductivity at (Hz).
Returns: Complex conductivity at this frequency.
Return type: complex

store_vjp(grad_data_fwd: tidy3d.components.data.monitor_data.FieldData, grad_data_adj: tidy3d.components.data.monitor_data.FieldData, sim_bounds: Tuple[Tuple[float, float, float], Tuple[float, float, float]], wvl_mat: float, inside_fn: Callable[[numpy.ndarray, numpy.ndarray, numpy.ndarray], numpy.ndarray]) → tidy3d.plugins.adjoint.components.medium.JaxMedium#: Returns the gradient of the medium parameters given forward and adjoint field data.

property time_modulated: bool#: Whether any component of the medium is time modulated.

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_medium() → tidy3d.components.medium.CustomMedium#: Convert JaxMedium instance to Medium

to_tidy3d() → tidy3d.plugins.adjoint.components.medium.AbstractJaxMedium#: Convert self to tidy3d component.

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.