tidy3d.FieldTimeData#

class tidy3d.FieldTimeData#

Bases: tidy3d.components.data.dataset.FieldTimeDataset, tidy3d.components.data.monitor_data.ElectromagneticFieldData

Data associated with a FieldTimeMonitor: scalar components of E and H fields.

Parameters

Ex (Optional[ScalarFieldTimeDataArray] = None) – Spatial distribution of the x-component of the electric field.
Ey (Optional[ScalarFieldTimeDataArray] = None) – Spatial distribution of the y-component of the electric field.
Ez (Optional[ScalarFieldTimeDataArray] = None) – Spatial distribution of the z-component of the electric field.
Hx (Optional[ScalarFieldTimeDataArray] = None) – Spatial distribution of the x-component of the magnetic field.
Hy (Optional[ScalarFieldTimeDataArray] = None) – Spatial distribution of the y-component of the magnetic field.
Hz (Optional[ScalarFieldTimeDataArray] = None) – Spatial distribution of the z-component of the magnetic field.
monitor (FieldTimeMonitor) – symmetry : Tuple[Literal[0, -1, 1], Literal[0, -1, 1], Literal[0, -1, 1]] = (0, 0, 0) Symmetry eigenvalues of the original simulation in x, y, and z.
symmetry_center (Optional[Tuple[float, float, float]] = None) – Center of the symmetry planes of the original simulation in x, y, and z. Required only if any of the symmetry field are non-zero.
grid_expanded (Optional[Grid] = None) – Grid on which the symmetry will be expanded. Required only if any of the symmetry field are non-zero.
grid_primal_correction (Union[float, FreqDataArray, TimeDataArray, FreqModeDataArray] = 1.0) – Correction factor that needs to be applied for data corresponding to a 2D monitor to take into account the finite grid in the normal direction in the simulation in which the data was computed. The factor is applied to fields defined on the primal grid locations along the normal direction.
grid_dual_correction (Union[float, FreqDataArray, TimeDataArray, FreqModeDataArray] = 1.0) – Correction factor that needs to be applied for data corresponding to a 2D monitor to take into account the finite grid in the normal direction in the simulation in which the data was computed. The factor is applied to fields defined on the dual grid locations along the normal direction.

Example

>>> from tidy3d import ScalarFieldTimeDataArray
>>> x = [-1,1]
>>> y = [-2,0,2]
>>> z = [-3,-1,1,3]
>>> t = [0, 1e-12, 2e-12]
>>> coords = dict(x=x, y=y, z=z, t=t)
>>> scalar_field = ScalarFieldTimeDataArray(np.random.random((2,3,4,3)), coords=coords)
>>> monitor = FieldTimeMonitor(size=(2,4,6), interval=100, name='field', fields=['Ex', 'Hz'])
>>> data = FieldTimeData(monitor=monitor, Ex=scalar_field, Hz=scalar_field)

Show JSON schema

