{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Tidy3D first walkthrough\n",
"\n",
"Our first tutorial focuses on illustrating the basic setup, run, and\n",
"analysis of a `Tidy3D` simulation. In this example, we will simulate a\n",
"plane wave impinging on dielectric slab with a triangular pillar made of\n",
"a lossy dielectric sitting on top. First, we import everything needed."
],
"id": "d0e6c492-5c0c-4d91-8810-f648c4c72604"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"# standard python imports\n",
"import h5py\n",
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"\n",
"# tidy3d imports\n",
"import tidy3d as td\n",
"from tidy3d import web"
],
"id": "57789a08"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We begin by initializing general simulation parameters. To streamline\n",
"the setup and management of frequency-related values, we use the\n",
"convenience class\n",
"[FreqRange](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.FreqRange.html).\n",
"\n",
"Note that the perfectly matched layer (PML) regions extend **outside**\n",
"the user-defined simulation domain. As a result, the total computational\n",
"domain is larger than the specified simulation region—unlike in some\n",
"solvers where the PML occupies a portion of the domain itself."
],
"id": "cfe02320-4dea-4b6c-a39b-44b4b6f85f9f"
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"# Simulation domain size (in micron)\n",
"sim_size = [4, 4, 4]\n",
"\n",
"# Central frequency and bandwidth of pulsed excitation, in Hz\n",
"freq0 = 2e14\n",
"fwidth = 1e13\n",
"\n",
"# set frequency range\n",
"freq_range = td.FreqRange(freq0=freq0, fwidth=fwidth)\n",
"\n",
"# apply a PML in all directions\n",
"boundary_spec = td.BoundarySpec.all_sides(boundary=td.PML())"
],
"id": "916daa0e"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The run time of a simulation depends a lot on whether there are any\n",
"long-lived resonances. In our example here, there is no strong\n",
"resonance. Thus, we do not need to run the simulation much longer than\n",
"after the sources have decayed. We thus set the run time based on the\n",
"source bandwidth."
],
"id": "4776ba03-0394-482f-bd63-dc7c44e8e7b6"
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"# Total time to run in seconds\n",
"run_time = 2 / fwidth"
],
"id": "3f91c03b"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Structures and materials\n",
"\n",
"Next, we initialize the simulated structure. The structure consists of\n",
"two\n",
"[Structure](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.Structure.html)\n",
"objects. Each object consists of a\n",
"[Geometry](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/index.html#geometry)\n",
"and a\n",
"[Medium](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/index.html#mediums)\n",
"to define the spatial extent and material properties, respectively. Note\n",
"that the size of any object (structure, source, or monitor) can extend\n",
"beyond the simulation domain, and is truncated at the edges of that\n",
"domain.\n",
"\n",
"Note: For best results, structures that intersect with the PML or\n",
"simulation edges should extend extend all the way through. In many such\n",
"cases, an “infinite” size `td.inf` can be used to define the size along\n",
"that dimension."
],
"id": "9d7858c2-2d9a-4874-ac2d-8af2a768c932"
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"# Lossless dielectric specified directly using relative permittivity\n",
"material1 = td.Medium(permittivity=6.0)\n",
"\n",
"# Lossy dielectric defined from the real and imaginary part of the refractive index\n",
"material2 = td.Medium.from_nk(n=1.5, k=0.0, freq=freq_range.freq0)\n",
"# material2 = td.Medium(permittivity=2.)\n",
"\n",
"\n",
"# Rectangular slab, extending infinitely in x and y with medium `material1`\n",
"box = td.Structure(geometry=td.Box(center=[0, 0, 0], size=[td.inf, td.inf, 1]), medium=material1)\n",
"\n",
"# Triangle in the xy-plane with a finite extent in z\n",
"equi_tri_verts = [[-1 / 2, -1 / 4], [1 / 2, -1 / 4], [0, np.sqrt(3) / 2 - 1 / 4]]\n",
"\n",
"poly = td.Structure(\n",
" geometry=td.PolySlab(\n",
" vertices=(2 * np.array(equi_tri_verts)).tolist(),\n",
" # vertices=equi_tri_verts,\n",
" slab_bounds=(0.5, 1.0),\n",
" axis=2,\n",
" ),\n",
" medium=material2,\n",
")"
],
"id": "4850cb9c"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Sources\n",
"\n",
"Next, we define a source injecting a normal-incidence plane-wave from\n",
"above. The time dependence of the source is a Gaussian pulse. A source\n",
"can be added to multiple simulations. After we add the source to a\n",
"specific simulation, such that the total run time is known, we can use\n",
"in-built plotting tools to visualize its time- and frequency-dependence,\n",
"which we will show below."
],
"id": "a407ee8c-8bfb-4dda-b5aa-b6453b76d972"
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"psource = td.PlaneWave(\n",
" center=(0, 0, 1.5),\n",
" direction=\"-\",\n",
" size=(td.inf, td.inf, 0),\n",
" source_time=freq_range.to_gaussian_pulse(),\n",
" pol_angle=np.pi / 2,\n",
")"
],
"id": "cca25a2e"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Monitors\n",
"\n",
"Finally, we can also add some monitors that will record the fields that\n",
"we request during the simulation run.\n",
"\n",
"The two monitor types for measuring fields are\n",
"[FieldMonitor](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.FieldMonitor.html)\n",
"and\n",
"[FieldTimeMonitor](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.FieldTimeMonitor.html),\n",
"which record the frequency-domain and time-domain fields, respectively.\n",
"\n",
"[FieldMonitor](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.FieldMonitor.html)\n",
"objects operate by running a discrete Fourier transform of the fields at\n",
"a given set of frequencies to perform the calculation “in-place” with\n",
"the time stepping.\n",
"[FieldMonitor](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.FieldMonitor.html)\n",
"objects are useful for investigating the steady-state field distribution\n",
"in 2D or even 3D regions of the simulation.\n",
"\n",
"[FieldTimeMonitor](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.FieldTimeMonitor.html)\n",
"objects are best used to monitor the time dependence of the fields at a\n",
"single point, but they can also be used to create “animations” of the\n",
"field pattern evolution. Because spatially large\n",
"[FieldMonitor](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.FieldMonitor.html)\n",
"objects can lead to a very large amount of data that needs to be stored,\n",
"an optional start and stop time can be supplied, as well as an\n",
"`interval` specifying the amount of time steps between each measurement\n",
"(default of 1)."
],
"id": "eb00d41c-44f3-4e4e-beea-d7b7e72b1c58"
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"# measure time domain fields at center location, measure every 5 time steps\n",
"time_mnt = td.FieldTimeMonitor(center=[0, 0, 0], size=[0, 0, 0], interval=5, name=\"field_time\")\n",
"\n",
"# measure the steady state fields at central frequency in the xy plane and the xz plane.\n",
"freq_mnt1 = td.FieldMonitor(\n",
" center=[0, 0, -1], size=[20, 20, 0], freqs=freq_range.freqs(num_points=1), name=\"field1\"\n",
")\n",
"freq_mnt2 = td.FieldMonitor(\n",
" center=[0, 0, 0], size=[20, 0, 20], freqs=freq_range.freqs(num_points=1), name=\"field2\"\n",
")"
],
"id": "49a2ec11"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Simulation\n",
"\n",
"Now we can initialize the\n",
"[Simulation](https://docs.flexcompute.com/projects/tidy3d/en/latest/api/_autosummary/tidy3d.Simulation.html)\n",
"with all the elements defined above. A nonuniform simulation grid is\n",
"generated automatically based on a given minimum number of cells per\n",
"wavelength in each material (10 by default), using the frequencies\n",
"defined in the source.\n",
"\n",
"Tidy3D uses a hybrid floating-point precision by default as it is\n",
"practically sufficient in almost all cases, double precision should only\n",
"be explored in large simulations when very high accuracy is desired.\n",
"Even then, it might not have a noticeable effect over other sources of\n",
"numerical error like the finite grid. As this is a small example with a\n",
"minimal cost, we will simply demonstrate you can leverage this option\n",
"depending on your simulation goals."
],
"id": "c580d47d-17e6-4077-b4b2-fb38b6db1eda"
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"# Initialize simulation\n",
"sim = td.Simulation(\n",
" size=sim_size,\n",
" grid_spec=td.GridSpec.auto(min_steps_per_wvl=20),\n",
" structures=[box, poly],\n",
" sources=[psource],\n",
" monitors=[time_mnt, freq_mnt1, freq_mnt2],\n",
" run_time=run_time,\n",
" boundary_spec=boundary_spec,\n",
" precision=\"double\",\n",
")"
],
"id": "ee153ca6"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can check the simulation monitors just to make sure everything looks\n",
"right."
],
"id": "f7661d22-b677-4d0e-92ae-3004766303fe"
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/html": [
"╭───────────────────────────── < class 'tidy3d.components.monitor.FieldTimeMonitor' > ──────────────────────────────╮ \n",
"│ class FieldTimeMonitor ( *, attrs: dict = < factory >, type: Literal [ 'FieldTimeMonitor' ] = 'FieldTimeMonitor' , │ \n",
"│ center: typing.Annotated [ tuple [ typing.Annotated [ object, BeforeValidator ( func =<function │ \n",
"│ traced_alias.<locals>._validate_box_or_container at 0x7f64651faca0 >, json_schema_input_type = PydanticUndefined ) , │ \n",
"│ PlainSerializer ( func =<function traced_alias.<locals>._serialize_traced at 0x7f64651fad40 >, │ \n",
"│ return_type = PydanticUndefined , when_used = 'json' ) , <tidy3d.components.autograd.types._TracedAliasJsonSchema │ \n",
"│ object at 0x7f646522c710 > ] , typing.Annotated [ object, BeforeValidator ( func =<function │ \n",
"│ traced_alias.<locals>._validate_box_or_container at 0x7f64651faca0 >, json_schema_input_type = PydanticUndefined ) , │ \n",
"│ PlainSerializer ( func =<function traced_alias.<locals>._serialize_traced at 0x7f64651fad40 >, │ \n",
"│ return_type = PydanticUndefined , when_used = 'json' ) , <tidy3d.components.autograd.types._TracedAliasJsonSchema │ \n",
"│ object at 0x7f646522c710 > ] , typing.Annotated [ object, BeforeValidator ( func =<function │ \n",
"│ traced_alias.<locals>._validate_box_or_container at 0x7f64651faca0 >, json_schema_input_type = PydanticUndefined ) , │ \n",
"│ PlainSerializer ( func =<function traced_alias.<locals>._serialize_traced at 0x7f64651fad40 >, │ \n",
"│ return_type = PydanticUndefined , when_used = 'json' ) , <tidy3d.components.autograd.types._TracedAliasJsonSchema │ \n",
"│ object at 0x7f646522c710 > ]] , WithJsonSchema ( json_schema = { 'type' : 'array' , 'minItems' : 3 , 'maxItems' : 3 , │ \n",
"│ 'prefixItems' : [{ 'type' : 'number' } , { 'type' : 'number' } , { 'type' : 'number' }]} , mode = None )] = ( 0.0 , 0.0 , 0.0 ) , │ \n",
"│ size: typing.Annotated [ tuple [ typing.Annotated [ object, BeforeValidator ( func =<function │ \n",
"│ traced_alias.<locals>._validate_box_or_container at 0x7f64651fac00 >, json_schema_input_type = PydanticUndefined ) , │ \n",
"│ PlainSerializer ( func =<function traced_alias.<locals>._serialize_traced at 0x7f64651fa7a0 >, │ \n",
"│ return_type = PydanticUndefined , when_used = 'json' ) , <tidy3d.components.autograd.types._TracedAliasJsonSchema │ \n",
"│ object at 0x7f6465215150 > ] , typing.Annotated [ object, BeforeValidator ( func =<function │ \n",
"│ traced_alias.<locals>._validate_box_or_container at 0x7f64651fac00 >, json_schema_input_type = PydanticUndefined ) , │ \n",
"│ PlainSerializer ( func =<function traced_alias.<locals>._serialize_traced at 0x7f64651fa7a0 >, │ \n",
"│ return_type = PydanticUndefined , when_used = 'json' ) , <tidy3d.components.autograd.types._TracedAliasJsonSchema │ \n",
"│ object at 0x7f6465215150 > ] , typing.Annotated [ object, BeforeValidator ( func =<function │ \n",
"│ traced_alias.<locals>._validate_box_or_container at 0x7f64651fac00 >, json_schema_input_type = PydanticUndefined ) , │ \n",
"│ PlainSerializer ( func =<function traced_alias.<locals>._serialize_traced at 0x7f64651fa7a0 >, │ \n",
"│ return_type = PydanticUndefined , when_used = 'json' ) , <tidy3d.components.autograd.types._TracedAliasJsonSchema │ \n",
"│ object at 0x7f6465215150 > ]] , WithJsonSchema ( json_schema = { 'type' : 'array' , 'minItems' : 3 , 'maxItems' : 3 , │ \n",
"│ 'prefixItems' : [{ 'minimum' : 0 , 'type' : 'number' } , { 'minimum' : 0 , 'type' : 'number' } , { 'minimum' : 0 , 'type' : │ \n",
"│ 'number' }]} , mode = None )] , name: typing.Annotated [ str, MinLen ( min_length = 1 )] , interval_space: │ \n",
"│ tuple [ typing.Annotated [ int, Gt ( gt = 0 )] , typing.Annotated [ int, Gt ( gt = 0 )] , typing.Annotated [ int, Gt ( gt = 0 )]] = ( 1 , │ \n",
"│ 1 , 1 ) , colocate: bool = True , use_colocated_integration: bool = True , start: typing.Annotated [ float, Ge ( ge = 0 )] │ \n",
"│ = 0.0 , stop: Optional [ Annotated [ float, Ge ( ge = 0 )]] = None , interval: Optional [ Annotated [ int, Gt ( gt = 0 )]] = None , │ \n",
"│ fields: tuple [ typing.Literal [ 'Ex' , 'Ey' , 'Ez' , 'Hx' , 'Hy' , 'Hz' ] , ... ] = [ 'Ex' , 'Ey' , 'Ez' , 'Hx' , 'Hy' , 'Hz' ]) │ \n",
"│ - > None : │ \n",
"│ │ \n",
"│ :class:`~tidy3d.Monitor` that records electromagnetic fields in the time domain. │ \n",
"│ │ \n",
"│ bounding_box = < property object at 0x7f6464ba8720 > │ \n",
"│ bounds = < property object at 0x7f6465228db0 > │ \n",
"│ geometry = < property object at 0x7f6457c68130 > │ \n",
"│ model_computed_fields = {} │ \n",
"│ model_config = { │ \n",
"│ 'arbitrary_types_allowed' : True , │ \n",
"│ 'defer_build' : True , │ \n",
"│ 'validate_default' : True , │ \n",
"│ 'populate_by_name' : True , │ \n",
"│ 'ser_json_inf_nan' : 'strings' , │ \n",
"│ 'extra' : 'forbid' , │ \n",
"│ 'frozen' : True , │ \n",
"│ 'validate_by_alias' : True , │ \n",
"│ 'validate_by_name' : True │ \n",
"│ } │ \n",
"│ model_extra = < property object at 0x7f6465a94b80 > │ \n",
"│ model_fields = { │ \n",
"│ 'attrs' : FieldInfo ( │ \n",
"│ annotation =dict , │ \n",
"│ required =False , │ \n",
"│ default_factory =dict , │ \n",
"│ title ='Attributes' , │ \n",
"│ description =\"Dictionary storing arbitrary metadata for a Tidy3D object. This │ \n",
"│ dictionary can be freely used by the user for storing data without affecting the │ \n",
"│ operation of Tidy3D as it is not used internally. Note that, unlike regular Tidy3D │ \n",
"│ fields, ``attrs`` are mutable. For example, the following is allowed for setting an │ \n",
"│ ``attr`` ``obj.attrs['foo'] = bar``. Also note that Tidy3D will raise a ``TypeError`` │ \n",
"│ if ``attrs`` contain objects that can not be serialized. One can check if ``attrs`` are │ \n",
"│ serializable by calling ``obj.model_dump_json()``.\" │ \n",
"│ ) , │ \n",
"│ 'type' : FieldInfo ( │ \n",
"│ annotation =Literal [ 'FieldTimeMonitor' ] , │ \n",
"│ required =False , │ \n",
"│ default ='FieldTimeMonitor' │ \n",
"│ ) , │ \n",
"│ 'center' : FieldInfo ( │ \n",
"│ annotation =tuple [ Annotated[ object, BeforeValidator, PlainSerializer, │ \n",
"│ _TracedAliasJsonSchema] , Annotated[ object, BeforeValidator, PlainSerializer, │ \n",
"│ _TracedAliasJsonSchema] , Annotated[ object, BeforeValidator, PlainSerializer, │ \n",
"│ _TracedAliasJsonSchema]] , │ \n",
"│ required =False , │ \n",
"│ default =( 0.0 , 0.0 , 0.0 ) , │ \n",
"│ title ='Center' , │ \n",
"│ description ='Center of object in x, y, and z.' , │ \n",
"│ json_schema_extra ={ 'units' : 'um' } , │ \n",
"│ metadata =[ │ \n",
"│ WithJsonSchema ( │ \n",
"│ json_schema ={ │ \n",
"│ 'type' : 'array' , │ \n",
"│ 'minItems' : 3 , │ \n",
"│ 'maxItems' : 3 , │ \n",
"│ 'prefixItems' : [ │ \n",
"│ { 'type' : 'number' } , │ \n",
"│ { 'type' : 'number' } , │ \n",
"│ { 'type' : 'number' } │ \n",
"│ ] │ \n",
"│ } , │ \n",
"│ mode =None │ \n",
"│ ) │ \n",
"│ ] │ \n",
"│ ) , │ \n",
"│ 'size' : FieldInfo ( │ \n",
"│ annotation =tuple [ Annotated[ object, BeforeValidator, PlainSerializer, │ \n",
"│ _TracedAliasJsonSchema] , Annotated[ object, BeforeValidator, PlainSerializer, │ \n",
"│ _TracedAliasJsonSchema] , Annotated[ object, BeforeValidator, PlainSerializer, │ \n",
"│ _TracedAliasJsonSchema]] , │ \n",
"│ required =True , │ \n",
"│ title ='Size' , │ \n",
"│ description ='Size in x, y, and z directions.' , │ \n",
"│ json_schema_extra ={ 'units' : 'um' } , │ \n",
"│ metadata =[ │ \n",
"│ WithJsonSchema ( │ \n",
"│ json_schema ={ │ \n",
"│ 'type' : 'array' , │ \n",
"│ 'minItems' : 3 , │ \n",
"│ 'maxItems' : 3 , │ \n",
"│ 'prefixItems' : [ │ \n",
"│ { 'minimum' : 0 , 'type' : 'number' } , │ \n",
"│ { 'minimum' : 0 , 'type' : 'number' } , │ \n",
"│ { 'minimum' : 0 , 'type' : 'number' } │ \n",
"│ ] │ \n",
"│ } , │ \n",
"│ mode =None │ \n",
"│ ) │ \n",
"│ ] │ \n",
"│ ) , │ \n",
"│ 'name' : FieldInfo ( │ \n",
"│ annotation =str , │ \n",
"│ required =True , │ \n",
"│ title ='Name' , │ \n",
"│ description ='Unique name for monitor.' , │ \n",
"│ metadata =[ MinLen ( min_length =1 )] │ \n",
"│ ) , │ \n",
"│ 'interval_space' : FieldInfo ( │ \n",
"│ annotation =tuple [ Annotated[ int, Gt] , Annotated[ int, Gt] , Annotated[ int, Gt]] , │ \n",
"│ required =False , │ \n",
"│ default =( 1 , 1 , 1 ) , │ \n",
"│ title ='Spatial Interval' , │ \n",
"│ description ='Number of grid step intervals between monitor recordings. If equal │ \n",
"│ to 1, there will be no downsampling. If greater than 1, the step will be applied, but │ \n",
"│ the first and last point of the monitor grid are always included.' │ \n",
"│ ) , │ \n",
"│ 'colocate' : FieldInfo ( │ \n",
"│ annotation =bool , │ \n",
"│ required =False , │ \n",
"│ default =True , │ \n",
"│ title ='Colocate Fields' , │ \n",
"│ description ='Toggle whether fields should be colocated to grid cell boundaries │ \n",
"│ (i.e. primal grid nodes).' │ \n",
"│ ) , │ \n",
"│ 'use_colocated_integration' : FieldInfo ( │ \n",
"│ annotation =bool , │ \n",
"│ required =False , │ \n",
"│ default =True , │ \n",
"│ title ='Use Colocated Integration' , │ \n",
"│ description ='Only takes effect when ``colocate=False``. If ``True``, flux, dot │ \n",
"│ products, and overlap integrals still use fields interpolated to grid cell boundaries │ \n",
"│ (colocated), even though the field data is stored at native Yee grid positions. │ \n",
"│ Experimental feature that can give improved accuracy by avoiding interpolation of │ \n",
"│ fields to Yee cell positions for integration.' │ \n",
"│ ) , │ \n",
"│ 'start' : FieldInfo ( │ \n",
"│ annotation =float , │ \n",
"│ required =False , │ \n",
"│ default =0.0 , │ \n",
"│ title ='Start Time' , │ \n",
"│ description ='Time at which to start monitor recording.' , │ \n",
"│ json_schema_extra ={ 'units' : 'sec' } , │ \n",
"│ metadata =[ Ge ( ge =0 )] │ \n",
"│ ) , │ \n",
"│ 'stop' : FieldInfo ( │ \n",
"│ annotation =Union [ Annotated[ float, Ge] , NoneType] , │ \n",
"│ required =False , │ \n",
"│ default =None , │ \n",
"│ title ='Stop Time' , │ \n",
"│ description ='Time at which to stop monitor recording. If not specified, record │ \n",
"│ until end of simulation.' , │ \n",
"│ json_schema_extra ={ 'units' : 'sec' } │ \n",
"│ ) , │ \n",
"│ 'interval' : FieldInfo ( │ \n",
"│ annotation =Union [ Annotated[ int, Gt] , NoneType] , │ \n",
"│ required =False , │ \n",
"│ default =None , │ \n",
"│ title ='Time Interval' , │ \n",
"│ description ='Sampling rate of the monitor: number of time steps between each │ \n",
"│ measurement. Set ``interval`` to 1 for the highest possible resolution in time. Higher │ \n",
"│ integer values downsample the data by measuring every ``interval`` time steps. This can │ \n",
"│ be useful for reducing data storage as needed by the application.' │ \n",
"│ ) , │ \n",
"│ 'fields' : FieldInfo ( │ \n",
"│ annotation =tuple [ Literal[ 'Ex' , 'Ey' , 'Ez' , 'Hx' , 'Hy' , 'Hz' ] , ... ] , │ \n",
"│ required =False , │ \n",
"│ default =[ 'Ex' , 'Ey' , 'Ez' , 'Hx' , 'Hy' , 'Hz' ] , │ \n",
"│ title ='Field Components' , │ \n",
"│ description ='Collection of field components to store in the monitor.' │ \n",
"│ ) │ \n",
"│ } │ \n",
"│ model_fields_set = < property object at 0x7f64653611c0 > │ \n",
"│ plot_params = < property object at 0x7f6457c680e0 > │ \n",
"│ zero_dims = < property object at 0x7f6464951d00 > │ \n",
"╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ \n",
"╭─────────────────────────────── < class 'tidy3d.components.monitor.FieldMonitor' > ────────────────────────────────╮ \n",
"│ class FieldMonitor ( *, attrs: dict = < factory >, type: Literal [ 'FieldMonitor' ] = 'FieldMonitor' , center: │ \n",
"│ typing.Annotated [ tuple [ typing.Annotated [ object, BeforeValidator ( func =<function │ \n",
"│ traced_alias.<locals>._validate_box_or_container at 0x7f64651faca0 >, json_schema_input_type = PydanticUndefined ) , │ \n",
"│ PlainSerializer ( func =<function traced_alias.<locals>._serialize_traced at 0x7f64651fad40 >, │ \n",
"│ return_type = PydanticUndefined , when_used = 'json' ) , <tidy3d.components.autograd.types._TracedAliasJsonSchema │ \n",
"│ object at 0x7f646522c710 > ] , typing.Annotated [ object, BeforeValidator ( func =<function │ \n",
"│ traced_alias.<locals>._validate_box_or_container at 0x7f64651faca0 >, json_schema_input_type = PydanticUndefined ) , │ \n",
"│ PlainSerializer ( func =<function traced_alias.<locals>._serialize_traced at 0x7f64651fad40 >, │ \n",
"│ return_type = PydanticUndefined , when_used = 'json' ) , <tidy3d.components.autograd.types._TracedAliasJsonSchema │ \n",
"│ object at 0x7f646522c710 > ] , typing.Annotated [ object, BeforeValidator ( func =<function │ \n",
"│ traced_alias.<locals>._validate_box_or_container at 0x7f64651faca0 >, json_schema_input_type = PydanticUndefined ) , │ \n",
"│ PlainSerializer ( func =<function traced_alias.<locals>._serialize_traced at 0x7f64651fad40 >, │ \n",
"│ return_type = PydanticUndefined , when_used = 'json' ) , <tidy3d.components.autograd.types._TracedAliasJsonSchema │ \n",
"│ object at 0x7f646522c710 > ]] , WithJsonSchema ( json_schema = { 'type' : 'array' , 'minItems' : 3 , 'maxItems' : 3 , │ \n",
"│ 'prefixItems' : [{ 'type' : 'number' } , { 'type' : 'number' } , { 'type' : 'number' }]} , mode = None )] = ( 0.0 , 0.0 , 0.0 ) , │ \n",
"│ size: typing.Annotated [ tuple [ typing.Annotated [ object, BeforeValidator ( func =<function │ \n",
"│ traced_alias.<locals>._validate_box_or_container at 0x7f64651fac00 >, json_schema_input_type = PydanticUndefined ) , │ \n",
"│ PlainSerializer ( func =<function traced_alias.<locals>._serialize_traced at 0x7f64651fa7a0 >, │ \n",
"│ return_type = PydanticUndefined , when_used = 'json' ) , <tidy3d.components.autograd.types._TracedAliasJsonSchema │ \n",
"│ object at 0x7f6465215150 > ] , typing.Annotated [ object, BeforeValidator ( func =<function │ \n",
"│ traced_alias.<locals>._validate_box_or_container at 0x7f64651fac00 >, json_schema_input_type = PydanticUndefined ) , │ \n",
"│ PlainSerializer ( func =<function traced_alias.<locals>._serialize_traced at 0x7f64651fa7a0 >, │ \n",
"│ return_type = PydanticUndefined , when_used = 'json' ) , <tidy3d.components.autograd.types._TracedAliasJsonSchema │ \n",
"│ object at 0x7f6465215150 > ] , typing.Annotated [ object, BeforeValidator ( func =<function │ \n",
"│ traced_alias.<locals>._validate_box_or_container at 0x7f64651fac00 >, json_schema_input_type = PydanticUndefined ) , │ \n",
"│ PlainSerializer ( func =<function traced_alias.<locals>._serialize_traced at 0x7f64651fa7a0 >, │ \n",
"│ return_type = PydanticUndefined , when_used = 'json' ) , <tidy3d.components.autograd.types._TracedAliasJsonSchema │ \n",
"│ object at 0x7f6465215150 > ]] , WithJsonSchema ( json_schema = { 'type' : 'array' , 'minItems' : 3 , 'maxItems' : 3 , │ \n",
"│ 'prefixItems' : [{ 'minimum' : 0 , 'type' : 'number' } , { 'minimum' : 0 , 'type' : 'number' } , { 'minimum' : 0 , 'type' : │ \n",
"│ 'number' }]} , mode = None )] , name: typing.Annotated [ str, MinLen ( min_length = 1 )] , interval_space: │ \n",
"│ tuple [ typing.Annotated [ int, Gt ( gt = 0 )] , typing.Annotated [ int, Gt ( gt = 0 )] , typing.Annotated [ int, Gt ( gt = 0 )]] = ( 1 , │ \n",
"│ 1 , 1 ) , colocate: bool = True , use_colocated_integration: bool = True , freqs: typing.Annotated [ numpy.ndarray, │ \n",
"│ BeforeValidator ( func =<function _from_complex_dict at 0x7f646531fc40 >, │ \n",
"│ json_schema_input_type = PydanticUndefined ) , BeforeValidator ( func =<function array_alias.<locals>.<lambda> at │ \n",
"│ 0x7f64651f9760 >, json_schema_input_type = PydanticUndefined ) , PlainSerializer ( func =<function _auto_serializer at │ \n",
"│ 0x7f64651380e0 >, return_type = PydanticUndefined , when_used = 'json' ) , WithJsonSchema ( json_schema = { 'type' : │ \n",
"│ 'ArrayLike' , 'x-array-dtype' : '<f8' , 'x-array-ndim' : 1 , 'x-array-shape' : None , 'x-array-forbid_nan' : True , │ \n",
"│ 'x-array-scalar_to_1d' : True , 'x-array-strict' : False } , mode = None )] , apodization: │ \n",
"│ tidy3d.components.apodization.ApodizationSpec = <factory>, fields: tuple [ typing.Literal [ 'Ex' , 'Ey' , 'Ez' , 'Hx' , │ \n",
"│ 'Hy' , 'Hz' ] , ... ] = [ 'Ex' , 'Ey' , 'Ez' , 'Hx' , 'Hy' , 'Hz' ]) - > None : │ \n",
"│ │ \n",
"│ :class:`~tidy3d.Monitor` that records electromagnetic fields in the frequency domain. │ \n",
"│ │ \n",
"│ bounding_box = < property object at 0x7f6464ba8720 > │ \n",
"│ bounds = < property object at 0x7f6465228db0 > │ \n",
"│ frequency_range = < property object at 0x7f6457c9bd80 > │ \n",
"│ geometry = < property object at 0x7f6457c68130 > │ \n",
"│ model_computed_fields = {} │ \n",
"│ model_config = { │ \n",
"│ 'arbitrary_types_allowed' : True , │ \n",
"│ 'defer_build' : True , │ \n",
"│ 'validate_default' : True , │ \n",
"│ 'populate_by_name' : True , │ \n",
"│ 'ser_json_inf_nan' : 'strings' , │ \n",
"│ 'extra' : 'forbid' , │ \n",
"│ 'frozen' : True , │ \n",
"│ 'validate_by_alias' : True , │ \n",
"│ 'validate_by_name' : True │ \n",
"│ } │ \n",
"│ model_extra = < property object at 0x7f6465a94b80 > │ \n",
"│ model_fields = { │ \n",
"│ 'attrs' : FieldInfo ( │ \n",
"│ annotation =dict , │ \n",
"│ required =False , │ \n",
"│ default_factory =dict , │ \n",
"│ title ='Attributes' , │ \n",
"│ description =\"Dictionary storing arbitrary metadata for a Tidy3D object. This │ \n",
"│ dictionary can be freely used by the user for storing data without affecting the │ \n",
"│ operation of Tidy3D as it is not used internally. Note that, unlike regular Tidy3D │ \n",
"│ fields, ``attrs`` are mutable. For example, the following is allowed for setting an │ \n",
"│ ``attr`` ``obj.attrs['foo'] = bar``. Also note that Tidy3D will raise a ``TypeError`` │ \n",
"│ if ``attrs`` contain objects that can not be serialized. One can check if ``attrs`` are │ \n",
"│ serializable by calling ``obj.model_dump_json()``.\" │ \n",
"│ ) , │ \n",
"│ 'type' : FieldInfo ( │ \n",
"│ annotation =Literal [ 'FieldMonitor' ] , │ \n",
"│ required =False , │ \n",
"│ default ='FieldMonitor' │ \n",
"│ ) , │ \n",
"│ 'center' : FieldInfo ( │ \n",
"│ annotation =tuple [ Annotated[ object, BeforeValidator, PlainSerializer, │ \n",
"│ _TracedAliasJsonSchema] , Annotated[ object, BeforeValidator, PlainSerializer, │ \n",
"│ _TracedAliasJsonSchema] , Annotated[ object, BeforeValidator, PlainSerializer, │ \n",
"│ _TracedAliasJsonSchema]] , │ \n",
"│ required =False , │ \n",
"│ default =( 0.0 , 0.0 , 0.0 ) , │ \n",
"│ title ='Center' , │ \n",
"│ description ='Center of object in x, y, and z.' , │ \n",
"│ json_schema_extra ={ 'units' : 'um' } , │ \n",
"│ metadata =[ │ \n",
"│ WithJsonSchema ( │ \n",
"│ json_schema ={ │ \n",
"│ 'type' : 'array' , │ \n",
"│ 'minItems' : 3 , │ \n",
"│ 'maxItems' : 3 , │ \n",
"│ 'prefixItems' : [ │ \n",
"│ { 'type' : 'number' } , │ \n",
"│ { 'type' : 'number' } , │ \n",
"│ { 'type' : 'number' } │ \n",
"│ ] │ \n",
"│ } , │ \n",
"│ mode =None │ \n",
"│ ) │ \n",
"│ ] │ \n",
"│ ) , │ \n",
"│ 'size' : FieldInfo ( │ \n",
"│ annotation =tuple [ Annotated[ object, BeforeValidator, PlainSerializer, │ \n",
"│ _TracedAliasJsonSchema] , Annotated[ object, BeforeValidator, PlainSerializer, │ \n",
"│ _TracedAliasJsonSchema] , Annotated[ object, BeforeValidator, PlainSerializer, │ \n",
"│ _TracedAliasJsonSchema]] , │ \n",
"│ required =True , │ \n",
"│ title ='Size' , │ \n",
"│ description ='Size in x, y, and z directions.' , │ \n",
"│ json_schema_extra ={ 'units' : 'um' } , │ \n",
"│ metadata =[ │ \n",
"│ WithJsonSchema ( │ \n",
"│ json_schema ={ │ \n",
"│ 'type' : 'array' , │ \n",
"│ 'minItems' : 3 , │ \n",
"│ 'maxItems' : 3 , │ \n",
"│ 'prefixItems' : [ │ \n",
"│ { 'minimum' : 0 , 'type' : 'number' } , │ \n",
"│ { 'minimum' : 0 , 'type' : 'number' } , │ \n",
"│ { 'minimum' : 0 , 'type' : 'number' } │ \n",
"│ ] │ \n",
"│ } , │ \n",
"│ mode =None │ \n",
"│ ) │ \n",
"│ ] │ \n",
"│ ) , │ \n",
"│ 'name' : FieldInfo ( │ \n",
"│ annotation =str , │ \n",
"│ required =True , │ \n",
"│ title ='Name' , │ \n",
"│ description ='Unique name for monitor.' , │ \n",
"│ metadata =[ MinLen ( min_length =1 )] │ \n",
"│ ) , │ \n",
"│ 'interval_space' : FieldInfo ( │ \n",
"│ annotation =tuple [ Annotated[ int, Gt] , Annotated[ int, Gt] , Annotated[ int, Gt]] , │ \n",
"│ required =False , │ \n",
"│ default =( 1 , 1 , 1 ) , │ \n",
"│ title ='Spatial Interval' , │ \n",
"│ description ='Number of grid step intervals between monitor recordings. If equal │ \n",
"│ to 1, there will be no downsampling. If greater than 1, the step will be applied, but │ \n",
"│ the first and last point of the monitor grid are always included.' │ \n",
"│ ) , │ \n",
"│ 'colocate' : FieldInfo ( │ \n",
"│ annotation =bool , │ \n",
"│ required =False , │ \n",
"│ default =True , │ \n",
"│ title ='Colocate Fields' , │ \n",
"│ description ='Toggle whether fields should be colocated to grid cell boundaries │ \n",
"│ (i.e. primal grid nodes).' │ \n",
"│ ) , │ \n",
"│ 'use_colocated_integration' : FieldInfo ( │ \n",
"│ annotation =bool , │ \n",
"│ required =False , │ \n",
"│ default =True , │ \n",
"│ title ='Use Colocated Integration' , │ \n",
"│ description ='Only takes effect when ``colocate=False``. If ``True``, flux, dot │ \n",
"│ products, and overlap integrals still use fields interpolated to grid cell boundaries │ \n",
"│ (colocated), even though the field data is stored at native Yee grid positions. │ \n",
"│ Experimental feature that can give improved accuracy by avoiding interpolation of │ \n",
"│ fields to Yee cell positions for integration.' │ \n",
"│ ) , │ \n",
"│ 'freqs' : FieldInfo ( │ \n",
"│ annotation =ndarray , │ \n",
"│ required =True , │ \n",
"│ title ='Frequencies' , │ \n",
"│ description ='Array or list of frequencies stored by the field monitor.' , │ \n",
"│ json_schema_extra ={ 'units' : 'Hz' } , │ \n",
"│ metadata =[ │ \n",
"│ BeforeValidator ( │ \n",
"│ func =< function _from_complex_dict at 0x7f646531fc40 >, │ \n",
"│ json_schema_input_type = PydanticUndefined │ \n",
"│ ) , │ \n",
"│ BeforeValidator ( │ \n",
"│ func =<function array_alias.<locals>.<lambda> at 0x7f64651f9760 >, │ \n",
"│ json_schema_input_type = PydanticUndefined │ \n",
"│ ) , │ \n",
"│ PlainSerializer ( │ \n",
"│ func =<function _auto_serializer at 0x7f64651380e0 > , │ \n",
"│ return_type =PydanticUndefined , │ \n",
"│ when_used ='json' │ \n",
"│ ) , │ \n",
"│ WithJsonSchema ( │ \n",
"│ json_schema ={ │ \n",
"│ 'type' : 'ArrayLike' , │ \n",
"│ 'x-array-dtype' : '<f8' , │ \n",
"│ 'x-array-ndim' : 1 , │ \n",
"│ 'x-array-shape' : None , │ \n",
"│ 'x-array-forbid_nan' : True , │ \n",
"│ 'x-array-scalar_to_1d' : True , │ \n",
"│ 'x-array-strict' : False │ \n",
"│ } , │ \n",
"│ mode =None │ \n",
"│ ) │ \n",
"│ ] │ \n",
"│ ) , │ \n",
"│ 'apodization' : FieldInfo ( │ \n",
"│ annotation =ApodizationSpec , │ \n",
"│ required =False , │ \n",
"│ default_factory =ApodizationSpec , │ \n",
"│ title ='Apodization Specification' , │ \n",
"│ description ='Sets parameters of (optional) apodization. Apodization applies a │ \n",
"│ windowing function to the Fourier transform of the time-domain fields into │ \n",
"│ frequency-domain ones, and can be used to truncate the beginning and/or end of the time │ \n",
"│ signal, for example to eliminate the source pulse when studying the eigenmodes of a │ \n",
"│ system. Note: apodization affects the normalization of the frequency-domain fields.' │ \n",
"│ ) , │ \n",
"│ 'fields' : FieldInfo ( │ \n",
"│ annotation =tuple [ Literal[ 'Ex' , 'Ey' , 'Ez' , 'Hx' , 'Hy' , 'Hz' ] , ... ] , │ \n",
"│ required =False , │ \n",
"│ default =[ 'Ex' , 'Ey' , 'Ez' , 'Hx' , 'Hy' , 'Hz' ] , │ \n",
"│ title ='Field Components' , │ \n",
"│ description ='Collection of field components to store in the monitor.' │ \n",
"│ ) │ \n",
"│ } │ \n",
"│ model_fields_set = < property object at 0x7f64653611c0 > │ \n",
"│ plot_params = < property object at 0x7f6457c680e0 > │ \n",
"│ zero_dims = < property object at 0x7f6464951d00 > │ \n",
"╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ \n",
"╭─────────────────────────────── < class 'tidy3d.components.monitor.FieldMonitor' > ────────────────────────────────╮ \n",
"│ class FieldMonitor ( *, attrs: dict = < factory >, type: Literal [ 'FieldMonitor' ] = 'FieldMonitor' , center: │ \n",
"│ typing.Annotated [ tuple [ typing.Annotated [ object, BeforeValidator ( func =<function │ \n",
"│ traced_alias.<locals>._validate_box_or_container at 0x7f64651faca0 >, json_schema_input_type = PydanticUndefined ) , │ \n",
"│ PlainSerializer ( func =<function traced_alias.<locals>._serialize_traced at 0x7f64651fad40 >, │ \n",
"│ return_type = PydanticUndefined , when_used = 'json' ) , <tidy3d.components.autograd.types._TracedAliasJsonSchema │ \n",
"│ object at 0x7f646522c710 > ] , typing.Annotated [ object, BeforeValidator ( func =<function │ \n",
"│ traced_alias.<locals>._validate_box_or_container at 0x7f64651faca0 >, json_schema_input_type = PydanticUndefined ) , │ \n",
"│ PlainSerializer ( func =<function traced_alias.<locals>._serialize_traced at 0x7f64651fad40 >, │ \n",
"│ return_type = PydanticUndefined , when_used = 'json' ) , <tidy3d.components.autograd.types._TracedAliasJsonSchema │ \n",
"│ object at 0x7f646522c710 > ] , typing.Annotated [ object, BeforeValidator ( func =<function │ \n",
"│ traced_alias.<locals>._validate_box_or_container at 0x7f64651faca0 >, json_schema_input_type = PydanticUndefined ) , │ \n",
"│ PlainSerializer ( func =<function traced_alias.<locals>._serialize_traced at 0x7f64651fad40 >, │ \n",
"│ return_type = PydanticUndefined , when_used = 'json' ) , <tidy3d.components.autograd.types._TracedAliasJsonSchema │ \n",
"│ object at 0x7f646522c710 > ]] , WithJsonSchema ( json_schema = { 'type' : 'array' , 'minItems' : 3 , 'maxItems' : 3 , │ \n",
"│ 'prefixItems' : [{ 'type' : 'number' } , { 'type' : 'number' } , { 'type' : 'number' }]} , mode = None )] = ( 0.0 , 0.0 , 0.0 ) , │ \n",
"│ size: typing.Annotated [ tuple [ typing.Annotated [ object, BeforeValidator ( func =<function │ \n",
"│ traced_alias.<locals>._validate_box_or_container at 0x7f64651fac00 >, json_schema_input_type = PydanticUndefined ) , │ \n",
"│ PlainSerializer ( func =<function traced_alias.<locals>._serialize_traced at 0x7f64651fa7a0 >, │ \n",
"│ return_type = PydanticUndefined , when_used = 'json' ) , <tidy3d.components.autograd.types._TracedAliasJsonSchema │ \n",
"│ object at 0x7f6465215150 > ] , typing.Annotated [ object, BeforeValidator ( func =<function │ \n",
"│ traced_alias.<locals>._validate_box_or_container at 0x7f64651fac00 >, json_schema_input_type = PydanticUndefined ) , │ \n",
"│ PlainSerializer ( func =<function traced_alias.<locals>._serialize_traced at 0x7f64651fa7a0 >, │ \n",
"│ return_type = PydanticUndefined , when_used = 'json' ) , <tidy3d.components.autograd.types._TracedAliasJsonSchema │ \n",
"│ object at 0x7f6465215150 > ] , typing.Annotated [ object, BeforeValidator ( func =<function │ \n",
"│ traced_alias.<locals>._validate_box_or_container at 0x7f64651fac00 >, json_schema_input_type = PydanticUndefined ) , │ \n",
"│ PlainSerializer ( func =<function traced_alias.<locals>._serialize_traced at 0x7f64651fa7a0 >, │ \n",
"│ return_type = PydanticUndefined , when_used = 'json' ) , <tidy3d.components.autograd.types._TracedAliasJsonSchema │ \n",
"│ object at 0x7f6465215150 > ]] , WithJsonSchema ( json_schema = { 'type' : 'array' , 'minItems' : 3 , 'maxItems' : 3 , │ \n",
"│ 'prefixItems' : [{ 'minimum' : 0 , 'type' : 'number' } , { 'minimum' : 0 , 'type' : 'number' } , { 'minimum' : 0 , 'type' : │ \n",
"│ 'number' }]} , mode = None )] , name: typing.Annotated [ str, MinLen ( min_length = 1 )] , interval_space: │ \n",
"│ tuple [ typing.Annotated [ int, Gt ( gt = 0 )] , typing.Annotated [ int, Gt ( gt = 0 )] , typing.Annotated [ int, Gt ( gt = 0 )]] = ( 1 , │ \n",
"│ 1 , 1 ) , colocate: bool = True , use_colocated_integration: bool = True , freqs: typing.Annotated [ numpy.ndarray, │ \n",
"│ BeforeValidator ( func =<function _from_complex_dict at 0x7f646531fc40 >, │ \n",
"│ json_schema_input_type = PydanticUndefined ) , BeforeValidator ( func =<function array_alias.<locals>.<lambda> at │ \n",
"│ 0x7f64651f9760 >, json_schema_input_type = PydanticUndefined ) , PlainSerializer ( func =<function _auto_serializer at │ \n",
"│ 0x7f64651380e0 >, return_type = PydanticUndefined , when_used = 'json' ) , WithJsonSchema ( json_schema = { 'type' : │ \n",
"│ 'ArrayLike' , 'x-array-dtype' : '<f8' , 'x-array-ndim' : 1 , 'x-array-shape' : None , 'x-array-forbid_nan' : True , │ \n",
"│ 'x-array-scalar_to_1d' : True , 'x-array-strict' : False } , mode = None )] , apodization: │ \n",
"│ tidy3d.components.apodization.ApodizationSpec = <factory>, fields: tuple [ typing.Literal [ 'Ex' , 'Ey' , 'Ez' , 'Hx' , │ \n",
"│ 'Hy' , 'Hz' ] , ... ] = [ 'Ex' , 'Ey' , 'Ez' , 'Hx' , 'Hy' , 'Hz' ]) - > None : │ \n",
"│ │ \n",
"│ :class:`~tidy3d.Monitor` that records electromagnetic fields in the frequency domain. │ \n",
"│ │ \n",
"│ bounding_box = < property object at 0x7f6464ba8720 > │ \n",
"│ bounds = < property object at 0x7f6465228db0 > │ \n",
"│ frequency_range = < property object at 0x7f6457c9bd80 > │ \n",
"│ geometry = < property object at 0x7f6457c68130 > │ \n",
"│ model_computed_fields = {} │ \n",
"│ model_config = { │ \n",
"│ 'arbitrary_types_allowed' : True , │ \n",
"│ 'defer_build' : True , │ \n",
"│ 'validate_default' : True , │ \n",
"│ 'populate_by_name' : True , │ \n",
"│ 'ser_json_inf_nan' : 'strings' , │ \n",
"│ 'extra' : 'forbid' , │ \n",
"│ 'frozen' : True , │ \n",
"│ 'validate_by_alias' : True , │ \n",
"│ 'validate_by_name' : True │ \n",
"│ } │ \n",
"│ model_extra = < property object at 0x7f6465a94b80 > │ \n",
"│ model_fields = { │ \n",
"│ 'attrs' : FieldInfo ( │ \n",
"│ annotation =dict , │ \n",
"│ required =False , │ \n",
"│ default_factory =dict , │ \n",
"│ title ='Attributes' , │ \n",
"│ description =\"Dictionary storing arbitrary metadata for a Tidy3D object. This │ \n",
"│ dictionary can be freely used by the user for storing data without affecting the │ \n",
"│ operation of Tidy3D as it is not used internally. Note that, unlike regular Tidy3D │ \n",
"│ fields, ``attrs`` are mutable. For example, the following is allowed for setting an │ \n",
"│ ``attr`` ``obj.attrs['foo'] = bar``. Also note that Tidy3D will raise a ``TypeError`` │ \n",
"│ if ``attrs`` contain objects that can not be serialized. One can check if ``attrs`` are │ \n",
"│ serializable by calling ``obj.model_dump_json()``.\" │ \n",
"│ ) , │ \n",
"│ 'type' : FieldInfo ( │ \n",
"│ annotation =Literal [ 'FieldMonitor' ] , │ \n",
"│ required =False , │ \n",
"│ default ='FieldMonitor' │ \n",
"│ ) , │ \n",
"│ 'center' : FieldInfo ( │ \n",
"│ annotation =tuple [ Annotated[ object, BeforeValidator, PlainSerializer, │ \n",
"│ _TracedAliasJsonSchema] , Annotated[ object, BeforeValidator, PlainSerializer, │ \n",
"│ _TracedAliasJsonSchema] , Annotated[ object, BeforeValidator, PlainSerializer, │ \n",
"│ _TracedAliasJsonSchema]] , │ \n",
"│ required =False , │ \n",
"│ default =( 0.0 , 0.0 , 0.0 ) , │ \n",
"│ title ='Center' , │ \n",
"│ description ='Center of object in x, y, and z.' , │ \n",
"│ json_schema_extra ={ 'units' : 'um' } , │ \n",
"│ metadata =[ │ \n",
"│ WithJsonSchema ( │ \n",
"│ json_schema ={ │ \n",
"│ 'type' : 'array' , │ \n",
"│ 'minItems' : 3 , │ \n",
"│ 'maxItems' : 3 , │ \n",
"│ 'prefixItems' : [ │ \n",
"│ { 'type' : 'number' } , │ \n",
"│ { 'type' : 'number' } , │ \n",
"│ { 'type' : 'number' } │ \n",
"│ ] │ \n",
"│ } , │ \n",
"│ mode =None │ \n",
"│ ) │ \n",
"│ ] │ \n",
"│ ) , │ \n",
"│ 'size' : FieldInfo ( │ \n",
"│ annotation =tuple [ Annotated[ object, BeforeValidator, PlainSerializer, │ \n",
"│ _TracedAliasJsonSchema] , Annotated[ object, BeforeValidator, PlainSerializer, │ \n",
"│ _TracedAliasJsonSchema] , Annotated[ object, BeforeValidator, PlainSerializer, │ \n",
"│ _TracedAliasJsonSchema]] , │ \n",
"│ required =True , │ \n",
"│ title ='Size' , │ \n",
"│ description ='Size in x, y, and z directions.' , │ \n",
"│ json_schema_extra ={ 'units' : 'um' } , │ \n",
"│ metadata =[ │ \n",
"│ WithJsonSchema ( │ \n",
"│ json_schema ={ │ \n",
"│ 'type' : 'array' , │ \n",
"│ 'minItems' : 3 , │ \n",
"│ 'maxItems' : 3 , │ \n",
"│ 'prefixItems' : [ │ \n",
"│ { 'minimum' : 0 , 'type' : 'number' } , │ \n",
"│ { 'minimum' : 0 , 'type' : 'number' } , │ \n",
"│ { 'minimum' : 0 , 'type' : 'number' } │ \n",
"│ ] │ \n",
"│ } , │ \n",
"│ mode =None │ \n",
"│ ) │ \n",
"│ ] │ \n",
"│ ) , │ \n",
"│ 'name' : FieldInfo ( │ \n",
"│ annotation =str , │ \n",
"│ required =True , │ \n",
"│ title ='Name' , │ \n",
"│ description ='Unique name for monitor.' , │ \n",
"│ metadata =[ MinLen ( min_length =1 )] │ \n",
"│ ) , │ \n",
"│ 'interval_space' : FieldInfo ( │ \n",
"│ annotation =tuple [ Annotated[ int, Gt] , Annotated[ int, Gt] , Annotated[ int, Gt]] , │ \n",
"│ required =False , │ \n",
"│ default =( 1 , 1 , 1 ) , │ \n",
"│ title ='Spatial Interval' , │ \n",
"│ description ='Number of grid step intervals between monitor recordings. If equal │ \n",
"│ to 1, there will be no downsampling. If greater than 1, the step will be applied, but │ \n",
"│ the first and last point of the monitor grid are always included.' │ \n",
"│ ) , │ \n",
"│ 'colocate' : FieldInfo ( │ \n",
"│ annotation =bool , │ \n",
"│ required =False , │ \n",
"│ default =True , │ \n",
"│ title ='Colocate Fields' , │ \n",
"│ description ='Toggle whether fields should be colocated to grid cell boundaries │ \n",
"│ (i.e. primal grid nodes).' │ \n",
"│ ) , │ \n",
"│ 'use_colocated_integration' : FieldInfo ( │ \n",
"│ annotation =bool , │ \n",
"│ required =False , │ \n",
"│ default =True , │ \n",
"│ title ='Use Colocated Integration' , │ \n",
"│ description ='Only takes effect when ``colocate=False``. If ``True``, flux, dot │ \n",
"│ products, and overlap integrals still use fields interpolated to grid cell boundaries │ \n",
"│ (colocated), even though the field data is stored at native Yee grid positions. │ \n",
"│ Experimental feature that can give improved accuracy by avoiding interpolation of │ \n",
"│ fields to Yee cell positions for integration.' │ \n",
"│ ) , │ \n",
"│ 'freqs' : FieldInfo ( │ \n",
"│ annotation =ndarray , │ \n",
"│ required =True , │ \n",
"│ title ='Frequencies' , │ \n",
"│ description ='Array or list of frequencies stored by the field monitor.' , │ \n",
"│ json_schema_extra ={ 'units' : 'Hz' } , │ \n",
"│ metadata =[ │ \n",
"│ BeforeValidator ( │ \n",
"│ func =< function _from_complex_dict at 0x7f646531fc40 >, │ \n",
"│ json_schema_input_type = PydanticUndefined │ \n",
"│ ) , │ \n",
"│ BeforeValidator ( │ \n",
"│ func =<function array_alias.<locals>.<lambda> at 0x7f64651f9760 >, │ \n",
"│ json_schema_input_type = PydanticUndefined │ \n",
"│ ) , │ \n",
"│ PlainSerializer ( │ \n",
"│ func =<function _auto_serializer at 0x7f64651380e0 > , │ \n",
"│ return_type =PydanticUndefined , │ \n",
"│ when_used ='json' │ \n",
"│ ) , │ \n",
"│ WithJsonSchema ( │ \n",
"│ json_schema ={ │ \n",
"│ 'type' : 'ArrayLike' , │ \n",
"│ 'x-array-dtype' : '<f8' , │ \n",
"│ 'x-array-ndim' : 1 , │ \n",
"│ 'x-array-shape' : None , │ \n",
"│ 'x-array-forbid_nan' : True , │ \n",
"│ 'x-array-scalar_to_1d' : True , │ \n",
"│ 'x-array-strict' : False │ \n",
"│ } , │ \n",
"│ mode =None │ \n",
"│ ) │ \n",
"│ ] │ \n",
"│ ) , │ \n",
"│ 'apodization' : FieldInfo ( │ \n",
"│ annotation =ApodizationSpec , │ \n",
"│ required =False , │ \n",
"│ default_factory =ApodizationSpec , │ \n",
"│ title ='Apodization Specification' , │ \n",
"│ description ='Sets parameters of (optional) apodization. Apodization applies a │ \n",
"│ windowing function to the Fourier transform of the time-domain fields into │ \n",
"│ frequency-domain ones, and can be used to truncate the beginning and/or end of the time │ \n",
"│ signal, for example to eliminate the source pulse when studying the eigenmodes of a │ \n",
"│ system. Note: apodization affects the normalization of the frequency-domain fields.' │ \n",
"│ ) , │ \n",
"│ 'fields' : FieldInfo ( │ \n",
"│ annotation =tuple [ Literal[ 'Ex' , 'Ey' , 'Ez' , 'Hx' , 'Hy' , 'Hz' ] , ... ] , │ \n",
"│ required =False , │ \n",
"│ default =[ 'Ex' , 'Ey' , 'Ez' , 'Hx' , 'Hy' , 'Hz' ] , │ \n",
"│ title ='Field Components' , │ \n",
"│ description ='Collection of field components to store in the monitor.' │ \n",
"│ ) │ \n",
"│ } │ \n",
"│ model_fields_set = < property object at 0x7f64653611c0 > │ \n",
"│ plot_params = < property object at 0x7f6457c680e0 > │ \n",
"│ zero_dims = < property object at 0x7f6464951d00 > │ \n",
"╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ \n",
"07:19:26 UTC Created task 'Simulation' with resource_id \n",
" 'fdve-f43fef39-8a9e-4410-af43-3844ee6f8272' and task_type 'FDTD' . \n",
" View task using web UI at \n",
" 'https://tidy3d.simulation.cloud/workbench?taskId=fdve-f43fef39-8a9 e-4410-af43-3844ee6f8272' Task folder: 'default' 07:19:28 UTC Estimated FlexCredit cost: 0.025 . This assumes the FDTD solver runs\n",
" for the full simulation time; if early shutoff is reached, the \n",
" billed cost can be lower. Use 'web.real_cost(task_id)' to get the \n",
" billed FlexCredit cost after a simulation run. \n",
"07:19:29 UTC Estimated FlexCredit cost: 0.025 . This assumes the FDTD solver runs\n",
" for the full simulation time; if early shutoff is reached, the \n",
" billed cost can be lower. Use 'web.real_cost(task_id)' to get the \n",
" billed FlexCredit cost after a simulation run. \n",
" status = queued \n",
"07:19:30 UTC To cancel the simulation, use 'web.abort(task_id)' or \n",
" 'web.delete(task_id)' or abort/delete the task in the web UI. \n",
" Terminating the Python script will not stop the job running on the \n",
" cloud. \n",
"07:19:37 UTC status = preprocess \n",
"07:19:42 UTC starting up solver \n",
" running solver \n",
"07:19:44 UTC status = postprocess \n",
"07:19:47 UTC status = success \n",
"07:19:49 UTC View simulation result at \n",
" 'https://tidy3d.simulation.cloud/workbench?taskId=fdve-f43fef39-8a9 e-4410-af43-3844ee6f8272' . \n",
"07:19:53 UTC Billed flex credit cost: 0.025 . \n",
" Note: the task cost pro-rated due to early shutoff was below the \n",
" minimum threshold, due to fast shutoff. Decreasing the simulation \n",
" 'run_time' should decrease the estimated, and correspondingly the \n",
" billed cost of such tasks. \n",
"07:19:55 UTC Loading results from data/sim_data.hdf5 \n",
" WARNING: Simulation final field decay value of 1.0 is greater than \n",
" the simulation shutoff threshold of 1e-05 . Consider running the \n",
" simulation again with a larger 'run_time' duration for more \n",
" accurate results. \n",
" WARNING: Warning messages were found in the solver log. For more \n",
" information, check 'SimulationData.log' or use \n",
" 'web.download_log(task_id)' . \n",
"\n",
"\n",
"\n",
" \n",
"\n",
" \n",
" \n",
" \n",
"
<xarray.ScalarFieldDataArray (x: 157, y: 157, z: 1, f: 1)> Size: 394kB\n",
"array([[[[ 0.00000000e+00-0.00000000e+00j]],\n",
"\n",
" [[ 4.48203150e-07+1.31972893e-07j]],\n",
"\n",
" [[ 3.28867231e-06+9.01092482e-07j]],\n",
"\n",
" ...,\n",
"\n",
" [[ 5.53139835e-07-2.67624859e-09j]],\n",
"\n",
" [[ 3.61294851e-08-4.11692073e-09j]],\n",
"\n",
" [[ 0.00000000e+00-0.00000000e+00j]]],\n",
"\n",
"\n",
" [[[ 0.00000000e+00-0.00000000e+00j]],\n",
"\n",
" [[ 2.01065001e-06+5.66329251e-07j]],\n",
"\n",
" [[ 1.47039524e-05+6.04044284e-06j]],\n",
"...\n",
" [[-2.79244519e-07+2.49222499e-08j]],\n",
"\n",
" [[-1.78363466e-08+3.46077729e-09j]],\n",
"\n",
" [[ 0.00000000e+00-0.00000000e+00j]]],\n",
"\n",
"\n",
" [[[ 0.00000000e+00-0.00000000e+00j]],\n",
"\n",
" [[-2.99808838e-08-2.24377945e-09j]],\n",
"\n",
" [[-2.08019756e-07+1.15107060e-08j]],\n",
"\n",
" ...,\n",
"\n",
" [[-3.09108161e-08+8.87712743e-09j]],\n",
"\n",
" [[-2.32996161e-09+5.34137600e-10j]],\n",
"\n",
" [[ 0.00000000e+00-0.00000000e+00j]]]], shape=(157, 157, 1, 1))\n",
"Coordinates:\n",
" * x (x) float64 1kB -2.364 -2.333 -2.303 -2.273 ... 2.303 2.333 2.364\n",
" * y (y) float64 1kB -2.367 -2.337 -2.306 -2.276 ... 2.295 2.325 2.354\n",
" * z (z) float64 8B -1.0\n",
" * f (f) float64 8B 2e+14\n",
"Attributes:\n",
" long_name: field value -0j (4.482031498732715e-07+1.3197289253853975e-07j) ... -0j
array([[[[ 0.00000000e+00-0.00000000e+00j]],\n",
"\n",
" [[ 4.48203150e-07+1.31972893e-07j]],\n",
"\n",
" [[ 3.28867231e-06+9.01092482e-07j]],\n",
"\n",
" ...,\n",
"\n",
" [[ 5.53139835e-07-2.67624859e-09j]],\n",
"\n",
" [[ 3.61294851e-08-4.11692073e-09j]],\n",
"\n",
" [[ 0.00000000e+00-0.00000000e+00j]]],\n",
"\n",
"\n",
" [[[ 0.00000000e+00-0.00000000e+00j]],\n",
"\n",
" [[ 2.01065001e-06+5.66329251e-07j]],\n",
"\n",
" [[ 1.47039524e-05+6.04044284e-06j]],\n",
"...\n",
" [[-2.79244519e-07+2.49222499e-08j]],\n",
"\n",
" [[-1.78363466e-08+3.46077729e-09j]],\n",
"\n",
" [[ 0.00000000e+00-0.00000000e+00j]]],\n",
"\n",
"\n",
" [[[ 0.00000000e+00-0.00000000e+00j]],\n",
"\n",
" [[-2.99808838e-08-2.24377945e-09j]],\n",
"\n",
" [[-2.08019756e-07+1.15107060e-08j]],\n",
"\n",
" ...,\n",
"\n",
" [[-3.09108161e-08+8.87712743e-09j]],\n",
"\n",
" [[-2.32996161e-09+5.34137600e-10j]],\n",
"\n",
" [[ 0.00000000e+00-0.00000000e+00j]]]], shape=(157, 157, 1, 1)) Coordinates: (4)
Attributes: (1)