Performing visualization of simulation data¶

This notebook is a tutorial on working with Tidy3D output data.

We will cover:

• Accessing data.

• Manipulating data.

• Visualizing data.

First we import the packages we'll need.

Setup¶

Creating Simulation¶

First, let's make a Simulation so we have data to plot.

We will add each possible type of monitor into the simulation to explore their output data separately.

Visualize Geometry¶

We've created a simple waveguide with a defect / scattering region defined using a Box geometry.

A modal source is injected from the -x side of the simulation and we measure the mode amplitudes and flux at the +x side.

We've also placed a couple field monitors to visualize the field patterns.

Let's take a look at the geometry from a few cross sections.

Make normalization Simulation¶

For purposes of demonstration, let's create another simulation without the scatterer, so we can compare what the data should look like for just the straight waveguide case.

This is as simple as making a copy of the original simulation and removing the scatterer from the list of structures.

Running simulations¶

Now we will run both simulations and load them into SimulationData objects.

Since these will be a short and simple simulations, we can use the web.run function to do them all in one line.

Inspecting Log¶

Now let's take a look at the log to see if everything looks ok (fields decayed, etc).

Post-Processing¶

Now that the simulations have run and their data are loaded into the sim_data and sim0_data variables, we will explore how to access, manipulate, and visualize the data.

Accessing Data¶

Original Simulation¶

The SimulationData objects store a copy of the original Simulation, so it can be recovered if the SimulationData is loaded in a new session and the Simulation is no longer in memory.

Monitor Data¶

More importantly, the SimulationData contains a reference to the data for each of the monitors within the original Simulation. This data can be accessed directly using the name given to the monitors initially.

For example, our FluxMonitor was named 'flux' while our FluxTimeMonitor was named 'flux_time', each with a .flux attribute storing the raw data. Therefore, we can access the data as follows.

Structure of Data¶

Now that we have the data loaded, let's inspect it.

The data is stored as a DataArray object using the xarray package. You can think of it as a dataset where the flux data is stored as a large, multi-dimensional array (like a numpy array) and the coordinates along each of the dimensions are specified so it is easy to work with.

For example:

So we can see the dataset stores a 1D array of flux values (Watts) and a 1D array of frequency values (Hz).

Manipulating Data¶

We can now do some useful operations with this data, including:

There are many more things you can do with the xarray package that are not covered here, so it is best to take a look at their documentation for more details.

Plotting Data¶

These datasets have built-in plotting methods, which can be handy for quickly producing customizable plots.

Let's plot the flux data to get a feeling.

Conveniently, xarray adds a lot of the plot labels and formatting automatically, which can save some time.

Complex, Multi-dimensional Data¶

While the flux data is 1D and quite simple, the same approaches apply to more complex data, such as mode amplitude and field data, which can be complex-valued and multi-dimensional.

Let's use the ModeMonitor data as an example. We'll access the data using its name 'mode' in the original simulation and print out some of the metadata to examine.

As we can see, the data is complex-valued and contains three dimensions.

• a propagation direction for the mode, which is just positive or negative (+/-)
• an index into the list of modes returned by the solver given our initial ModeSpec specifications.
• the frequency of the mode

Let's plot the data just to get a feeling for it, using .sel() to split the forward and backward propagating modes onto separate plot axes.

As before, we can manipulate the data using basic algebra or xarray built ins, for example.

Field Data¶

Data from a FieldMonitor or FieldTimeMonitor is more complicated as it contains data from several field components.

As such, when we just grab the data by name, we don't get an xarray object, but rather a FieldData container holding all of the field components.

The field_data object contains data for each of the field components in its data_dict dictionary.

Let's look at what field components are contained.

The individual field components, themselves, can be accessed conveniently using a "dot" syntax, and are stored similarly to the flux and mode data as xarray data arrays.

In this case, the dimensions of the data are the spatial locations on the yee lattice (x,y,z) and the frequency.

Colocating Field Data¶

For many advanced plots and other manipulations, it is convenient to have the field data co-located at the same positions, since they are naturally defined on separate locations on the yee lattice. There are several convenience methods that can be used for this.

All these methods return an xarray Dataset, which provides similar functionality as the DataArray objects, but is aware of all of the field data and provides more convenience methods, as we will explore in the next section.

Plotting Fields¶

Simple¶

Plotting fields requires a little bit of manipulation to get them in the right shape, but then it is straightforward.

Advanced¶

More advanced plotting is available and is best done with the centered field data.

Structure Overlay¶

One can overlay the structure permittivity by calling plot_fields from the SimulationData object as follows:

Quiver Plots¶

Quiver plotting can be done through the centered field Dataset. We first should spatially downsample the data to be quivered to reduce clutter on the plot, which can be done by .sel() with slice(None, None, skip) range to select every skip data point along that axis.

Stream Plots¶

Stream plots can be another useful feature, although they do not take the amplitude into account, so use with caution.

Time Lapse Fields¶

For time-domain data, it can be convenient to see the fields at various snapshots of the simulation. For this, it is convenient to supply the row and col keyword arguments to plot, which expand all plots on a row or column.

Export data to csv¶

In many cases, you might want to save the monitor data as a .csv file for future use. This can be done in multiple ways. Here we demonstrate two methods as examples.

For saving a 2D array such as a field plot at a specific frequency or time instance, we can first convert the xarray.DataArray to a numpy.array using the to_numpy() method and then using numpy's savetxt() method to save the 2D numpy array as a .csv file. The spatial coordinates can be saved as separate .csv files in the same way.

If the data you want to save is higher dimensional such as the field distribution at multiple time instances, you can consider export the xarray.DataArray to a csv file using its to_dataframe() method.

It will stack the array coordinates to generate a 2D table. Import the csv file to check the content:

Load data¶

When running the simulations, we have specified the path to save the simulation data, i.e. path="data/simulation0.hdf5". It means the simulation data is saved as a .hdf5 file, which can be loaded into a SimulationData object in the future for analysis. Here we demonstrate loading the .hdf5 files using the from_file method. If you performed a mode solving simulation instead of a FDTD simulation, ModeSolverData can be loaded in a similar fashion.

After the simulation data is loaded, you can perform postprocessing as discussed above such as plotting the field distribution by using the plot_field method.

Conclusion¶

This hopefully gives some sense of what kind of data post-processing and visualization can be done in Tidy3D.

For more detailed information and reference, the best places to check out are

• API reference for SimulationData.

• Xarray documentation.

If you are new to the finite-difference time-domain (FDTD) method, we highly recommend going through our FDTD101 tutorials.