{
   "title": "FieldTimeData",
   "description": "Data associated with a :class:`.FieldTimeMonitor`: scalar components of E and H fields.\n\nParameters\n----------\nEx : Optional[ScalarFieldTimeDataArray] = None\n    Spatial distribution of the x-component of the electric field.\nEy : Optional[ScalarFieldTimeDataArray] = None\n    Spatial distribution of the y-component of the electric field.\nEz : Optional[ScalarFieldTimeDataArray] = None\n    Spatial distribution of the z-component of the electric field.\nHx : Optional[ScalarFieldTimeDataArray] = None\n    Spatial distribution of the x-component of the magnetic field.\nHy : Optional[ScalarFieldTimeDataArray] = None\n    Spatial distribution of the y-component of the magnetic field.\nHz : Optional[ScalarFieldTimeDataArray] = None\n    Spatial distribution of the z-component of the magnetic field.\nmonitor : FieldTimeMonitor\n        symmetry : Tuple[Literal[0, -1, 1], Literal[0, -1, 1], Literal[0, -1, 1]] = (0, 0, 0)\n    Symmetry eigenvalues of the original simulation in x, y, and z.\nsymmetry_center : Optional[Tuple[float, float, float]] = None\n    Center of the symmetry planes of the original simulation in x, y, and z. Required only if any of the ``symmetry`` field are non-zero.\ngrid_expanded : Optional[Grid] = None\n    :class:`.Grid` on which the symmetry will be expanded. Required only if any of the ``symmetry`` field are non-zero.\ngrid_primal_correction : Union[float, FreqDataArray, TimeDataArray, FreqModeDataArray] = 1.0\n    Correction factor that needs to be applied for data corresponding to a 2D monitor to take into account the finite grid in the normal direction in the simulation in which the data was computed. The factor is applied to fields defined on the primal grid locations along the normal direction.\ngrid_dual_correction : Union[float, FreqDataArray, TimeDataArray, FreqModeDataArray] = 1.0\n    Correction factor that needs to be applied for data corresponding to a 2D monitor to take into account the finite grid in the normal direction in the simulation in which the data was computed. The factor is applied to fields defined on the dual grid locations along the normal direction.\n\nExample\n-------\n>>> from tidy3d import ScalarFieldTimeDataArray\n>>> x = [-1,1]\n>>> y = [-2,0,2]\n>>> z = [-3,-1,1,3]\n>>> t = [0, 1e-12, 2e-12]\n>>> coords = dict(x=x, y=y, z=z, t=t)\n>>> scalar_field = ScalarFieldTimeDataArray(np.random.random((2,3,4,3)), coords=coords)\n>>> monitor = FieldTimeMonitor(size=(2,4,6), interval=100, name='field', fields=['Ex', 'Hz'])\n>>> data = FieldTimeData(monitor=monitor, Ex=scalar_field, Hz=scalar_field)",
   "type": "object",
   "properties": {
      "type": {
         "title": "Type",
         "default": "FieldTimeData",
         "enum": [
            "FieldTimeData"
         ],
         "type": "string"
      },
      "Ex": {
         "title": "DataArray",
         "description": "Spatial distribution of the x-component of the electric field.",
         "type": "xr.DataArray",
         "properties": {
            "_dims": {
               "title": "_dims",
               "type": "Tuple[str, ...]"
            }
         },
         "required": [
            "_dims"
         ]
      },
      "Ey": {
         "title": "DataArray",
         "description": "Spatial distribution of the y-component of the electric field.",
         "type": "xr.DataArray",
         "properties": {
            "_dims": {
               "title": "_dims",
               "type": "Tuple[str, ...]"
            }
         },
         "required": [
            "_dims"
         ]
      },
      "Ez": {
         "title": "DataArray",
         "description": "Spatial distribution of the z-component of the electric field.",
         "type": "xr.DataArray",
         "properties": {
            "_dims": {
               "title": "_dims",
               "type": "Tuple[str, ...]"
            }
         },
         "required": [
            "_dims"
         ]
      },
      "Hx": {
         "title": "DataArray",
         "description": "Spatial distribution of the x-component of the magnetic field.",
         "type": "xr.DataArray",
         "properties": {
            "_dims": {
               "title": "_dims",
               "type": "Tuple[str, ...]"
            }
         },
         "required": [
            "_dims"
         ]
      },
      "Hy": {
         "title": "DataArray",
         "description": "Spatial distribution of the y-component of the magnetic field.",
         "type": "xr.DataArray",
         "properties": {
            "_dims": {
               "title": "_dims",
               "type": "Tuple[str, ...]"
            }
         },
         "required": [
            "_dims"
         ]
      },
      "Hz": {
         "title": "DataArray",
         "description": "Spatial distribution of the z-component of the magnetic field.",
         "type": "xr.DataArray",
         "properties": {
            "_dims": {
               "title": "_dims",
               "type": "Tuple[str, ...]"
            }
         },
         "required": [
            "_dims"
         ]
      },
      "monitor": {
         "$ref": "#/definitions/FieldTimeMonitor"
      },
      "symmetry": {
         "title": "Symmetry",
         "description": "Symmetry eigenvalues of the original simulation in x, y, and z.",
         "default": [
            0,
            0,
            0
         ],
         "type": "array",
         "minItems": 3,
         "maxItems": 3,
         "items": [
            {
               "enum": [
                  0,
                  -1,
                  1
               ],
               "type": "integer"
            },
            {
               "enum": [
                  0,
                  -1,
                  1
               ],
               "type": "integer"
            },
            {
               "enum": [
                  0,
                  -1,
                  1
               ],
               "type": "integer"
            }
         ]
      },
      "symmetry_center": {
         "title": "Symmetry Center",
         "description": "Center of the symmetry planes of the original simulation in x, y, and z. Required only if any of the ``symmetry`` field are non-zero.",
         "type": "array",
         "minItems": 3,
         "maxItems": 3,
         "items": [
            {
               "type": "number"
            },
            {
               "type": "number"
            },
            {
               "type": "number"
            }
         ]
      },
      "grid_expanded": {
         "title": "Expanded Grid",
         "description": ":class:`.Grid` on which the symmetry will be expanded. Required only if any of the ``symmetry`` field are non-zero.",
         "allOf": [
            {
               "$ref": "#/definitions/Grid"
            }
         ]
      },
      "grid_primal_correction": {
         "title": "Field correction factor",
         "description": "Correction factor that needs to be applied for data corresponding to a 2D monitor to take into account the finite grid in the normal direction in the simulation in which the data was computed. The factor is applied to fields defined on the primal grid locations along the normal direction.",
         "default": 1.0,
         "anyOf": [
            {
               "type": "number"
            },
            {
               "title": "DataArray",
               "type": "xr.DataArray",
               "properties": {
                  "_dims": {
                     "title": "_dims",
                     "type": "Tuple[str, ...]"
                  }
               },
               "required": [
                  "_dims"
               ]
            },
            {
               "title": "DataArray",
               "type": "xr.DataArray",
               "properties": {
                  "_dims": {
                     "title": "_dims",
                     "type": "Tuple[str, ...]"
                  }
               },
               "required": [
                  "_dims"
               ]
            },
            {
               "title": "DataArray",
               "type": "xr.DataArray",
               "properties": {
                  "_dims": {
                     "title": "_dims",
                     "type": "Tuple[str, ...]"
                  }
               },
               "required": [
                  "_dims"
               ]
            }
         ]
      },
      "grid_dual_correction": {
         "title": "Field correction factor",
         "description": "Correction factor that needs to be applied for data corresponding to a 2D monitor to take into account the finite grid in the normal direction in the simulation in which the data was computed. The factor is applied to fields defined on the dual grid locations along the normal direction.",
         "default": 1.0,
         "anyOf": [
            {
               "type": "number"
            },
            {
               "title": "DataArray",
               "type": "xr.DataArray",
               "properties": {
                  "_dims": {
                     "title": "_dims",
                     "type": "Tuple[str, ...]"
                  }
               },
               "required": [
                  "_dims"
               ]
            },
            {
               "title": "DataArray",
               "type": "xr.DataArray",
               "properties": {
                  "_dims": {
                     "title": "_dims",
                     "type": "Tuple[str, ...]"
                  }
               },
               "required": [
                  "_dims"
               ]
            },
            {
               "title": "DataArray",
               "type": "xr.DataArray",
               "properties": {
                  "_dims": {
                     "title": "_dims",
                     "type": "Tuple[str, ...]"
                  }
               },
               "required": [
                  "_dims"
               ]
            }
         ]
      }
   },
   "required": [
      "monitor"
   ],
   "additionalProperties": false,
   "definitions": {
      "FieldTimeMonitor": {
         "title": "FieldTimeMonitor",
         "description": ":class:`Monitor` that records electromagnetic fields in the time domain.\n\nParameters\n----------\ncenter : Tuple[float, float, float] = (0.0, 0.0, 0.0)\n    [units = um].  Center of object in x, y, and z.\nsize : Tuple[NonNegativeFloat, NonNegativeFloat, NonNegativeFloat]\n    [units = um].  Size in x, y, and z directions.\nname : ConstrainedStrValue\n    Unique name for monitor.\nstart : NonNegativeFloat = 0.0\n    [units = sec].  Time at which to start monitor recording.\nstop : Optional[NonNegativeFloat] = None\n    [units = sec].  Time at which to stop monitor recording.  If not specified, record until end of simulation.\ninterval : PositiveInt = 1\n    Number of time step intervals between monitor recordings.\nfields : Tuple[Literal['Ex', 'Ey', 'Ez', 'Hx', 'Hy', 'Hz'], ...] = ['Ex', 'Ey', 'Ez', 'Hx', 'Hy', 'Hz']\n    Collection of field components to store in the monitor.\ninterval_space : Tuple[PositiveInt, PositiveInt, PositiveInt] = (1, 1, 1)\n    Number of grid step intervals between monitor recordings. If equal to 1, there will be no downsampling. If greater than 1, fields will be downsampled and automatically colocated.\ncolocate : Optional[bool] = None\n    Toggle whether fields should be colocated to grid cell centers. Default: ``False`` if ``interval_space`` is 1 in each direction, ``True`` if ``interval_space`` is greater than one in any direction.\n\nExample\n-------\n>>> monitor = FieldTimeMonitor(\n...     center=(1,2,3),\n...     size=(2,2,2),\n...     fields=['Hx'],\n...     start=1e-13,\n...     stop=5e-13,\n...     interval=2,\n...     name='movie_monitor')",
         "type": "object",
         "properties": {
            "type": {
               "title": "Type",
               "default": "FieldTimeMonitor",
               "enum": [
                  "FieldTimeMonitor"
               ],
               "type": "string"
            },
            "center": {
               "title": "Center",
               "description": "Center of object in x, y, and z.",
               "default": [
                  0.0,
                  0.0,
                  0.0
               ],
               "units": "um",
               "type": "array",
               "minItems": 3,
               "maxItems": 3,
               "items": [
                  {
                     "type": "number"
                  },
                  {
                     "type": "number"
                  },
                  {
                     "type": "number"
                  }
               ]
            },
            "size": {
               "title": "Size",
               "description": "Size in x, y, and z directions.",
               "units": "um",
               "type": "array",
               "minItems": 3,
               "maxItems": 3,
               "items": [
                  {
                     "type": "number",
                     "minimum": 0
                  },
                  {
                     "type": "number",
                     "minimum": 0
                  },
                  {
                     "type": "number",
                     "minimum": 0
                  }
               ]
            },
            "name": {
               "title": "Name",
               "description": "Unique name for monitor.",
               "minLength": 1,
               "type": "string"
            },
            "start": {
               "title": "Start time",
               "description": "Time at which to start monitor recording.",
               "default": 0.0,
               "units": "sec",
               "minimum": 0,
               "type": "number"
            },
            "stop": {
               "title": "Stop time",
               "description": "Time at which to stop monitor recording.  If not specified, record until end of simulation.",
               "units": "sec",
               "minimum": 0,
               "type": "number"
            },
            "interval": {
               "title": "Time interval",
               "description": "Number of time step intervals between monitor recordings.",
               "default": 1,
               "exclusiveMinimum": 0,
               "type": "integer"
            },
            "fields": {
               "title": "Field Components",
               "description": "Collection of field components to store in the monitor.",
               "default": [
                  "Ex",
                  "Ey",
                  "Ez",
                  "Hx",
                  "Hy",
                  "Hz"
               ],
               "type": "array",
               "items": {
                  "enum": [
                     "Ex",
                     "Ey",
                     "Ez",
                     "Hx",
                     "Hy",
                     "Hz"
                  ],
                  "type": "string"
               }
            },
            "interval_space": {
               "title": "Spatial interval",
               "description": "Number of grid step intervals between monitor recordings. If equal to 1, there will be no downsampling. If greater than 1, fields will be downsampled and automatically colocated.",
               "default": [
                  1,
                  1,
                  1
               ],
               "type": "array",
               "minItems": 3,
               "maxItems": 3,
               "items": [
                  {
                     "type": "integer",
                     "exclusiveMinimum": 0
                  },
                  {
                     "type": "integer",
                     "exclusiveMinimum": 0
                  },
                  {
                     "type": "integer",
                     "exclusiveMinimum": 0
                  }
               ]
            },
            "colocate": {
               "title": "Colocate fields",
               "description": "Toggle whether fields should be colocated to grid cell centers. Default: ``False`` if ``interval_space`` is 1 in each direction, ``True`` if ``interval_space`` is greater than one in any direction.",
               "type": "boolean"
            }
         },
         "required": [
            "size",
            "name"
         ],
         "additionalProperties": false
      },
      "Coords": {
         "title": "Coords",
         "description": "Holds data about a set of x,y,z positions on a grid.\n\nParameters\n----------\nx : ArrayLike_dtype=<class 'float'>_ndim=1\n    1-dimensional array of x coordinates.\ny : ArrayLike_dtype=<class 'float'>_ndim=1\n    1-dimensional array of y coordinates.\nz : ArrayLike_dtype=<class 'float'>_ndim=1\n    1-dimensional array of z coordinates.\n\nExample\n-------\n>>> x = np.linspace(-1, 1, 10)\n>>> y = np.linspace(-1, 1, 11)\n>>> z = np.linspace(-1, 1, 12)\n>>> coords = Coords(x=x, y=y, z=z)",
         "type": "object",
         "properties": {
            "x": {
               "title": "ArrayLike",
               "description": "1-dimensional array of x coordinates.",
               "type": "ArrayLike"
            },
            "y": {
               "title": "ArrayLike",
               "description": "1-dimensional array of y coordinates.",
               "type": "ArrayLike"
            },
            "z": {
               "title": "ArrayLike",
               "description": "1-dimensional array of z coordinates.",
               "type": "ArrayLike"
            },
            "type": {
               "title": "Type",
               "default": "Coords",
               "enum": [
                  "Coords"
               ],
               "type": "string"
            }
         },
         "required": [
            "x",
            "y",
            "z"
         ],
         "additionalProperties": false
      },
      "Grid": {
         "title": "Grid",
         "description": "Contains all information about the spatial positions of the FDTD grid.\n\nParameters\n----------\nboundaries : Coords\n    x,y,z coordinates of the boundaries between cells, defining the FDTD grid.\n\nExample\n-------\n>>> x = np.linspace(-1, 1, 10)\n>>> y = np.linspace(-1, 1, 11)\n>>> z = np.linspace(-1, 1, 12)\n>>> coords = Coords(x=x, y=y, z=z)\n>>> grid = Grid(boundaries=coords)\n>>> centers = grid.centers\n>>> sizes = grid.sizes\n>>> yee_grid = grid.yee",
         "type": "object",
         "properties": {
            "boundaries": {
               "title": "Boundary Coordinates",
               "description": "x,y,z coordinates of the boundaries between cells, defining the FDTD grid.",
               "allOf": [
                  {
                     "$ref": "#/definitions/Coords"
                  }
               ]
            },
            "type": {
               "title": "Type",
               "default": "Grid",
               "enum": [
                  "Grid"
               ],
               "type": "string"
            }
         },
         "required": [
            "boundaries"
         ],
         "additionalProperties": false
      }
   }
}

