tidy3d.Medium2D#

Bases: tidy3d.components.medium.AbstractMedium

2D diagonally anisotropic medium.

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.
ss (Union[Medium, PoleResidue, Sellmeier, Lorentz, Debye, Drude, PECMedium]) – Medium describing the ss-component of the diagonal permittivity tensor. The ss-component refers to the in-plane dimension of the medium that is the first component in order of ‘x’, ‘y’, ‘z’. If the 2D material is normal to the y-axis, for example, then this determines the xx-component of the corresponding 3D medium.
tt (Union[Medium, PoleResidue, Sellmeier, Lorentz, Debye, Drude, PECMedium]) – Medium describing the tt-component of the diagonal permittivity tensor. The tt-component refers to the in-plane dimension of the medium that is the second component in order of ‘x’, ‘y’, ‘z’. If the 2D material is normal to the y-axis, for example, then this determines the zz-component of the corresponding 3D medium.

Note

Only diagonal anisotropy is currently supported.

Example

>>> drude_medium = Drude(eps_inf=2.0, coeffs=[(1,2), (3,4)])
>>> medium2d = Medium2D(ss=drude_medium, tt=drude_medium)

__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.
`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.
`eps_comp`(row, col, frequency)	Single component of the complex-valued permittivity tensor as a function of frequency.
`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_diagonal`(frequency)	Main diagonal of the complex-valued permittivity tensor as a function of frequency.
`eps_model`(frequency)	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_anisotropic_medium`(medium, axis, thickness)	Generate a `Medium2D` equivalent of a `AnisotropicMedium` with given normal axis and thickness.
`from_dispersive_medium`(medium, thickness)	Generate a `Medium2D` equivalent of a `DispersiveMedium` with a given thickness.
`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_medium`(medium, thickness)	Generate a `Medium2D` equivalent of a `Medium` with a given thickness.
`from_orm`(obj)
`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_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`.
`is_comp_pec_2d`(comp, axis)	Whether the medium is a PEC.
`json`(*[, include, exclude, by_alias, ...])	Generate a JSON representation of the model, include and exclude arguments as per dict().
`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.
`plot_sigma`(freqs[, ax])	Plot the surface conductivity of the 2D material.
`schema`([by_alias, ref_template])
`schema_json`(*[, by_alias, ref_template])
`sigma_model`(freq)	Complex-valued conductivity as a function of frequency.
`to_anisotropic_medium`(axis, thickness)	Generate a 3D `AnisotropicMedium` equivalent of a given thickness.
`to_file`(fname)	Exports `Tidy3dBaseModel` instance to .yaml, .json, or .hdf5 file
`to_hdf5`(fname[, custom_encoders])	Exports `Tidy3dBaseModel` 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`(thickness)	Generate a `Medium` equivalent of a given thickness.
`to_pole_residue`(thickness)	Generate a `PoleResidue` equivalent of a given thickness.
`to_yaml`(fname)	Exports `Tidy3dBaseModel` instance to .yaml file.
`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)
`volumetric_equivalent`(axis, adjacent_media, ...)	Produces a 3D volumetric equivalent medium.

Attributes

`elements`	The diagonal elements of the 2D medium as a dictionary.
`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.
`ss`
`tt`

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.

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

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 elements: Dict[str, Union[tidy3d.components.medium.Medium, tidy3d.components.medium.PoleResidue, tidy3d.components.medium.Sellmeier, tidy3d.components.medium.Lorentz, tidy3d.components.medium.Debye, tidy3d.components.medium.Drude, tidy3d.components.medium.PECMedium]]#: The diagonal elements of the 2D medium as a dictionary.

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

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_diagonal(frequency: float) → Tuple[complex, complex]#: Main diagonal of the complex-valued permittivity tensor as a function of frequency.

eps_model(frequency: float) → complex#: 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

classmethod from_anisotropic_medium(medium: tidy3d.components.medium.AnisotropicMedium, axis: Literal[0, 1, 2], thickness: float) → tidy3d.components.medium.Medium2D#

