Skip to content

Working with dLux Objects

This tutorial is designed to give users a quick overview of how to work with dLux objects. Build using Equinox and Zodiax, dLux objects intuitive and simple to work with, so lets have a look at how to get started.

# Basic imports
import jax.numpy as np
import jax.random as jr

# dLux imports
import dLux as dl
import dLux.utils as dlu

An Optical System

First we set up a dLux object to work with, in this case a simple optical system. We will not cover the details of how to build an optical system here, as it is covered elsewhere in the tutorials.

# Define our wavefront properties
wf_npix = 512  # Number of pixels in the wavefront
diameter = 1.0  # Diameter of the wavefront, meters

# Construct a simple circular aperture
coords = dlu.pixel_coords(wf_npix, diameter)
aperture = dlu.circle(coords, 0.5 * diameter)

# Zernike aberrations
indices = np.array([2, 3, 7, 8, 9, 10])
basis = 1e-9 * dlu.zernike_basis(indices, coords, diameter=diameter)
coefficients = 50 * jr.normal(jr.PRNGKey(0), indices.shape)

# Define our detector properties
psf_npix = 64  # Number of pixels in the PSF
psf_pixel_scale = 50e-3  # 50 mili-arcseconds
oversample = 3  # Oversampling factor for the PSF

# Define the optical layers
# Note here we can pass in a tuple of (key, layer) pairs to be able to
# access the layer from the optics object with the key!
layers = [
    (
        "aperture",
        dl.layers.BasisOptic(
            transmission=aperture,
            basis=basis,
            coefficients=coefficients,
            normalise=True,
        ),
    ),
    dl.layers.Tilt(np.zeros(2)),

]

# Construct the optics object
optics = dl.AngularOpticalSystem(
    wf_npix, diameter, layers, psf_npix, psf_pixel_scale, oversample
)


# Let examine the optics object! The dLux framework has in-built
# pretty-printing, so we can just print the object to see what it contains.
print(optics)

AngularOpticalSystem(
  wf_npixels=512,
  diameter=1.0,
  layers={
    'aperture':
    BasisOptic(
      basis=f32[6,512,512],
      coefficients=f32[6],
      as_phase=False,
      transmission=f32[512,512],
      normalise=True
    ),
    'Tilt':
    Tilt(angles=f32[2])
  },
  psf_npixels=64,
  oversample=3,
  psf_pixel_scale=0.05
)

Paths

So now that we have our optical system set up and we can see the layout, lets have a look at how to work with them. Being built in Zodiax, dLux gains access to a 'path-based' interface, greatly simplifying how we work with these objects.

A path in Zodiax works very similarly to a path in a file system. It is a way of navigating through the object, and accessing the data we want via strings, joined with a dot ('.'). Here are some example paths for our optical system:

  • 'diameter'
  • 'layers.Tilt.angles'
  • 'layers.aperture.transmission'

dLux also makes extensive use of the __getattr__ methods, which allows for the raising of low-level attributes to the top level object. Primarily this means we can skip the 'layers' part of these paths, so the above paths become:

  • 'diameter'
  • 'Tilt.angles'
  • 'aperture.transmission'

Now to access these values at these paths, we can either use the .get(path) method, or just access the via the regular attribute accessors. Lets have a look at this in practice:

# Using the regular accessors
print("Diameter: ", optics.diameter)
print("Angles: ", optics.Tilt.angles)
print("Transmission", optics.aperture.transmission)

Diameter:  1.0
Angles:  [0. 0.]
Transmission [[0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 ...
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]]

# Using the .get method
print("Diameter: ", optics.get('diameter'))
print("Angles: ", optics.get('Tilt.angles'))
print("Transmission", optics.get('aperture.transmission'))

Diameter:  1.0
Angles:  [0. 0.]
Transmission [[0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 ...
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]]

So, if we can access the attributes with regular accessors, what is the point of the Zodiax .get method? Well the .get method lets us access multiple attributes at once by passing in a list of paths. Lets have a look at this in practice:

print(optics.get(['diameter', 'Tilt.angles', 'aperture.transmission']))

[1.0, Array([0., 0.], dtype=float32), Array([[0., 0., 0., ..., 0., 0., 0.],
       [0., 0., 0., ..., 0., 0., 0.],
       [0., 0., 0., ..., 0., 0., 0.],
       ...,
       [0., 0., 0., ..., 0., 0., 0.],
       [0., 0., 0., ..., 0., 0., 0.],
       [0., 0., 0., ..., 0., 0., 0.]], dtype=float32)]

These paths can actually be simplified further, since dLux also raises attributes from the values of the layers dictionary, so the above paths become:

  • 'diameter'
  • 'transmission'
  • 'angles'

Lets look at this in practice.

NOTE

While this level parameter raising can greatly simplify the paths we work with, we need to cognisant that each path is unique. For example if we have two layers that have the same values as_phase, then using 'as_phase' as our path will only return one of these values. To distinguish between these two we would need to reference the layer by its dictionary key, ie 'layer1.as_phase' or 'layer2.as_phase'.

print(optics.get(['diameter', 'angles', 'transmission']))

[1.0, Array([0., 0.], dtype=float32), Array([[0., 0., 0., ..., 0., 0., 0.],
       [0., 0., 0., ..., 0., 0., 0.],
       [0., 0., 0., ..., 0., 0., 0.],
       ...,
       [0., 0., 0., ..., 0., 0., 0.],
       [0., 0., 0., ..., 0., 0., 0.],
       [0., 0., 0., ..., 0., 0., 0.]], dtype=float32)]

Zodiax Methods

Zodiax gives us access to a series of class methods that are designed to mirror the jax.Array syntax, ie .at, .set, .multiply etc. The syntax a slightly different in that we need to specify a path to the data we want to work with, but the functionality is the same. Here are the main Zodiax methods: some of the zodiax methods:

  • .get(paths)
  • .set(paths, values)
  • .add(paths, values)
  • .multiply(paths, values)
  • .divide(paths, values)
  • .min(paths, values)
  • .max(paths, values)

Lets use the .add method to see how we can modify our optical system.

paths = ['diameter', 'angles']
new_optics = optics.add(paths, [1, 0.5])
print(new_optics.get(paths))

[2.0, Array([0.5, 0.5], dtype=float32)]

Nesting

Zodiax goes further here, and allows to 'nest' paths, such that we can operate on mulitple values in the same operation. Lets look at some examples of this in practice:

# Operate on multiple values simultaneously
paths = ['diameter', 'angles']
new_optics = optics.multiply(paths, 0)
print(new_optics.get(paths))

[0.0, Array([0., 0.], dtype=float32)]

We can also nest within our path itself, lets see how:

# Set nested values simulatenously
# Note that 'paths' here has two entries, so we need to supply a 
# list of values of the same length
paths = [['diameter', 'angles'], 'transmission']
values = [1, 2]
new_optics = optics.set(paths, values)
print(new_optics.get(paths))

[1, 1, 2]

Excellent! Now some keen readers may have noticed that using the .set method, the transmission values has changes from an array to a float! This is becuase there is no robust way to do runtime type and shape checking, plus sometimes we may want to change the type anyway. Do be cognisant when setting values that you are setting then to valid types for the object.

Summary

So that is a quick overview of how to work with dLux objects. We have seen how to access the data via paths, and how to modify the data using the Zodiax methods. We have also seen how to nest paths, and how to nest paths within paths. Hopefully this has given you a good overview of how to work with dLux objects, and you can now go and work with the objects with ease!