0:00 All right. Okay. Yeah. So, my, my name is Greg Roberts. I’m a research scientist at Flexcompute. Originally, one of our co-founders, Qiqi, was going to come also give this talk with me, but he unfortunately couldn’t make it down. So I I’ll give the the whole talk today. My background is a little bit different. The original title of the talk was to talk about CFD and GPU native simulation for it.

0:32 But my background is a little more in electromagnetics. So I’ll kind of switch things up a little and do a little title title change on you guys. And actually talk more just generally about how simulation helps us in computer aided optimization. And I’ll try and illustrate some core concept for Flexcompute that we can learn about a bit through electromagnetics and electromagnetic design. So to be fully transparent, we’ll just fully say EM simulations and optimizations for today.

1:06 So a little background on myself. I did my PhD at Caltech in applied physics where I worked on photonic metamaterials. I worked on this for volutric metamaterials where we were trying to push the capabilities of three-dimensional metamaterial design for improving image sensor technology both in efficiency and capabilities. And for this we used a design technique called inverse design that you may or may not be familiar with but if not we’ll talk about it a little bit today.

6:29 And we actually made these three-dimensional devices that could sit on top of camera image sensors and printed them using two photon lithography with submicron feature sizes and showed that while a little bit rough in performance they do do what they’re supposed to and a lot of the challenges that I actually I faced in my PhD in getting these things to work are things that we’re actively working on at Flexcompute.

One of which is actually making the process of doing a design like this easy and accessible to users and another one that these are inherently hard to make robust while keeping the performance and that’s something that will be a big theme of the talk today. So I’ll start with kind of talking a bit about the big idea behind what we do at Flexcompute and then we’ll talk a little bit more specifically about this idea of inverse design in the context of electromagnetics and finally talk about a key challenge that kind of illustrates and hopefully pulls together the goals of Flexcompute and the types of things we’re enabling for our users.

So let’s start with the introduction to FlexMP compute and and what we do. So at Flexcompute, we build high-speed GPU accelerated physics solvers. These are used across a large variety of industries by a bunch of different users. There’s over 200 companies that use our solvers and over 10,000 engineers that that take advantage of the performance we have. The main ones you’re most likely familiar with u are ones for electromagnetics and ones for computational fluid dynamics.

But there’s other ones either being created or the initial versions of them have already been pushed out. We’re building things for radio frequency solving as well as heat and charge simulations. So I would say the beginning of this slide probably needs very little introduction. But we are likely all familiar with the idea that hardware can be a very difficult thing to do in practice and hardware iteration can be slow, it can be costly and it can also be risky.

And on the other hand, we often think of software as something that is the opposite in many ways. The development time of software is usually fast. It’s low cost and carries little risk. If we can simulate something, we would much rather do that than actually make it unless there’s some real reason we need to actually make the device. So the big dream at Flexcompute is how can we bridge this gap?

Can we make hardware innovation as easy as software? And I want to talk about this as I mentioned before with a common challenge in photonic design. But first I want to just introduce that this idea of inverse design in tidy3d which is our electromagnetic solver at Flexcompute and show how we make computational design accessible to people using the software and make it and make it as easy as setting up and running simulations.

So in order to talk about this I’d like to show a pretty common design problem for photonic integrated circuit design. One where we want to couple light from outside of a photonic chip into the waveguides that are on that chip or vice versa. Couple light that is flowing around this chip outside of the chip into free space. And in order to do that the way people one way people do this is to design a grading coupler.

And the grading coupler’s sole purpose is to do exactly that. Couple a known input excitation into the chip. So a blayer grading coupler is one that you can see where it uses multiple layers of design. Something that in order to extract the most amount of performance out, you often need a either some sort of optimization algorithm and it’s difficult to do with purely just intuitive types of design.

And here I’m just putting up a figure from a paper where they did a global optimization on on this type of grading coupler design. So they turned the problem into a few different geometric parameters that they could optimize and ran a global search to find the best gradient coupler they could find with those parameters. So the difference in inverse design is we actually usually kind of sounds like we make the problem a little bit more complex and we actually increase usually the the amount of parameters we can work with and increase the parameterization space that we can design in.

6:35 So maybe we remove some restrictions like periodic and we make it not strictly periodic anymore. We design every tooth of the grading coupler instead of assuming some of them are the same and we essentially make our problem sound a little bit harder. And in order to actually optimize in this space, usually it means we can’t take advantage of a global optimization solution because we now have many many parameters we’re working with.

