Module MeasurementEquations

Changes made in the current development cycle can be found in the changelog.

Description (classes)

MeasurementEquations express how synthesis measurements are made

Prerequisite

Etymology

Measurement Equation describes a model for measurements from a generic radio telescope.

Synopsis

Synthesis processing in AIPS++ is implemented using the measurement equation due to Hamaker, Bregman and Sault and later extended by Noordam, and Cornwell. The HBS measurement equation expresses the measured visibility in terms of Jones matrices and other components. A Jones matrix is a two by two complex matrix that describes how two orthogonal senses of polarization are affected by an element in a measurement system. In the HBS formulation of synthesis processing, the antenna is described by a compound Jones matrix formed from a product each element of which represents a different physical effect:

J = G D C E P T F K

The measured visibility from a radio telescope is then given by:

V_i,j=X_i,j (M_i,j integral directProduct(J_i, Conjugate(J_j)) S I + A_i,j)

where the elements in the equation are

and the integral is over time, frequency, sky position. The direct product of two 2 by 2 matrices gives a 4 by 4 matrix in which every possible product of the 2 by 2 matrix elements appears.

Manipulation of the equation in this form is possible but is much too expensive for most uses so we break it down into two parts and also use a special machine for the Fourier summation. This loses some generality but makes the use of the HBS measurement equation feasible.

The split is such that the class VisEquation expresses the visibility-plane part of the ME:

J = G D C P

where the visibility is V_i,j=X_i,j (M_i,j integral directProduct(J_i, Conjugate(J_j)) Vsky_i,j + A_i,j) and the integral is over time, frequency.

and the class SkyEquation expresses the sky-plane part of the ME:

J = E T F K

Vsky_i,j=integral directProduct(J_i, Conjugate(J_j)) S I and the integral is over time, frequency, sky position.

The last integral (over K) amounts to a Fourier transform and so the SkyEquation is given FT machines to use for this purpose. Note that we have chosen to move the position of the parallactic angle term. This has been done for expediency but will lead to some difficulties in difficult cases.

The terms G, D, C, etc, are represented by the classes in the module MeasurementComponents. This classes can typically do two basic things: apply a correction to a VisBuffer (which is a holder of a chunk of visibility data), and solve for its own internal parameters. Solution is accomplished using gradients of chi-squared obtained via standard services of the MeasurementEquation.

The SkyBrightness is modelled by a special type of MeasurementComponent called a SkyModel. This has an interface to the SkyEquation via a PagedImage.

Another type of MeasurementComponent is the Fourier transform machine FTMachine which is used for performing forward and inverse Fourier transforms. The class GridFT implements a straightforward grid and degrid FFT-based Fourier transform. We anticipate that other FTMachines will be needed for e.g. wide-field imaging.

Visibility Data is held in a MeasurementSet. To expedite processing, we use a VisibilityIterator (found in this module) to iterate through the MeasurementSet as needed. Setting up the iterator is relatively expensive so we store the iterator in a VisSet (also found in this module). Thus one should construct a VisSet and then use the iterator method to retrieve the iterator. Once one has a VisibilityIterator, it can be used to access the actual visibility data in chunk by using the VisBuffer (also in this module). This scheme may seem baroque but it is needed to cut down on superfluous otherhead of various types.

Example

      // Create a VisSet from a MeasurementSet on disk
      VisSet vs("3c84.MS");

      // Now make an FTMachine with a 2048 by 2048
      // complex pixel cache of 16 by 16 tiles,
      // using Spheriodal Function gridding
      GridFT ft(2048*2048, 16, "SF")

      // Create an ImageSkyModel from an image on disk
      PagedImage<Float> im("3c84.modelImage"));
      ImageSkyModel ism(im);

      // For the imaging, we need a SkyEquation and
      // an FTMachine
      SkyEquation se(vs, ft);

      // Predict the visibility set for the model
      se.predict();

      // Make a VisEquation
      VisEquation ve(vs);

      // Solve for calibration of G matrix every 5 minutes
      GJones gj(vs, 5*60);
      ve.solve(gj);

      // Solve for calibration of D matrix every 12 hours
      DJones dj(vs, 12*60*60);
      ve.solve(dj);

      // Now use the SkyEquaton to make a Clean Image
      HogbomCleanImageSkyModel csm(ism);
      if (se.solve(csm)) {
        Image<StokesVector> cleanImage=csm.getImage();
        cleanImage.setName("3c84.cleanImage");
      }

