Optiland vs OpticStudio PSF parameters

[crnh]

I am trying to understand the parameters of optiland.psf.FFTPSF and obtain results similar to the FFT PSF in OpticStudio.
OpticStudio's FFT PSF has two sampling parameters: the pupil sampling and the 'display' sampling.
The pupil sampling determines the sampling grid at the pupil, and the display sampling the output grid size.
The display sampling can be up to twice the pupil sampling, e.g. with a pupil sampling of 32x32, the maximum possible display sampling is 64x64.
I thought Optiland's num_rays corresponds to the pupil sampling and the grid_size to the display sampling, but this does not yield the expected results.

As an example, I created the same eye model in OpticStudio and Optiland (see attached zmx and JSON files). Many outputs, including ray tracing and Zernike standard coefficients, are the same for these two models, so the PSF differences are unlikely to stem from model differences.

OpticStudio result for pupil sampling of 32x32, display sampling of 32x32:

OpticStudio result for pupil sampling of 32x32, display sampling of 64x64:

Optiland result for pupil sampling of 32x32, display sampling of 32x32:

Optiland result for pupil sampling of 32x32, display sampling of 64x64:

The Optiland results are obtained through the FFTPSF.psf property, to circumvent the cropping and interpolation performed by FFTPSF.view.

The extent of the Optiland PSF output is also much larger than the extent of the OpticStudio output (FFTPSF._get_psf_units yields 383 x 383 for the result with pupil sampling of 32x32, display sampling of 32x32, which is considerably larger than the 160 x 160 for the corresponding OpticStudio result).

Can you help me figuring out which settings to use to reproduce the OpticStudio result in Optiland?

model.json

[crnh]

I cannot attach zmx files to GitHub discussions. If you want to inspect the OpticStudio model, let me know and I'll send it in a different way.

[HarrisonKramer]

Hi @crnh,

Thanks for opening this and for the clear description.

I believe the difference here simply comes down to definitions. If you closely follow the logic of the FFT PSF calculation in psf.FFTPSF, you will find that there is a padding step. This takes the pupils, which are computed over a grid of size (num_rays, num_rays) and pads them with zeros to a size of (grid_size, grid_size). Optiland does not attempt to enforce the exact size of the output PSF grid.

Without access to the internals of OpticStudio, I suspect it will be difficult to debug this fully. Nonetheless, I assume the difference is related only to this padding step, as all other calculation steps should be the same. Playing with the grid_size parameter should bring you closer to the exact OpticStudio result, I'd expect. This also assumes that the OpticStudio "pupil sampling" corresponds exactly to the number of rays spanning the pupil in each axis before padding.

In any case, I am not opposed to changing the behavior of the PSF calculation if you want to make a proposal. Padding the pupils will be required, but perhaps the grid_size parameter can be inferred from a target "display_size" parameter. I am happy to explore this further if you want to go this route, but it will not be a high priority. If you like, you can also submit a PR for this change, assuming it does not drastically change the API. I will also note that the psf module is likely soon to be (slightly) refactored due to changes in the wavefront module required for the Huygens PSF implementation.

Regards,
Kramer

[crnh]

Please let me know if you get an answer regarding the OpticStudio calculation.

Sure! I plan to write the forum post next week and add a link to the forum post in this discussion.

Would you be interested in exploring this and maybe contributing a PR? Otherwise, I can add it to the backlog. It should be a quick fix.

Yes, I'm interested in implementing this. What would be a good cutoff value for the warning? A factor of 5? Showing the original resolution in the plot would be good, because the cutoff value for the warning will always be arbitrary.

[HarrisonKramer]

Great, thanks!

Yes, I think a value of 5 works. We could even be a bit more conservative since it's only a warning and not throwing an error. I leave it up to you.

[crnh]

