def test_get_frequency_map_different_channel(self):
self.model = create_image_from_visibility(self.vis, npixel=128, cellsize=0.001,
frequency=self.startfrequency, nchan=3,
channel_bandwidth=2e7)
spectral_mode, vfrequency_map = get_frequency_map(self.vis, self.model)
assert numpy.max(vfrequency_map) == self.model.nchan - 1
assert spectral_mode == 'channel'
def test_get_frequency_map_channel(self):
self.model = create_image_from_visibility(self.vis, npixel=128, cellsize=0.001,
nchan=self.vnchan,
frequency=self.startfrequency)
spectral_mode, vfrequency_map = get_frequency_map(self.vis, self.model)
assert numpy.max(vfrequency_map) == self.model.nchan - 1
assert numpy.min(vfrequency_map) == 0
assert spectral_mode == 'channel'
def predict_skycomponent_visibility(
vis: Union[Visibility, BlockVisibility], sc: Union[Skycomponent,
List[Skycomponent]]
) -> Union[Visibility, BlockVisibility]:
"""Predict the visibility from a Skycomponent, add to existing visibility, for Visibility or BlockVisibility
:param vis: Visibility or BlockVisibility
:param sc: Skycomponent or list of SkyComponents
:return: Visibility or BlockVisibility
"""
if sc is None:
return vis
if not isinstance(sc, collections.Iterable):
sc = [sc]
if isinstance(vis, Visibility):
_, im_nchan = list(get_frequency_map(vis, None))
for comp in sc:
assert isinstance(comp, Skycomponent), comp
assert_same_chan_pol(vis, comp)
l, m, n = skycoord_to_lmn(comp.direction, vis.phasecentre)
phasor = simulate_point(vis.uvw, l, m)
comp_flux = comp.flux[im_nchan, :]
vis.data['vis'][...] += comp_flux[:, :] * phasor[:, numpy.newaxis]
elif isinstance(vis, BlockVisibility):
ntimes, nant, _, nchan, npol = vis.vis.shape
k = numpy.array(vis.frequency) / constants.c.to('m s^-1').value
for comp in sc:
# assert isinstance(comp, Skycomponent), comp
assert_same_chan_pol(vis, comp)
flux = comp.flux
if comp.polarisation_frame != vis.polarisation_frame:
flux = convert_pol_frame(flux, comp.polarisation_frame,
vis.polarisation_frame)
l, m, n = skycoord_to_lmn(comp.direction, vis.phasecentre)
uvw = vis.uvw[..., numpy.newaxis] * k
phasor = numpy.ones([ntimes, nant, nant, nchan, npol],
dtype='complex')
for chan in range(nchan):
phasor[:, :, :,
chan, :] = simulate_point(uvw[..., chan], l,
m)[..., numpy.newaxis]
vis.data['vis'][..., :, :] += flux[:, :] * phasor[..., :]
return vis
def idft_visibility_skycomponent(vis: Union[Visibility, BlockVisibility],
sc: Union[Skycomponent, List[Skycomponent]]) -> \
([Skycomponent, List[Skycomponent]], List[numpy.ndarray]):
"""Inverse DFT a Skycomponent from Visibility or BlockVisibility
:param vis: Visibility or BlockVisibility
:param sc: Skycomponent or list of SkyComponents
:return: Skycomponent or list of SkyComponents, array of weights
"""
if sc is None:
return sc
if not isinstance(sc, collections.abc.Iterable):
sc = [sc]
newsc = list()
weights_list = list()
for comp in sc:
assert isinstance(comp, Skycomponent), comp
assert_same_chan_pol(vis, comp)
newcomp = copy_skycomponent(comp)
if isinstance(vis, Visibility):
flux = numpy.zeros_like(comp.flux, dtype='complex')
weight = numpy.zeros_like(comp.flux, dtype='float')
_, im_nchan = list(get_frequency_map(vis, None))
phasor = numpy.conjugate(
calculate_visibility_phasor(comp.direction, vis))
fvwp = vis.flagged_weight * vis.flagged_vis * phasor
fw = vis.flagged_weight
for row in range(vis.nvis):
ic = im_nchan[row]
flux[ic, :] += fvwp[row, :]
weight[ic, :] += fw[row, :]
elif isinstance(vis, BlockVisibility):
phasor = numpy.conjugate(
calculate_blockvisibility_phasor(comp.direction, vis))
flux = numpy.sum(vis.flagged_weight * vis.flagged_vis * phasor,
axis=(0, 1, 2))
weight = numpy.sum(vis.flagged_weight, axis=(0, 1, 2))
flux[weight > 0.0] = flux[weight > 0.0] / weight[weight > 0.0]
flux[weight <= 0.0] = 0.0
if comp.polarisation_frame != vis.polarisation_frame:
flux = convert_pol_frame(flux, vis.polarisation_frame,
comp.polarisation_frame)
newcomp.flux = flux
newsc.append(newcomp)
weights_list.append(weight)
return newsc, weights_list
def dft_skycomponent_visibility(vis: Union[Visibility, BlockVisibility], sc: Union[Skycomponent, List[Skycomponent]]) \
-> Union[Visibility, BlockVisibility]:
"""DFT to get the visibility from a Skycomponent, for Visibility or BlockVisibility
:param vis: Visibility or BlockVisibility
:param sc: Skycomponent or list of SkyComponents
:return: Visibility or BlockVisibility
"""
if sc is None:
return vis
if not isinstance(sc, collections.abc.Iterable):
sc = [sc]
for comp in sc:
assert_same_chan_pol(vis, comp)
assert isinstance(comp, Skycomponent), comp
flux = comp.flux
if comp.polarisation_frame != vis.polarisation_frame:
flux = convert_pol_frame(flux, comp.polarisation_frame,
vis.polarisation_frame)
if isinstance(vis, Visibility):
_, im_nchan = list(get_frequency_map(vis, None))
phasor = calculate_visibility_phasor(comp.direction, vis)
for row in range(vis.nvis):
ic = im_nchan[row]
vis.data['vis'][row, :] += flux[ic, :] * phasor[row]
elif isinstance(vis, BlockVisibility):
phasor = calculate_blockvisibility_phasor(comp.direction, vis)
vis.data['vis'] += flux * phasor
return vis
def test_get_frequency_map_gleam(self):
self.model = create_low_test_image_from_gleam(npixel=128, cellsize=0.001, frequency=self.frequency,
channel_bandwidth=self.channel_bandwidth, flux_limit=10.0)
spectral_mode, vfrequency_map = get_frequency_map(self.vis, self.model)
assert numpy.max(vfrequency_map) == self.model.nchan - 1
assert spectral_mode == 'channel'