tidy3d.plugins.adjoint.JaxStructure#

class tidy3d.plugins.adjoint.JaxStructure#

Bases: tidy3d.components.structure.Structure, tidy3d.plugins.adjoint.components.base.JaxObject

A Structure registered with jax.

Parameters

geometry (JaxBox) – Geometry of the structure, which is jax-compatible.
name (Optional[str] = None) – Optional name for the structure.
medium (Union[JaxMedium, JaxAnisotropicMedium, JaxCustomMedium]) – Medium of the structure, which is jax-compatible.

Show JSON schema

{
   "title": "JaxStructure",
   "description": "A :class:`.Structure` registered with jax.\n\nParameters\n----------\ngeometry : JaxBox\n    Geometry of the structure, which is jax-compatible.\nname : Optional[str] = None\n    Optional name for the structure.\nmedium : Union[JaxMedium, JaxAnisotropicMedium, JaxCustomMedium]\n    Medium of the structure, which is jax-compatible.",
   "type": "object",
   "properties": {
      "type": {
         "title": "Type",
         "default": "JaxStructure",
         "enum": [
            "JaxStructure"
         ],
         "type": "string"
      },
      "geometry": {
         "title": "Geometry",
         "description": "Geometry of the structure, which is jax-compatible.",
         "jax_field": true,
         "allOf": [
            {
               "$ref": "#/definitions/JaxBox"
            }
         ]
      },
      "name": {
         "title": "Name",
         "description": "Optional name for the structure.",
         "type": "string"
      },
      "medium": {
         "title": "Medium",
         "description": "Medium of the structure, which is jax-compatible.",
         "jax_field": true,
         "anyOf": [
            {
               "$ref": "#/definitions/JaxMedium"
            },
            {
               "$ref": "#/definitions/JaxAnisotropicMedium"
            },
            {
               "$ref": "#/definitions/JaxCustomMedium"
            }
         ]
      }
   },
   "required": [
      "geometry",
      "medium"
   ],
   "additionalProperties": false,
   "definitions": {
      "JaxBox": {
         "title": "JaxBox",
         "description": "A :class:`.Box` registered with jax.\n\nParameters\n----------\ncenter : Tuple[Union[float, NumpyArrayType, Array, JVPTracer], Union[float, NumpyArrayType, Array, JVPTracer], Union[float, NumpyArrayType, Array, JVPTracer]]\n    Center of the box in (x,y,z). May contain ``jax`` ``DeviceArray`` instances.\nsize : Tuple[Union[float, NumpyArrayType, Array, JVPTracer], Union[float, NumpyArrayType, Array, JVPTracer], Union[float, NumpyArrayType, Array, JVPTracer]]\n    Size of the box in (x,y,z). May contain ``jax`` ``DeviceArray`` instances.",
         "type": "object",
         "properties": {
            "type": {
               "title": "Type",
               "default": "JaxBox",
               "enum": [
                  "JaxBox"
               ],
               "type": "string"
            },
            "center": {
               "title": "Center",
               "description": "Center of the box in (x,y,z). May contain ``jax`` ``DeviceArray`` instances.",
               "jax_field": true,
               "type": "array",
               "minItems": 3,
               "maxItems": 3,
               "items": [
                  {
                     "anyOf": [
                        {
                           "type": "number"
                        },
                        {
                           "title": "npdarray",
                           "type": "numpy.ndarray"
                        },
                        {
                           "title": "DeviceArray",
                           "type": "jaxlib.xla_extension.DeviceArray"
                        },
                        {
                           "title": "JVPTracer",
                           "type": "jax.interpreters.ad.JVPTracer"
                        }
                     ]
                  },
                  {
                     "anyOf": [
                        {
                           "type": "number"
                        },
                        {
                           "title": "npdarray",
                           "type": "numpy.ndarray"
                        },
                        {
                           "title": "DeviceArray",
                           "type": "jaxlib.xla_extension.DeviceArray"
                        },
                        {
                           "title": "JVPTracer",
                           "type": "jax.interpreters.ad.JVPTracer"
                        }
                     ]
                  },
                  {
                     "anyOf": [
                        {
                           "type": "number"
                        },
                        {
                           "title": "npdarray",
                           "type": "numpy.ndarray"
                        },
                        {
                           "title": "DeviceArray",
                           "type": "jaxlib.xla_extension.DeviceArray"
                        },
                        {
                           "title": "JVPTracer",
                           "type": "jax.interpreters.ad.JVPTracer"
                        }
                     ]
                  }
               ]
            },
            "size": {
               "title": "Size",
               "description": "Size of the box in (x,y,z). May contain ``jax`` ``DeviceArray`` instances.",
               "jax_field": true,
               "type": "array",
               "minItems": 3,
               "maxItems": 3,
               "items": [
                  {
                     "anyOf": [
                        {
                           "type": "number"
                        },
                        {
                           "title": "npdarray",
                           "type": "numpy.ndarray"
                        },
                        {
                           "title": "DeviceArray",
                           "type": "jaxlib.xla_extension.DeviceArray"
                        },
                        {
                           "title": "JVPTracer",
                           "type": "jax.interpreters.ad.JVPTracer"
                        }
                     ]
                  },
                  {
                     "anyOf": [
                        {
                           "type": "number"
                        },
                        {
                           "title": "npdarray",
                           "type": "numpy.ndarray"
                        },
                        {
                           "title": "DeviceArray",
                           "type": "jaxlib.xla_extension.DeviceArray"
                        },
                        {
                           "title": "JVPTracer",
                           "type": "jax.interpreters.ad.JVPTracer"
                        }
                     ]
                  },
                  {
                     "anyOf": [
                        {
                           "type": "number"
                        },
                        {
                           "title": "npdarray",
                           "type": "numpy.ndarray"
                        },
                        {
                           "title": "DeviceArray",
                           "type": "jaxlib.xla_extension.DeviceArray"
                        },
                        {
                           "title": "JVPTracer",
                           "type": "jax.interpreters.ad.JVPTracer"
                        }
                     ]
                  }
               ]
            }
         },
         "required": [
            "center",
            "size"
         ],
         "additionalProperties": false
      },
      "JaxMedium": {
         "title": "JaxMedium",
         "description": "A :class:`.Medium` registered with jax.\n\nParameters\n----------\nname : Optional[str] = None\n    Optional unique name for medium.\nfrequency_range : Optional[Tuple[float, float]] = None\n    [units = (Hz, Hz)].  Optional range of validity for the medium.\npermittivity : Union[float, NumpyArrayType, Array, JVPTracer] = 1.0\n    Relative permittivity of the medium. May be a ``jax`` ``DeviceArray``.\nconductivity : ConstrainedFloatValue = 0.0\n    [units = S/um].  Electric conductivity.  Defined such that the imaginary part of the complex permittivity at angular frequency omega is given by conductivity/omega.",
         "type": "object",
         "properties": {
            "type": {
               "title": "Type",
               "default": "JaxMedium",
               "enum": [
                  "JaxMedium"
               ],
               "type": "string"
            },
            "name": {
               "title": "Name",
               "description": "Optional unique name for medium.",
               "type": "string"
            },
            "frequency_range": {
               "title": "Frequency Range",
               "description": "Optional range of validity for the medium.",
               "units": [
                  "Hz",
                  "Hz"
               ],
               "type": "array",
               "minItems": 2,
               "maxItems": 2,
               "items": [
                  {
                     "type": "number"
                  },
                  {
                     "type": "number"
                  }
               ]
            },
            "permittivity": {
               "title": "Permittivity",
               "description": "Relative permittivity of the medium. May be a ``jax`` ``DeviceArray``.",
               "default": 1.0,
               "jax_field": true,
               "anyOf": [
                  {
                     "type": "number"
                  },
                  {
                     "title": "npdarray",
                     "type": "numpy.ndarray"
                  },
                  {
                     "title": "DeviceArray",
                     "type": "jaxlib.xla_extension.DeviceArray"
                  },
                  {
                     "title": "JVPTracer",
                     "type": "jax.interpreters.ad.JVPTracer"
                  }
               ]
            },
            "conductivity": {
               "title": "Conductivity",
               "description": "Electric conductivity.  Defined such that the imaginary part of the complex permittivity at angular frequency omega is given by conductivity/omega.",
               "default": 0.0,
               "minimum": 0.0,
               "units": "S/um",
               "type": "number"
            }
         },
         "additionalProperties": false
      },
      "JaxAnisotropicMedium": {
         "title": "JaxAnisotropicMedium",
         "description": "A :class:`.Medium` registered with jax.\n\nParameters\n----------\nname : Optional[str] = None\n    Optional unique name for medium.\nfrequency_range : Optional[Tuple[float, float]] = None\n    [units = (Hz, Hz)].  Optional range of validity for the medium.\nxx : JaxMedium\n    Medium describing the xx-component of the diagonal permittivity tensor.\nyy : JaxMedium\n    Medium describing the yy-component of the diagonal permittivity tensor.\nzz : JaxMedium\n    Medium describing the zz-component of the diagonal permittivity tensor.",
         "type": "object",
         "properties": {
            "type": {
               "title": "Type",
               "default": "JaxAnisotropicMedium",
               "enum": [
                  "JaxAnisotropicMedium"
               ],
               "type": "string"
            },
            "name": {
               "title": "Name",
               "description": "Optional unique name for medium.",
               "type": "string"
            },
            "frequency_range": {
               "title": "Frequency Range",
               "description": "Optional range of validity for the medium.",
               "units": [
                  "Hz",
                  "Hz"
               ],
               "type": "array",
               "minItems": 2,
               "maxItems": 2,
               "items": [
                  {
                     "type": "number"
                  },
                  {
                     "type": "number"
                  }
               ]
            },
            "xx": {
               "title": "XX Component",
               "description": "Medium describing the xx-component of the diagonal permittivity tensor.",
               "jax_field": true,
               "allOf": [
                  {
                     "$ref": "#/definitions/JaxMedium"
                  }
               ]
            },
            "yy": {
               "title": "YY Component",
               "description": "Medium describing the yy-component of the diagonal permittivity tensor.",
               "jax_field": true,
               "allOf": [
                  {
                     "$ref": "#/definitions/JaxMedium"
                  }
               ]
            },
            "zz": {
               "title": "ZZ Component",
               "description": "Medium describing the zz-component of the diagonal permittivity tensor.",
               "jax_field": true,
               "allOf": [
                  {
                     "$ref": "#/definitions/JaxMedium"
                  }
               ]
            }
         },
         "required": [
            "xx",
            "yy",
            "zz"
         ],
         "additionalProperties": false
      },
      "JaxDataArray": {
         "title": "JaxDataArray",
         "description": "A :class:`.DataArray`-like class that only wraps xarray for jax compability.\n\nParameters\n----------\nvalues : Optional[Any]\n    Nested list containing the raw values, which can be tracked by jax.\ncoords : Mapping[str, list]\n    Dictionary storing the coordinates, namely ``(direction, f, mode_index)``.",
         "type": "object",
         "properties": {
            "values": {
               "title": "Values",
               "description": "Nested list containing the raw values, which can be tracked by jax.",
               "jax_field": true
            },
            "coords": {
               "title": "Coords",
               "description": "Dictionary storing the coordinates, namely ``(direction, f, mode_index)``.",
               "type": "object",
               "additionalProperties": {
                  "type": "array",
                  "items": {}
               }
            },
            "type": {
               "title": "Type",
               "default": "JaxDataArray",
               "enum": [
                  "JaxDataArray"
               ],
               "type": "string"
            }
         },
         "required": [
            "values",
            "coords"
         ],
         "additionalProperties": false
      },
      "JaxPermittivityDataset": {
         "title": "JaxPermittivityDataset",
         "description": "A :class:`.PermittivityDataset` registered with jax.\n\nParameters\n----------\neps_xx : JaxDataArray\n    Spatial distribution of the xx-component of the relative permittivity.\neps_yy : JaxDataArray\n    Spatial distribution of the yy-component of the relative permittivity.\neps_zz : JaxDataArray\n    Spatial distribution of the zz-component of the relative permittivity.",
         "type": "object",
         "properties": {
            "type": {
               "title": "Type",
               "default": "JaxPermittivityDataset",
               "enum": [
                  "JaxPermittivityDataset"
               ],
               "type": "string"
            },
            "eps_xx": {
               "title": "Epsilon xx",
               "description": "Spatial distribution of the xx-component of the relative permittivity.",
               "jax_field": true,
               "allOf": [
                  {
                     "$ref": "#/definitions/JaxDataArray"
                  }
               ]
            },
            "eps_yy": {
               "title": "Epsilon yy",
               "description": "Spatial distribution of the yy-component of the relative permittivity.",
               "jax_field": true,
               "allOf": [
                  {
                     "$ref": "#/definitions/JaxDataArray"
                  }
               ]
            },
            "eps_zz": {
               "title": "Epsilon zz",
               "description": "Spatial distribution of the zz-component of the relative permittivity.",
               "jax_field": true,
               "allOf": [
                  {
                     "$ref": "#/definitions/JaxDataArray"
                  }
               ]
            }
         },
         "required": [
            "eps_xx",
            "eps_yy",
            "eps_zz"
         ],
         "additionalProperties": false
      },
      "JaxCustomMedium": {
         "title": "JaxCustomMedium",
         "description": "A :class:`.CustomMedium` registered with ``jax``.\nNote: The gradient calculation assumes uniform field across the pixel.\nTherefore, the accuracy degrades as the pixel size becomes large\nwith respect to the field variation.\n\n\nParameters\n----------\nname : Optional[str] = None\n    Optional unique name for medium.\nfrequency_range : Optional[Tuple[float, float]] = None\n    [units = (Hz, Hz)].  Optional range of validity for the medium.\neps_dataset : JaxPermittivityDataset\n    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.\ninterp_method : Literal['nearest', 'linear'] = nearest\n    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.",
         "type": "object",
         "properties": {
            "type": {
               "title": "Type",
               "default": "JaxCustomMedium",
               "enum": [
                  "JaxCustomMedium"
               ],
               "type": "string"
            },
            "name": {
               "title": "Name",
               "description": "Optional unique name for medium.",
               "type": "string"
            },
            "frequency_range": {
               "title": "Frequency Range",
               "description": "Optional range of validity for the medium.",
               "units": [
                  "Hz",
                  "Hz"
               ],
               "type": "array",
               "minItems": 2,
               "maxItems": 2,
               "items": [
                  {
                     "type": "number"
                  },
                  {
                     "type": "number"
                  }
               ]
            },
            "eps_dataset": {
               "title": "Permittivity Dataset",
               "description": "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.",
               "jax_field": true,
               "allOf": [
                  {
                     "$ref": "#/definitions/JaxPermittivityDataset"
                  }
               ]
            },
            "interp_method": {
               "title": "Interpolation method",
               "description": "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.",
               "default": "nearest",
               "enum": [
                  "nearest",
                  "linear"
               ],
               "type": "string"
            }
         },
         "required": [
            "eps_dataset"
         ],
         "additionalProperties": false
      }
   }
}

