Пример #1
0
    def test_phase_rotation(self):
        self.vis = create_visibility(
            self.lowcore,
            self.times,
            self.frequency,
            channel_bandwidth=self.channel_bandwidth,
            phasecentre=self.phasecentre,
            weight=1.0,
            polarisation_frame=PolarisationFrame("stokesIQUV"))
        self.vismodel = predict_skycomponent_visibility(self.vis, self.comp)
        # Predict visibilities with new phase centre independently
        ha_diff = -(self.compabsdirection.ra - self.phasecentre.ra).to(
            u.rad).value
        vispred = create_visibility(
            self.lowcore,
            self.times + ha_diff,
            self.frequency,
            channel_bandwidth=self.channel_bandwidth,
            phasecentre=self.compabsdirection,
            weight=1.0,
            polarisation_frame=PolarisationFrame("stokesIQUV"))
        vismodel2 = predict_skycomponent_visibility(vispred, self.comp)

        # Should yield the same results as rotation
        rotatedvis = phaserotate_visibility(
            self.vismodel, newphasecentre=self.compabsdirection, tangent=False)
        assert_allclose(rotatedvis.vis, vismodel2.vis, rtol=3e-6)
        assert_allclose(rotatedvis.uvw, vismodel2.uvw, rtol=3e-6)