attribute Ex: tidy3d.components.data.data_array.ScalarFieldTimeDataArray = None#

Spatial distribution of the x-component of the electric field.

Constraints

title = DataArray
type = xr.DataArray
properties = {‘_dims’: {‘title’: ‘_dims’, ‘type’: ‘Tuple[str, …]’}}
required = [‘_dims’]

Validated by

_contains_fields

attribute Ey: tidy3d.components.data.data_array.ScalarFieldTimeDataArray = None#

Spatial distribution of the y-component of the electric field.

Constraints

title = DataArray
type = xr.DataArray
properties = {‘_dims’: {‘title’: ‘_dims’, ‘type’: ‘Tuple[str, …]’}}
required = [‘_dims’]

Validated by

_contains_fields

attribute Ez: tidy3d.components.data.data_array.ScalarFieldTimeDataArray = None#

Spatial distribution of the z-component of the electric field.

Constraints

title = DataArray
type = xr.DataArray
properties = {‘_dims’: {‘title’: ‘_dims’, ‘type’: ‘Tuple[str, …]’}}
required = [‘_dims’]

Validated by

_contains_fields

attribute Hx: tidy3d.components.data.data_array.ScalarFieldTimeDataArray = None#

Spatial distribution of the x-component of the magnetic field.

Constraints