attribute geometry: tidy3d.plugins.adjoint.components.geometry.JaxBox [Required]#: Geometry of the structure, which is jax-compatible.

attribute medium: Union[tidy3d.plugins.adjoint.components.medium.JaxMedium, tidy3d.plugins.adjoint.components.medium.JaxAnisotropicMedium, tidy3d.plugins.adjoint.components.medium.JaxCustomMedium] [Required]#

Medium of the structure, which is jax-compatible.

Validated by

_check_2d_geometry

attribute name: str = None#

Optional name for the structure.

Validated by

field_has_unique_names

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

Parameters

fname (str) – Full path to the .yaml or .json 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 = '') → 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.

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

eps_diagonal(frequency: float, coords: tidy3d.components.grid.grid.Coords) → Tuple[complex, complex, complex]#

Main diagonal of the complex-valued permittivity tensor as a function of frequency.

Parameters: frequency (float) – Frequency to evaluate permittivity at (Hz).
Returns: The diagonal elements of the relative permittivity tensor evaluated at frequency.
Return type: complex

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

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

Parameters

fname (str) – Full path to the .yaml or .json 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 = '', **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.
**parse_obj_kwargs – Keyword arguments passed to pydantic’s parse_obj method.

Example

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

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_orm(obj: Any) → Model#