Generate a Medium2D equivalent of a AnisotropicMedium with given normal axis and thickness. The ss and tt components of the resulting 2D medium correspond to the first of the xx, yy, and zz components of the 3D medium, with the axis component removed.

Parameters

medium (AnisotropicMedium) – The 3D anisotropic medium to convert.
axis (Axis) – The normal axis to the 2D material.
thickness (float) – The thickness of the 3D material.

Returns

The 2D equivalent of the given 3D medium.

Return type

Medium2D

classmethod from_dispersive_medium(medium: tidy3d.components.medium.DispersiveMedium, thickness: float) → tidy3d.components.medium.Medium2D#

Generate a Medium2D equivalent of a DispersiveMedium with a given thickness.

Parameters

medium (DispersiveMedium) – The 3D dispersive medium to convert.
thickness (float) – The thickness of the 3D material.

Returns

The 2D equivalent of the given 3D medium.

Return type

Medium2D

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_medium(medium: tidy3d.components.medium.Medium, thickness: float) → tidy3d.components.medium.Medium2D#

Generate a Medium2D equivalent of a Medium with a given thickness.

Parameters

medium (Medium) – The 3D medium to convert.
thickness (float) – The thickness of the 3D material.

Returns

The 2D equivalent of the given 3D medium.

Return type

Medium2D

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

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) 

is_comp_pec_2d(comp: Literal[0, 1, 2], axis: Literal[0, 1, 2])#: Whether the medium is a PEC.

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

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.

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.

plot_sigma(freqs: float, ax: matplotlib.axes._axes.Axes = None) → matplotlib.axes._axes.Axes#: Plot the surface conductivity of the 2D material.

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

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

to_anisotropic_medium(axis: Literal[0, 1, 2], thickness: float) → tidy3d.components.medium.AnisotropicMedium#

Generate a 3D AnisotropicMedium equivalent of a given thickness.

Parameters

axis (Axis) – The normal axis to the 2D medium.
thickness (float) – The thickness of the desired 3D medium.

Returns

The 3D equivalent of this 2D medium.

Return type

AnisotropicMedium

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 Tidy3dBaseModel instance to .hdf5 file.

Parameters

fname (str) – Full path to the .hdf5 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(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(thickness: float) → tidy3d.components.medium.Medium#

Generate a Medium equivalent of a given thickness. The 2D medium must be isotropic in-plane (otherwise the components are averaged) and non-dispersive besides a constant conductivity.

Parameters: thickness (float) – The thickness of the desired 3D medium.
Returns: The 3D equivalent of this 2D medium.
Return type: Medium

to_pole_residue(thickness: float) → tidy3d.components.medium.PoleResidue#

Generate a PoleResidue equivalent of a given thickness. The 2D medium to be isotropic in-plane (otherwise the components are averaged).

Parameters: thickness (float) – The thickness of the desired 3D medium.
Returns: The 3D equivalent pole residue model of this 2D medium.
Return type: PoleResidue

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

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.

Produces a 3D volumetric equivalent medium. The new medium has thickness equal to the average of the dls in the axis direction. The ss and tt components of the 2D material are mapped in order onto the xx, yy, and zz components of the 3D material, excluding the axis component. The conductivity and residues (in the case of a dispersive 2D material) are rescaled by 1/dl. The neighboring media neighbors enter in as a background for the resulting volumetric equivalent.

Parameters

axis (Axis) – Index (0, 1, or 2 for x, y, or z respectively) of the normal direction to the 2D material.
adjacent_media (Tuple[MediumType3D, MediumType3D]) – The neighboring media on either side of the 2D material. The first element is directly on the - side of the 2D material in the supplied axis, and the second element is directly on the + side.
adjacent_dls (Tuple[float, float]) – Each dl represents twice the thickness of the desired volumetric model on the respective side of the 2D material.

Returns

The 3D material corresponding to this 2D material.

Return type

AnisotropicMedium