title = DataArray
type = xr.DataArray
properties = {‘_dims’: {‘title’: ‘_dims’, ‘type’: ‘Tuple[str, …]’}}
required = [‘_dims’]

Validated by

_contains_fields

attribute Hy: tidy3d.components.data.data_array.ScalarFieldTimeDataArray = None#

Spatial distribution of the y-component of the magnetic field.

Constraints

title = DataArray
type = xr.DataArray
properties = {‘_dims’: {‘title’: ‘_dims’, ‘type’: ‘Tuple[str, …]’}}
required = [‘_dims’]

Validated by

_contains_fields

attribute Hz: tidy3d.components.data.data_array.ScalarFieldTimeDataArray = None#

Spatial distribution of the z-component of the magnetic field.

Constraints

title = DataArray
type = xr.DataArray
properties = {‘_dims’: {‘title’: ‘_dims’, ‘type’: ‘Tuple[str, …]’}}
required = [‘_dims’]

Validated by

_contains_fields

attribute grid_dual_correction: Union[float, tidy3d.components.data.data_array.FreqDataArray, tidy3d.components.data.data_array.TimeDataArray, tidy3d.components.data.data_array.FreqModeDataArray] = 1.0#

Correction factor that needs to be applied for data corresponding to a 2D monitor to take into account the finite grid in the normal direction in the simulation in which the data was computed. The factor is applied to fields defined on the dual grid locations along the normal direction.