classmethod from_structure(structure: tidy3d.components.structure.Structure) → tidy3d.plugins.adjoint.components.structure.JaxStructure#: Convert Structure to JaxStructure.

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.

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.

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

make_grad_monitors(freq: float, name: str) → tidy3d.components.monitor.FieldMonitor#: Return gradient monitor associated with this object.

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(x: float = None, y: float = None, z: float = None, ax: matplotlib.axes._axes.Axes = None, **patch_kwargs) → matplotlib.axes._axes.Axes#

Plot structure’s geometric cross section at single (x,y,z) coordinate.

Parameters

x (float = None) – Position of plane in x direction, only one of x,y,z can be specified to define plane.
y (float = None) – Position of plane in y direction, only one of x,y,z can be specified to define plane.
z (float = None) – Position of plane in z direction, only one of x,y,z can be specified to define plane.
ax (matplotlib.axes._subplots.Axes = None) – Matplotlib axes to plot on, if not specified, one is created.
**patch_kwargs – Optional keyword arguments passed to the matplotlib patch plotting of structure. For details on accepted values, refer to Matplotlib’s documentation.

Returns

The supplied or created matplotlib axes.

Return type

matplotlib.axes._subplots.Axes

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#

store_vjp(grad_data_fwd: tidy3d.components.data.monitor_data.FieldData, grad_data_adj: tidy3d.components.data.monitor_data.FieldData, grad_data_eps: tidy3d.components.data.monitor_data.PermittivityData, sim_bounds: Tuple[Tuple[float, float, float], Tuple[float, float, float]]) → tidy3d.plugins.adjoint.components.structure.JaxStructure#: Returns the gradient of the structure parameters given forward and adjoint field 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) → None#

Exports Tidy3dBaseModel instance to .hdf5 file.

Parameters: fname (str) – Full path to the .hdf5 file to save the Tidy3dBaseModel to.

Example

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

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_structure() → tidy3d.components.structure.Structure#: Convert JaxStructure instance to Structure

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(value: Any) → Model#