def solve_calibrate_chain(vis, model_vis, calibration_context='T', controls=None, iteration=0, tol=1e-6, **kwargs):
""" Calibrate using algorithm specified by calibration_context
The context string can denote a sequence of calibrations e.g. TGB with different timescales.
:param vis:
:param model_vis:
:param calibration_context: calibration contexts in order of correction e.g. 'TGB'
:param controls: controls dictionary, modified as necessary
:param iteration: Iteration number to be compared to the 'first_selfcal' field.
:param kwargs:
:return: Calibrated data_models, dict(gaintables)
"""
gaintables = {}
if controls is None:
controls = create_calibration_controls()
isVis = isinstance(vis, Visibility)
if isVis:
avis = convert_visibility_to_blockvisibility(vis)
else:
avis = vis
isMVis = isinstance(model_vis, Visibility)
if isMVis:
amvis = convert_visibility_to_blockvisibility(model_vis)
else:
amvis = model_vis
assert isinstance(avis, BlockVisibility), avis
assert amvis.__repr__() != avis.__repr__(), "Vis and model vis are the same object: convert problem"
# Always return a gain table, even if null
for c in calibration_context:
gaintables[c] = \
create_gaintable_from_blockvisibility(avis, timeslice=controls[c]['timeslice'])
if iteration >= controls[c]['first_selfcal']:
if numpy.max(numpy.abs(vis.weight)) > 0.0 and (amvis is None or numpy.max(numpy.abs(amvis.vis)) > 0.0):
gaintables[c] = solve_gaintable(avis, amvis,
timeslice=controls[c]['timeslice'],
phase_only=controls[c]['phase_only'],
crosspol=controls[c]['shape'] == 'matrix',
tol=tol)
log.debug('calibrate_chain: Jones matrix %s, iteration %d' % (c, iteration))
log.debug(qa_gaintable(gaintables[c], context='Jones matrix %s, iteration %d' % (c, iteration)))
avis = apply_gaintable(avis, gaintables[c], inverse=True, timeslice=controls[c]['timeslice'])
else:
log.debug('calibrate_chain: Jones matrix %s not solved, iteration %d' % (c, iteration))
else:
log.debug('calibrate_chain: Jones matrix %s not solved, iteration %d' % (c, iteration))
return gaintables
def calibrate_list_serial_workflow(vis_list,
model_vislist,
calibration_context='TG',
global_solution=True,
**kwargs):
""" Create a set of components for (optionally global) calibration of a list of visibilities
If global solution is true then visibilities are gathered to a single visibility data set which is then
self-calibrated. The resulting gaintable is then effectively scattered out for application to each visibility
set. If global solution is false then the solutions are performed locally.
:param vis_list:
:param model_vislist:
:param calibration_context: String giving terms to be calibrated e.g. 'TGB'
:param global_solution: Solve for global gains
:param kwargs: Parameters for functions in components
:return:
"""
def solve(vis, modelvis=None):
return solve_calibrate_chain(vis,
modelvis,
calibration_context=calibration_context,
**kwargs)
def apply(vis, gt):
assert gt is not None
return apply_calibration_chain(vis,
gt,
calibration_context=calibration_context,
**kwargs)
if global_solution:
point_vislist = [
convert_visibility_to_blockvisibility(v) for v in vis_list
]
point_modelvislist = [
convert_visibility_to_blockvisibility(mv) for mv in model_vislist
]
point_vislist = [
divide_visibility(point_vislist[i], point_modelvislist[i])
for i, _ in enumerate(point_vislist)
]
global_point_vis_list = visibility_gather_channel(point_vislist)
global_point_vis_list = integrate_visibility_by_channel(
global_point_vis_list)
# This is a global solution so we only compute one gain table
gt_list = [solve(global_point_vis_list)]
return [apply(v, gt_list[0]) for v in vis_list], gt_list
else:
gt_list = [solve(v, model_vislist[i]) for i, v in enumerate(vis_list)]
return [apply(v, gt_list[i]) for i, v in enumerate(vis_list)], gt_list
def ift_ical_sm(v, sm, g):
assert isinstance(v, Visibility) or isinstance(v, BlockVisibility), v
assert isinstance(sm, SkyModel), sm
if g is not None:
assert len(g) == 2, g
assert isinstance(g[0], Image), g[0]
assert isinstance(g[1], ConvolutionFunction), g[1]
if docal and isinstance(sm.gaintable, GainTable):
if isinstance(v, Visibility):
bv = convert_visibility_to_blockvisibility(v)
bv = apply_gaintable(bv, sm.gaintable)
v = convert_blockvisibility_to_visibility(bv)
else:
v = apply_gaintable(v, sm.gaintable)
result = invert_list_serial_workflow([v], [sm.image],
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=[g],
**kwargs)[0]
if isinstance(sm.mask, Image):
result[0].data *= sm.mask.data
return result
def apply_calibration_chain(vis,
gaintables,
calibration_context='T',
controls=None,
iteration=0,
tol=1e-6,
**kwargs):
""" Calibrate using algorithm specified by calibration_context and the calibration controls
The context string can denote a sequence of calibrations e.g. TGB with different timescales.
:param vis:
:param model_vis:
:param calibration_context: calibration contexts in order of correction e.g. 'TGB'
:param control: controls dictionary, modified as necessary
:param iteration: Iteration number to be compared to the 'first_selfcal' field.
:param kwargs:
:return: Calibrated data_models, dict(gaintables)
"""
if controls is None:
controls = create_calibration_controls()
# Check to see if changes are required
changes = False
for c in calibration_context:
if (iteration >=
controls[c]['first_selfcal']) and (c in gaintables.keys()):
changes = True
if changes:
isVis = isinstance(vis, Visibility)
if isVis:
avis = convert_visibility_to_blockvisibility(vis)
else:
avis = vis
assert isinstance(avis, BlockVisibility), avis
for c in calibration_context:
if iteration >= controls[c]['first_selfcal']:
avis = apply_gaintable(avis,
gaintables[c],
timeslice=controls[c]['timeslice'])
if isVis:
return convert_blockvisibility_to_visibility(avis)
else:
return avis
else:
return vis
def corrupt_vis(vis, gt, **kwargs):
if isinstance(vis, Visibility):
bv = convert_visibility_to_blockvisibility(vis)
else:
bv = vis
if gt is None:
gt = create_gaintable_from_blockvisibility(bv, **kwargs)
gt = simulate_gaintable(gt, **kwargs)
bv = apply_gaintable(bv, gt)
if isinstance(vis, Visibility):
return convert_blockvisibility_to_visibility(bv)
else:
return bv
def ft_cal_sm(ov, sm, g):
assert isinstance(ov, Visibility) or isinstance(ov,
BlockVisibility), ov
assert isinstance(sm, SkyModel), sm
if g is not None:
assert len(g) == 2, g
assert isinstance(g[0], Image), g[0]
assert isinstance(g[1], ConvolutionFunction), g[1]
v = copy_visibility(ov)
v.data['vis'][...] = 0.0 + 0.0j
if len(sm.components) > 0:
if isinstance(sm.mask, Image):
comps = copy_skycomponent(sm.components)
comps = apply_beam_to_skycomponent(comps, sm.mask)
v = predict_skycomponent_visibility(v, comps)
else:
v = predict_skycomponent_visibility(v, sm.components)
if isinstance(sm.image, Image):
if numpy.max(numpy.abs(sm.image.data)) > 0.0:
if isinstance(sm.mask, Image):
model = copy_image(sm.image)
model.data *= sm.mask.data
else:
model = sm.image
v = predict_list_serial_workflow([v], [model],
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=[g],
**kwargs)[0]
if docal and isinstance(sm.gaintable, GainTable):
if isinstance(ov, Visibility):
bv = convert_visibility_to_blockvisibility(v)
bv = apply_gaintable(bv, sm.gaintable, inverse=True)
v = convert_blockvisibility_to_visibility(bv)
else:
v = apply_gaintable(v, sm.gaintable, inverse=True)
return v
def to_bvis(v, ov):
if isinstance(ov, BlockVisibility):
av = convert_visibility_to_blockvisibility(v)
return av
else:
return v
def calibrate_chain(vis,
model_vis,
gaintables=None,
calibration_context='T',
controls=None,
iteration=0,
tol=1e-8,
**kwargs):
""" Calibrate using algorithm specified by calibration_context
The context string can denote a sequence of calibrations e.g. TGB with different timescales.
:param vis:
:param model_vis:
:param calibration_context: calibration contexts in order of correction e.g. 'TGB'
:param controls: controls dictionary, modified as necessary
:param iteration: Iteration number to be compared to the 'first_selfcal' field.
:param kwargs:
:return: Calibrated data_models, dict(gaintables)
"""
if controls is None:
controls = create_calibration_controls()
# Check to see if changes are required
changes = False
for c in calibration_context:
if iteration >= controls[c]['first_selfcal']:
changes = True
if changes:
isVis = isinstance(vis, Visibility)
if isVis:
avis = convert_visibility_to_blockvisibility(vis)
else:
avis = vis
isMVis = isinstance(model_vis, Visibility)
if isMVis:
amvis = convert_visibility_to_blockvisibility(model_vis)
else:
amvis = model_vis
assert isinstance(avis, BlockVisibility), avis
if gaintables is None:
gaintables = dict()
for c in calibration_context:
if iteration >= controls[c]['first_selfcal']:
if c not in gaintables.keys():
log.info("Creating new {} gaintable".format(c))
gaintables[c] = \
create_gaintable_from_blockvisibility(avis,
timeslice=controls[c]['timeslice'])
gaintables[c] = solve_gaintable(
avis,
amvis,
gt=gaintables[c],
timeslice=controls[c]['timeslice'],
phase_only=controls[c]['phase_only'],
crosspol=controls[c]['shape'] == 'matrix',
tol=tol)
log.debug('calibrate_chain: Jones matrix %s, iteration %d' %
(c, iteration))
log.debug(
qa_gaintable(gaintables[c],
context='Jones matrix %s, iteration %d' %
(c, iteration)))
avis = apply_gaintable(avis,
gaintables[c],
inverse=True,
timeslice=controls[c]['timeslice'])
else:
log.debug(
'calibrate_chain: Jones matrix %s not solved, iteration %d'
% (c, iteration))
if isVis:
return convert_blockvisibility_to_visibility(avis), gaintables
else:
return avis, gaintables
else:
return vis, gaintables