How to account for field rotation

Unlike the venerable Palomar Hale Telescope that stands out as one of the last great telescopes to feature an equatorial mount, large telescopes use a more compact alt-azimuthal mount which means that as the telescope tracks a given target, if one were to lie down on the primary mirror, one would see the sky rotate. At the focus of an instrument that is at a fixed orientation relative to the pupil, the sky also rotates. Thus when tracking a star with companions as they transit, the companions will rotate around the primary.

It is possible to compensate for this apparent motion of the target that prevents the use of very long integrations, with a field derotator, but from the point of view of the camera, it is now the pupil of the telescope that rotates, and this will result in spinning diffraction features.

For high-contrast imaging, field rotation turns out to be a useful feature that makes it possible to easily disentangle the static diffraction features from actual companions. Full-aperture kernel-phase and sparse aperture closure-phase operate in fixed pupil mode, which means that they have to compose with sky rotation.

This page introduces how to use the XARA pipeline to account for field rotation when interpreting kernel-phase.

When experiencing field rotation, the only way to make sense of the data being acquired at any instant is to keep track of the orientation of the detector relative to the true north, with an angle refered to as the detector position angle. In the software, the variable keeping track of this angle is called DETPA.

Assuming that one has been processing an image datacube with the XARA pipeline using the default cube extraction method (cf. example script), a look at the kpo1.DETPA variable would reveal an array filled with zeros: by default, the pipeline simply assumes that the detector pixels are aligned with the on-sky reference axis, with the north (N) pointing up and east (E) to the left, as is actually the case for PHARO images.

The convention used in the software is illustrated in the following image. The detector position angle DETPA is labeled ω and the companion position angle measured relative to the north is labeled \(\theta\).

At the time of the extraction, the knowledge of the DETPA is not required: the only thing that matters is that you have a good, reliable discrete model that correctly accounts for all the features of the pupil. But when the time to interpret the data comes, such as when attempting to fit a binary kernel-phase model to the kernel-phase extracted from the datacube, then the proper DETPA info must be fed to the kpo data structure. Assuming the first data cube (index = 0) contains nim images, and that the known detector position angles are available in a distinct array called mydetpa, one can directly update the values using:

kpo1.DETPA[0] = mydetpa[:nim]

so that later, the call of kpo1.kpd_binary_model([sep, PA, con]) returns a list of arrays that matches the shape of the data acquired.

The following program uses the XAOSIM package to simulate a SPHERE SAM data-set in the K1 filter. XAOSIM features a preset for the AO system of GRAVITY that we can use here since SPHERE equips one of the VLT telescopes.

It saves a fits datacube of SAM interferograms recorded on a binary and (for the purpose of the demonstration) as the detector position angle varies continuously from 0 to 89 degrees… over 90 frames (1 additional degree of rotation per frame).

Note that no atmosphere or AO residuals are used here: the point of this tutorial is to see how field rotation affects the interpretation of kernel-phase.

Also note that we use XAOSIM but do not use its pseudo real-time features. In order to produce images, we need to do two things at each iteration:

• make_image() updates the image on a shared memory data structure
• get_image() reads the data on the shared memory data structure and returns an array

import xaosim as xs
import numpy as np
from xaosim.pupil import SPHERE_IRDIS_SAM as sam
import astropy.io.fits as pf
import matplotlib.pyplot as plt

pscale = 12.255   # SPHERE IRDIS plate scale (mas/pixel)
cwavel = 2.11e-6  # K1 filter central wavelength (in meters)

try:
        _ = sphere.name
except NameError:
        sphere = xs.instrument("gravity", csz=480)
        sphere.cam2.update_cam(pscale=pscale, wl=cwavel)
        csz = sphere.csz
        ppscale = sphere.cam2.pdiam / csz  # pupil plate scale (meter/pixel)
        pupil0 = sphere.cam2.pupil.copy()  # the original pupil

sphere.cam2.update_cam(between_pixel=False)
sphere.cam2.pupil *= sam(csz)  # replacing the pupil by the SAM mask

# ----------------------------------------------------------------------
# prepare for later image crops: the cube built here is 215 x 215 pixels
# ----------------------------------------------------------------------

rsz = 215  # image size retained for cube
sphere.cam2.make_image()  # update simulation$
img0 = sphere.cam2.get_image()  # take an image
isz = img0.shape[0]  # image size

xy0 = (isz - rsz) // 2 + 1
xy1 = xy0 + rsz

imgc = img0[xy0:xy1, xy0:xy1]  # image cropped

# ----------------------------------------------------------------------
# properties of the simulated companion.
# ----------------------------------------------------------------------
sep = 115.  # separation (in mas)
PA = 257.0  # position angle (in degrees)
con = 0.1   # contrast (secondary/primary)

# ----------------------------------------------------------------------
# field rotation parameters: detector P.A. varies from 0 to 90 degrees
# ----------------------------------------------------------------------
nim = 90
detpas = np.arange(nim)
dcube = np.zeros((nim, rsz, rsz))

off_pointing = sphere.cam2.off_pointing  # short-hand!

# ----------------------------------------------------------------------
# simulating field rotation while observing the binary
# ----------------------------------------------------------------------
sep_pix = sep/pscale  # separation in # of pixels
for ii, detpa in enumerate(detpas):
        azim = (PA + detpa)*np.pi/180.0
        dx = -sep_pix * np.sin(azim)
        dy = sep_pix * np.cos(azim)
        sphere.cam2.make_image(phscreen=off_pointing(dx, dy))
                print("\r%04d: dra=%+6.2f, ddec=%+6.2f" % (ii, -dx, dy),
                  end="", flush=True)
        img1 = sphere.cam2.get_image()[xy0:xy1, xy0:xy1]
        dcube[ii] = imgc + con * img1

# save a datacube with a binary including rotation model
pf.writeto("sim_cube.fits", dcube, overwrite=True)

f1 = plt.figure(figsize=(5, 5))
ax1 = f1.add_subplot(111)
ax1.imshow(dcube[0]**0.2)
ax1.set_title("First frame of the saved datacube")
f1.set_tight_layout(True)

To extract sensible kernel-phase out of the dataset that was just simulated, one first needs a model of the aperture. This is a sparse aperture masking dataset: there are more or less sophisticated ways of building models for one such dataset but we will stick to the simplest approach: our model will consist in only one sampling point per aperture.