def setUp(self):
self.lowcore = create_named_configuration('LOWBD2-CORE')
self.times = numpy.linspace(-300.0, 300.0, 11) * numpy.pi / 43200.0
self.frequency = numpy.linspace(1e8, 1.5e9, 7)
self.channel_bandwidth = numpy.array(
7 * [self.frequency[1] - self.frequency[0]])
self.phasecentre = SkyCoord(ra=+15.0 * u.deg,
dec=-35.0 * u.deg,
frame='icrs',
equinox='J2000')
def actualSetup(self,
sky_pol_frame='stokesIQUV',
data_pol_frame='linear',
f=None,
vnchan=1):
self.lowcore = create_named_configuration('LOWBD2-CORE')
self.times = (numpy.pi / 43200.0) * numpy.linspace(0.0, 30.0, 3)
self.frequency = numpy.linspace(1.0e8, 1.1e8, vnchan)
if vnchan > 1:
self.channel_bandwidth = numpy.array(
vnchan * [self.frequency[1] - self.frequency[0]])
else:
self.channel_bandwidth = numpy.array([2e7])
if f is None:
f = [100.0, 50.0, -10.0, 40.0]
if sky_pol_frame == 'stokesI':
f = [100.0]
self.flux = numpy.outer(
numpy.array(
[numpy.power(freq / 1e8, -0.7) for freq in self.frequency]), f)
# The phase centre is absolute and the component is specified relative (for now).
# This means that the component should end up at the position phasecentre+compredirection
self.phasecentre = SkyCoord(ra=+180.0 * u.deg,
dec=-35.0 * u.deg,
frame='icrs',
equinox='J2000')
self.compabsdirection = SkyCoord(ra=+181.0 * u.deg,
dec=-35.0 * u.deg,
frame='icrs',
equinox='J2000')
self.comp = Skycomponent(
direction=self.compabsdirection,
frequency=self.frequency,
flux=self.flux,
polarisation_frame=PolarisationFrame(sky_pol_frame))
self.vis = create_blockvisibility(
self.lowcore,
self.times,
self.frequency,
phasecentre=self.phasecentre,
channel_bandwidth=self.channel_bandwidth,
weight=1.0,
polarisation_frame=PolarisationFrame(data_pol_frame))
self.vis = dft_skycomponent_visibility(self.vis, self.comp)
def setUp(self):
self.lowcore = create_named_configuration('LOWBD2-CORE')
self.times = (numpy.pi / 43200.0) * numpy.arange(0.0, 300.0, 30.0)
self.frequency = numpy.linspace(1.0e8, 1.1e8, 3)
self.channel_bandwidth = numpy.array([1e7, 1e7, 1e7])
# Define the component and give it some spectral behaviour
f = numpy.array([100.0, 20.0, -10.0, 1.0])
self.flux = numpy.array([f, 0.8 * f, 0.6 * f])
# The phase centre is absolute and the component is specified relative (for now).
# This means that the component should end up at the position phasecentre+compredirection
self.phasecentre = SkyCoord(ra=+180.0 * u.deg, dec=-35.0 * u.deg, frame='icrs', equinox='J2000')
self.compabsdirection = SkyCoord(ra=+181.0 * u.deg, dec=-35.0 * u.deg, frame='icrs', equinox='J2000')
pcof = self.phasecentre.skyoffset_frame()
self.compreldirection = self.compabsdirection.transform_to(pcof)
self.comp = Skycomponent(direction=self.compreldirection, frequency=self.frequency, flux=self.flux)
def test_rfi(self):
sample_freq = 3e4
nchannels = 1000
frequency = 170.5e6 + numpy.arange(nchannels) * sample_freq
ntimes = 100
integration_time = 0.5
times = numpy.arange(ntimes) * integration_time
# Perth from Google for the moment
perth = EarthLocation(lon="115.8605", lat="-31.9505", height=0.0)
rmax = 1000.0
low = create_named_configuration('LOWR3', rmax=rmax)
antskip = 33
low.data = low.data[::antskip]
nants = len(low.names)
# Calculate the power spectral density of the DTV station: Watts/Hz
emitter = simulate_DTV(frequency,
times,
power=50e3,
timevariable=False)
numpy.testing.assert_almost_equal(numpy.max(numpy.abs(emitter)),
0.00166834)
assert emitter.shape == (ntimes, nchannels)
# Calculate the propagators for signals from Perth to the stations in low
# These are fixed in time but vary with frequency. The ad hoc attenuation
# is set to produce signal roughly equal to noise at LOW
attenuation = 1.0
propagators = create_propagators(low,
perth,
frequency=frequency,
attenuation=attenuation)
assert propagators.shape == (nants, nchannels), propagators.shape
# Now calculate the RFI at the stations, based on the emitter and the propagators
rfi_at_station = calculate_rfi_at_station(propagators, emitter)
assert rfi_at_station.shape == (ntimes, nants,
nchannels), rfi_at_station.shape
# Calculate the rfi correlation
# [nants, nants, ntimes, nchan]
correlation = calculate_station_correlation_rfi(rfi_at_station)
assert correlation.shape == (ntimes, nants, nants, nchannels,
1), correlation.shape
def createVis(self, config='MID', dec=-35.0, rmax=1e2, freq=1.3e9):
self.frequency = numpy.array([freq])
self.channel_bandwidth = numpy.array([1e6])
self.flux = numpy.array([[100.0, 60.0, -10.0, +1.0]])
self.phasecentre = SkyCoord(ra=+15.0 * u.deg,
dec=dec * u.deg,
frame='icrs',
equinox='J2000')
self.config = create_named_configuration(config, rmax=rmax)
self.times = numpy.linspace(-300.0, 300.0, 3) * numpy.pi / 43200.0
nants = self.config.xyz.shape[0]
self.npixel = 512
self.fov = 4
self.cellsize = numpy.pi * self.fov / (self.npixel * 180.0)
assert nants > 1
assert len(self.config.names) == nants
assert len(self.config.mount) == nants
def setUp(self):
from rascil.data_models.parameters import rascil_path
self.dir = rascil_path('test_results')
self.mid = create_named_configuration('MID', rmax=1000.0)
self.times = (numpy.pi / 43200.0) * numpy.arange(0.0, 300.0, 100.0)
self.frequency = numpy.linspace(1.0e8, 1.1e8, 3)
self.channel_bandwidth = numpy.array([1e7, 1e7, 1e7])
# Define the component and give it some spectral behaviour
f = numpy.array([100.0, 20.0, -10.0, 1.0])
self.flux = numpy.array([f, 0.8 * f, 0.6 * f])
# The phase centre is absolute and the component is specified relative (for now).
# This means that the component should end up at the position phasecentre+compredirection
self.phasecentre = SkyCoord(ra=+180.0 * u.deg, dec=-35.0 * u.deg, frame='icrs', equinox='J2000')
self.compabsdirection = SkyCoord(ra=+181.0 * u.deg, dec=-35.0 * u.deg, frame='icrs', equinox='J2000')
self.comp = Skycomponent(direction=self.compabsdirection, frequency=self.frequency, flux=self.flux)
def actualSetUp(self, freqwin=1, 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 = [
rsexecute.execute(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 = rsexecute.compute(self.vis_list)
def setUp(self):
self.lowcore = create_named_configuration('LOWBD2-CORE')
self.times = (numpy.pi / 43200.0) * numpy.arange(
-21600, +21600, 3600.0)
self.phasecentre = SkyCoord(ra=+180.0 * u.deg,
dec=-65.0 * u.deg,
frame='icrs',
equinox='J2000')
self.frequency = numpy.linspace(1.0e8, 1.1e8, 3)
self.channel_bandwidth = numpy.array([1e7, 1e7, 1e7])
self.bvis = create_blockvisibility(
self.lowcore,
self.times,
self.frequency,
channel_bandwidth=self.channel_bandwidth,
phasecentre=self.phasecentre,
weight=1.0)
def setUp(self):
from rascil.data_models.parameters import rascil_path
self.dir = rascil_path('test_results')
self.frequency = numpy.linspace(0.8e8, 1.2e8, 5)
self.channel_bandwidth = numpy.array([1e7, 1e7, 1e7, 1e7, 1e7])
self.flux = numpy.array([[100.0], [100.0], [100.0], [100.0], [100.0]])
self.phasecentre = SkyCoord(ra=+15.0 * u.deg,
dec=-35.0 * u.deg,
frame='icrs',
equinox='J2000')
self.config = create_named_configuration('LOWBD2-CORE')
self.times = numpy.linspace(-300.0, 300.0, 3) * numpy.pi / 43200.0
nants = self.config.xyz.shape[0]
assert nants > 1
assert len(self.config.names) == nants
assert len(self.config.mount) == nants
def setUp(self):
from rascil.data_models.parameters import rascil_path, rascil_data_path
self.dir = rascil_path('test_results')
self.vnchan = 7
self.lowcore = create_named_configuration('LOWBD2', rmax=300.0)
self.times = (numpy.pi / 12.0) * numpy.linspace(-3.0, 3.0, 7)
self.frequency = numpy.linspace(8e7, 1.2e8, self.vnchan)
self.startfrequency = numpy.array([8e7])
self.channel_bandwidth = numpy.array(self.vnchan * [(1.0 - 1.0e-7) * (self.frequency[1] - self.frequency[0])])
self.phasecentre = SkyCoord(ra=+180.0 * u.deg, dec=-60.0 * u.deg, frame='icrs', equinox='J2000')
self.vis = create_visibility(self.lowcore, times=self.times, frequency=self.frequency,
phasecentre=self.phasecentre, weight=1.0,
polarisation_frame=PolarisationFrame('stokesI'),
channel_bandwidth=self.channel_bandwidth)
self.model = create_image_from_visibility(self.vis, npixel=128, cellsize=0.001, nchan=self.vnchan,
frequency=self.startfrequency)
def setUp(self):
self.lowcore = create_named_configuration('LOWBD2', rmax=1000.0)
self.times = numpy.linspace(-300.0, 300.0, 11) * numpy.pi / 43200.0
self.frequency = numpy.array([1e8])
self.channel_bandwidth = numpy.array([1e8])
self.phasecentre = SkyCoord(ra=+15.0 * u.deg,
dec=-35.0 * u.deg,
frame='icrs',
equinox='J2000')
self.vis = create_visibility(self.lowcore,
self.times,
self.frequency,
channel_bandwidth=self.channel_bandwidth,
phasecentre=self.phasecentre,
weight=1.0)
def setUp(self):
self.lowcore = create_named_configuration('LOWBD2', rmax=300.0)
self.times = (numpy.pi / 43200.0) * numpy.arange(0.0, 30 * 3.76, 3.76)
df = 27343.75000
self.frequency = numpy.array([1e8 - df, 1e8, 1e8 + df])
self.channel_bandwidth = numpy.array([27343.75, 27343.75, 27343.75])
self.phasecentre = SkyCoord(ra=+0.0 * u.deg,
dec=-35.0 * u.deg,
frame='icrs',
equinox='J2000')
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,
meta={"RASCIL": 0.1})
def setUp(self):
self.persist = os.getenv("RASCIL_PERSIST", False)
from rascil.data_models.parameters import rascil_path, rascil_data_path
self.dir = rascil_path('test_results')
self.lowcore = create_named_configuration('LOWBD2-CORE')
self.times = (numpy.pi / (12.0)) * numpy.linspace(-3.0, 3.0, 7)
self.frequency = numpy.array([1e8])
self.channel_bandwidth = numpy.array([1e6])
self.phasecentre = SkyCoord(ra=+180.0 * u.deg,
dec=-60.0 * u.deg,
frame='icrs',
equinox='J2000')
self.vis = create_visibility(
self.lowcore,
self.times,
self.frequency,
channel_bandwidth=self.channel_bandwidth,
phasecentre=self.phasecentre,
weight=1.0,
polarisation_frame=PolarisationFrame('stokesI'),
zerow=True)
self.vis.data['vis'] *= 0.0
# Create model
self.test_model = create_test_image(cellsize=0.001,
phasecentre=self.vis.phasecentre,
frequency=self.frequency)
self.vis = predict_2d(self.vis, self.test_model)
assert numpy.max(numpy.abs(self.vis.vis)) > 0.0
self.model = create_image_from_visibility(
self.vis,
npixel=512,
cellsize=0.001,
polarisation_frame=PolarisationFrame('stokesI'))
self.dirty, sumwt = invert_2d(self.vis, self.model)
self.psf, sumwt = invert_2d(self.vis, self.model, dopsf=True)
def setUp(self):
rsexecute.set_client(use_dask=True,
processes=True,
threads_per_worker=1)
from rascil.data_models.parameters import rascil_path, rascil_data_path
self.dir = rascil_path('test_results')
self.frequency = numpy.linspace(1e8, 1.5e8, 3)
self.channel_bandwidth = numpy.array([2.5e7, 2.5e7, 2.5e7])
self.flux = numpy.array([[100.0], [100.0], [100.0]])
self.phasecentre = SkyCoord(ra=+15.0 * u.deg,
dec=-35.0 * u.deg,
frame='icrs',
equinox='J2000')
self.config = create_named_configuration('LOWBD2-CORE')
self.times = numpy.linspace(-300.0, 300.0, 3) * numpy.pi / 43200.0
nants = self.config.xyz.shape[0]
assert nants > 1
assert len(self.config.names) == nants
assert len(self.config.mount) == nants
self.persist = os.getenv("RASCIL_PERSIST", False)
def test_predict_sky_components_coalesce(self):
sc = create_low_test_skycomponents_from_gleam(
flux_limit=10.0,
polarisation_frame=PolarisationFrame("stokesI"),
frequency=self.frequency,
kind='cubic',
phasecentre=SkyCoord("17h20m31s", "-00d58m45s"),
radius=0.1)
self.config = create_named_configuration('LOWBD2-CORE')
self.phasecentre = SkyCoord("17h20m31s", "-00d58m45s")
sampling_time = 3.76
self.times = numpy.arange(0.0, +300 * sampling_time, sampling_time)
self.vis = create_blockvisibility(
self.config,
self.times,
self.frequency,
phasecentre=self.phasecentre,
weight=1.0,
polarisation_frame=PolarisationFrame('stokesI'),
channel_bandwidth=self.channel_bandwidth)
self.vis = dft_skycomponent_visibility(self.vis, sc)
cvt = convert_blockvisibility_to_visibility(self.vis)
assert cvt.cindex is not None
def actualSetup(self, sky_pol_frame='stokesIQUV', data_pol_frame='linear'):
self.lowcore = create_named_configuration('LOWBD2', rmax=100.0)
self.times = (numpy.pi / 43200.0) * numpy.arange(0.0, 3000.0, 60.0)
vnchan = 3
self.frequency = numpy.linspace(1.0e8, 1.1e8, vnchan)
self.channel_bandwidth = numpy.array(
vnchan * [self.frequency[1] - self.frequency[0]])
# Define the component and give it some spectral behaviour
f = numpy.array([100.0, 20.0, -10.0, 1.0])
self.flux = numpy.array([f, 0.8 * f, 0.6 * f])
self.phasecentre = SkyCoord(ra=+180.0 * u.deg,
dec=-35.0 * u.deg,
frame='icrs',
equinox='J2000')
self.compabsdirection = SkyCoord(ra=+181.0 * u.deg,
dec=-35.0 * u.deg,
frame='icrs',
equinox='J2000')
if sky_pol_frame == 'stokesI':
self.flux = self.flux[:, 0][:, numpy.newaxis]
self.comp = Skycomponent(
direction=self.compabsdirection,
frequency=self.frequency,
flux=self.flux,
polarisation_frame=PolarisationFrame(sky_pol_frame))
self.vis = create_blockvisibility(
self.lowcore,
self.times,
self.frequency,
phasecentre=self.phasecentre,
channel_bandwidth=self.channel_bandwidth,
weight=1.0,
polarisation_frame=PolarisationFrame(data_pol_frame))
self.vis = dft_skycomponent_visibility(self.vis, self.comp)
def setUp(self):
from rascil.data_models.parameters import rascil_path
self.doplot = True
self.midcore = create_named_configuration('MID', rmax=100.0)
self.nants = len(self.midcore.names)
self.dir = rascil_path('test_results')
self.ntimes = 100
interval = 10.0
self.times = numpy.arange(0.0, float(self.ntimes)) * interval
self.times *= numpy.pi / 43200.0
self.frequency = numpy.array([1.4e9])
self.channel_bandwidth = numpy.array([1e7])
self.phasecentre = SkyCoord(ra=+15.0 * u.deg,
dec=-45.0 * u.deg,
frame='icrs',
equinox='J2000')
self.vis = create_blockvisibility(
self.midcore,
self.times,
self.frequency,
channel_bandwidth=self.channel_bandwidth,
phasecentre=self.phasecentre,
weight=1.0,
polarisation_frame=PolarisationFrame('stokesI'))
self.vis.data['vis'] *= 0.0
# Create model
self.model = create_image(
npixel=512,
cellsize=0.001,
polarisation_frame=PolarisationFrame("stokesI"),
frequency=self.frequency,
channel_bandwidth=self.channel_bandwidth,
phasecentre=self.phasecentre)
def setUp(self):
from rascil.data_models.parameters import rascil_path
self.dir = rascil_path('test_results')
self.persist = os.getenv("RASCIL_PERSIST", False)
self.niter = 1000
self.lowcore = create_named_configuration('LOWBD2-CORE')
self.nchan = 5
self.times = (numpy.pi / 12.0) * numpy.linspace(-3.0, 3.0, 7)
self.frequency = numpy.linspace(0.9e8, 1.1e8, self.nchan)
self.channel_bandwidth = numpy.array(self.nchan * [self.frequency[1] - self.frequency[0]])
self.phasecentre = SkyCoord(ra=+0.0 * u.deg, dec=-45.0 * u.deg, frame='icrs', equinox='J2000')
self.vis = create_visibility(self.lowcore, self.times, self.frequency, self.channel_bandwidth,
phasecentre=self.phasecentre, weight=1.0,
polarisation_frame=PolarisationFrame('stokesI'), zerow=True)
self.vis.data['vis'] *= 0.0
# Create model
self.test_model = create_low_test_image_from_gleam(npixel=512, cellsize=0.001,
phasecentre=self.vis.phasecentre,
frequency=self.frequency,
channel_bandwidth=self.channel_bandwidth,
flux_limit=1.0)
beam = create_low_test_beam(self.test_model)
if self.persist: export_image_to_fits(beam, "%s/test_deconvolve_mmclean_beam.fits" % self.dir)
self.test_model.data *= beam.data
if self.persist: export_image_to_fits(self.test_model, "%s/test_deconvolve_mmclean_model.fits" % self.dir)
self.vis = predict_2d(self.vis, self.test_model)
assert numpy.max(numpy.abs(self.vis.vis)) > 0.0
self.model = create_image_from_visibility(self.vis, npixel=512, cellsize=0.001,
polarisation_frame=PolarisationFrame('stokesI'))
self.dirty, sumwt = invert_2d(self.vis, self.model)
self.psf, sumwt = invert_2d(self.vis, self.model, dopsf=True)
if self.persist: export_image_to_fits(self.dirty, "%s/test_deconvolve_mmclean-dirty.fits" % self.dir)
if self.persist: export_image_to_fits(self.psf, "%s/test_deconvolve_mmclean-psf.fits" % self.dir)
window = numpy.ones(shape=self.model.shape, dtype=numpy.bool)
window[..., 129:384, 129:384] = True
self.innerquarter = create_image_from_array(window, self.model.wcs, polarisation_frame=PolarisationFrame('stokesI'))
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) == 35, len(
self.skymodel_list[0].components)
self.skymodel_list = expand_skymodel_by_skycomponents(
self.skymodel_list[0])
assert len(self.skymodel_list) == 36, 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 test_clip_configuration(self):
for rmax in [
100.0, 3000.0, 1000.0, 3000.0, 10000.0, 30000.0, 100000.0
]:
self.config = create_named_configuration('LOWBD2', rmax=rmax)
assert self.config.size() > 0.0
def test_unknown_configuration(self):
with self.assertRaises(ValueError):
self.config = create_named_configuration("SKA1-OWL")
def actualSetUp(self,
add_errors=False,
freqwin=3,
block=True,
dospectral=True,
dopol=False,
zerow=False,
makegcfcf=False):
self.npixel = 256
self.low = create_named_configuration('LOWBD2', rmax=750.0)
self.freqwin = freqwin
self.bvis_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])
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.bvis_list = [
ingest_unittest_visibility(
self.low,
numpy.array([self.frequency[freqwin]]),
numpy.array([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.bvis_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=False)
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.bvis_list = [
dft_skycomponent_visibility(self.bvis_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)
if self.persist:
export_image_to_fits(self.model,
'%s/test_imaging_model.fits' % self.dir)
if self.persist:
export_image_to_fits(self.cmodel,
'%s/test_imaging_cmodel.fits' % self.dir)
if add_errors and block:
self.bvis_list = [
insert_unittest_errors(self.bvis_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=8,
support=64,
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=8,
support=64,
use_aaf=True)
]
else:
self.gcfcf = None
self.gcfcf_clipped = None
self.gcfcf_joint = None
# We pass in the scheduler from the invoking script
if len(sys.argv) > 1:
scheduler = sys.argv[1]
client = Client(scheduler)
else:
client = Client()
rsexecute.set_client(client=client)
from rascil.data_models.parameters import rascil_path
dir = rascil_path('test_results')
frequency = numpy.linspace(1e8, 1.5e8, 3)
channel_bandwidth = numpy.array([2.5e7, 2.5e7, 2.5e7])
flux = numpy.array([[100.0], [100.0], [100.0]])
config = create_named_configuration('LOWBD2-CORE')
times = numpy.linspace(-300.0, 300.0, 3) * numpy.pi / 43200.0
nants = config.xyz.shape[0]
assert nants > 1
assert len(config.names) == nants
assert len(config.mount) == nants
config = create_named_configuration('LOWBD2', rmax=1000.0)
phasecentre = SkyCoord(ra=+15 * u.deg, dec=-45.0 * u.deg, frame='icrs', equinox='J2000')
bvis_graph = rsexecute.execute(create_blockvisibility)(config, times, frequency,
channel_bandwidth=channel_bandwidth,
phasecentre=phasecentre, weight=1.0,
polarisation_frame=PolarisationFrame('stokesI'))
vis_graph = rsexecute.execute(convert_blockvisibility_to_visibility)(bvis_graph)
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 = [
dft_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)
if self.persist:
export_image_to_fits(
model,
'%s/test_imaging_serial_deconvolved_model.fits' % self.dir)
if self.persist:
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, zerow=True):
self.doplot = False
self.npixel = 256
self.cellsize = 0.0009
self.low = create_named_configuration('LOWBD2', rmax=750.0)
self.freqwin = 1
self.vis_list = list()
self.ntimes = 3
self.times = numpy.linspace(-2.0, +2.0, self.ntimes) * numpy.pi / 12.0
if self.freqwin == 1:
self.frequency = numpy.array([1e8])
self.channelwidth = numpy.array([4e7])
else:
self.frequency = numpy.linspace(0.8e8, 1.2e8, self.freqwin)
self.channelwidth = numpy.array(
self.freqwin * [self.frequency[1] - self.frequency[0]])
self.vis_pol = PolarisationFrame('linear')
self.image_pol = PolarisationFrame('stokesIQUV')
f = numpy.array([100.0, 20.0, -10.0, 1.0])
flux = numpy.array(
[f * numpy.power(freq / 1e8, -0.7) for freq in self.frequency])
self.phasecentre = SkyCoord(ra=+180.0 * u.deg,
dec=-60.0 * u.deg,
frame='icrs',
equinox='J2000')
self.vis = ingest_unittest_visibility(self.low,
self.frequency,
self.channelwidth,
self.times,
self.vis_pol,
self.phasecentre,
block=False,
zerow=zerow)
self.model = create_unittest_model(self.vis,
self.image_pol,
cellsize=self.cellsize,
npixel=self.npixel,
nchan=self.freqwin)
self.components = create_unittest_components(self.model,
flux,
applypb=False,
scale=0.5,
single=False,
symmetric=True)
self.model = insert_skycomponent(self.model, self.components)
self.vis = predict_skycomponent_visibility(self.vis, self.components)
# Calculate the model convolved with a Gaussian.
self.cmodel = smooth_image(self.model)
if self.persist:
export_image_to_fits(self.model,
'%s/test_gridding_model.fits' % self.dir)
export_image_to_fits(self.cmodel,
'%s/test_gridding_cmodel.fits' % self.dir)
pb = create_pb_generic(self.model,
diameter=35.0,
blockage=0.0,
use_local=False)
self.cmodel.data *= pb.data
if self.persist:
export_image_to_fits(self.cmodel,
'%s/test_gridding_cmodel_pb.fits' % self.dir)
self.peak = numpy.unravel_index(
numpy.argmax(numpy.abs(self.cmodel.data)), self.cmodel.shape)
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, 0.0, 0.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 = \
[rsexecute.execute(ingest_unittest_visibility, nout=1)(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.blockvis_list = rsexecute.compute(self.blockvis_list, sync=True)
self.blockvis_list = rsexecute.scatter(self.blockvis_list)
self.vis_list = [
rsexecute.execute(convert_blockvisibility_to_visibility,
nout=1)(bv) for bv in self.blockvis_list
]
self.vis_list = rsexecute.compute(self.vis_list, sync=True)
self.vis_list = rsexecute.scatter(self.vis_list)
self.model_imagelist = [
rsexecute.execute(create_unittest_model,
nout=1)(self.vis_list[i],
self.image_pol,
npixel=self.npixel,
cellsize=0.0005) for i in range(nfreqwin)
]
self.model_imagelist = rsexecute.compute(self.model_imagelist,
sync=True)
self.model_imagelist = rsexecute.scatter(self.model_imagelist)
self.components_list = [
rsexecute.execute(create_unittest_components)(
self.model_imagelist[freqwin],
flux[freqwin, :][numpy.newaxis, :])
for freqwin, m in enumerate(self.model_imagelist)
]
self.components_list = rsexecute.compute(self.components_list,
sync=True)
self.components_list = rsexecute.scatter(self.components_list)
self.blockvis_list = [
rsexecute.execute(dft_skycomponent_visibility)(
self.blockvis_list[freqwin], self.components_list[freqwin])
for freqwin, _ in enumerate(self.blockvis_list)
]
self.blockvis_list = rsexecute.compute(self.blockvis_list, sync=True)
self.vis = self.blockvis_list[0]
self.blockvis_list = rsexecute.scatter(self.blockvis_list)
self.model_imagelist = [
rsexecute.execute(insert_skycomponent,
nout=1)(self.model_imagelist[freqwin],
self.components_list[freqwin])
for freqwin in range(nfreqwin)
]
self.model_imagelist = rsexecute.compute(self.model_imagelist,
sync=True)
model = self.model_imagelist[0]
self.cmodel = smooth_image(model)
if self.persist:
export_image_to_fits(
model, '%s/test_pipelines_rsexecute_model.fits' % self.dir)
export_image_to_fits(
self.cmodel,
'%s/test_pipelines_rsexecute_cmodel.fits' % self.dir)
if add_errors:
gt = create_gaintable_from_blockvisibility(self.vis)
gt = simulate_gaintable(gt,
phase_error=0.1,
amplitude_error=0.0,
smooth_channels=1,
leakage=0.0)
self.blockvis_list = [
rsexecute.execute(apply_gaintable,
nout=1)(self.blockvis_list[i], gt)
for i in range(self.freqwin)
]
self.blockvis_list = rsexecute.compute(self.blockvis_list,
sync=True)
self.blockvis_list = rsexecute.scatter(self.blockvis_list)
self.vis_list = [
rsexecute.execute(convert_blockvisibility_to_visibility)(bv)
for bv in self.blockvis_list
]
self.vis_list = rsexecute.compute(self.vis_list, sync=True)
self.vis_list = rsexecute.scatter(self.vis_list)
self.model_imagelist = [
rsexecute.execute(create_unittest_model,
nout=1)(self.vis_list[i],
self.image_pol,
npixel=self.npixel,
cellsize=0.0005) for i in range(nfreqwin)
]
self.model_imagelist = rsexecute.compute(self.model_imagelist,
sync=True)
self.model_imagelist = rsexecute.scatter(self.model_imagelist)
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 = [
rsexecute.execute(ingest_unittest_visibility,
nout=1)(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.blockvis_list = rsexecute.compute(self.blockvis_list, sync=True)
for v in self.blockvis_list:
v.data['vis'][...] = 1.0 + 0.0j
self.error_blockvis_list = [
rsexecute.execute(copy_visibility(v)) for v in self.blockvis_list
]
gt = rsexecute.execute(create_gaintable_from_blockvisibility)(
self.blockvis_list[0])
gt = rsexecute.execute(simulate_gaintable)(gt,
phase_error=0.1,
amplitude_error=0.0,
smooth_channels=1,
leakage=0.0,
seed=180555)
self.error_blockvis_list = [
rsexecute.execute(apply_gaintable)(self.error_blockvis_list[i], gt)
for i in range(self.freqwin)
]
self.error_blockvis_list = rsexecute.compute(self.error_blockvis_list,
sync=True)
assert numpy.max(
numpy.abs(self.error_blockvis_list[0].vis -
self.blockvis_list[0].vis)) > 0.0
from rascil.processing_components.imaging.base import invert_2d, predict_2d, shift_vis_to_image, normalize_sumwt
from rascil.processing_components.visibility.base import copy_visibility
from rascil.processing_components.imaging.ng import predict_ng, invert_ng
from rascil.processing_components.griddata.kernels import create_awterm_convolutionfunction
# In[3]:
rdir = './'
verbosity = True
dopol = False
dospectral = True
zerow = False
block = True
persist = True
npixel = 1024
low = create_named_configuration('LOWBD2', rmax=750.0)
freqwin = 21
blockvis = list()
ntimes = 5
times = numpy.linspace(-3.0, +3.0, ntimes) * numpy.pi / 12.0
if freqwin > 1:
frequency = numpy.linspace(0.99e8, 1.01e8, freqwin)
channelwidth = numpy.array(freqwin * [frequency[1] - frequency[0]])
else:
frequency = numpy.array([1e8])
channelwidth = numpy.array([1e6])
if dopol:
blockvis_pol = PolarisationFrame('linear')
image_pol = PolarisationFrame('stokesIQUV')
def test_export_ms(self):
if run_ms_tests == False:
return
msoutfile = rascil_path("test_results/test_export_ms_ASKAP_output.ms")
from astropy.coordinates import SkyCoord
from astropy import units as u
from rascil.processing_components.image.operations import show_image, export_image_to_fits
from rascil.processing_components.simulation import create_named_configuration
from rascil.processing_components.simulation import create_test_image
from rascil.processing_components.imaging.base import create_image_from_visibility
from rascil.processing_components.imaging.base import advise_wide_field
from rascil.workflows.serial.imaging.imaging_serial import invert_list_serial_workflow, predict_list_serial_workflow
from rascil.data_models.polarisation import PolarisationFrame
lowr3 = create_named_configuration('LOWBD2', rmax=750.0)
times = numpy.zeros([1])
frequency = numpy.array([1e8])
channelbandwidth = numpy.array([1e6])
phasecentre = SkyCoord(ra=+15.0 * u.deg,
dec=-45.0 * u.deg,
frame='icrs',
equinox='J2000')
bvis = create_blockvisibility(
lowr3,
times,
frequency,
phasecentre=phasecentre,
weight=1.0,
polarisation_frame=PolarisationFrame('stokesI'),
channel_bandwidth=channelbandwidth)
vt = convert_blockvisibility_to_visibility(bvis)
advice = advise_wide_field(vt,
guard_band_image=3.0,
delA=0.1,
facets=1,
wprojection_planes=1,
oversampling_synthesised_beam=4.0)
cellsize = advice['cellsize']
m31image = create_test_image(frequency=frequency, cellsize=cellsize)
nchan, npol, ny, nx = m31image.data.shape
m31image.wcs.wcs.crval[0] = vt.phasecentre.ra.deg
m31image.wcs.wcs.crval[1] = vt.phasecentre.dec.deg
m31image.wcs.wcs.crpix[0] = float(nx // 2)
m31image.wcs.wcs.crpix[1] = float(ny // 2)
vt = predict_list_serial_workflow([vt], [m31image], context='2d')[0]
# uvdist = numpy.sqrt(vt.data['uvw'][:, 0] ** 2 + vt.data['uvw'][:, 1] ** 2)
#
# model = create_image_from_visibility(vt, cellsize=cellsize, npixel=512)
# dirty, sumwt = invert_list_serial_workflow([vt], [model], context='2d')[0]
# psf, sumwt = invert_list_serial_workflow([vt], [model], context='2d', dopsf=True)[0]
#
# show_image(dirty)
# print("Max, min in dirty image = %.6f, %.6f, sumwt = %f" % (dirty.data.max(), dirty.data.min(), sumwt))
#
# print("Max, min in PSF = %.6f, %.6f, sumwt = %f" % (psf.data.max(), psf.data.min(), sumwt))
# results_dir="/Users/f.wang"
# export_image_to_fits(dirty, '%s/imaging_dirty.fits' % (results_dir))
# export_image_to_fits(psf, '%s/imaging_psf.fits' % (results_dir))
v = convert_visibility_to_blockvisibility(vt)
vis_list = []
vis_list.append(v)
export_blockvisibility_to_ms(msoutfile, vis_list, source_name='M31')
if __name__ == '__main__':
dir = '.'
# Set up a short observation with MID
dec = -45.0
rmax = 1e3
freq = 1.4e9
frequency = numpy.linspace(freq, 1.5 * freq, 3)
channel_bandwidth = numpy.array([2.5e7, 2.5e7, 2.5e7])
flux = numpy.array([[100.0], [100.0], [100.0]])
phasecentre = SkyCoord(ra=+15.0 * u.deg,
dec=-35.0 * u.deg,
frame='icrs',
equinox='J2000')
config = create_named_configuration('MIDR5', rmax=rmax)
times = numpy.linspace(-300.0, 300.0, 3) * numpy.pi / 43200.0
nants = config.xyz.shape[0]
assert nants > 1
assert len(config.names) == nants
assert len(config.mount) == nants
vis = create_visibility(config,
times,
frequency,
channel_bandwidth=channel_bandwidth,
phasecentre=phasecentre,
weight=1.0,
polarisation_frame=PolarisationFrame('stokesI'))
cellsize = 8 * numpy.pi / 180.0 / 280