Validated by

_contains_fields

attribute grid_expanded: tidy3d.components.grid.grid.Grid = None#

Grid on which the symmetry will be expanded. Required only if any of the symmetry field are non-zero.

Validated by

_contains_fields
_make_required

attribute grid_primal_correction: Union[float, tidy3d.components.data.data_array.FreqDataArray, tidy3d.components.data.data_array.TimeDataArray, tidy3d.components.data.data_array.FreqModeDataArray] = 1.0#

Validated by

_contains_fields

attribute monitor: tidy3d.components.monitor.FieldTimeMonitor [Required]#

Validated by

_contains_fields

attribute symmetry: Tuple[Literal[0, -1, 1], Literal[0, -1, 1], Literal[0, -1, 1]] = (0, 0, 0)#

Symmetry eigenvalues of the original simulation in x, y, and z.

Validated by

_contains_fields

attribute symmetry_center: Tuple[float, float, float] = None#

Center of the symmetry planes of the original simulation in x, y, and z. Required only if any of the symmetry field are non-zero.

Validated by

_contains_fields
_make_required

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

colocate(x=None, y=None, z=None) → xarray.core.dataset.Dataset#

colocate all of the data at a set of x, y, z coordinates.

Parameters

x (Optional[array-like] = None) – x coordinates of locations. If not supplied, does not try to colocate on this dimension.
y (Optional[array-like] = None) – y coordinates of locations. If not supplied, does not try to colocate on this dimension.
z (Optional[array-like] = None) – z coordinates of locations. If not supplied, does not try to colocate on this dimension.

