Calibration

Calibration is performed by fitting observed visibilities to a model visibility.

The scalar equation to be minimised is:

\[S = \sum_{t,f}^{}{\sum_{i,j}^{}{w_{t,f,i,j}\left| V_{t,f,i,j}^{\text{obs}} - J_{i}{J_{j}^{*}V}_{t,f,i,j}^{\text{mod}} \right|}^{2}}\]

The least squares fit algorithm uses an iterative substitution (or relaxation) algorithm from Larry D’Addario in the late seventies.

rascil.processing_components.calibration.chain_calibration Module

Functions to solve for and apply chains of antenna/station gain tables.

Calibration control is via a calibration_controls dictionary created by rascil.processing_components.calibration.chain_calibration.create_calibration_controls(). This supports the following Jones matrices:

. T - Atmospheric phase
. G - Electronics gain
. P - Polarisation
. B - Bandpass
. I - Ionosphere

This is specified via a dictionary:

contexts = {'T': {'shape': 'scalar', 'timeslice': 'auto', 'phase_only': True, 'first_iteration': 0},
            'G': {'shape': 'vector', 'timeslice': 60.0, 'phase_only': False, 'first_iteration': 0},
            'P': {'shape': 'matrix', 'timeslice': 1e4, 'phase_only': False, 'first_iteration': 0},
            'B': {'shape': 'vector', 'timeslice': 1e5, 'phase_only': False, 'first_iteration': 0},
            'I': {'shape': 'vector', 'timeslice': 1.0, 'phase_only': True, 'first_iteration': 0}}

Currently P and I are not supported.

For example:

controls = create_calibration_controls()

controls['T']['first_selfcal'] = 1
controls['T']['phase_only'] = True
controls['T']['timeslice'] = 'auto'

controls['G']['first_selfcal'] = 3
controls['G']['timeslice'] = 'auto'

controls['B']['first_selfcal'] = 4
controls['B']['timeslice'] = 1e5

ical_list = ical_list_rsexecute_workflow(vis_list,
                                          model_imagelist=future_model_list,
                                          context='wstack', vis_slices=51,
                                          scales=[0, 3, 10], algorithm='mmclean',
                                          nmoment=3, niter=1000,
                                          fractional_threshold=0.1,
                                          threshold=0.1, nmajor=5, gain=0.25,
                                          deconvolve_facets=1,
                                          deconvolve_overlap=0,
                                          deconvolve_taper='tukey',
                                          timeslice='auto',
                                          psf_support=64,
                                          global_solution=False,
                                          calibration_context='TGB',
                                          do_selfcal=True)

Functions

`calibrate_chain`(vis, model_vis[, ...])	Calibrate using algorithm specified by calibration_context
`solve_calibrate_chain`(vis, model_vis[, ...])	Calibrate using algorithm specified by calibration_context
`create_calibration_controls`()	Create a dictionary containing default chanin calibration controls
`apply_calibration_chain`(vis, gaintables[, ...])	Calibrate using algorithm specified by calibration_context and the calibration controls

rascil.processing_components.calibration.iterators Module

GainTable iterators for iterating through a GainTable

Functions

`gaintable_timeslice_iter`(gt, **kwargs)	GainTable iterator
`gaintable_null_iter`(gt, **kwargs)	One time iterator returning true for all rows

rascil.processing_components.calibration.operations Module

Functions for calibration, including creation of gaintables, application of gaintables, and merging gaintables.

Functions

`gaintable_summary`(gt)	Return string summarizing the Gaintable
`qa_gaintable`(gt[, context])	Assess the quality of a gaintable
`apply_gaintable`(vis, gt[, inverse])	Apply a gain table to a visibility
`append_gaintable`(gt, othergt)	Append othergt to gt
`create_gaintable_from_visibility`(vis[, ...])	Create gain table from visibility.
`create_gaintable_from_rows`(gt, rows[, makecopy])	Create a GainTable from selected rows
`copy_gaintable`(gt[, zero])	Copy a GainTable
`gaintable_plot`(gt[, cc, title, ants, ...])	Standard plot of gain table
`multiply_gaintables`(gt, dgt[, time_tolerance])	Multiply two gaintables
`concatenate_gaintables`(gt_list[, dim])	Concatenate a list of gaintables

rascil.processing_components.calibration.pointing Module

Functions for calibration, including creation of pointingtables, application of pointingtables, and merging pointingtables.

Functions

`create_pointingtable_from_rows`(pt, rows[, ...])	Create a PointingTable from selected rows
`create_pointingtable_from_visibility`(vis[, ...])	Create pointing table from visibility.
`copy_pointingtable`(pt[, zero])	Copy a PointingTable

rascil.processing_components.calibration.rcal Module

Real time calibration pipeline

Functions

rcal(vis, components, **kwargs)

Real-time calibration pipeline.

rascil.processing_components.calibration.solvers Module

Functions to solve for antenna/station gain

This uses an iterative substitution algorithm due to Larry D’Addario c 1980’ish. Used in the original VLA Dec-10 Antsol.

For example:

gtsol = solve_gaintable(vis, originalvis, phase_only=True, niter=niter, crosspol=False, tol=1e-6)
vis = apply_gaintable(vis, gtsol, inverse=True)

Functions

solve_gaintable(vis[, modelvis, gt, ...])

Solve a gain table by fitting an observed visibility to a model visibility