7:00 And instead we turn to something like a local optimizer, one that uses gradient information to slowly evolve and iterate the device towards something very high performing. So a key question is is there a way to efficiently compute that gradient when you have a lot of degrees of freedom or a a highdimensional optimization problem like this. And I won’t explain this in too much detail, but I’ll show an illustration to kind of motivate the kind of work we’ve done at Flexcompute to make this type of stuff easy.

7:32 And the way to do this in electromagnetics is to actually use something called the adjint method. In the adjoin method, we have usually a simulation that represents how our device will be excited in in the real world. So we have some input input excitation and forward simulation we call. And then depending on what we want our device to do, we can actually figure out another simulation that’s built around something called an adjint source that allows us to specifically optimize for a spe for a given figure of merit.

8:09 And if we can find what this correct adjint source is, we actually only need to run these two simulations. And we can combine together the information inside of the device in order to compute the gradient. And crucially to compute the gradient for every parameter that we’re optimizing against using only just a fixed number, in this case two simulations. So now we don’t scale with the number of parameters we’re optimizing over.

8:33 We actually just scale with the simulation time which is a place where flexib is is well suited to to help because a big thing we do is make very fast solvers. So fast solvers mean also fast calculations of these gradients. So if we go back to the problem from before we can look at a comparison of what you could do with a local optimization method versus a global one when you expand the space that you’re working in.

8:58 So in this case we compare the number of simulations and the number of degrees of freedom as well as total simulation time and final performance for the global versus local optimization technique. And we find that actually in the local case you can get an even better performing device using less simulations by expanding this design space. So the key takeaway here is that gradients give you that the fast computation of gradients gives you the ability to explore these interesting optimization spaces.

9:31 So this is great, but actually like what I skipped over is the complexity in trying to solve for what that adjoint simulation looks like. And there is a way to there is a way to compute what you need to do in that with a mathematical formula. But the amounts of combinations and different things you might need to do aren’t completely straightforward. So what we’ve done to make this easy is we’ve pulled in this concept of a differentiable simulation.

9:55 And the idea of this is to be able to stick that whole simulation creation and run inside of an objective function and put that objective function into a traditional automatic differentiation library and with a single line of code be able to get out the gradient of your whole of your whole figure of merit. So this is what this looks like if you if you’re familiar with something like neural network optimization.

10:19 You have something that looks like a computational graph which chains together a bunch of optimizations and tracks what you’re doing in the simulation. But what we’ve built inside of Tidy 3D is a way to actually chain together the inputs to your simulation to the outputs so that you can run this automatic differentiation back through your whole simulation creation process. And you can do this for any number of geometries, any number of simulations that you want to put in in order to compute these net gradients.

10:45 So you can write a function that looks like this where you have a simulation based on a parameterization. You run it and you compute a figure of merit and you can take a single line of code and compute the gradient function of your objective function with respect to your input parameters and automatically you’re able to access this local gradient-based optimization. Okay. So that’s a great tool to build on.

11:19 The last thing that I kind of want to talk about today is how can we talk how can we address our original goal of software replacing hardware iteration and I want to talk about this for a key challenge in photonic in photonic design especially photonic integrated circuits and getting these types of design methods adopted in industry and the major challenge is dealing with fabrication robustness and the ability for the device to work well post fabric fabrication and an interesting challenge in photonix is that the relevant feature scale we have is the wavelength and if you look at something like a telecom photonic integrated circuit that might be operating at 1.3 or 1.5 micron wavelength your relevant manufacturing scale is something on the order actually of deeply deeply subwavelength in the maybe 50 to 100 nanometers or less which means that things that seem like very small fabrication imperfections can have very large effects effects on your output performance of your device.

12:21 And we actually have a lot of different types of variability when you make one of these devices in a foundry. The layer thickness, the alignment if you’re doing of layer to layer if you’re doing a multi-layer design, the etch depth and the lithographic bias. And we also have other sources of variability when we actually use these things in practice or test them in the lab such as the actual angle of the the input excitation that we’ve assumed in our in our design.

12:50 And if you want to actually be able to get the advantages of a powerful computational design technique, you have to be able to be robust to at least some of these fabrication errors that you can’t predict at the outset. So here’s a way we can use this nice formulation of a differentiable simulation to account for this type of variability. So it’s not good enough to just have this nominal device because we don’t know how it’s going to get changed in the fabrication.

13:17 And we have a bunch of different sources of variability each of which could be taken in any combination. So in general what we need is something that is robust against combinations of these or the or being at the extreme points of what we call process corners. Additionally, you have to make sure you can obey minimum gap and width sizes and other manufacturing tolerances. So really what we’re going to rely on is sampling a few of these different things that fall under those specifications and designing devices around that.