I just opened a PR with my proposal (#180).

[crnh]

Zemax forum discussion: https://community.zemax.com/got-a-question-7/how-does-opticstudio-determine-the-grid-over-which-the-fft-psf-is-calculated-5690

[crnh]

OpticStudio FFT PSF sampling behavior is apparently explained in detail in the documentation: https://ansyshelp.ansys.com/public/account/secured?returnurl=/Views/Secured/Zemax/v251/en/OpticStudio_User_Guide/OpticStudio_Help/topics/FFT_PSF.html. I'll see if I can replicate this with Optiland.

[crnh]

I tried to replicate OpticStudio sampling behavior in Optiland, which seems doable.
According to the OpticStudio documentation:

There is a tradeoff between the sampling grid size in the pupil, and the sampling period in the diffraction image. For example, to decrease the sampling period in the diffraction image, the sampling period in the pupil must increase. This is done by "stretching" the pupil sampling grid so that it overfills the pupil. This process means fewer points actually lie within the pupil.

As the sampling grid size is increased, OpticStudio scales the grid on the pupil to yield an increase in the number of points that lie on the pupil, while simultaneously yielding closer sampling in the diffraction image. Each time the grid size is doubled, the pupil sampling period (the distance between points in the pupil) decreases by the square root of 2 in each dimension, the image surface sampling period also decreases by the square root of 2 in each dimension, and the width of the diffraction image grid increases by a factor of the square root of 2 (since there are twice as many points in each dimension). All ratios are approximate, and asymptotically correct for large grids.

Which results in the following 'effective pupil samplings':

Furthermore, the grid size is doubled after adjusting the pupil sampling:

Once the sampling is specified, OpticStudio doubles the array size in a process called "zero padding". This means for a 32 x 32 sampling, OpticStudio uses the center portion of a 64 x 64 grid. Therefore, the diffraction PSF will be distributed over a 64 x 64 size grid. The sampling in the image space is always twice the pupil sampling. Zero padding is performed to reduce aliasing.

If I interpret this correctly, it should be fairly straightforward to calculate the effective pupil sampling (i.e. number or rays) that should be used by Optiland. This function replicates the table in OpticStudio's documentation:

def effective_pupil_sampling(pupil_sampling: int) -> int:
    return np.floor(32 * np.sqrt(2) ** (np.log2(pupil_sampling) - 5)).astype(int)

There is a slight problem with the current padding implementation in Optiland: it adds the same amount of zeros on both sides of the pupil. If the difference between the effective pupil sampling and the grid size is odd (e.g. when the pupil sampling is 64, num_rays = 45 and grid_size = 128), this results in a different grid size (in this case 127x127).
I modified the padding code to be able to compare the PSFs between Optiland and OpticStudio:

def _pad_pupils(self):
    pupils_padded = []
    for pupil in self.pupils:
        padded = np.zeros((self.grid_size, self.grid_size), dtype=pupil.dtype)
        center = self.grid_size // 2
        padded[
            center - pupil.shape[0] // 2 : center + pupil.shape[0] // 2 + pupil.shape[0] % 2,
            center - pupil.shape[1] // 2 : center + pupil.shape[1] // 2 + pupil.shape[1] % 2,
        ] = pupil
        pupils_padded.append(padded)

    return pupils_padded

Here are a few comparisons for different samplings:

Observations:

1. Optiland's PSF is, as far as I know, always normalized. I also calculated normalized PSFs in OpticStudio, but the value ranges suggest OpticStudio has a different definition for 'normalization'.
2. The PSF extents are (almost) equal and the results are qualitatively similar, so at least we're close to replicating the OpticStudio PSF in Optiland.
3. However, there are still large differences. This does not change if I normalize both PSFs to the range [0, 1]. Part of these differences may be caused by differences in the PSF center location, especially the 32x32 difference plot clearly shows this is the case. Nevertheless, I can also see feature differences between the PSFs, so centration differences do not explain all differences.

Do you have any ideas where the differences may come from? Could it be differences in the sampling method (the table in OpticStudio's documentation mentions the 'approximate effective pupil sampling', suggesting that OpticStudio may use a non-integer pupil sampling)? Or could there be differences between the wavefronts used to calculate the PSFs?

Regarding Optiland's PSF implementation, I think there are two viable options:

1. Keep it as is and let the user manually choose the pupil sampling and grid size. The OpticStudio implementation feels a bit arbitrary, maybe even restrictive. Still, it would be a good idea to update the padding function to ensure the specified grid size is used.
2. Make only the pupil sampling configurable and determine the number of rays and grid size in the same way as OpticStudio. This might allow for non-integer pupil samplings and could possibly get the results closer to those of OpticStudio.

[HarrisonKramer]

Thanks for the follow-up.

• Optiland converts the PSF into percent (return be.real(be.sum(psf, axis=0)) / norm_factor * 100). Does ZOS do the same? Maybe that's the root cause of the 100 factor.
• Very good to see that the wavefront maps are effectively identical. This rules that out.
• On the PSF comparisons, the first and the third plot look quite similar (how different are they?). Is these are the same (within some tolerance), then that must indicate that the remainder of the implementation is the same.

My attempt to obtain the pupil function from OpticStudio resulted in a PSF that differs from both Optiland and OpticStudio.

With the factor of 100 included, how different are these actually? Qualitatively, the ZOS PSF actually looks sort of smoothed, or perhaps my eyes are playing tricks on me.

OpticStudio does not use the intensity to calculate the amplitude.

I would be surprised if this were ignored. You could try to add a (dramatic) apodization to check if the PSF changes.

I would also be surprised if the FFT algorithms differ, although I suppose it's possible.

I guess my last questions are - how close should the ZOS and Optiland results be? When do we say it's close enough? Assuming we fix the minor offset issue and image-space index issue, are we then able to call our implementation "verified"?

[crnh]

Hi,

Thanks for your repsonse.

• Judging from its output, OpticStudio does not seem to convert the PSF to percent.

• Yes, I agree with that. To be sure I still checked the impact on the FFT of the wavefront (with the wavefront as phase), and the impact is indeed negligible.

• the first and the third plot look quite similar (how different are they?)

  Yes, they look indeed quite similar. I'll show the differences later in this post.

  then that must indicate that the remainder of the implementation is the same

  Please note that the first plot is effectively Optiland's PSF with the pupil function from OpticStudio and the third plot is Optiland's PSF. So technically you are correct, apart from the wavefront the implementation is the same, because it's Optiland's implementation in both cases. However, I am not sure if that is what you meant. Did you mistake the third plot for OpticStudio's PSF?

Here is an improved comparison, including difference maps. The peak of the OpticStudio PSF was not in the same location as the peaks in the other PSFs, so I shifted OpticStudio's PSF to have equal peak locations in all PSFs in this comparison. This was a shift of 1 pixel in both directions. Furthermore, OpticStudio's PSF was converted to percent.

Differences are all in the order of 10%.

Qualitatively, the ZOS PSF actually looks sort of smoothed, or perhaps my eyes are playing tricks on me.

No, I thought the same. But it could still be caused by implementation differences. The documentation doesn't say anything about smoothing.

I would be surprised if this were ignored.

I meant it might calculate the amplitude differently. When I scanned the OpticStudio documentation about ray tracing and wavefronts, it seemed to state somewhere that 'amplitude' may have different meanings and can be calculated in different ways. Anyways, the amplitude shouldn't cause differences in this example.

I guess my last questions are - how close should the ZOS and Optiland results be? When do we say it's close enough? Assuming we fix the minor offset issue and image-space index issue, are we then able to call our implementation "verified"?

In my opinion, the current differences are acceptable, at least sufficiently small to finish the PSF implementation in Visisipy.

Assuming we fix the minor offset issue and image-space index issue, are we then able to call our implementation "verified"?

Assuming the 'minor offset issue' is the padding issue, I'd say we can call the implementation verified.

Conclusions

The differences between the FFT PSF output of Optiland and OpticStudio is likely caused by differences in pupil sampling (e.g. choice of the grid) and maybe slight differences in the remaining implementation. It is difficult to find out what these differences are; the benefit of Optiland is its transparency about these calculations, but we don't know what OpticStudio is doing.

Next steps

I suggest to change the following in the FFT PSF implementation:

• Fix the calculation of the PSF for off-axis fields and non-air image space media;
• Change the pupil padding mechanism so the PSF grid always has the size specified by grid_size;
• By default, make the sampling behaviour mimic OpticStudio, but keep the grid_size parameter so the user can override the grid size. This involves some design changes; for example, OpticStudio now has an 'effective pupil sampling' that is different from the user-specified sampling. For transparency, we could choose to let the user specify that 'effective pupil sampling' and calculate the grid size based on that value.

If you agree, I can open issues for these changes, to keep the discussions about design decisions for these points separated and focused.

[HarrisonKramer]

Thanks for the detailed response.

You're right - I mixed up the plots above. I suppose that comparison then only tells us that differences in the pupil function (ZOS vs. Optiland) likely aren't to blame for differences in the PSF. You had already verified this anyway.

Okay, good to hear the current differences are acceptable.

On your proposed next steps, I agree. I briefly investigated the issue above, in which an off-axis point has a shifted PSF. I was not able to quickly identify the issue. More investigation is needed there. And yes, opening issues for these makes sense so that we can better track them.

Regards,
Kramer

[jwmbeenakker]

Differences are all in the order of 10%.

Qualitatively, the ZOS PSF actually looks sort of smoothed, or perhaps my eyes are playing tricks on me.

I guess my last questions are - how close should the ZOS and Optiland results be? When do we say it's close enough? Assuming we fix the minor offset issue and image-space index issue, are we then able to call our implementation "verified"?

In my opinion, the current differences are acceptable, at least sufficiently small to finish the PSF implementation in Visisipy.

Thank you for your work on this topic. Two points I would like to add:
Differences in the order of 10% could be problematic, but depend on the signal intensity/energy they occur. The PSF is used as a basis for multiple applications, eg. simulating how a subject percieves a particular aberration. Starting with a 10% error in the center/high intensity region of the PSF could be quite problematic. If this error is however on the outer/low intensity part of the PSF, it would be not a problem.

Looking deeper at the Optiland PSF, I see a regular grid-like pattern in the PSF which I would consider it erroneous/artifact as the system is rotationally symmetric:

I think (part of) the difference is attributed to the matrix-size. In OpticStudio it is forced to be odd, which is good because the central pixel will have most of the intensity. in Optiland the matrix is even, resulting in no central pixel. As a result the peak of the PSF has to be divided over the 4-central pixels, which I think is leaking to the rest of the image and resulting in a grid-like pattern superimposed over the PSF.

[HarrisonKramer]

Hi @jwmbeenakker,

I fully recognize your remarks. I agree that a 10% error could be problematic. I am not opposed to enforcing an odd number of rays per axis when a uniform grid over the pupil is used. I was not aware that this was the default behavior in ZOS.

Another possible root cause is the normalization method. A small difference in the calculation there could of course result in a global offset. Perhaps that even couples to the even/odd grid size effect.

I will plan to investigate these. I see no reason not to enforce an odd number of rays per axis, so I propose we already change that once it's appropriately tested.

Thanks,
Kramer