Пример #2
0
 def test_elevation(self):
     self.phasecentre = SkyCoord(ra=+180.0 * u.deg,
                                 dec=+15.0 * u.deg,
                                 frame='icrs',
                                 equinox='J2000')
     self.times = (numpy.pi / 43200.0) * numpy.arange(
         -43200, +43200, 3600.0)
     self.vis = create_visibility(
         self.lowcore,
         self.times,
         self.frequency,
         channel_bandwidth=self.channel_bandwidth,
         phasecentre=self.phasecentre,
         weight=1.0,
         polarisation_frame=PolarisationFrame("stokesIQUV"),
         elevation_limit=numpy.pi * 15.0 / 180.0)
     n_elevation_limit = len(numpy.unique(self.vis.time))
     self.vis = create_visibility(
         self.lowcore,
         self.times,
         self.frequency,
         channel_bandwidth=self.channel_bandwidth,
         phasecentre=self.phasecentre,
         weight=1.0,
         polarisation_frame=PolarisationFrame("stokesIQUV"),
         elevation_limit=None)
     assert len(numpy.unique(self.vis.time)) >= n_elevation_limit
    def test_phase_rotation_stokesi(self):
       # Define the component and give it some spectral behaviour
        f = numpy.array([100.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,
                                     polarisation_frame=PolarisationFrame("stokesI"))
    
        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"))
        self.vismodel = predict_skycomponent_visibility(self.vis, self.comp)
        # Predict visibilities with new phase centre independently
        ha_diff = -(self.compabsdirection.ra - self.phasecentre.ra).to(u.rad).value
        vispred = create_visibility(self.lowcore, self.times + ha_diff, self.frequency,
                                    channel_bandwidth=self.channel_bandwidth,
                                    phasecentre=self.compabsdirection, weight=1.0,
                                    polarisation_frame=PolarisationFrame("stokesI"))
        vismodel2 = predict_skycomponent_visibility(vispred, self.comp)

        # Should yield the same results as rotation
        rotatedvis = phaserotate_visibility(self.vismodel, newphasecentre=self.compabsdirection, tangent=False)
        assert_allclose(rotatedvis.vis, vismodel2.vis, rtol=3e-6)
        assert_allclose(rotatedvis.uvw, vismodel2.uvw, rtol=3e-6)
 def test_append_visibility(self):
     self.vis = create_visibility(self.lowcore, self.times, self.frequency,
                                  channel_bandwidth=self.channel_bandwidth,
                                  phasecentre=self.phasecentre,
                                  weight=1.0)
     othertimes = (numpy.pi / 43200.0) * numpy.arange(300.0, 600.0, 30.0)
     self.othervis = create_visibility(self.lowcore, othertimes, self.frequency,
                                       channel_bandwidth=self.channel_bandwidth,
                                       phasecentre=self.phasecentre,
                                       weight=1.0)
     self.vis = append_visibility(self.vis, self.othervis)
     assert self.vis.nvis == len(self.vis.time)
     assert self.vis.nvis == len(self.vis.frequency)
 def test_subtract(self):
     vis1 = create_visibility(self.lowcore, self.times, self.frequency,
                              channel_bandwidth=self.channel_bandwidth,
                              phasecentre=self.phasecentre, weight=1.0,
                              polarisation_frame=PolarisationFrame("stokesIQUV"))
     vis1.data['vis'][...] = 1.0
     vis2 = create_visibility(self.lowcore, self.times, self.frequency,
                              channel_bandwidth=self.channel_bandwidth,
                              phasecentre=self.phasecentre, weight=1.0,
                              polarisation_frame=PolarisationFrame("stokesIQUV"))
     vis2.data['vis'][...] = 1.0
     zerovis = subtract_visibility(vis1, vis2)
     qa = qa_visibility(zerovis, context='test_qa')
     self.assertAlmostEqual(qa.data['maxabs'], 0.0, 7)
Пример #6
0
def ingest_unittest_visibility(config,
                               frequency,
                               channel_bandwidth,
                               times,
                               vis_pol,
                               phasecentre,
                               block=False,
                               zerow=False):
    if block:
        vt = create_blockvisibility(config,
                                    times,
                                    frequency,
                                    channel_bandwidth=channel_bandwidth,
                                    phasecentre=phasecentre,
                                    weight=1.0,
                                    polarisation_frame=vis_pol,
                                    zerow=zerow)
    else:
        vt = create_visibility(config,
                               times,
                               frequency,
                               channel_bandwidth=channel_bandwidth,
                               phasecentre=phasecentre,
                               weight=1.0,
                               polarisation_frame=vis_pol,
                               zerow=zerow)
    vt.data['vis'][...] = 0.0
    return vt
Пример #7
0
 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 createVis(self, config='MID', dec=-35.0, rmax=1e3, freq=1e9):
        self.frequency = numpy.linspace(freq, 1.5 * freq, 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(config)
        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.config = create_named_configuration(config, rmax=rmax)
        self.phasecentre = SkyCoord(ra=+15 * u.deg,
                                    dec=dec * u.deg,
                                    frame='icrs',
                                    equinox='J2000')
        self.vis = create_visibility(
            self.config,
            self.times,
            self.frequency,
            channel_bandwidth=self.channel_bandwidth,
            phasecentre=self.phasecentre,
            weight=1.0,
            polarisation_frame=PolarisationFrame('stokesI'))
Пример #9
0
 def test_phase_rotation_identity(self):
     self.vis = create_visibility(
         self.lowcore,
         self.times,
         self.frequency,
         channel_bandwidth=self.channel_bandwidth,
         phasecentre=self.phasecentre,
         weight=1.0,
         polarisation_frame=PolarisationFrame("stokesIQUV"))
     self.vismodel = predict_skycomponent_visibility(self.vis, self.comp)
     newphasecenters = [
         SkyCoord(182, -35, unit=u.deg),
         SkyCoord(182, -30, unit=u.deg),
         SkyCoord(177, -30, unit=u.deg),
         SkyCoord(176, -35, unit=u.deg),
         SkyCoord(216, -35, unit=u.deg),
         SkyCoord(180, -70, unit=u.deg)
     ]
     for newphasecentre in newphasecenters:
         # Phase rotating back should not make a difference
         original_vis = self.vismodel.vis
         original_uvw = self.vismodel.uvw
         rotatedvis = phaserotate_visibility(phaserotate_visibility(
             self.vismodel, newphasecentre, tangent=False),
                                             self.phasecentre,
                                             tangent=False)
         assert_allclose(rotatedvis.uvw, original_uvw, rtol=1e-7)
         assert_allclose(rotatedvis.vis, original_vis, rtol=1e-7)
    def test_fit_visibility(self):
        # Sum the visibilities in the correct_visibility direction. This is limited by numerical precision
        methods = [
            'CG', 'BFGS', 'Powell', 'trust-ncg', 'trust-exact', 'trust-krylov'
        ]
        for method in methods:
            self.actualSetup()
            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"))
            self.vismodel = dft_skycomponent_visibility(self.vis, self.comp)
            initial_comp = Skycomponent(
                direction=self.comp_start_direction,
                frequency=self.frequency,
                flux=2.0 * self.flux,
                polarisation_frame=PolarisationFrame("stokesI"))

            sc, res = fit_visibility(self.vismodel,
                                     initial_comp,
                                     niter=200,
                                     tol=1e-5,
                                     method=method,
                                     verbose=False)
            assert sc.direction.separation(self.comp_actual_direction).to('rad').value < 1e-6, \
                sc.direction.separation(self.comp_actual_direction).to('rad')
 def test_create_visibility_from_rows_makecopy(self):
     self.vis = create_visibility(self.lowcore, self.times, self.frequency, phasecentre=self.phasecentre,
                                  weight=1.0, channel_bandwidth=self.channel_bandwidth)
     rows = self.vis.time > 150.0
     for makecopy in [True, False]:
         selected_vis = create_visibility_from_rows(self.vis, rows, makecopy=makecopy)
         assert selected_vis.nvis == numpy.sum(numpy.array(rows))
 def test_create_visibility_polarisation(self):
     self.vis = create_visibility(self.lowcore, self.times, self.frequency,
                                  channel_bandwidth=self.channel_bandwidth,
                                  phasecentre=self.phasecentre, weight=1.0,
                                  polarisation_frame=PolarisationFrame("linear"))
     assert self.vis.nvis == len(self.vis.time)
     assert self.vis.nvis == len(self.vis.frequency)
 def test_create_visibility1(self):
     self.vis = create_visibility(self.lowcore, self.times, self.frequency,
                                  channel_bandwidth=self.channel_bandwidth,
                                  phasecentre=self.phasecentre,
                                  weight=1.0)
     assert self.vis.nvis == len(self.vis.time)
     assert self.vis.nvis == len(self.vis.frequency)
Пример #14
0
    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)
Пример #15
0
    def actualSetUp(self,
                    time=None,
                    frequency=None,
                    dospectral=False,
                    dopol=False):
        self.lowcore = create_named_configuration('LOWBD2', rmax=600)
        self.times = (numpy.pi / 12.0) * numpy.linspace(-3.0, 3.0, 5)

        if time is not None:
            self.times = time
        log.info("Times are %s" % (self.times))

        if dospectral:
            self.nchan = 3
            self.frequency = numpy.array([0.9e8, 1e8, 1.1e8])
            self.channel_bandwidth = numpy.array([1e7, 1e7, 1e7])
        else:
            self.frequency = numpy.array([1e8])
            self.channel_bandwidth = numpy.array([1e7])

        if dopol:
            self.vis_pol = PolarisationFrame('linear')
            self.image_pol = PolarisationFrame('stokesIQUV')
        else:
            self.vis_pol = PolarisationFrame('stokesI')
            self.image_pol = PolarisationFrame('stokesI')

        if dopol:
            f = numpy.array([100.0, 20.0, -10.0, 1.0])
        else:
            f = numpy.array([100.0])

        if dospectral:
            numpy.array([f, 0.8 * f, 0.6 * f])
        else:
            numpy.array([f])

        self.phasecentre = SkyCoord(ra=+180.0 * u.deg,
                                    dec=-60.0 * u.deg,
                                    frame='icrs',
                                    equinox='J2000')
        self.componentvis = create_visibility(
            self.lowcore,
            self.times,
            self.frequency,
            channel_bandwidth=self.channel_bandwidth,
            phasecentre=self.phasecentre,
            weight=1.0,
            polarisation_frame=self.vis_pol)
        self.uvw = self.componentvis.data['uvw']
        self.componentvis.data['vis'] *= 0.0

        # Create model
        self.model = create_image_from_visibility(
            self.componentvis,
            npixel=self.npixel,
            cellsize=0.0005,
            nchan=len(self.frequency),
            polarisation_frame=self.image_pol)
Пример #16
0
 def actualSetUp(self, times=None):
     if times is not None:
         self.times = times
     
     self.vis = create_visibility(self.lowcore, self.times, self.frequency,
                                  channel_bandwidth=self.channel_bandwidth, phasecentre=self.phasecentre,
                                  weight=1.0)
     self.vis.data['vis'][:, 0] = self.vis.time
 def test_copy_visibility(self):
     self.vis = create_visibility(self.lowcore, self.times, self.frequency,
                                  channel_bandwidth=self.channel_bandwidth, phasecentre=self.phasecentre, weight=1.0,
                                  polarisation_frame=PolarisationFrame("stokesIQUV"))
     vis = copy_visibility(self.vis)
     self.vis.data['vis'] = 0.0
     vis.data['vis'] = 1.0
     assert (vis.data['vis'][0, 0].real == 1.0)
     assert (self.vis.data['vis'][0, 0].real == 0.0)
Пример #18
0
 def test_convert_visibility_stokes(self):
     for pol in ['linear', 'circular']:
         vis = create_visibility(self.lowcore, self.times, self.frequency,
                                 channel_bandwidth=self.channel_bandwidth,
                                 phasecentre=self.phasecentre, weight=1.0,
                                 polarisation_frame=PolarisationFrame(pol))
         visi = convert_visibility_to_stokes(vis)
         assert visi.polarisation_frame.type == 'stokesIQUV'
         assert visi.npol == 4
 def test_qa(self):
     self.vis = create_visibility(self.lowcore, self.times, self.frequency,
                                  channel_bandwidth=self.channel_bandwidth,
                                  phasecentre=self.phasecentre, weight=1.0,
                                  polarisation_frame=PolarisationFrame("stokesIQUV"))
     self.vismodel = dft_skycomponent_visibility(self.vis, self.comp)
     qa = qa_visibility(self.vis, context='test_qa')
     self.assertAlmostEqual(qa.data['maxabs'], 100.0, 7)
     self.assertAlmostEqual(qa.data['medianabs'], 11.0, 7)
     assert qa.context == 'test_qa'
Пример #20
0
 def test_sum_visibility(self):
     self.vis = create_visibility(
         self.lowcore,
         self.times,
         self.frequency,
         channel_bandwidth=self.channel_bandwidth,
         phasecentre=self.phasecentre,
         polarisation_frame=PolarisationFrame("linear"),
         weight=1.0)
     self.vis = predict_skycomponent_visibility(self.vis, self.comp)
     flux, weight = sum_visibility(self.vis, self.comp.direction)
     assert numpy.max(numpy.abs(flux - self.flux)) < 1e-7
Пример #21
0
 def test_addnoise_visibility(self):
     self.vis = create_visibility(
         self.config,
         self.times,
         self.frequency,
         phasecentre=self.phasecentre,
         weight=1.0,
         polarisation_frame=PolarisationFrame('stokesIQUV'),
         channel_bandwidth=self.channel_bandwidth)
     original = copy_visibility(self.vis)
     self.vis = addnoise_visibility(self.vis)
     actual = numpy.std(numpy.abs(self.vis.vis - original.vis))
     assert abs(actual - 0.010786973492702846) < 1e-4, actual
Пример #22
0
 def createVis(self, config, dec=-35.0, rmax=None):
     self.config = create_named_configuration(config, rmax=rmax)
     self.phasecentre = SkyCoord(ra=+15 * u.deg,
                                 dec=dec * u.deg,
                                 frame='icrs',
                                 equinox='J2000')
     self.vis = create_visibility(
         self.config,
         self.times,
         self.frequency,
         channel_bandwidth=self.channel_bandwidth,
         phasecentre=self.phasecentre,
         weight=1.0,
         polarisation_frame=PolarisationFrame('stokesI'))
Пример #23
0
    def actualSetup(self, dopol=False):

        if dopol:
            self.vis_pol = PolarisationFrame("linear")
            self.image_pol = PolarisationFrame("stokesIQUV")
            self.pol_flux = numpy.array([1.0, -0.8, 0.2, 0.01])
        else:
            self.vis_pol = PolarisationFrame("stokesI")
            self.image_pol = PolarisationFrame("stokesI")
            self.pol_flux = numpy.array([1.0])

        self.times = (numpy.pi / 12.0) * numpy.linspace(-3.0, 3.0, 7)
        self.image_frequency = numpy.linspace(0.9e8, 1.1e8, 5)
        self.image_channel_bandwidth = numpy.array(5 * [5e6])
        self.component_frequency = numpy.linspace(0.8e8, 1.2e8, 7)
        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.image_channel_bandwidth,
            phasecentre=self.phasecentre,
            weight=1.0,
            polarisation_frame=self.vis_pol,
            zerow=True)
        self.vis.data['vis'] *= 0.0

        # Create model
        self.model = create_image(
            npixel=256,
            cellsize=0.0015,
            phasecentre=self.vis.phasecentre,
            frequency=self.image_frequency,
            channel_bandwidth=self.image_channel_bandwidth,
            polarisation_frame=self.image_pol)

        dphasecentre = SkyCoord(ra=+181.0 * u.deg,
                                dec=-58.0 * u.deg,
                                frame='icrs',
                                equinox='J2000')
        flux_scale = numpy.power(self.component_frequency / 1e8, -0.7)
        self.flux = numpy.outer(flux_scale, self.pol_flux)
        self.sc = create_skycomponent(direction=dphasecentre,
                                      flux=self.flux,
                                      frequency=self.component_frequency,
                                      polarisation_frame=self.image_pol)
 def test_phase_rotation_inverse(self):
     self.vis = create_visibility(self.lowcore, self.times, self.frequency,
                                  channel_bandwidth=self.channel_bandwidth,
                                  phasecentre=self.phasecentre, weight=1.0,
                                  polarisation_frame=PolarisationFrame("stokesIQUV"))
     self.vismodel = dft_skycomponent_visibility(self.vis, self.comp)
     there = SkyCoord(ra=+250.0 * u.deg, dec=-60.0 * u.deg, frame='icrs', equinox='J2000')
     # Phase rotating back should not make a difference
     original_vis = self.vismodel.vis
     original_uvw = self.vismodel.uvw
     rotatedvis = phaserotate_visibility(phaserotate_visibility(self.vismodel, there, tangent=False,
                                                                inverse=True),
                                         self.phasecentre, tangent=False, inverse=True)
     assert_allclose(rotatedvis.uvw, original_uvw, rtol=1e-7)
     assert_allclose(rotatedvis.vis, original_vis, rtol=1e-7)
 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)
