def actualSetUp(self, freqwin=3, block=False, dopol=False, zerow=False):
self.npixel = 1024
self.low = create_named_configuration('LOWBD2', rmax=750.0)
self.freqwin = freqwin
self.vis_list = list()
self.ntimes = 5
self.cellsize = 0.0005
# Choose the interval so that the maximum change in w is smallish
integration_time = numpy.pi * (24 / (12 * 60))
self.times = numpy.linspace(-integration_time * (self.ntimes // 2),
integration_time * (self.ntimes // 2),
self.ntimes)
if freqwin > 1:
self.frequency = numpy.linspace(0.8e8, 1.2e8, self.freqwin)
self.channelwidth = numpy.array(
freqwin * [self.frequency[1] - self.frequency[0]])
else:
self.frequency = numpy.array([1.0e8])
self.channelwidth = numpy.array([4e7])
if dopol:
self.vis_pol = PolarisationFrame('linear')
self.image_pol = PolarisationFrame('stokesIQUV')
f = numpy.array([100.0, 20.0, -10.0, 1.0])
else:
self.vis_pol = PolarisationFrame('stokesI')
self.image_pol = PolarisationFrame('stokesI')
f = numpy.array([100.0])
self.phasecentre = SkyCoord(ra=+30.0 * u.deg,
dec=-60.0 * u.deg,
frame='icrs',
equinox='J2000')
self.vis_list = [
ingest_unittest_visibility(self.low, [self.frequency[freqwin]],
[self.channelwidth[freqwin]],
self.times,
self.vis_pol,
self.phasecentre,
block=block,
zerow=zerow)
for freqwin, _ in enumerate(self.frequency)
]
def actualSetUp(self,
nfreqwin=3,
dospectral=True,
dopol=False,
amp_errors=None,
phase_errors=None,
zerow=True):
if amp_errors is None:
amp_errors = {'T': 0.0, 'G': 0.1}
if phase_errors is None:
phase_errors = {'T': 1.0, 'G': 0.0}
self.npixel = 512
self.low = create_named_configuration('LOWBD2', rmax=750.0)
self.freqwin = nfreqwin
self.vis_list = list()
self.ntimes = 1
self.times = numpy.linspace(-3.0, +3.0, self.ntimes) * numpy.pi / 12.0
self.frequency = numpy.linspace(0.8e8, 1.2e8, self.freqwin)
if self.freqwin > 1:
self.channelwidth = numpy.array(
self.freqwin * [self.frequency[1] - self.frequency[0]])
else:
self.channelwidth = numpy.array([1e6])
if dopol:
self.vis_pol = PolarisationFrame('linear')
self.image_pol = PolarisationFrame('stokesIQUV')
f = numpy.array([100.0, 20.0, -10.0, 1.0])
else:
self.vis_pol = PolarisationFrame('stokesI')
self.image_pol = PolarisationFrame('stokesI')
f = numpy.array([100.0])
if dospectral:
flux = numpy.array(
[f * numpy.power(freq / 1e8, -0.7) for freq in self.frequency])
else:
flux = numpy.array([f])
self.phasecentre = SkyCoord(ra=+180.0 * u.deg,
dec=-60.0 * u.deg,
frame='icrs',
equinox='J2000')
self.blockvis_list = [
ingest_unittest_visibility(self.low, [self.frequency[i]],
[self.channelwidth[i]],
self.times,
self.vis_pol,
self.phasecentre,
block=True,
zerow=zerow) for i in range(nfreqwin)
]
for v in self.blockvis_list:
v.data['vis'][...] = 1.0 + 0.0j
self.error_blockvis_list = [
copy_visibility(v) for v in self.blockvis_list
]
gt = create_gaintable_from_blockvisibility(self.blockvis_list[0])
gt = simulate_gaintable(gt,
phase_error=0.1,
amplitude_error=0.0,
smooth_channels=1,
leakage=0.0,
seed=180555)
self.error_blockvis_list = [
apply_gaintable(self.error_blockvis_list[i], gt)
for i in range(self.freqwin)
]
assert numpy.max(
numpy.abs(self.error_blockvis_list[0].vis -
self.blockvis_list[0].vis)) > 0.0
def actualSetUp(self, add_errors=False, freqwin=7, block=False, dospectral=True, dopol=False,
zerow=True):
self.npixel = 256
self.low = create_named_configuration('LOWBD2', rmax=750.0)
self.freqwin = freqwin
self.vis_list = list()
self.ntimes = 5
cellsize = 0.001
self.times = numpy.linspace(-3.0, +3.0, self.ntimes) * numpy.pi / 12.0
self.frequency = numpy.linspace(0.8e8, 1.2e8, self.freqwin)
if freqwin > 1:
self.channelwidth = numpy.array(freqwin * [self.frequency[1] - self.frequency[0]])
else:
self.channelwidth = numpy.array([1e6])
if dopol:
self.vis_pol = PolarisationFrame('linear')
self.image_pol = PolarisationFrame('stokesIQUV')
f = numpy.array([100.0, 20.0, -10.0, 1.0])
else:
self.vis_pol = PolarisationFrame('stokesI')
self.image_pol = PolarisationFrame('stokesI')
f = numpy.array([100.0])
if dospectral:
flux = numpy.array([f * numpy.power(freq / 1e8, -0.7) for freq in self.frequency])
else:
flux = numpy.array([f])
self.phasecentre = SkyCoord(ra=+180.0 * u.deg, dec=-60.0 * u.deg, frame='icrs', equinox='J2000')
self.vis_list = [ingest_unittest_visibility(self.low,
[self.frequency[freqwin]],
[self.channelwidth[freqwin]],
self.times,
self.vis_pol,
self.phasecentre, block=block,
zerow=zerow)
for freqwin, _ in enumerate(self.frequency)]
self.model_imagelist = [create_unittest_model(self.vis_list[freqwin],
self.image_pol,
cellsize=cellsize,
npixel=self.npixel)
for freqwin, _ in enumerate(self.frequency)]
self.componentlist = [create_unittest_components(self.model_imagelist[freqwin],
flux[freqwin, :][numpy.newaxis, :])
for freqwin, _ in enumerate(self.frequency)]
self.model_imagelist = [insert_skycomponent(self.model_imagelist[freqwin],
self.componentlist[freqwin])
for freqwin, _ in enumerate(self.frequency)]
self.vis_list = [predict_skycomponent_visibility(self.vis_list[freqwin],
self.componentlist[freqwin])
for freqwin, _ in enumerate(self.frequency)]
# Calculate the model convolved with a Gaussian.
model = self.model_imagelist[0]
self.cmodel = smooth_image(model)
export_image_to_fits(model, '%s/test_imaging_serial_deconvolved_model.fits' % self.dir)
export_image_to_fits(self.cmodel, '%s/test_imaging_serial_deconvolved_cmodel.fits' % self.dir)
if add_errors and block:
self.vis_list = [insert_unittest_errors(self.vis_list[i])
for i, _ in enumerate(self.frequency)]
def actualSetUp(self,
add_errors=False,
freqwin=3,
block=False,
dospectral=True,
dopol=False,
zerow=False,
makegcfcf=False):
self.npixel = 256
self.low = create_named_configuration('LOWBD2', rmax=750.0)
self.freqwin = freqwin
self.vis_list = list()
self.ntimes = 5
self.cellsize = 0.0005
self.times = numpy.linspace(-3.0, +3.0, self.ntimes) * numpy.pi / 12.0
self.frequency = numpy.linspace(0.8e8, 1.2e8, self.freqwin)
if freqwin > 1:
self.frequency = numpy.linspace(0.8e8, 1.2e8, self.freqwin)
self.channelwidth = numpy.array(
freqwin * [self.frequency[1] - self.frequency[0]])
else:
self.frequency = numpy.array([1.0e8])
self.channelwidth = numpy.array([4e7])
if dopol:
self.vis_pol = PolarisationFrame('linear')
self.image_pol = PolarisationFrame('stokesIQUV')
f = numpy.array([100.0, 20.0, -10.0, 1.0])
else:
self.vis_pol = PolarisationFrame('stokesI')
self.image_pol = PolarisationFrame('stokesI')
f = numpy.array([100.0])
if dospectral:
flux = numpy.array(
[f * numpy.power(freq / 1e8, -0.7) for freq in self.frequency])
else:
flux = numpy.array([f])
self.phasecentre = SkyCoord(ra=+180.0 * u.deg,
dec=-60.0 * u.deg,
frame='icrs',
equinox='J2000')
self.vis_list = [
ingest_unittest_visibility(self.low, [self.frequency[freqwin]],
[self.channelwidth[freqwin]],
self.times,
self.vis_pol,
self.phasecentre,
block=block,
zerow=zerow)
for freqwin, _ in enumerate(self.frequency)
]
self.model_list = [
create_unittest_model(self.vis_list[freqwin],
self.image_pol,
cellsize=self.cellsize,
npixel=self.npixel)
for freqwin, _ in enumerate(self.frequency)
]
self.components_list = [
create_unittest_components(self.model_list[freqwin],
flux[freqwin, :][numpy.newaxis, :],
single=True)
for freqwin, _ in enumerate(self.frequency)
]
self.model_list = [
insert_skycomponent(self.model_list[freqwin],
self.components_list[freqwin])
for freqwin, _ in enumerate(self.frequency)
]
self.vis_list = [
predict_skycomponent_visibility(self.vis_list[freqwin],
self.components_list[freqwin])
for freqwin, _ in enumerate(self.frequency)
]
centre = self.freqwin // 2
# Calculate the model convolved with a Gaussian.
self.model = self.model_list[centre]
self.cmodel = smooth_image(self.model)
export_image_to_fits(self.model,
'%s/test_imaging_model.fits' % self.dir)
export_image_to_fits(self.cmodel,
'%s/test_imaging_cmodel.fits' % self.dir)
if add_errors and block:
self.vis_list = [
insert_unittest_errors(self.vis_list[i])
for i, _ in enumerate(self.frequency)
]
self.components = self.components_list[centre]
if makegcfcf:
self.gcfcf = [
create_awterm_convolutionfunction(self.model,
nw=61,
wstep=16.0,
oversampling=4,
support=60,
use_aaf=True)
]
self.gcfcf_clipped = [
(self.gcfcf[0][0],
apply_bounding_box_convolutionfunction(self.gcfcf[0][1],
fractional_level=1e-3))
]
self.gcfcf_joint = [
create_awterm_convolutionfunction(self.model,
nw=11,
wstep=16.0,
oversampling=4,
support=60,
use_aaf=True)
]
else:
self.gcfcf = None
self.gcfcf_clipped = None
self.gcfcf_joint = None
def actualSetUp(self, freqwin=1, block=True, dopol=False, zerow=False):
self.npixel = 1024
self.low = create_named_configuration('LOWBD2', rmax=550.0)
self.freqwin = freqwin
self.blockvis_list = list()
self.ntimes = 5
self.cellsize = 0.0005
# Choose the interval so that the maximum change in w is smallish
integration_time = numpy.pi * (24 / (12 * 60))
self.times = numpy.linspace(-integration_time * (self.ntimes // 2),
integration_time * (self.ntimes // 2),
self.ntimes)
if freqwin > 1:
self.frequency = numpy.linspace(0.8e8, 1.2e8, self.freqwin)
self.channelwidth = numpy.array(
freqwin * [self.frequency[1] - self.frequency[0]])
else:
self.frequency = numpy.array([1.0e8])
self.channelwidth = numpy.array([4e7])
if dopol:
self.vis_pol = PolarisationFrame('linear')
self.image_pol = PolarisationFrame('stokesIQUV')
f = numpy.array([100.0, 20.0, -10.0, 1.0])
else:
self.vis_pol = PolarisationFrame('stokesI')
self.image_pol = PolarisationFrame('stokesI')
f = numpy.array([100.0])
self.phasecentre = SkyCoord(ra=+0.0 * u.deg,
dec=-40.0 * u.deg,
frame='icrs',
equinox='J2000')
self.blockvis_list = [
ingest_unittest_visibility(self.low, [self.frequency[freqwin]],
[self.channelwidth[freqwin]],
self.times,
self.vis_pol,
self.phasecentre,
block=block,
zerow=zerow)
for freqwin, _ in enumerate(self.frequency)
]
self.vis_list = [
convert_blockvisibility_to_visibility(bv)
for bv in self.blockvis_list
]
self.skymodel_list = [
create_low_test_skymodel_from_gleam(
npixel=self.npixel,
cellsize=self.cellsize,
frequency=[self.frequency[f]],
phasecentre=self.phasecentre,
polarisation_frame=PolarisationFrame("stokesI"),
flux_limit=0.6,
flux_threshold=1.0,
flux_max=5.0) for f, freq in enumerate(self.frequency)
]
assert isinstance(self.skymodel_list[0].image,
Image), self.skymodel_list[0].image
assert isinstance(self.skymodel_list[0].components[0],
Skycomponent), self.skymodel_list[0].components[0]
assert len(self.skymodel_list[0].components) == 19, len(
self.skymodel_list[0].components)
self.skymodel_list = expand_skymodel_by_skycomponents(
self.skymodel_list[0])
assert len(self.skymodel_list) == 20, len(self.skymodel_list)
assert numpy.max(numpy.abs(
self.skymodel_list[-1].image.data)) > 0.0, "Image is empty"
self.vis_list = [
copy_visibility(self.vis_list[0], zero=True)
for i, _ in enumerate(self.skymodel_list)
]
def simulate_list_serial_workflow(
config='LOWBD2',
phasecentre=SkyCoord(ra=+15.0 * u.deg,
dec=-60.0 * u.deg,
frame='icrs',
equinox='J2000'),
frequency=None,
channel_bandwidth=None,
times=None,
polarisation_frame=PolarisationFrame("stokesI"),
order='frequency',
format='blockvis',
rmax=1000.0,
zerow=False):
""" A component to simulate an observation
The simulation step can generate a single BlockVisibility or a list of BlockVisibility's.
The parameter keyword determines the way that the list is constructed.
If order='frequency' then len(frequency) BlockVisibility's with all times are created.
If order='time' then len(times) BlockVisibility's with all frequencies are created.
If order = 'both' then len(times) * len(times) BlockVisibility's are created each with
a single time and frequency. If order = None then all data are created in one BlockVisibility.
The output format can be either 'blockvis' (for calibration) or 'vis' (for imaging)
:param config: Name of configuration: def LOWBDS-CORE
:param phasecentre: Phase centre def: SkyCoord(ra=+15.0 * u.deg, dec=-60.0 * u.deg, frame='icrs', equinox='J2000')
:param frequency: def [1e8]
:param channel_bandwidth: def [1e6]
:param times: Observing times in radians: def [0.0]
:param polarisation_frame: def PolarisationFrame("stokesI")
:param order: 'time' or 'frequency' or 'both' or None: def 'frequency'
:param format: 'blockvis' or 'vis': def 'blockvis'
:return: vis_list with different frequencies in different elements
"""
if format == 'vis':
create_vis = create_visibility
else:
create_vis = create_blockvisibility
if times is None:
times = [0.0]
if channel_bandwidth is None:
channel_bandwidth = [1e6]
if frequency is None:
frequency = [1e8]
conf = create_named_configuration(config, rmax=rmax)
if order == 'time':
log.debug(
"simulate_list_serial_workflow: Simulating distribution in %s" %
order)
vis_list = list()
for i, time in enumerate(times):
vis_list.append(
create_vis(conf,
numpy.array([times[i]]),
frequency=frequency,
channel_bandwidth=channel_bandwidth,
weight=1.0,
phasecentre=phasecentre,
polarisation_frame=polarisation_frame,
zerow=zerow))
elif order == 'frequency':
log.debug(
"simulate_list_serial_workflow: Simulating distribution in %s" %
order)
vis_list = list()
for j, _ in enumerate(frequency):
vis_list.append(
create_vis(conf,
times,
frequency=numpy.array([frequency[j]]),
channel_bandwidth=numpy.array(
[channel_bandwidth[j]]),
weight=1.0,
phasecentre=phasecentre,
polarisation_frame=polarisation_frame,
zerow=zerow))
elif order == 'both':
log.debug(
"simulate_list_serial_workflow: Simulating distribution in time and frequency"
)
vis_list = list()
for i, _ in enumerate(times):
for j, _ in enumerate(frequency):
vis_list.append(
create_vis(conf,
numpy.array([times[i]]),
frequency=numpy.array([frequency[j]]),
channel_bandwidth=numpy.array(
[channel_bandwidth[j]]),
weight=1.0,
phasecentre=phasecentre,
polarisation_frame=polarisation_frame,
zerow=zerow))
elif order is None:
log.debug("simulate_list_serial_workflow: Simulating into single %s" %
format)
vis_list = list()
vis_list.append(
create_vis(conf,
times,
frequency=frequency,
channel_bandwidth=channel_bandwidth,
weight=1.0,
phasecentre=phasecentre,
polarisation_frame=polarisation_frame,
zerow=zerow))
else:
raise NotImplementedError("order $s not known" % order)
return vis_list
def actualSetup(self, nsources=None, nvoronoi=None):
n_workers = 8
# Set up the observation: 10 minutes at transit, with 10s integration.
# Skip 5/6 points to avoid outstation redundancy
nfreqwin = 1
ntimes = 3
self.rmax = 2500.0
dec = -40.0 * u.deg
frequency = [1e8]
channel_bandwidth = [0.1e8]
times = numpy.linspace(-10.0, 10.0,
ntimes) * numpy.pi / (3600.0 * 12.0)
phasecentre = SkyCoord(ra=+0.0 * u.deg,
dec=dec,
frame='icrs',
equinox='J2000')
low = create_named_configuration('LOWBD2', rmax=self.rmax)
centre = numpy.mean(low.xyz, axis=0)
distance = numpy.hypot(low.xyz[:, 0] - centre[0],
low.xyz[:, 1] - centre[1],
low.xyz[:, 2] - centre[2])
lowouter = low.data[distance > 1000.0][::6]
lowcore = low.data[distance < 1000.0][::3]
low.data = numpy.hstack((lowcore, lowouter))
blockvis = create_blockvisibility(
low,
times,
frequency=frequency,
channel_bandwidth=channel_bandwidth,
weight=1.0,
phasecentre=phasecentre,
polarisation_frame=PolarisationFrame("stokesI"),
zerow=True)
vis = convert_blockvisibility_to_visibility(blockvis)
advice = advise_wide_field(vis, guard_band_image=2.0, delA=0.02)
cellsize = advice['cellsize']
npixel = advice['npixels2']
small_model = create_image_from_visibility(blockvis,
npixel=512,
frequency=frequency,
nchan=nfreqwin,
cellsize=cellsize,
phasecentre=phasecentre)
vis.data['imaging_weight'][...] = vis.data['weight'][...]
vis = weight_list_serial_workflow([vis], [small_model])[0]
vis = taper_list_serial_workflow([vis], 3 * cellsize)[0]
blockvis = convert_visibility_to_blockvisibility(vis)
# ### Generate the model from the GLEAM catalog, including application of the primary beam.
beam = create_image_from_visibility(blockvis,
npixel=npixel,
frequency=frequency,
nchan=nfreqwin,
cellsize=cellsize,
phasecentre=phasecentre)
beam = create_low_test_beam(beam)
flux_limit = 0.5
original_gleam_components = create_low_test_skycomponents_from_gleam(
flux_limit=flux_limit,
phasecentre=phasecentre,
frequency=frequency,
polarisation_frame=PolarisationFrame('stokesI'),
radius=0.15)
all_components = apply_beam_to_skycomponent(original_gleam_components,
beam)
all_components = filter_skycomponents_by_flux(all_components,
flux_min=flux_limit)
voronoi_components = filter_skycomponents_by_flux(all_components,
flux_min=1.5)
def max_flux(elem):
return numpy.max(elem.flux)
voronoi_components = sorted(voronoi_components,
key=max_flux,
reverse=True)
if nsources is not None:
all_components = [all_components[0]]
if nvoronoi is not None:
voronoi_components = [voronoi_components[0]]
self.screen = import_image_from_fits(
arl_path('data/models/test_mpc_screen.fits'))
all_gaintables = create_gaintable_from_screen(blockvis, all_components,
self.screen)
gleam_skymodel_noniso = [
SkyModel(components=[all_components[i]],
gaintable=all_gaintables[i])
for i, sm in enumerate(all_components)
]
# ### Now predict the visibility for each skymodel and apply the gaintable for that skymodel,
# returning a list of visibilities, one for each skymodel. We then sum these to obtain
# the total predicted visibility. All images and skycomponents in the same skymodel
# get the same gaintable applied which means that in this case each skycomponent has a separate gaintable.
self.all_skymodel_noniso_vis = convert_blockvisibility_to_visibility(
blockvis)
ngroup = n_workers
future_vis = arlexecute.scatter(self.all_skymodel_noniso_vis)
chunks = [
gleam_skymodel_noniso[i:i + ngroup]
for i in range(0, len(gleam_skymodel_noniso), ngroup)
]
for chunk in chunks:
result = predict_skymodel_list_arlexecute_workflow(future_vis,
chunk,
context='2d',
docal=True)
work_vis = arlexecute.compute(result, sync=True)
for w in work_vis:
self.all_skymodel_noniso_vis.data['vis'] += w.data['vis']
assert numpy.max(
numpy.abs(self.all_skymodel_noniso_vis.data['vis'])) > 0.0
self.all_skymodel_noniso_blockvis = convert_visibility_to_blockvisibility(
self.all_skymodel_noniso_vis)
# ### Remove weaker of components that are too close (0.02 rad)
idx, voronoi_components = remove_neighbouring_components(
voronoi_components, 0.02)
model = create_image_from_visibility(blockvis,
npixel=npixel,
frequency=frequency,
nchan=nfreqwin,
cellsize=cellsize,
phasecentre=phasecentre)
# Use the gaintable for the brightest component as the starting gaintable
all_gaintables[0].gain[...] = numpy.conjugate(
all_gaintables[0].gain[...])
all_gaintables[0].gain[...] = 1.0 + 0.0j
self.theta_list = initialize_skymodel_voronoi(model,
voronoi_components,
all_gaintables[0])
def actualSetUp(self,
add_errors=False,
nfreqwin=7,
dospectral=True,
dopol=False,
zerow=True):
self.npixel = 512
self.low = create_named_configuration('LOWBD2', rmax=750.0)
self.freqwin = nfreqwin
self.vis_list = list()
self.ntimes = 5
self.times = numpy.linspace(-3.0, +3.0, self.ntimes) * numpy.pi / 12.0
self.frequency = numpy.linspace(0.8e8, 1.2e8, self.freqwin)
if self.freqwin > 1:
self.channelwidth = numpy.array(
self.freqwin * [self.frequency[1] - self.frequency[0]])
else:
self.channelwidth = numpy.array([1e6])
if dopol:
self.vis_pol = PolarisationFrame('linear')
self.image_pol = PolarisationFrame('stokesIQUV')
f = numpy.array([100.0, 20.0, -10.0, 1.0])
else:
self.vis_pol = PolarisationFrame('stokesI')
self.image_pol = PolarisationFrame('stokesI')
f = numpy.array([100.0])
if dospectral:
flux = numpy.array(
[f * numpy.power(freq / 1e8, -0.7) for freq in self.frequency])
else:
flux = numpy.array([f])
self.phasecentre = SkyCoord(ra=+180.0 * u.deg,
dec=-60.0 * u.deg,
frame='icrs',
equinox='J2000')
self.blockvis_list = [
ingest_unittest_visibility(self.low, [self.frequency[i]],
[self.channelwidth[i]],
self.times,
self.vis_pol,
self.phasecentre,
block=True,
zerow=zerow) for i in range(nfreqwin)
]
self.vis_list = [
convert_blockvisibility_to_visibility(bv)
for bv in self.blockvis_list
]
self.model_imagelist = [
create_unittest_model(self.vis_list[i],
self.image_pol,
npixel=self.npixel,
cellsize=0.0005) for i in range(nfreqwin)
]
self.components_list = [
create_unittest_components(self.model_imagelist[freqwin],
flux[freqwin, :][numpy.newaxis, :])
for freqwin, m in enumerate(self.model_imagelist)
]
self.blockvis_list = [
predict_skycomponent_visibility(self.blockvis_list[freqwin],
self.components_list[freqwin])
for freqwin, _ in enumerate(self.blockvis_list)
]
self.model_imagelist = [
insert_skycomponent(self.model_imagelist[freqwin],
self.components_list[freqwin])
for freqwin in range(nfreqwin)
]
model = self.model_imagelist[0]
self.cmodel = smooth_image(model)
if self.persist:
export_image_to_fits(
model, '%s/test_imaging_serial_model.fits' % self.dir)
export_image_to_fits(
self.cmodel, '%s/test_imaging_serial_cmodel.fits' % self.dir)
if add_errors:
gt = create_gaintable_from_blockvisibility(self.blockvis_list[0])
gt = simulate_gaintable(gt,
phase_error=0.1,
amplitude_error=0.0,
smooth_channels=1,
leakage=0.0,
seed=180555)
self.blockvis_list = [
apply_gaintable(self.blockvis_list[i], gt)
for i in range(self.freqwin)
]
self.vis_list = [
convert_blockvisibility_to_visibility(bv)
for bv in self.blockvis_list
]
self.model_imagelist = [
create_unittest_model(self.vis_list[i],
self.image_pol,
npixel=self.npixel,
cellsize=0.0005) for i in range(nfreqwin)
]
# In[4]:
nfreqwin = 1
ntimes = 61
rmax = 550.0
dec = -40.0 * u.deg
frequency = numpy.linspace(1e8, 1.3e8, nfreqwin)
if nfreqwin > 1:
channel_bandwidth = numpy.array(nfreqwin * [frequency[1] - frequency[0]])
else:
channel_bandwidth = [0.3e8]
times = numpy.linspace(-300, 300.0, ntimes) * numpy.pi / (3600.0 * 12.0)
phasecentre = SkyCoord(ra=+0.0 * u.deg, dec=dec, frame='icrs', equinox='J2000')
lowcore = create_named_configuration('LOWBD2', rmax=rmax)
blockvis = create_blockvisibility(
lowcore,
times,
frequency=frequency,
channel_bandwidth=channel_bandwidth,
weight=1.0,
phasecentre=phasecentre,
polarisation_frame=PolarisationFrame("stokesI"),
zerow=True)
# ### Find sampling, image size, etc
# In[5]:
def ingest_visibility(self, freq=None, chan_width=None, times=None, add_errors=False,
block=True, bandpass=False):
if freq is None:
freq = [1e8]
if chan_width is None:
chan_width = [1e6]
if times is None:
times = (numpy.pi / 12.0) * numpy.linspace(-3.0, 3.0, 5)
lowcore = create_named_configuration('LOWBD2', rmax=750.0)
frequency = numpy.array(freq)
channel_bandwidth = numpy.array(chan_width)
phasecentre = SkyCoord(ra=+180.0 * u.deg, dec=-60.0 * u.deg, frame='icrs', equinox='J2000')
if block:
vt = create_blockvisibility(lowcore, times, frequency, channel_bandwidth=channel_bandwidth,
weight=1.0, phasecentre=phasecentre,
polarisation_frame=PolarisationFrame("stokesI"))
else:
vt = create_visibility(lowcore, times, frequency, channel_bandwidth=channel_bandwidth,
weight=1.0, phasecentre=phasecentre,
polarisation_frame=PolarisationFrame("stokesI"))
cellsize = 0.001
model = create_image_from_visibility(vt, npixel=self.npixel, cellsize=cellsize, npol=1,
frequency=frequency, phasecentre=phasecentre,
polarisation_frame=PolarisationFrame("stokesI"))
nchan = len(self.frequency)
flux = numpy.array(nchan * [[100.0]])
facets = 4
rpix = model.wcs.wcs.crpix - 1.0
spacing_pixels = self.npixel // facets
centers = [-1.5, -0.5, 0.5, 1.5]
comps = list()
for iy in centers:
for ix in centers:
p = int(round(rpix[0] + ix * spacing_pixels * numpy.sign(model.wcs.wcs.cdelt[0]))), \
int(round(rpix[1] + iy * spacing_pixels * numpy.sign(model.wcs.wcs.cdelt[1])))
sc = pixel_to_skycoord(p[0], p[1], model.wcs, origin=1)
comp = create_skycomponent(direction=sc, flux=flux, frequency=frequency,
polarisation_frame=PolarisationFrame("stokesI"))
comps.append(comp)
if block:
predict_skycomponent_visibility(vt, comps)
else:
predict_skycomponent_visibility(vt, comps)
insert_skycomponent(model, comps)
self.comps = comps
self.model = copy_image(model)
self.empty_model = create_empty_image_like(model)
export_image_to_fits(model, '%s/test_pipeline_functions_model.fits' % (self.dir))
if add_errors:
# These will be the same for all calls
numpy.random.seed(180555)
gt = create_gaintable_from_blockvisibility(vt)
gt = simulate_gaintable(gt, phase_error=1.0, amplitude_error=0.0)
vt = apply_gaintable(vt, gt)
if bandpass:
bgt = create_gaintable_from_blockvisibility(vt, timeslice=1e5)
bgt = simulate_gaintable(bgt, phase_error=0.01, amplitude_error=0.01, smooth_channels=4)
vt = apply_gaintable(vt, bgt)
return vt