Motivation

MeasurementEquations are needed to encapsulate the measurement equations for linear systems, and both single dish and synthesis observations. The idea is that the structure of many calibration and imaging algorithms is much the same for many different types of telescope. MeasurementEquations are part of a framework of classes that are designed for synthesis and single dish imaging. The others are the MeasurementComponents.

To Do


Classes

ArrayModel -- models with an internal & external representation as an array (full description)
CCList -- (full description)
CEMemModel -- Implements the Cornwell & Evans MEM Algorithm on Lattices (full description)
CEMemProgress -- Class to monitor progress in MEM deconvolution (full description)
CStokesVector -- Two specialized 4-vector classes for polarization handling (full description)
ClarkCleanLatModel -- A Class for performing the Clark Clean Algorithm on Arrays (full description)
ClarkCleanModel -- A Class for performing the Clark Clean Algorithm on Arrays (full description)
ClarkCleanProgress -- Abstract base class to monitor progress in lattice operations (full description)
ConvolutionEquation -- Implements the convolution equation (full description)
Entropy -- base class for entropy functions as used by MEM (full description)
EntropyEmptiness -- Maximum Emptiness measure used by MEM (full description)
EntropyI -- Thermodynamic or Information entropy used by MEM (full description)
HogbomCleanModel -- A Class for performing Hogbom Clean's of Arrays (full description)
IPLatConvEquation -- Implements the image plane lattice convolution equation (full description)
Imager -- Class that contains functions needed for imager (full description)
IncCEMemModel -- performs MEM algorithm incrementally (full description)
IncEntropy -- Base class for incremental entropies used by incremental MEM algorithm (full description)
IncEntropyEmptiness -- Emptiness measure for incremental MEM (full description)
IncEntropyI -- Thermodynamic or Information entropy for incremental MEM (full description)
Iterate -- (full description)
LatConvEquation -- Implements the convolution equation (full description)
LatticeModel -- models with an internal & external representation as an Lattice (full description)
LinearEquation -- defines a relationship between Domain and Range objects (full description)
LinearModel -- Provides a model for use in model fitting applications (full description)
MaskedArrayModel -- base class for models with an internal & external representation as a MaskedArray (full description)
MaskedHogbomCleanModel -- A Class for performing Hogbom Clean's of Arrays (full description)
MosaicSkyEquation -- Relate Sky brightness to the visibility, for the multi field case (full description)
PSkyEquation -- Parallelized version of class SkyEquation (full description)
Qimager -- Class that contains functions needed for qimager (full description)
ROVisibilityIterator -- ROVisibilityIterator iterates through one or more readonly MeasurementSets (full description)
ResidualEquation -- Interface class containing functions returning "Domain" type (full description)
SkyEquation -- Relate Sky brightness to the visibility (full description)
StokesImageUtil -- (full description)
StokesVector ancillary Functions -- for use with StokesVectors and related classes (full description)
StokesVector -- (full description)
VisBuffer -- VisBuffers encapulsate one chunk of visibility data for processing. (full description)
VisEquation -- Visibility Measurement Equation (full description)
VisSet -- The interface to the MeasurementSet for synthesis processing (full description)
VisSetUtil -- Utilities for operating on VisSets. (full description)
VisTimeAverager -- A class to average VisBuffers in time (full description)
VisibilityIterator -- VisibilityIterator iterates through one or more writable MeasurementSets (full description)
WFSkyEquation -- (full description)
deconvolver -- A simple deconvolver operating on images (no SkyEquation) (full description)
imager -- Makes images from a MeasurementSet with the SkyEquation (full description)
newsimulator -- Simulates MeasurementSets from SkyModel and SkyEquation (full description)
pimager -- Parallel version of imager (full description)
qimager -- Makes images from a MeasurementSet with the SkyEquation (full description)
simulator -- Simulates MeasurementSets from SkyModel and SkyEquation (full description)