Coronagraph

Overview

The coronagraph module simulates electric field propagation through a coronagraph located downstream the AO loop. The input is the target residual phase, and the main output is the coronagraph image. Two types of coronagraphs are implemented : a perfect coronagraph and a more realistic coronagraph called four-plane coronagraph hereafter.

Perfect coronagraph

The perfect coronagraph substracts the diffractive effect of the telescope. Mathematically speaking, the following operations are performed:

1. Electric field is computed from the incoming phase screen
2. The average of the electric field over the pupil is substracted to the electric field
3. Optical Fourier transform and square modulus yield the image in focal plane

References : Galicher, Raphaël : PhD thesis, section I.2.2.4 Sauvage, Jean-François : PhD thesis, section 2.4.3.1

Four-plane coronagraph

The four-plane coronagraph includes the different pupil and focal planes of a stellar coronagraph, in this order following the light in the instrument:

Custom DM

What is it ?

The custom DM option allows the user to provide COMPASS with some specific influence functions and positions of actuators. COMPASS will read the influence functions and resample them to its own geometry and sampling using splines.

The custom DM can be used to feature well-known, famous DMs such as the M4 of the ELT, the Boston 32x32 MEMS, or the ALPAO 64x64 magnetic DM for instance.

The “custom DM” feature of COMPASS allows you to adjust finely the magnification of the DM with respect to the pupil size, as the simulation of a real experiment would require.

Custom DM fits file

The custom DM fits file shall contain 3 extensions with data:

• Extension n°1 (EXTNAME = 'I1_J1') : is the list of all the indexing values (ix, iy) where the first pixel of each minimap is placed in the original large frame. As this list correspond to some index values, it has to be integers. The shape shall be (2, ntotact).

  [Read More]

Optical gains with a pyramid wavefront sensor

Detailed information about this problem and the proposed method can be found in this paper.

The very good sensitivity of the pyramid wavefront sensor (PWFS) has lead the AO community to strongly consider this type of WFS in new designs of high performance AO systems on relatively (or extremely) large telescopes. However, the limited dynamic range of this kind of sensors carries non linearity in the form of a sensitivity reduction that can be modeled as a function of the wavefront spatial frequency. This non linearity, called Optical Gains, can be a problem when one wants to implement algorithms that rely on linearity of the WFS, and the need to find a method to measure and compensate these optical gains arose.

The CLOSE modal gain optimization algorithm

To overcome the problem of optical gains, COMPASS includes an implementation of the Correlation-Locking Optimization SchEme (CLOSE) algorithm that uses an auto-correlation based self-regulating method that drives the integrator modal gains.

Intro to generic_linear

The generic_linear controller is designed to be suitable for any practical linear control law, from the simple leaky integrator, to POLC with arbitrary order IIR filters, to LQG. The entire pipeline in it’s fullest generality is outlined below (python syntax for readability - though the actual implementation is in cublas accelerated c++).

Most General Pipeline:

centroids are computed in the centroider object, and the output of the controller is the com vector, to be sent to the DMs.

# compute appropriate slope vector including delay:
if POLC:
  s_now = comp_polc(centroids)
else:
  s_now = centroids

# update circular buffer of slopes:
for i in range(nslope_buffer-1):
  s[i+1] = s[i]
s[0] = s_now

# clear temporary variable:
x_now *= 0.0

# do recursions of x with matA:
for i in range(nstate_buffer):
  x_now += matA[i] @ x[i]

# do innovations of s with matL:
for i in range(nslope_buffer):
  x_now += matL[i] @ s[i]

# update circular buffer of states:
for i in range(nstate_buffer-1):
  x[i+1] = x[i]
x[0] = x_now

# modal projection:
if MODAL:
  u_now = matK @ x_now
else:
  u_now = x_now

# update circular buffer of iir inputs:
for i in range(n_iir_in-1):
  u_in[i+1] = u_in[i]
u_in[0] = u_now

# perform iir recursions:
if n_iir_in > 0:
	u_now *= 0.0
for i in range(n_iir_in):
  u_now += iir_b[i] * u_in[i]
for i in range(n_iir_out):
  u_now += iir_a[i] * u_out[i]

# update circular buffer of iir outputs:
for i in range(n_iir_out-1):
  u_out[i+1] = u_out[i]
u_out[0] = u_now

# do final modal projection to command space
if MODAL:
  com = matF @ u_now
else:
  com = u_now

Without a specific application in mind, the above pseudo-code can be overwhelming. To understand the pipeline, it is useful to consider a few example uses.