Returns

Dataset containing all fields at the same spatial locations. For more details refer to xarray’s Documentaton.

Return type

xr.Dataset

Note

For many operations (such as flux calculations and plotting), it is important that the fields are colocated at the same spatial locations. Be sure to apply this method to your field data in those cases.

classmethod construct(_fields_set: Optional[SetStr] = None, **values: Any) → Model#: Creates a new model setting __dict__ and __fields_set__ from trusted or pre-validated data. Default values are respected, but no other validation is performed. Behaves as if Config.extra = ‘allow’ was set since it adds all passed values

copy(**kwargs) → tidy3d.components.base.Tidy3dBaseModel#: Copy a Tidy3dBaseModel. With deep=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') 

dot(field_data: tidy3d.components.data.monitor_data.ElectromagneticFieldData, conjugate: bool = True) → xarray.core.dataarray.DataArray#: Inner product is not defined for time-domain data.

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

static get_tuple_group_name(index: int) → str#: Get the group name of a tuple element.

static get_tuple_index(key_name: str) → int#: Get the index into the tuple based on its group name.

help(methods: bool = False) → None#

Prints message describing the fields and methods of a Tidy3dBaseModel.

Parameters: methods (bool = False) – Whether to also print out information about object’s methods.

Example

>>> simulation.help(methods=True) 