13:55 So now what we can do is we can take our parameterization, we can turn that into a big series of devices and simulations, ones that have modulations on the widths of all our grading teeth. For example, the source tilt could be changed. The layer thicknesses could be different. And we can run simulations very quickly in Tidy 3D for all of these different cases. We can actually take that whole batch of simulation output and turn it into an objective function.

14:19 We could optimize for average performance over them. We could optimize for the the minimum performing device. And as long as we can write a differentiable function to combine together all of those different objective functions into one, we can actually now immediately get a gradient for how to improve let’s say the worst performing device in our batch. And we can optimize that instead. And actually the results are pretty dramatic when you do an optimization like this.

14:45 This is an example of a a grading coupler where in the blue solid line we’re showing what happens if you don’t take into account any fabrication variability and in the solid orange line we’re showing what happens if you do this if you do actually an optimization over the worst performing device in your batch. What you see is something that you commonly see with robust design is actually your peak performance is a little bit lower when you take into account all this variability.

15:12 But if you look at the shaded lines on either side of the solid curves, those are showing the amount the device performance can vary at each of these wavelengths when you sample over all of these different process corners. And what you end up trading off is a little bit of peak performance for a much more robust design that will more likely work as you expect it to in practice.

15:32 So another thing we can do that fits well into this into this optimization framework is sometimes you have fabrication imperfections that you actually know what they are before you fabricate. If you’re use if you’re using a lithographic process and you input a square as your design likely what you’re going to see is some sort of rounded corners things like that. So we actually do have things we can take advantage of that we know will happen in our real fabrication.

16:01 So we can insert a model like that. We can have a design variable that we’re optimizing against and we can have figured out a fabrication model and this is something we’re actively developing internally that allows you to map between what you think you’re going to make and what you’re actually going to make and we can put this whole chain into the objective function where we’re designing the actual design variable that we will send to the manufacturer but we’re running the simulations on the on the device that we expect to actually get fabric fricated one with these rounded corners and non idealities of the fabrication process.

16:38 We can turn that into simulations and we can turn that into an objective function. And now we can optimize for our expected device that’s going to come out of the fab. So if you do something like this, here’s another type of photonic device where you’re splitting an input band of wavelengths into a bunch of different output channels in different waveguides. And we can show that if you actually take into account a fabrication model like this, you can design a device that’s very high performing.

17:04 Whereas if you don’t take it into account and apply it later, you’ll have a natural degradation of the performance in your design. So one other very interesting thing we can do now that we have gradients and we have potentially devices that we’ve taken from design to fabrication is we can actually use these gradients to understand different fabrication imperfections that we might have had that we didn’t know about.

17:32 So let’s say you get a you have a simulated spectrum for your device and you have the actual measured spectrum that you got in the lab for that device and you know that there was some fabrication imperfection and it was maybe due to things that weren’t actually in your control in the design process. Maybe you assumed there was some variability in the layers the layer thicknesses or there was some imperfection that you just didn’t know about.

17:57 We can actually use gradients to try and move our simulated performance towards what our actual realized performance was in the measurement data. And if we can do that, we can actually start to train and build these fabrication models just purely based on the observable of the measurement data versus what we expected to get out in simulation. So here’s a couple things that are just in addition that our tools were we’re building on top of this differentiable framework.

18:27 We have another product called Photon Forge which actually allows you to integrate directly with PDKs and Foundry process parameters and set up devices and different circuit models with them. And we’re adding this ability to optimize directly in that space with gradient-based design. We also are working on extending this framework to be able to compute gradients for radio frequency devices which which requires knowing about different types of material types like PC and lossy metals.

19:05 And continually working on tools to help with robust optimization, sensitivity analysis, the ability to integrate with AI from a post-processing or pre-processing standpoint and building these fabrication models and the way to access them inside of Tidy3D. So, just a quick summary of kind of what we talked about today. I think hopefully I made it clear that we can use we can take advantage of these really fast solvers we’re building at Flexcompute.

19:35 We can find gradients easy. We can make finding gradients as easy as writing a simulation and objective function. And through that we can take some of what would normally be an iteration in hardware and move it back into the software domain saving time complexity and and cost. Just want to put up a few acknowledgements here for the talk. Everyone in in many ways at Flexcompute has contributed to what I showed today, but just a couple special thanks for people who contributed directly to this presentation today. Qiqi, Yanik, Tyler, and and Momcher who have also worked on previous iterations of of this talk I gave today. So thank you