Adjoint Optimizatin of Robust Device

[berzoll]

Hello everyone,

first of all thanks a lot for all the work and effort put in Meep!

I am trying to replicate some of the work found in Hammond's presentations designing a robust splitter. I would like to use the adjoint sover to find a design which is tolerant to fabrication variability within a certain range.

I understand how to define multiple figure of merits and let the solver optimize a single design, but what would be the right approach to make it consider mutliple designs, i.e. nominal + underetched + overetched, at once? Is there any resource in the various tutorials abour this?

Thanks!

[smartalecH]

Typically you'd want to perform a "worst-cast" or minimax optimization. The optimizer considers the ideal and perturbed geometries equally and systematically maximizes performance across all of them uniformly. We have a minimax tutorial that optimizes over multiple wavelengths. You can easily extend that to optimize over multiple design fields/FOMs.

[berzoll]

Thank you Alec.

I understand that Meep solves a single design problem over multiple frequencies. The gradient and FOM are then built accordingly and they already have the right dimensions, i.e. (degrees_of_freedom X num_frequencies).
However, if I want to run inside my constraint function multiple simulations over the same design region (changing each time, e.g. the eta_i to simulate different etchings), the results and gradient containers initialized by the optimization problem are not correct, as they do not contain the additional columns I would need.

How would I proceed and approach this issue?

[smartalecH]

I think you're overthinking it:

def nlopt_constraint_func(result,x,grad):
    f1, df1 = opt([mapping(x,beta,eta_1])

    f2, df2 = opt([mapping(x,beta,eta_2])

    f3, df3 = opt([mapping(x,beta,eta_3])

    # now just concatenate the gradients, reshape them, etc

You can actually use MPI and do this with just one OptimizationProblem solve, where each MPI group has a different eta defined, and then you broadcast results. But there's a lot of bookkeeping with that approach, so I would start with the brute force approach first.

[berzoll]

Thank you. This is the approach I was following, but I forgot to also adjust the size of the list containing the tolerances for the constraint function. Now this runs smoothly.

I would very much like to be able to use different cores to distribute the calculations at different etas and perform them in parallel, instead of serially. Any resource that could put me on the right path on how to approach this?

[smartalecH]

Yep, check out this section of the manual describing embarrassingly parallel simulations:

https://meep.readthedocs.io/en/latest/Parallel_Meep/#different-forms-of-parallelization