json(*, include: Optional[Union[AbstractSetIntStr, MappingIntStrAny]] = None, exclude: Optional[Union[AbstractSetIntStr, MappingIntStrAny]] = None, by_alias: bool = False, skip_defaults: Optional[bool] = None, exclude_unset: bool = False, exclude_defaults: bool = False, exclude_none: bool = False, encoder: Optional[Callable[[Any], Any]] = None, models_as_dict: bool = True, **dumps_kwargs: Any) → unicode#

Generate a JSON representation of the model, include and exclude arguments as per dict().

encoder is an optional function to supply as default to json.dumps(), other arguments as per json.dumps().

normalize(source_spectrum_fn: Callable[[float], complex]) → tidy3d.components.data.dataset.Dataset#: Return copy of self after normalization is applied using source spectrum function.

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#

classmethod schema(by_alias: bool = True, ref_template: unicode = '#/definitions/{model}') → DictStrAny#

classmethod schema_json(*, by_alias: bool = True, ref_template: unicode = '#/definitions/{model}', **dumps_kwargs: Any) → unicode#

to_file(fname: str) → None#

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

classmethod validate(value: Any) → Model#

property field_components: Dict[str, tidy3d.components.data.data_array.DataArray]#: Maps the field components to thier associated data.

property flux: tidy3d.components.data.data_array.FluxTimeDataArray#: Flux for data corresponding to a 2D monitor.

property grid_locations: Dict[str, str]#: Maps field components to the string key of their grid locations on the yee lattice.

property poynting: tidy3d.components.data.data_array.ScalarFieldTimeDataArray#: Instantaneous Poynting vector for time-domain data associated to a 2D monitor, projected to the direction normal to the monitor plane.

property symmetry_eigenvalues: Dict[str, Callable[[Literal[0, 1, 2]], float]]#: Maps field components to their (positive) symmetry eigenvalues.

property symmetry_expanded_copy: tidy3d.components.data.monitor_data.AbstractFieldData#

Create a copy of the AbstractFieldData with fields expanded based on symmetry.

Returns: A data object with the symmetry expanded fields.
Return type: AbstractFieldData

property time_reversed_copy: tidy3d.components.data.monitor_data.FieldTimeData#: Make a copy of the data with time-reversed fields. The sign of the magnetic fields is flipped, and the data is reversed along the t dimension, such that for a given field, field[t_beg + t] -> field[t_end - t], where t_beg and t_end are the first and last coordinates along the t dimension.