Пример #26
0
    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 test_dft_idft_stokesiquv_visibility(self):
     for vpol in [
             PolarisationFrame("linear"),
             PolarisationFrame("circular")
     ]:
         self.vis = create_visibility(
             self.lowcore,
             self.times,
             self.frequency,
             channel_bandwidth=self.channel_bandwidth,
             phasecentre=self.phasecentre,
             weight=1.0,
             polarisation_frame=PolarisationFrame("stokesIQUV"))
         self.vismodel = dft_skycomponent_visibility(self.vis, self.comp)
         rcomp, weights = idft_visibility_skycomponent(
             self.vismodel, self.comp)
         assert_allclose(self.comp.flux,
                         numpy.real(rcomp[0].flux),
                         rtol=1e-11)
 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'))
Пример #29
0
    def test_readwritevisibility(self):
        self.vis = create_visibility(self.mid, self.times, self.frequency,
                                     channel_bandwidth=self.channel_bandwidth,
                                     phasecentre=self.phasecentre,
                                     polarisation_frame=PolarisationFrame("linear"),
                                     weight=1.0)
        self.vis = predict_skycomponent_visibility(self.vis, self.comp)
        export_visibility_to_hdf5(self.vis, '%s/test_data_model_helpers_visibility.hdf' % self.dir)
        newvis = import_visibility_from_hdf5('%s/test_data_model_helpers_visibility.hdf' % self.dir)
        
        assert str(newvis) == str(self.vis), "Original %s, import %s" % (str(newvis), str(self.vis))
        
        for key in self.vis.data.dtype.fields:
            assert numpy.max(numpy.abs(newvis.data[key]-self.vis.data[key])) < 1e-15

        assert numpy.array_equal(newvis.frequency, self.vis.frequency)
        assert newvis.data.shape == self.vis.data.shape
        assert numpy.array_equal(newvis.frequency, self.vis.frequency)
        assert numpy.max(numpy.abs(self.vis.vis - newvis.vis)) < 1e-15
        assert numpy.max(numpy.abs(self.vis.uvw - newvis.uvw)) < 1e-15
        assert numpy.abs(newvis.configuration.location.x.value - self.vis.configuration.location.x.value) < 1e-15
        assert numpy.abs(newvis.configuration.location.y.value - self.vis.configuration.location.y.value) < 1e-15
        assert numpy.abs(newvis.configuration.location.z.value - self.vis.configuration.location.z.value) < 1e-15
        assert numpy.max(numpy.abs(newvis.configuration.xyz - self.vis.configuration.xyz)) < 1e-15
    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
    
    phasecentre = SkyCoord(ra=+15 * u.deg, dec=dec * u.deg, frame='icrs', equinox='J2000')
    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
    model = create_image_from_visibility(vis, npixel=512, cellsize=cellsize, override_cellsize=False)
    
    # These are the nolls that maintain left-right symmetry
    plt.clf()
    fig, axs = plt.subplots(4, 4, gridspec_kw={'hspace': 0, 'wspace': 0})
    ntrials = 16
    zernikes = list()
    default_vp = create_vp_generic_numeric(model, pointingcentre=None, diameter=15.0, blockage=0.0,
                                              taper='gaussian',
                                              edge=0.03162278, padding=2, use_local=True)

    key_nolls = [3, 5, 6, 7]