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 selfcal_convert(error_bvis, no_error_bvis):
if selfcal:
gt = solve_gaintable(error_bvis,
no_error_bvis,
gt=None,
phase_only=True,
niter=30,
tol=1e-8,
crosspol=False,
normalise_gains=True,
**kwargs)
error_bvis = apply_gaintable(error_bvis, gt)
if residual:
error_bvis.data[
'vis'] = error_bvis.data['vis'] - no_error_bvis.data['vis']
if context != "ng":
error_vis = convert_blockvisibility_to_visibility(error_bvis)
return error_vis
else:
return error_bvis
def to_vis(v):
if isinstance(v, BlockVisibility):
av = convert_blockvisibility_to_visibility(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
def subtract_vis_convert(error_bvis, no_error_bvis):
error_bvis.data[
'vis'] = error_bvis.data['vis'] - no_error_bvis.data['vis']
error_vis = convert_blockvisibility_to_visibility(error_bvis)
return error_vis
