Wavelength-dependent PhaseInteractionModel

[blu-canopus]

I am exploring the use of PhaseInteractionModel to model diffractive elements (e.g. DOEs or metasurfaces) and I have a question regarding spectral dependence.

From what I understand, PhaseInteractionModel currently applies a single phase map that is identical for all wavelengths defined in the system. However, for physical diffractive elements, the phase is generally wavelength-dependent, for example when derived from a height profile and a dispersive material.

My questions are:

• Is there currently a native way to use PhaseInteractionModel with different phase values for different wavelengths?

• If not, what would be the recommended approach within optiland’s architecture to support this?

Some possible approaches I considered:

• Allowing PhaseInteractionModel to accept a callable or wavelength-indexed structure that returns the phase map for a given wavelength.

• Defining the interaction model in terms of a height map plus a dispersive material, with phase computed internally per wavelength.

I would like to know whether this has already been discussed or if there is a conceptual reason why wavelength-dependent phase is intentionally not supported.

[HarrisonKramer]

Hi @blu-canopus,

Thanks for the questions.

You are right. There is currently no native way to specify wavelength-dependent phase values in PhaseInteractionModel. The implementation of PhaseInteractionModel.interact_real_rays retrieves the phase and gradient based solely on spatial coordinates $(x, y)$, applying the same phase map to all wavelengths. While the model does use the wavelength (via k0) to calculate the ray direction changes, it assumes the phase profile itself is static.

As far as I am aware, updating the phase model to handle wavelength-dependence has not been discussed. This functionality was simply overlooked. However, this could be added without too much difficulty, I think. As you suggest, the easiest approach would be to update the API for BasePhaseProfile, e.g., by adding wavelength as an argument:

class BasePhaseProfile(ABC):
    @abstractmethod
    def get_phase(self, x: Array, y: Array, wavelength: Array = None) -> Array:
        pass

    @abstractmethod
    def get_gradient(self, x: Array, y: Array, wavelength: Array = None) -> tuple[Array, Array]:
        pass

Then, PhaseInteractionModel could be updated to retrieve the wavelength-dependent phase:

def interact_real_rays(self, rays: RealRays, surface: Surface) -> None:
    # ... existing setup ...
    
    # Pass wavelength (rays.w) to the profile
    grad_x, grad_y = self.phase_profile.get_gradient(x, y, wavelength=rays.w)
    
    # ... rest of the physics calculation ...

You'd probably then want to sub-class BasePhaseProfile to create your desired phase profile.

I hadn't considered your second approach, but this also could be implemented in a new MaterialHeightProfile class (subclass of BasePhaseProfile), which would need to accept a material instance for wavelength-dependent refractive index calculation. Other details TBD.

Are you interested in implementing this and submitting a PR (assuming you're able)? If not, I will add it to the to-do list and we can get to it in due time.

Thanks again!

Kramer

[gustavu92]

Hi @HarrisonKramer,

Thanks for the explanation! I will implement this and submit a PR using my other profile (@gustavu92). I’ll add wavelength support to BasePhaseProfile and update PhaseInteractionModel. I also like the idea of a MaterialHeightProfile and will look into it.

Thanks!