Multilevel Diffractive Lenses Design Simulation using Ansys Lumerical

Hello, welcome to the second video in this multilevel diffractive lens demonstration with numerical.

So as we saw last time, multilevel diffractive lenses are an alternative to metal lenses for performing imaging with flat optics, and they provide certain advantages, particularly in terms of fabrication.

For example, to achieve a similar performance, multilevel diffractive lenses would actually have much bigger features, making them easier to fabricate. Here, we are just seeing how they look like. For example, this is a standard refractive lens with a spherical lens.

If you wanted to increase the numerical aperture of the bending of light, you would have to go to thicker and thicker lenses.

But then, you can use the principle of diffraction: keep the thickness fixed and use different pitch to achieve different values of the bending of light or the numerical aperture. The next one is the binary diffraction lens.

This is the binary diffraction lens, which is essentially the same as this one, where you have just two values of height. Then, we have the multilevel diffractive gratings or the lens, where you have different values of height.

This is the metal lens, which has much smaller features to achieve a comparable performance. This table summarizes the performance and the feature sizes needed for multilevel diffractive lenses and a meta lens to achieve similar performances.

Here, we provide the frequency range: for a single frequency or a very narrow region around the frequency, while this is a broadband region, which is several hundred nanometers or several microns.

And you can see that for the multilevel diffractive lens, the feature sizes are much bigger, like the height and the widths, for example, are much bigger than the meta lens. And you achieve better performance, especially in the case of broadband, significantly better performance.

Last time, we had also seen an analysis of the performance of the multilevel diffractive lens. Here, we have a multilevel diffractive lens. We have an algorithm which could be used to design such a grating: you start essentially with the initial solution and then you perform an iteration.

You take one groove, you apply a positive perturbation, then you measure a quantity called as the FOM or the figure of merit, which looks at the performance of the beam which is being produced after the grading, and then it iteratively looks at how the FOM score is being improved.

If it's not improving with the positive perturbation, you apply a negative one, and if it does not change, then you discard that particular perturbation and go to the next group, and so on.

For example, this is one particular example for the material refraction reading, where you have a wavelength of interest, which is fairly broadband, although we would look at the performance at only these three values of the wavelength.

You want the focal length to be 10 mm, the number of rules to be 80, and the material is a photoresist polymer, which has a particular refractive index.

Then, the design steps which you had used are: you specify your desired optical response, like focal length, wavelengths, numerical aperture, etc., and then using the DBS algorithm, you can obtain your height profile.

Then, you can import this height profile in numerical FDTD and perform FDTD simulations to obtain the near field data.

Then, you can use numerical far-field functions and obtain actual far-field profiles, so you can actually test how well the grating is performing using FDTD and far fields at long distances.

We had gone through the scripts briefly, which are used to actually load your data, for example, and then you can store the near field data.

You have a near-field monitor, and then this data can be saved in any particular format you can choose the fields and the data can be used to store whether it is a cross-field Fabry's under the measure Clumbic and dio uh to the standard format, for particular wavelengths like 460, 540, and 620, and that's what we can see.

For example, for 460, you see a focused spot at 10 mm, and the same with 540, and for 620. This focusing is absent for the other wavelengths for which the grating was not designed, which is 500 and 580 nanometers.

Now, I'll just show you, so in principle, all this procedure, the entire procedure including the Python script for optimization, the DBS algorithm, can actually be done on numerical, which provides support for Python coding.

So this is essentially the script for the algorithm, the optimization algorithm, which is looking at the figure of merit and then performing optimization. This is the FOM calculation and this is the function which performs that.

As you can see, you can work in the numerical script file editor just like you're working in on some any Python platform, and you can import all the functions and libraries and perform all the optimization here. You provide all the parameters and then you can write it in the desired format.

So you can write it in, for example, JSON format or in the text file format, depends. So in this case, at least, we're writing it in the text format, like we wanted to look at the height profile, for example.

And yeah, I mean, you can just it will just start running and it goes through these multiple iterations, and basically, this is how it looks like.

So you just run that, perform 10 iterations, and it prints the time taken and it provides the the height profile of your multilevel diffraction grating, which can then be imported into your numerical file using this this structured script, and then you can perform the further analysis as I explained before.

One other nice feature which numerical provides is you can actually write all the data, including, for example, the file, the file obtained far-field profile, the wavelengths, the structural parameters, and it can be written and exported into a JSON file.

So this is what is done by this particular script.

So essentially, I'm just loading in my structural parameters first and then the final analyzed data, which is the far-field profile, and yeah, you just have to give them some names and then you can actually write all the data you want into a JSON file.

So, for example, the JSON file can be something like this. So you can see here, for example, it writes all the so this is the height profile of your structure, and if you go down below, you can get, for example, the refractive index file and the wavelengths and all the other field profiles, etc.

So this is very useful because then this can directly be loaded into Xeamax, for example, where you want to load a particular or design a particular uh source with certain features, both geometric features and spectral features, and then you can perform beam propagation in Xeamax and perform further analysis.

So this basically provides a very handy tool to perform seamless integration between numerical and ZMaps. And all of this, all platform support, all Python analysis, can be done very easily on numerical itself.

So I hope you like this video and please do try out Python script in numerical and hope you learn something nice from this. Thank you.