def test_scatter_gather_facet(self): m31original = create_test_image( polarisation_frame=PolarisationFrame('stokesI')) assert numpy.max(numpy.abs(m31original.data)), "Original is empty" for nraster in [1, 4, 8]: m31model = create_test_image( polarisation_frame=PolarisationFrame('stokesI')) image_list = image_scatter_facets(m31model, facets=nraster) for patch in image_list: assert patch.data.shape[3] == (m31model.data.shape[3] // nraster), \ "Number of pixels in each patch: %d not as expected: %d" % (patch.data.shape[3], (m31model.data.shape[3] // nraster)) assert patch.data.shape[2] == (m31model.data.shape[2] // nraster), \ "Number of pixels in each patch: %d not as expected: %d" % (patch.data.shape[2], (m31model.data.shape[2] // nraster)) patch.data[...] = 1.0 m31reconstructed = create_empty_image_like(m31model) m31reconstructed = image_gather_facets(image_list, m31reconstructed, facets=nraster) flat = image_gather_facets(image_list, m31reconstructed, facets=nraster, return_flat=True) assert numpy.max(numpy.abs( flat.data)), "Flat is empty for %d" % nraster assert numpy.max(numpy.abs( m31reconstructed.data)), "Raster is empty for %d" % nraster
def setUp(self): from rascil.data_models.parameters import rascil_path self.lowcore = create_named_configuration('LOWBD2', rmax=300.0) self.dir = rascil_path('test_results') 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_blockvisibility( self.lowcore, 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_test_image(cellsize=0.0015, phasecentre=self.vis.phasecentre, frequency=self.frequency) self.model.data[self.model.data > 1.0] = 1.0 self.mask = create_test_image(cellsize=0.0015, phasecentre=self.vis.phasecentre, frequency=self.frequency) self.mask.data[self.mask.data > 0.1] = 1.0 self.mask.data[self.mask.data <= 0.1] = 0.0
def test_scatter_gather_facet_overlap_taper(self): m31original = create_test_image( polarisation_frame=PolarisationFrame('stokesI')) assert numpy.max(numpy.abs(m31original.data)), "Original is empty" for taper in ['linear', None]: for nraster, overlap in [(1, 0), (4, 8), (8, 8), (8, 16)]: m31model = create_test_image( polarisation_frame=PolarisationFrame('stokesI')) image_list = image_scatter_facets(m31model, facets=nraster, overlap=overlap, taper=taper) for patch in image_list: assert patch.data.shape[3] == (2 * overlap + m31model.data.shape[3] // nraster), \ "Number of pixels in each patch: %d not as expected: %d" % (patch.data.shape[3], (2 * overlap + m31model.data.shape[3] // nraster)) assert patch.data.shape[2] == (2 * overlap + m31model.data.shape[2] // nraster), \ "Number of pixels in each patch: %d not as expected: %d" % (patch.data.shape[2], (2 * overlap + m31model.data.shape[2] // nraster)) m31reconstructed = create_empty_image_like(m31model) m31reconstructed = image_gather_facets(image_list, m31reconstructed, facets=nraster, overlap=overlap, taper=taper) flat = image_gather_facets(image_list, m31reconstructed, facets=nraster, overlap=overlap, taper=taper, return_flat=True) if self.persist: export_image_to_fits( m31reconstructed, "%s/test_image_gather_scatter_%dnraster_%doverlap_%s_reconstructed.fits" % (self.dir, nraster, overlap, taper)) if self.persist: export_image_to_fits( flat, "%s/test_image_gather_scatter_%dnraster_%doverlap_%s_flat.fits" % (self.dir, nraster, overlap, taper)) assert numpy.max(numpy.abs( flat.data)), "Flat is empty for %d" % nraster assert numpy.max(numpy.abs( m31reconstructed.data)), "Raster is empty for %d" % nraster
def test_raster_exception(self): m31original = create_test_image( polarisation_frame=PolarisationFrame('stokesI')) assert numpy.max(numpy.abs(m31original.data)), "Original is empty" for nraster, overlap in [(-1, -1), (-1, 0), (2, 128), (1e6, 127)]: with self.assertRaises(AssertionError) as context: m31model = create_test_image( polarisation_frame=PolarisationFrame('stokesI')) for patch in image_raster_iter(m31model, facets=nraster, overlap=overlap): patch.data *= 2.0
def test_null(self): m31cube = create_test_image( polarisation_frame=PolarisationFrame('stokesI'), frequency=numpy.linspace(1e8, 1.1e8, 128)) for i, im in enumerate(image_null_iter(m31cube)): assert i < 1, "Null iterator returns more than one value"
def setUp(self): from rascil.data_models.parameters import rascil_path self.dir = rascil_path('test_results') self.m31image = create_test_image(cellsize=0.0001) self.cellsize = 180.0 * 0.0001 / numpy.pi
def test_create_low_test_beam(self): im = create_test_image( canonical=True, cellsize=0.002, frequency=numpy.array([1e8 - 5e7, 1e8, 1e8 + 5e7]), channel_bandwidth=numpy.array([5e7, 5e7, 5e7]), polarisation_frame=PolarisationFrame("stokesIQUV"), phasecentre=self.phasecentre) bm = create_low_test_beam(model=im) if self.persist: export_image_to_fits( bm, '%s/test_test_support_low_beam.fits' % (self.dir)) assert bm.data.shape[0] == 3 assert bm.data.shape[1] == 4 assert bm.data.shape[2] == im.data.shape[2] assert bm.data.shape[3] == im.data.shape[3] # Check to see if the beam scales as expected for i in [30, 40]: assert numpy.max( numpy.abs(bm.data[0, 0, 128, 128 - 2 * i] - bm.data[1, 0, 128, 128 - i])) < 0.02 assert numpy.max( numpy.abs(bm.data[0, 0, 128, 128 - 3 * i] - bm.data[2, 0, 128, 128 - i])) < 0.02 assert numpy.max( numpy.abs(bm.data[0, 0, 128 - 2 * i, 128] - bm.data[1, 0, 128 - i, 128])) < 0.02 assert numpy.max( numpy.abs(bm.data[0, 0, 128 - 3 * i, 128] - bm.data[2, 0, 128 - i, 128])) < 0.02
def test_readwriteimage(self): im = create_test_image() export_image_to_hdf5(im, '%s/test_data_model_helpers_image.hdf' % self.dir) newim = import_image_from_hdf5('%s/test_data_model_helpers_image.hdf' % self.dir) assert newim.data.shape == im.data.shape assert numpy.max(numpy.abs(im.data - newim.data)) < 1e-15
def test_apply_voltage_pattern(self): vp = create_vp(telescope='MID_FEKO_B2') # vp = scale_and_rotate_image(vp, 30.0 * numpy.pi / 180.0, [1.0, 2.0]) cellsize = vp.wcs.wcs.cdelt[1] * numpy.pi / 180.0 m31image = create_test_image(cellsize=cellsize, frequency=[1.36e9], canonical=True) padded = pad_image(m31image, [1, 1, 1024, 1024]) padded.data = numpy.repeat(padded.data, repeats=4, axis=1) padded.polarisation_frame = PolarisationFrame("stokesIQUV") padded.data[:, 1:, ...] = 0.0 applied = apply_voltage_pattern_to_image(padded, vp) unapplied = apply_voltage_pattern_to_image(applied, vp, inverse=True, min_det=1e-12) if self.persist: applied.data = applied.data.real fitsfile = '{}/test_apply_voltage_pattern_real.fits'.format( self.dir) export_image_to_fits(applied, fitsfile=fitsfile) unapplied.data = unapplied.data.real fitsfile = '{}/test_apply_voltage_pattern_inv_real.fits'.format( self.dir) export_image_to_fits(unapplied, fitsfile=fitsfile) err = numpy.max(numpy.abs(unapplied.data - padded.data)) assert err < 1e-12, err
def setUp(self): from rascil.data_models.parameters import rascil_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 test_create_vis_iter_with_model(self): model = create_test_image(canonical=True, cellsize=0.001, frequency=self.frequency, phasecentre=self.phasecentre) comp = Skycomponent(direction=self.phasecentre, frequency=self.frequency, flux=self.flux, polarisation_frame=PolarisationFrame('stokesI')) vis_iter = create_blockvisibility_iterator( self.config, self.times, self.frequency, channel_bandwidth=self.channel_bandwidth, phasecentre=self.phasecentre, weight=1.0, polarisation_frame=PolarisationFrame('stokesI'), integration_time=30.0, number_integrations=3, model=model, components=comp) fullvis = None totalnvis = 0 for i, bvis in enumerate(vis_iter): assert bvis.phasecentre == self.phasecentre assert bvis.nvis if i == 0: fullvis = bvis totalnvis = bvis.nvis else: fullvis = append_visibility(fullvis, bvis) totalnvis += bvis.nvis assert fullvis.nvis == totalnvis
def test_polarisation_frame_from_wcs(self): assert self.m31image.polarisation_frame == PolarisationFrame("stokesI") stokes = create_test_image( cellsize=0.0001, polarisation_frame=PolarisationFrame("stokesIQUV")) wcs = stokes.wcs.deepcopy() shape = stokes.shape assert polarisation_frame_from_wcs( wcs, shape) == PolarisationFrame("stokesIQUV") wcs = stokes.wcs.deepcopy().sub(['stokes']) wcs.wcs.crpix[0] = 1.0 wcs.wcs.crval[0] = -1.0 wcs.wcs.cdelt[0] = -1.0 assert polarisation_frame_from_wcs( wcs, shape) == PolarisationFrame('circular') wcs.wcs.crpix[0] = 1.0 wcs.wcs.crval[0] = -5.0 wcs.wcs.cdelt[0] = -1.0 assert polarisation_frame_from_wcs( wcs, shape) == PolarisationFrame('linear') wcs.wcs.crpix[0] = 1.0 wcs.wcs.crval[0] = -1.0 wcs.wcs.cdelt[0] = -1.0 assert polarisation_frame_from_wcs( wcs, shape) == PolarisationFrame('circular') with self.assertRaises(ValueError): wcs.wcs.crpix[0] = 1.0 wcs.wcs.crval[0] = -100.0 wcs.wcs.cdelt[0] = -1.0 polarisation_frame_from_wcs(wcs, shape)
def test_readwriteskymodel(self): vis = create_blockvisibility( self.midcore, self.times, self.frequency, channel_bandwidth=self.channel_bandwidth, phasecentre=self.phasecentre, polarisation_frame=PolarisationFrame("linear"), weight=1.0) gt = create_gaintable_from_blockvisibility(vis, timeslice='auto') gt = simulate_gaintable(gt, phase_error=1.0, amplitude_error=0.1) im = create_test_image() sm = SkyModel(components=[self.comp], image=im, gaintable=gt) config = { "buffer": { "directory": self.dir }, "skymodel": { "name": "test_bufferskymodel.hdf", "data_model": "SkyModel" } } bdm = BufferSkyModel(config["buffer"], config["skymodel"], sm) bdm.sync() new_bdm = BufferSkyModel(config["buffer"], config["skymodel"]) new_bdm.sync() newsm = bdm.memory_data_model assert newsm.components[0].flux.shape == self.comp.flux.shape assert newsm.image.data.shape == im.data.shape assert newsm.gaintable.data.shape == gt.data.shape assert numpy.max(numpy.abs(newsm.image.data - im.data)) < 1e-15
def test_create_gaintable_from_screen(self): screen = import_image_from_fits( rascil_path('data/models/test_mpc_screen.fits')) beam = create_test_image(cellsize=0.0015, phasecentre=self.vis.phasecentre, frequency=self.frequency) beam = create_low_test_beam(beam, use_local=False) gleam_components = create_low_test_skycomponents_from_gleam( flux_limit=1.0, phasecentre=self.phasecentre, frequency=self.frequency, polarisation_frame=PolarisationFrame('stokesI'), radius=0.2) pb_gleam_components = apply_beam_to_skycomponent( gleam_components, beam) actual_components = filter_skycomponents_by_flux(pb_gleam_components, flux_min=1.0) gaintables = create_gaintable_from_screen(self.vis, actual_components, screen) assert len(gaintables) == len(actual_components), len(gaintables) assert gaintables[0].gain.shape == (3, 94, 3, 1, 1), gaintables[0].gain.shape
def setUp(self): from rascil.data_models.parameters import rascil_path self.lowcore = create_named_configuration('LOWBD2-CORE') self.dir = rascil_path('test_results') self.times = (numpy.pi / 12.0) * numpy.linspace(-3.0, 3.0, 7) self.image_frequency = numpy.linspace(0.9e8, 1.1e8, 5) self.component_frequency = numpy.linspace(0.8e8, 1.2e8, 7) self.channel_bandwidth = numpy.array(5*[1e7]) 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.image_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.model = create_test_image(cellsize=0.0015, phasecentre=self.vis.phasecentre, frequency=self.image_frequency) self.model.data[self.model.data > 1.0] = 1.0 self.vis = predict_2d(self.vis, self.model) assert numpy.max(numpy.abs(self.vis.vis)) > 0.0 dphasecentre = SkyCoord(ra=+181.0 * u.deg, dec=-58.0 * u.deg, frame='icrs', equinox='J2000') flux = [[numpy.power(f/1e8, -0.7)] for f in self.component_frequency] self.sc = create_skycomponent(direction=dphasecentre, flux=flux, frequency=self.component_frequency, polarisation_frame=PolarisationFrame('stokesI'))
def test_expand_skymodel_by_skycomponents(self): beam = create_test_image(cellsize=0.0015, phasecentre=self.vis.phasecentre, frequency=self.frequency) beam = create_low_test_beam(beam, use_local=False) gleam_components = create_low_test_skycomponents_from_gleam( flux_limit=1.0, phasecentre=self.phasecentre, frequency=self.frequency, polarisation_frame=PolarisationFrame('stokesI'), radius=0.2) pb_gleam_components = apply_beam_to_skycomponent( gleam_components, beam) actual_components = filter_skycomponents_by_flux(pb_gleam_components, flux_min=1.0) assert len(actual_components) == 37, len(actual_components) sm = SkyModel(image=self.model, components=actual_components) assert len(sm.components) == len(actual_components) scatter_sm = expand_skymodel_by_skycomponents(sm) assert len(scatter_sm) == len(actual_components) + 1 assert len(scatter_sm[0].components) == 1
def test_readwritegriddata(self): im = create_test_image() gd = create_griddata_from_image(im) export_griddata_to_hdf5(gd, '%s/test_data_model_helpers_griddata.hdf' % self.dir) newgd = import_griddata_from_hdf5('%s/test_data_model_helpers_griddata.hdf' % self.dir) assert newgd.data.shape == gd.data.shape assert numpy.max(numpy.abs(gd.data - newgd.data)) < 1e-15
def setUp(self): from rascil.data_models.parameters import rascil_path self.dir = rascil_path('test_results') self.m31image = create_test_image(cellsize=0.0001) self.cellsize = 180.0 * 0.0001 / numpy.pi self.persist = os.getenv("RASCIL_PERSIST", False)
def test_channelise(self): m31cube = create_test_image( polarisation_frame=PolarisationFrame('stokesI'), frequency=numpy.linspace(1e8, 1.1e8, 128)) for subimages in [128, 16, 8, 2, 1]: for slab in image_channel_iter(m31cube, subimages=subimages): assert slab.data.shape[0] == 128 // subimages
def test_readwriteconvolutionfunction(self): im = create_test_image() cf = create_convolutionfunction_from_image(im) export_convolutionfunction_to_hdf5(cf, '%s/test_data_model_helpers_convolutionfunction.hdf' % self.dir) newcf = import_convolutionfunction_from_hdf5('%s/test_data_model_helpers_convolutionfunction.hdf' % self.dir) assert newcf.data.shape == cf.data.shape assert numpy.max(numpy.abs(cf.data - newcf.data)) < 1e-15
def test_create_test_image(self): im = create_test_image(canonical=False) assert len(im.data.shape) == 2 im = create_test_image(canonical=True) assert len(im.data.shape) == 4 im = create_test_image(canonical=True, frequency=numpy.array([1e8]), polarisation_frame=PolarisationFrame('stokesI')) assert len(im.data.shape) == 4 assert im.data.shape[0] == 1 assert im.data.shape[1] == 1 im = create_test_image( canonical=True, frequency=numpy.array([1e8]), polarisation_frame=PolarisationFrame('stokesIQUV')) assert len(im.data.shape) == 4 assert im.data.shape[0] == 1 assert im.data.shape[1] == 4
def test_fftim(self): self.m31image = create_test_image(cellsize=0.001, frequency=[1e8], canonical=True) m31_fft = fft_image(self.m31image) m31_fft_ifft = fft_image(m31_fft, self.m31image) numpy.testing.assert_array_almost_equal(self.m31image.data, m31_fft_ifft.data.real, 12) m31_fft.data = numpy.abs(m31_fft.data) export_image_to_fits(m31_fft, fitsfile='%s/test_m31_fft.fits' % (self.dir))
def test_raster_overlap(self): m31original = create_test_image( polarisation_frame=PolarisationFrame('stokesI')) assert numpy.max(numpy.abs(m31original.data)), "Original is empty" flat = create_empty_image_like(m31original) for nraster, overlap in [(1, 0), (1, 16), (4, 8), (4, 16), (8, 8), (16, 4), (9, 5)]: m31model = create_test_image( polarisation_frame=PolarisationFrame('stokesI')) for patch, flat_patch in zip( image_raster_iter(m31model, facets=nraster, overlap=overlap), image_raster_iter(flat, facets=nraster, overlap=overlap)): patch.data *= 2.0 flat_patch.data[...] += 1.0 assert numpy.max(numpy.abs( m31model.data)), "Raster is empty for %d" % nraster
def test_convert_image_to_kernel(self): m31image = create_test_image(cellsize=0.001, frequency=[1e8], canonical=True) screen = create_w_term_like(m31image, w=20000.0, remove_shift=True) screen_fft = fft_image(screen) converted = convert_image_to_kernel(screen_fft, 8, 8) assert converted.shape == (1, 1, 8, 8, 8, 8) with self.assertRaises(AssertionError): converted = convert_image_to_kernel(m31image, 15, 1) with self.assertRaises(AssertionError): converted = convert_image_to_kernel(m31image, 15, 1000)
def test_create_pointingtable(self): beam = create_test_image(cellsize=0.0015, phasecentre=self.vis.phasecentre, frequency=self.frequency) for telescope in ['MID', 'LOW', 'ASKAP']: vp = create_vp(beam, telescope) pt = create_pointingtable_from_blockvisibility(self.vis, vp) pt = simulate_pointingtable(pt, 0.1, static_pointing_error=[0.01, 0.001]) assert pt.pointing.shape == (self.ntimes, self.nants, 1, 1, 2), pt.pointing.shape
def test_gather_channel(self): for nchan in [128, 16]: m31cube = create_test_image( polarisation_frame=PolarisationFrame('stokesI'), frequency=numpy.linspace(1e8, 1.1e8, nchan)) image_list = image_scatter_channels(m31cube, subimages=nchan) m31cuberec = image_gather_channels(image_list, None, subimages=nchan) assert m31cube.shape == m31cuberec.shape diff = m31cube.data - m31cuberec.data assert numpy.max( numpy.abs(diff)) == 0.0, "Scatter gather failed for %d" % nchan
def test_raster(self): m31original = create_test_image( polarisation_frame=PolarisationFrame('stokesI')) assert numpy.max(numpy.abs(m31original.data)), "Original is empty" for nraster in [1, 2, 4, 8, 9]: m31model = create_test_image( polarisation_frame=PolarisationFrame('stokesI')) for patch in image_raster_iter(m31model, facets=nraster): assert patch.data.shape[3] == (m31model.data.shape[3] // nraster), \ "Number of pixels in each patch: %d not as expected: %d" % (patch.data.shape[3], (m31model.data.shape[3] // nraster)) assert patch.data.shape[2] == (m31model.data.shape[2] // nraster), \ "Number of pixels in each patch: %d not as expected: %d" % (patch.data.shape[2], (m31model.data.shape[2] // nraster)) patch.data *= 2.0 diff = m31model.data - 2.0 * m31original.data assert numpy.max(numpy.abs( m31model.data)), "Raster is empty for %d" % nraster assert numpy.max( numpy.abs(diff)) == 0.0, "Raster set failed for %d" % nraster
def test_pad_image(self): m31image = create_test_image(cellsize=0.001, frequency=[1e8], canonical=True) padded = pad_image(m31image, [1, 1, 1024, 1024]) assert padded.shape == (1, 1, 1024, 1024) padded = pad_image(m31image, [3, 4, 2048, 2048]) assert padded.shape == (3, 4, 2048, 2048) with self.assertRaises(ValueError): padded = pad_image(m31image, [1, 1, 100, 100]) with self.assertRaises(IndexError): padded = pad_image(m31image, [1, 1])
def test_readwriteskymodel(self): self.vis = create_blockvisibility(self.mid, self.times, self.frequency, channel_bandwidth=self.channel_bandwidth, phasecentre=self.phasecentre, polarisation_frame=PolarisationFrame("linear"), weight=1.0) im = create_test_image() gt = create_gaintable_from_blockvisibility(self.vis, timeslice='auto') sm = SkyModel(components=[self.comp], image=im, gaintable=gt) export_skymodel_to_hdf5(sm, '%s/test_data_model_helpers_skymodel.hdf' % self.dir) newsm = import_skymodel_from_hdf5('%s/test_data_model_helpers_skymodel.hdf' % self.dir) assert newsm.components[0].flux.shape == self.comp.flux.shape assert newsm.image.data.shape == im.data.shape assert numpy.max(numpy.abs(newsm.image.data - im.data)) < 1e-15
def test_fftim_factors(self): for i in [3, 5, 7]: npixel = 256 * i m31image = create_test_image(cellsize=0.001, frequency=[1e8], canonical=True) padded = pad_image(m31image, [1, 1, npixel, npixel]) assert padded.shape == (1, 1, npixel, npixel) padded_fft = fft_image(padded) padded_fft_ifft = fft_image(padded_fft, m31image) numpy.testing.assert_array_almost_equal(padded.data, padded_fft_ifft.data.real, 12) padded_fft.data = numpy.abs(padded_fft.data) export_image_to_fits(padded_fft, fitsfile='%s/test_m31_fft_%d.fits' % (self.dir, npixel))