def calibrate_visibility(vt: Visibility,
model: Image = None,
components=None,
predict=predict_2d,
**kwargs) -> Visibility:
""" calibrate Visibility with respect to model and optionally components
:param vt: Visibility
:param model: Model image
:param components: Sky components
:return: Calibrated visibility
"""
assert model is not None or components is not None, "calibration requires a model or skycomponents"
vtpred = copy_visibility(vt, zero=True)
if model is not None:
vtpred = predict(vtpred, model, **kwargs)
if components is not None:
vtpred = predict_skycomponent_visibility(vtpred, components)
else:
vtpred = predict_skycomponent_visibility(vtpred, components)
bvt = decoalesce_visibility(vt)
bvtpred = decoalesce_visibility(vtpred)
gt = solve_gaintable(bvt, bvtpred, **kwargs)
bvt = apply_gaintable(bvt,
gt,
inverse=get_parameter(kwargs, "inverse", False))
return convert_blockvisibility_to_visibility(bvt)
def test_convert_decoalesce_zero(self):
cvis = convert_blockvisibility_to_visibility(self.blockvis)
assert numpy.min(cvis.frequency) == numpy.min(self.frequency)
assert numpy.min(cvis.frequency) > 0.0
dvis = decoalesce_visibility(cvis)
assert dvis.nvis == self.blockvis.nvis
dvis = decoalesce_visibility(cvis, overwrite=True)
assert dvis.nvis == self.blockvis.nvis
def test_coalesce_decoalesce_time(self):
cvis = coalesce_visibility(self.blockvis, time_coal=1.0, frequency_coal=0.0, max_frequency_coal=1)
assert numpy.min(cvis.frequency) == numpy.min(self.frequency)
assert numpy.min(cvis.frequency) > 0.0
dvis = decoalesce_visibility(cvis)
assert dvis.nvis == self.blockvis.nvis
dvis = decoalesce_visibility(cvis, overwrite=True)
assert dvis.nvis == self.blockvis.nvis
def calibrate_blockvisibility(bvt: BlockVisibility,
model=None,
components=None,
predict=predict_2d,
**kwargs):
""" calibrate BlockVisibility with respect to model and optionally components
:param bvt: BlockVisibility
:param model: Model image
:param components: Sky components
:returns: Calibrated BlockVisibility
"""
assert model is not None or components is not None, "calibration requires a model or skycomponents"
if model is not None:
vtpred = convert_blockvisibility_to_visibility(bvt)
vtpred = predict(vtpred, model, **kwargs)
bvtpred = decoalesce_visibility(vtpred)
if components is not None:
bvtpred = predict_skycomponent_blockvisibility(bvtpred, components)
else:
bvtpred = copy_visibility(bvt, zero=True)
bvtpred = predict_skycomponent_blockvisibility(bvtpred, components)
gt = solve_gaintable(bvt, bvtpred, **kwargs)
return apply_gaintable(bvt, gt, **kwargs)
def test_coalesce_decoalesce_with_iter(self):
for rows in vis_timeslice_iter(self.blockvis):
visslice = create_visibility_from_rows(self.blockvis, rows)
cvisslice = convert_blockvisibility_to_visibility(visslice)
assert numpy.min(cvisslice.frequency) == numpy.min(self.frequency)
assert numpy.min(cvisslice.frequency) > 0.0
dvisslice = decoalesce_visibility(cvisslice)
assert dvisslice.nvis == visslice.nvis
def test_coalesce_decoalesce_singletime(self):
self.times = numpy.array([0.0])
self.blockvis = create_blockvisibility(self.lowcore, self.times, self.frequency, phasecentre=self.phasecentre,
weight=1.0, polarisation_frame=PolarisationFrame('stokesI'),
channel_bandwidth=self.channel_bandwidth)
# Fill in the vis values so each can be uniquely identified
self.blockvis.data['vis'] = range(self.blockvis.nvis)
cvis = coalesce_visibility(self.blockvis, time_coal=1.0)
assert numpy.min(cvis.frequency) == numpy.min(self.frequency)
assert numpy.min(cvis.frequency) > 0.0
dvis = decoalesce_visibility(cvis)
assert dvis.nvis == self.blockvis.nvis
def visibility_gather_w(visibility_list, vis, **kwargs):
if type(vis) == BlockVisibility:
cvis = coalesce_visibility(vis, **kwargs)
return decoalesce_visibility(
visibility_gather(visibility_list,
cvis,
vis_iter=vis_wstack_iter,
**kwargs))
else:
return visibility_gather(visibility_list,
vis,
vis_iter=vis_wstack_iter,
**kwargs)
def gather_vis(results, vis):
# Gather across the visibility iteration axis
assert vis is not None
if isinstance(vis, BlockVisibility):
avis = coalesce_visibility(vis, **kwargs)
else:
avis = vis
for i, rows in enumerate(
vis_iter(avis, vis_slices=vis_slices, **kwargs)):
assert i < len(results), "Insufficient results for the gather"
if rows is not None and results[i] is not None:
avis.data['vis'][rows] = results[i].data['vis']
if isinstance(vis, BlockVisibility):
return decoalesce_visibility(avis, **kwargs)
else:
return avis
def predict_wstack_single(vis, model, remove=True, **kwargs) -> Visibility:
""" Predict using a single w slices.
This processes a single w plane, rotating out the w beam for the average w
:param vis: Visibility to be predicted
:param model: model image
:return: resulting visibility (in place works)
"""
if not isinstance(vis, Visibility):
log.debug("predict_wstack_single: Coalescing")
avis = coalesce_visibility(vis, **kwargs)
else:
avis = vis
log.debug("predict_wstack_single: predicting using single w slice")
avis.data['vis'] *= 0.0
# We might want to do wprojection so we remove the average w
w_average = numpy.average(avis.w)
avis.data['uvw'][..., 2] -= w_average
tempvis = copy_visibility(avis)
# Calculate w beam and apply to the model. The imaginary part is not needed
workimage = copy_image(model)
w_beam = create_w_term_like(model, w_average, vis.phasecentre)
# Do the real part
workimage.data = w_beam.data.real * model.data
avis = predict_2d_base(avis, workimage, **kwargs)
# and now the imaginary part
workimage.data = w_beam.data.imag * model.data
tempvis = predict_2d_base(tempvis, workimage, **kwargs)
avis.data['vis'] -= 1j * tempvis.data['vis']
if not remove:
avis.data['uvw'][..., 2] += w_average
if isinstance(vis, BlockVisibility) and isinstance(avis, Visibility):
log.debug("imaging.predict decoalescing post prediction")
return decoalesce_visibility(avis)
else:
return avis
def predict_2d_base(vis: Union[BlockVisibility, Visibility], model: Image,
**kwargs) -> Union[BlockVisibility, Visibility]:
""" Predict using convolutional degridding.
This is at the bottom of the layering i.e. all transforms are eventually expressed in terms of
this function. Any shifting needed is performed here.
:param vis: Visibility to be predicted
:param model: model image
:return: resulting visibility (in place works)
"""
if isinstance(vis, BlockVisibility):
log.debug("imaging.predict: coalescing prior to prediction")
avis = coalesce_visibility(vis, **kwargs)
else:
avis = vis
assert isinstance(avis, Visibility), avis
_, _, ny, nx = model.data.shape
padding = {}
if get_parameter(kwargs, "padding", False):
padding = {'padding': get_parameter(kwargs, "padding", False)}
spectral_mode, vfrequencymap = get_frequency_map(avis, model)
polarisation_mode, vpolarisationmap = get_polarisation_map(avis, model)
uvw_mode, shape, padding, vuvwmap = get_uvw_map(avis, model, **padding)
kernel_name, gcf, vkernellist = get_kernel_list(avis, model, **kwargs)
uvgrid = fft((pad_mid(model.data, int(round(padding * nx))) *
gcf).astype(dtype=complex))
avis.data['vis'] = convolutional_degrid(vkernellist,
avis.data['vis'].shape, uvgrid,
vuvwmap, vfrequencymap,
vpolarisationmap)
# Now we can shift the visibility from the image frame to the original visibility frame
svis = shift_vis_to_image(avis, model, tangent=True, inverse=True)
if isinstance(vis, BlockVisibility) and isinstance(svis, Visibility):
log.debug("imaging.predict decoalescing post prediction")
return decoalesce_visibility(svis)
else:
return svis
def predict_2d_base(vis: Visibility, model: Image, **kwargs) -> Visibility:
""" Predict using convolutional degridding.
This is at the bottom of the layering i.e. all transforms are eventually expressed in terms of
this function. Any shifting needed is performed here.
:param vis: Visibility to be predicted
:param model: model image
:return: resulting visibility (in place works)
"""
if type(vis) is not Visibility:
avis = coalesce_visibility(vis, **kwargs)
else:
avis = vis
_, _, ny, nx = model.data.shape
# print(model.shape)
spectral_mode, vfrequencymap = get_frequency_map(avis, model) # 可以并行
polarisation_mode, vpolarisationmap = get_polarisation_map(
avis, model, **kwargs) # 可以并行
uvw_mode, shape, padding, vuvwmap = get_uvw_map(avis, model,
**kwargs) # 可以并行
kernel_name, gcf, vkernellist = get_kernel_list(avis, model, **kwargs)
uvgrid = fft((pad_mid(model.data, int(round(padding * nx))) *
gcf).astype(dtype=complex))
avis.data['vis'] = convolutional_degrid(vkernellist,
avis.data['vis'].shape, uvgrid,
vuvwmap, vfrequencymap,
vpolarisationmap)
# Now we can shift the visibility from the image frame to the original visibility frame
svis = shift_vis_to_image(avis, model, tangent=True, inverse=True)
if type(vis) is not Visibility:
return decoalesce_visibility(svis)
else:
return svis
def predict_2d_base_timing(vis: Visibility, model: Image,
**kwargs) -> (Visibility, tuple):
""" Predict using convolutional degridding.
This is at the bottom of the layering i.e. all transforms are eventually expressed in terms of
this function. Any shifting needed is performed here.
:param vis: Visibility to be predicted
:param model: model image
:return: resulting visibility (in place works)
"""
if not isinstance(vis, Visibility):
avis = coalesce_visibility(vis, **kwargs)
else:
avis = vis
_, _, ny, nx = model.data.shape
opt = get_parameter(kwargs, 'opt', False)
if not opt:
log.debug('Using original algorithm')
else:
log.debug('Using optimized algorithm')
padding = {}
if get_parameter(kwargs, "padding", False):
padding = {'padding': get_parameter(kwargs, "padding", False)}
spectral_mode, vfrequencymap = get_frequency_map(avis, model, opt)
polarisation_mode, vpolarisationmap = get_polarisation_map(avis, model)
uvw_mode, shape, padding, vuvwmap = get_uvw_map(avis, model, **padding)
kernel_name, gcf, vkernellist = get_kernel_list(avis, model, **kwargs)
inarr = (pad_mid(model.data, int(round(padding * nx))) *
gcf).astype(dtype=complex)
# Use original algorithm
if not opt:
time_fft = -time.time()
uvgrid = fft(inarr)
time_fft += time.time()
time_degrid = -time.time()
vt = convolutional_degrid(vkernellist, avis.data['vis'].shape, uvgrid,
vuvwmap, vfrequencymap, vpolarisationmap)
time_degrid += time.time()
# Use optimized algorithm
else:
time_fft = -time.time()
uvgrid = numpy.zeros(inarr.shape, dtype=inarr.dtype)
fft_c(uvgrid, inarr)
time_fft += time.time()
time_degrid = -time.time()
kernel_indices, kernels = vkernellist
ks0, ks1, ks2, ks3 = kernels[0].shape
kernels_c = numpy.zeros((len(kernels), ks0, ks1, ks2, ks3),
dtype=kernels[0].dtype)
for i in range(len(kernels)):
kernels_c[i, ...] = kernels[i]
vfrequencymap_c = numpy.array(vfrequencymap, dtype=numpy.int32)
vt = numpy.zeros(avis.data['vis'].shape, dtype=numpy.complex128)
convolutional_degrid_c(vt, native_order(kernels_c),
native_order(kernel_indices),
native_order(uvgrid), native_order(vuvwmap),
native_order(vfrequencymap_c))
time_degrid += time.time()
avis.data['vis'] = vt
# Now we can shift the visibility from the image frame to the original visibility frame
svis = shift_vis_to_image(avis, model, tangent=True, inverse=True)
if not isinstance(vis, Visibility):
svis = decoalesce_visibility(svis)
return svis, (time_degrid, time_fft)
def visibility_gather_w(visibility_list: List[Visibility], vis: Visibility, **kwargs) -> Visibility:
if isinstance(vis, BlockVisibility):
cvis = coalesce_visibility(vis, **kwargs)
return decoalesce_visibility(visibility_gather(visibility_list, cvis, vis_iter=vis_wstack_iter, **kwargs))
else:
return visibility_gather(visibility_list, vis, vis_iter=vis_wstack_iter, **kwargs)
def test_solve_gaintable(self):
'''
测试solve_gaintable
:return:
'''
#===串行===
newphasecentre = SkyCoord(ra=+15.0 * u.deg,
dec=-10.0 * u.deg,
frame='icrs',
equinox='J2000')
image = copy.deepcopy(image_graph)
image.data = np.zeros_like(image.data)
#将lsm插入到image中
insert_skycomponent(image, comp, insert_method="Sinc")
# 期间可能会有fft和reproject暂不考虑
#生成telescope_data
telescope_data = copy.deepcopy(vis)
#image做卷积并且degrid生成modelvis
model_vis = predict_facets(telescope_data, image)
model_vis = predict_skycomponent_visibility(model_vis, comp)
model_vis = decoalesce_visibility(model_vis)
#模拟望远镜实际接收到的visibility
blockvis_observed = create_blockvisibility(
lowcore,
times=times,
frequency=frequency,
channel_bandwidth=channel_bandwidth,
phasecentre=phasecentre,
weight=1,
polarisation_frame=PolarisationFrame('linear'),
integration_time=1.0)
# 用自然数值填充vis，模拟实际接收到的block_visibility，并且各个vis的值各不相同易于区分
blockvis_observed.data['vis'] = range(blockvis_observed.nvis)
gt = solve_gaintable(blockvis_observed, model_vis)
apply_gaintable(blockvis_observed, gt)
#===并行===
# TODO暂未完成
# 生成telescope_data
telescope_data, visibility_share = visibility_to_visibility_para(
vis, 'npol')
ims, image_share = image_to_image_para(image_graph, FACETS)
ims2 = []
for i in ims:
insert_skycomponent_para(i, comp, insert_method='Sinc')
ims2.append(i)
model_vis1 = []
viss2 = []
for v in viss:
for im in ims2:
if v[0][0] == im.frequency:
temp = predict_facets_para(v[1], im)
# (chan, time, ant1, ant2)
model_vis1.append(
((v[0][0], v[0][1], v[0][2], v[0][3]), temp))
viss2.append(((v[0][0], v[0][1], v[0][2], v[0][3],
im.facet, im.polarisation),
phaserotate_visibility_para(temp,
newphasecentre,
tangent=False)))
predict_skycoponent_visibility_para_modified(viss2, comp, mode='test2')
# 将visibility的facet和polarisation合并起来
viss3 = defaultdict(list)
model_vis2 = defaultdict(list)
for v in range(0, len(viss2), 4 * 4):
temp = copy.deepcopy(viss2[v][1])
temp2 = copy.deepcopy(model_vis1[v][1])
for id in range(v + 1, v + 16):
temp.data['vis'] += viss2[id][1].data['vis']
temp2.data['vis'] += model_vis1[id][1].data['vis']
viss3[viss2[v][0][0:2]].append(((viss2[v][0][2:4]), temp))
model_vis2[model_vis1[v][0][0:2]].append(
((model_vis1[v][0][2:]), temp2))
# TODO 将并行程序从此开始填入
gts = []
for key in viss3:
xs = []
xwts = []
for v, mv in zip(viss3[key], model_vis2[key]):
x, xwt = solve_gaintable_para(v[1], mv[1])
xs.append(((0, 0, 0, 0, key[0], key[1], v[0][0], v[0][1]), x))
xwts.append(xwt)
g = create_gaintable_from_visibility_para(viss3[key][0][1], 3)
solve_from_X_para(xs, xwts, g, npol=viss3[key][0][1].npol)
gts.append((key, g))
gaintable_right(gt, gts)
new_gain = combine_gaintable(gt, gts)
for key in viss3:
print(key)
chan, time = key
temp = gaintable_for_para(new_gain.gain[time, :,
chan, :, :].reshape[1, 3,
2, 2])
apply_gaintable_para(viss3[key], temp)
for key in viss3:
chan, time = key
vis_serial = block_vis.vis[time, :, :chan, :]
for id, v in viss3[key]:
ant1 = id[2]
ant2 = id[3]
vis_serial = block_vis.vis[time, ant2, ant1, chan]
print(vis_serial)
print(v.vis)
print()
