In this example, we will walk you through performing a simple inverse design optimization of a 3D waveguide crossing.

In this example, we'll be using a pixelated material grid to define the design region. However, one could also use shape parameterization to solve the same problem. You can see how this is done for a waveguide bend here.

If you are unfamiliar with inverse design, we also recommend our intro to inverse design tutorials and our primer on automatic differentiation with tidy3d.

Before using Tidy3D, you must first sign up for a user account. See this link for installation instructions.

In this tutorial we are demonstrating the smoothed projection by Alec Hammond et al. from the paper "Unifying and accelerating level-set and density-based topology optimization by subpixel-smoothed projection". You can find the article here.

Setup¶

First we import the packages we need and also define some of the global parameters that define our problem.

Important note: we use autograd.numpy instead of regular numpy, this allows numpy functions to be differentiable. If one forgets this step, the error may be a bit opaque, just a heads up.

Next, we will define all the components that make up our "base" simulation. This simulation defines the static portion of our optimization, which doesn't change over the iterations. Since our simulation scene has a symmetry in the y and z-axis, we will include the correspoding symmetry flag in the Simulation definition. This makes the simulation four times as fast and also reduces cost by a factor of four. For a tutorial on symmetries in simulations check out this notebook here.

For now, we'll include a definition of the design region geometry, just to have that on hand later, but will not include a design region in the base simulation as we'll add it later.

Let's visualize the base simulations to verify that they look correct. The shaded region indicates that we are using a symmetry condition to determine the fields in this region, such that this region does not need to be simulated.

Define Parameterization¶

Next, we will define how our design region is constructed as a function of our optimization parameters.

We will define a structure containing a grid of permittivity values defined by an array. Since we have a symmetric waveguide crossing, we only need to optimize 1/8 of the design volume. Therefore, we use some symmetry helper functions to constrain our device to these symmetries.

We will convolve our optimization parameters with a conic filter to smooth the features over a given radius. Then we will add a smoothed projection function (see the paper here for full details). The advantage of this projection is that we can work with fully binarized structures in our simulation. Since we assume that our topology should not change during optimization, we can use a value of $\beta = \infty$ during the whole simulation process, which completely binarizes the design except for a small boundary at the interface change. If we want to change the topology during optimization, we could also add a scheduling for the beta parameter, increasing it step-wise towards $\beta = \infty$. However, for our example this is not necessary.

For more details on the parameterization process, we highly recommend our short tutorial, which explains the process in more detail.

Next, it is very convenient to wrap this in a function that returns an updated copy of the base simulation with the design region added. We'll be calling this in our objective function. We'll also add some logic to exclude field monitors if they aren't needed, for example during the optimization.

To start with the optimization, we need some initial parameters that can be optimized. These initial parameters could be chosen randomly, but the optimization will run faster and need less iterations to converge if we start from a design that is already performing a little better than random. In this case it is very easy to come up with such a design: We just initialize our parameters such that they represent the waveguides of the base simulations, which we defined above. In other words, we initialize our parameters such that they represent a naive waveguide crossing where the two waveguides simply overlap.

However, it can be a bit difficult to work out how the parameters should look to form this structure in the simulation since there is a smoothing and projection involved. Luckily, we have a helper function, which automatically determines how the parameters should look to represent the base simulation. This helper function takes the desired simulation as input and optimizes our initial parameters to reflect this simulation as best as possible.

Let's take a look at the resulting parameters which form the initial design. The raw parameters look noisy, but due to the conic filter and smoothed projection the parameters used in simulations form the initial cross design.

We can also run a quick simulation with a field monitor added to verify how poorly the initial device is transmitting. This gives us lots of room to improve things through optimization!

Define Objective Function¶

The next step is to define the metric that we want to optimize, or our "figure of merit". We will first write a function to compute the transmission (between 0-1) of the output mode given the simulation data.

Next we can put everything together into a single objective function.

Optimization¶

Getting the gradient of the objective function is easy using autograd. Calling g = autograd.value_and_grad(f) returns a function g that when evaluated returns the objective function value and its gradient.

We use this as it's more efficient and we don't have to re-compute the objective during the gradient calculation step if we want to store the value too.

Let's construct this function now and have it ready to use in the main optimization loop.

Next we will run the optimizer, we first make a cell to define the parameters and some convenience functions and objects to store our history.

And then we can iteratively update our optimizer and parameters using the gradient calculated in each step.

We'll throw in a quick visualization of our device material density just to keep an eye on things as the optimization progresses.

Note: the following optimization loop will take about half an hour. To run fewer iterations, just change num_steps to something smaller above.

Analysis¶

Now is the fun part! We get to take a look at our optimization results.

We first plot the objective function values over the course of optimization, which should show a steady increase. Since the curve has not yet leveled off completely, we can conclude that we could run the optimization for longer to achieve even more improvements.

Next, we can look at the performance of our optimized device, we first construct it using the final parameter values and then take a look at the design.

This optimized device seems to have some very intricate structures, which might be difficult to fabricate. This can be recifified by adding an additional loss term penalizing small structures. You can take a look at this notebook on how this may be done.

Let's add a multi-frequency mode monitor and a field monitor to inspect the performance.

It seems to perform quite well! Let's export the simulation to a GDS file for fabrication!

Other Examples¶

Here are some other selected inverse design examples if you want to explore more!

• Mode converter
• Shape optimized taper
• Metalens optimization
• Wavelength division de-multiplexer