コード例 #1
0
def convert_blockvisibility_to_visibility(vis: BlockVisibility) -> Visibility:
    """ Convert the BlockVisibility data with no coalescence

    :param vis: BlockVisibility to be converted
    :return: Visibility with  cindex and blockvis filled in
    """

    assert isinstance(
        vis, BlockVisibility), "vis is not a BlockVisibility: %r" % vis

    cvis, cuvw, cwts, ctime, cfrequency, cchannel_bandwidth, ca1, ca2, cintegration_time, cindex \
        = convert_blocks(vis.data['vis'], vis.data['uvw'], vis.data['weight'], vis.time, vis.integration_time,
                         vis.frequency, vis.channel_bandwidth)
    cimwt = numpy.ones(cvis.shape)
    converted_vis = Visibility(uvw=cuvw,
                               time=ctime,
                               frequency=cfrequency,
                               channel_bandwidth=cchannel_bandwidth,
                               phasecentre=vis.phasecentre,
                               antenna1=ca1,
                               antenna2=ca2,
                               vis=cvis,
                               weight=cwts,
                               imaging_weight=cimwt,
                               configuration=vis.configuration,
                               integration_time=cintegration_time,
                               polarisation_frame=vis.polarisation_frame,
                               cindex=cindex,
                               blockvis=vis)

    log.debug('convert_visibility: Original %s, converted %s' %
              (vis_summary(vis), vis_summary(converted_vis)))

    return converted_vis
コード例 #2
0
def convert_hdf_to_visibility(f):
    """ Convert HDF root to visibility

    :param f:
    :return:
    """
    assert f.attrs['ARL_data_model'] == "Visibility", "Not a Visibility"
    s = f.attrs['phasecentre_coords'].split()
    ss = [float(s[0]), float(s[1])] * u.deg
    phasecentre = SkyCoord(ra=ss[0], dec=ss[1], frame=f.attrs['phasecentre_frame'])
    polarisation_frame = PolarisationFrame(f.attrs['polarisation_frame'])
    data = numpy.array(f['data'])
    vis = Visibility(data=data, polarisation_frame=polarisation_frame,
                     phasecentre=phasecentre)
    vis.configuration = convert_configuration_from_hdf(f)
    return vis
コード例 #3
0
def visibility_gather(visibility_list: List[Visibility],
                      vis: Visibility,
                      vis_iter,
                      vis_slices=None) -> Visibility:
    """Gather a list of subvisibilities back into a visibility
    
    The iterator setup must be the same as used in the scatter.

    :param visibility_list: List of subvisibilities
    :param vis: Output visibility
    :param vis_iter: visibility iterator
    :param vis_slices: Number of slices to be gathered (optional)
    :return: vis
    """

    if vis_slices == 1:
        return visibility_list[0]

    if vis_slices is None:
        vis_slices = len(visibility_list)

    rowses = []
    for i, rows in enumerate(vis_iter(vis, vis_slices=vis_slices)):
        rowses.append(rows)

    for i, rows in enumerate(rowses):
        assert i < len(visibility_list
                       ), "Gather not consistent with scatter for slice %d" % i
        if visibility_list[i] is not None and numpy.sum(rows):
            assert numpy.sum(rows) == visibility_list[i].nvis, \
                "Mismatch in number of rows (%d, %d) in gather for slice %d" % \
            (numpy.sum(rows), visibility_list[i].nvis, i)
            vis.data[rows] = visibility_list[i].data[...]

    return vis
コード例 #4
0
def weight_visibility(vis: Visibility, im: Image, **kwargs) -> Visibility:
    """ Reweight the visibility data using a selected algorithm

    Imaging uses the column "imaging_weight" when imaging. This function sets that column using a
    variety of algorithms
    
    Options are:
        - Natural: by visibility weight (optimum for noise in final image)
        - Uniform: weight of sample divided by sum of weights in cell (optimum for sidelobes)
        - Super-uniform: As uniform, by sum of weights is over extended box region
        - Briggs: Compromise between natural and uniform
        - Super-briggs: As Briggs, by sum of weights is over extended box region

    :param vis:
    :param im:
    :return: visibility with imaging_weights column added and filled
    """
    assert isinstance(vis, Visibility), "vis is not a Visibility: %r" % vis

    assert get_parameter(kwargs, "padding", False) is False
    spectral_mode, vfrequencymap = get_frequency_map(vis, im)
    polarisation_mode, vpolarisationmap = get_polarisation_map(vis, im)
    uvw_mode, shape, padding, vuvwmap = get_uvw_map(vis, im)

    density = None
    densitygrid = None

    weighting = get_parameter(kwargs, "weighting", "uniform")
    vis.data['imaging_weight'], density, densitygrid = weight_gridding(
        im.data.shape, vis.data['weight'], vuvwmap, vfrequencymap,
        vpolarisationmap, weighting)

    return vis, density, densitygrid
コード例 #5
0
def shift_vis_to_image(vis: Visibility, im: Image, tangent: bool = True, inverse: bool = False) \
        -> Visibility:
    """Shift visibility to the FFT phase centre of the image in place

    :param vis: Visibility data
    :param im: Image model used to determine phase centre
    :param tangent: Is the shift purely on the tangent plane True|False
    :param inverse: Do the inverse operation True|False
    :return: visibility with phase shift applied and phasecentre updated

    """
    assert isinstance(vis, Visibility), "vis is not a Visibility: %r" % vis
    
    nchan, npol, ny, nx = im.data.shape
    
    # Convert the FFT definition of the phase center to world coordinates (1 relative)
    # This is the only place in ARL where the relationship between the image and visibility
    # frames is defined.
    
    image_phasecentre = pixel_to_skycoord(nx // 2 + 1, ny // 2 + 1, im.wcs, origin=1)
    if vis.phasecentre.separation(image_phasecentre).rad > 1e-15:
        if inverse:
            log.debug("shift_vis_from_image: shifting phasecentre from image phase centre %s to visibility phasecentre "
                      "%s" % (image_phasecentre, vis.phasecentre))
        else:
            log.debug("shift_vis_from_image: shifting phasecentre from vis phasecentre %s to image phasecentre %s" %
                      (vis.phasecentre, image_phasecentre))
        vis = phaserotate_visibility(vis, image_phasecentre, tangent=tangent, inverse=inverse)
        vis.phasecentre = im.phasecentre
    
    assert isinstance(vis, Visibility), "after phase_rotation, vis is not a Visibility"
    
    return vis
コード例 #6
0
def taper_visibility_tukey(vis: Visibility, tukey=0.1) -> Visibility:
    """ Taper the visibility weights
    
    This algorithm is present in WSClean.

    See https://sourceforge.net/p/wsclean/wiki/Tapering

    tukey, a circular taper that smooths the outer edge set by -maxuv-l
    inner-tukey, a circular taper that smooths the inner edge set by -minuv-l
    edge-tukey, a square-shaped taper that smooths the edge set by the uv grid and -taper-edge.

    These are cumulative. If You can reset the imaging_weights
    using :py:mod:`processing_library.imaging.weighting.weight_visibility`

    :param vis: Visibility with imaging_weight's to be tapered
    :return: visibility with imaging_weight column modified
    """

    assert isinstance(vis, Visibility), vis

    uvdist = numpy.sqrt(vis.u**2 + vis.v**2)
    uvdistmax = numpy.max(uvdist)
    uvdist /= uvdistmax
    wt = numpy.array([tukey_filter(uv, tukey) for uv in uvdist])
    vis.data['imaging_weight'][:, :] = vis.imaging_weight[:, :] * wt[:, numpy.
                                                                     newaxis]

    return vis
コード例 #7
0
def coalesce_visibility(vis: BlockVisibility, **kwargs) -> Visibility:
    """ Coalesce the BlockVisibility data_models. The output format is a Visibility, as needed for imaging

    Coalesce by baseline-dependent averaging (optional). The number of integrations averaged goes as the ratio of the
    maximum possible baseline length to that for this baseline. This number can be scaled by coalescence_factor and
    limited by max_coalescence.

    When faceting, the coalescence factors should be roughly the same as the number of facets on one axis.

    If coalescence_factor=0.0 then just a format conversion is done

    :param vis: BlockVisibility to be coalesced
    :return: Coalesced visibility with  cindex and blockvis filled in
    """

    assert isinstance(
        vis, BlockVisibility), "vis is not a BlockVisibility: %r" % vis

    time_coal = get_parameter(kwargs, 'time_coal', 0.0)
    max_time_coal = get_parameter(kwargs, 'max_time_coal', 100)
    frequency_coal = get_parameter(kwargs, 'frequency_coal', 0.0)
    max_frequency_coal = get_parameter(kwargs, 'max_frequency_coal', 100)

    if time_coal == 0.0 and frequency_coal == 0.0:
        return convert_blockvisibility_to_visibility((vis))

    cvis, cuvw, cwts, cimwt, ctime, cfrequency, cchannel_bandwidth, ca1, ca2, cintegration_time, cindex \
        = average_in_blocks(vis.data['vis'], vis.data['uvw'], vis.data['weight'], vis.data['imaging_weight'],
                            vis.time, vis.integration_time,
                            vis.frequency, vis.channel_bandwidth, time_coal, max_time_coal,
                            frequency_coal, max_frequency_coal)
    coalesced_vis = Visibility(uvw=cuvw,
                               time=ctime,
                               frequency=cfrequency,
                               channel_bandwidth=cchannel_bandwidth,
                               phasecentre=vis.phasecentre,
                               antenna1=ca1,
                               antenna2=ca2,
                               vis=cvis,
                               weight=cwts,
                               imaging_weight=cimwt,
                               configuration=vis.configuration,
                               integration_time=cintegration_time,
                               polarisation_frame=vis.polarisation_frame,
                               cindex=cindex,
                               blockvis=vis,
                               meta=vis.meta)

    log.debug(
        'coalesce_visibility: Created new Visibility for coalesced data_models, coalescence factors (t,f) = (%.3f,%.3f)'
        % (time_coal, frequency_coal))
    log.debug('coalesce_visibility: Maximum coalescence (t,f) = (%d, %d)' %
              (max_time_coal, max_frequency_coal))
    log.debug('coalesce_visibility: Original %s, coalesced %s' %
              (vis_summary(vis), vis_summary(coalesced_vis)))

    return coalesced_vis
コード例 #8
0
def helper_create_visibility_object(c_vis):
    # This may be incorrect
    # especially the data field...
    tvis = Visibility(data=c_vis,
                      frequency=c_vis['frequency'],
                      channel_bandwidth=c_vis['channel_bandwidth'],
                      integration_time=c_vis['integration_time'],
                      antenna1=c_vis['antenna1'],
                      antenna2=c_vis['antenna2'],
                      weight=c_vis['weight'],
                      imaging_weight=c_vis['imaging_weight'],
                      uvw=c_vis['uvw'],
                      time=c_vis['time'])
    return tvis
コード例 #9
0
def convert_visibility_to_stokesI(vis):
    """Convert the polarisation frame data into Stokes I dropping other polarisations, return new Visibility

    Args:
    vis (obj): ARL visibility data.

    Returns:
    vis: New, converted visibility data.
    """
    polarisation_frame = PolarisationFrame('stokesI')
    poldef = vis.polarisation_frame
    if poldef == PolarisationFrame('linear'):
        vis_data = convert_linear_to_stokesI(vis.data['vis'])
        vis_weight = (vis.weight[..., 0] + vis.weight[..., 3])[...,
                                                               numpy.newaxis]
        vis_imaging_weight = (vis.imaging_weight[..., 0] +
                              vis.imaging_weight[..., 3])[..., numpy.newaxis]
    elif poldef == PolarisationFrame('circular'):
        vis_data = convert_circular_to_stokesI(vis.data['vis'])
        vis_weight = (vis.weight[..., 0] + vis.weight[..., 3])[...,
                                                               numpy.newaxis]
        vis_imaging_weight = (vis.imaging_weight[..., 0] +
                              vis.imaging_weight[..., 3])[..., numpy.newaxis]
    else:
        raise NameError("Polarisation frame %s unknown" % poldef)

    return Visibility(frequency=vis.frequency,
                      channel_bandwidth=vis.channel_bandwidth,
                      phasecentre=vis.phasecentre,
                      configuration=vis.configuration,
                      uvw=vis.uvw,
                      time=vis.time,
                      antenna1=vis.antenna1,
                      antenna2=vis.antenna2,
                      vis=vis_data,
                      weight=vis_weight,
                      imaging_weight=vis_imaging_weight,
                      integration_time=vis.integration_time,
                      polarisation_frame=polarisation_frame,
                      cindex=vis.cindex,
                      blockvis=vis.blockvis,
                      source=vis.source,
                      meta=vis.meta)
コード例 #10
0
def visibility_gather_channel(vis_list: List[Visibility], vis: Visibility = None):
    """ Gather a visibility by channel
    
    :param vis_list:
    :param vis:
    :return:
    """
    
    cols = ['vis', 'weight']
    
    if vis is None:

        vis_shape = numpy.array(vis_list[0].vis.shape)
        vis_shape[-2] = len(vis_list)
        for v in vis_list:
            assert len(v.frequency) == 1
            assert len(v.channel_bandwidth) == 1
        vis = BlockVisibility(data=None,
                              frequency=numpy.array([v.frequency[0] for v in vis_list]),
                              channel_bandwidth=numpy.array([v.channel_bandwidth[0] for v in vis_list]),
                              phasecentre=vis_list[0].phasecentre,
                              configuration=vis_list[0].configuration,
                              uvw=vis_list[0].uvw,
                              time=vis_list[0].time,
                              vis=numpy.zeros(vis_shape, dtype=vis_list[0].vis.dtype),
                              weight=numpy.ones(vis_shape, dtype=vis_list[0].weight.dtype),
                              integration_time=vis_list[0].integration_time,
                              polarisation_frame=vis_list[0].polarisation_frame)
    
    assert len(vis.frequency) == len(vis_list)
    
    for chan, _ in enumerate(vis_list):
        subvis = vis_list[chan]
        assert abs(subvis.frequency[0] - vis.frequency[chan]) < 1e-15
        for col in cols:
            vis.data[col][..., chan, :] = subvis.data[col][..., 0, :]
        vis.frequency[chan] = subvis.frequency[0]
        
    nchan = vis.vis.shape[-2]
    assert nchan == len(vis.frequency)
    
    return vis
コード例 #11
0
def taper_visibility_gaussian(vis: Visibility, beam=None) -> Visibility:
    """ Taper the visibility weights

    These are cumulative. If You can reset the imaging_weights
    using :py:mod:`processing_library.imaging.weighting.weight_visibility`

    :param vis: Visibility with imaging_weight's to be tapered
    :param beam: desired resolution (Full width half maximum, radians)
    :return: visibility with imaging_weight column modified
    """
    assert isinstance(vis, Visibility), vis

    if beam is None:
        raise ValueError("Beam size not specified for Gaussian taper")
    uvdistsq = vis.u**2 + vis.v**2
    # See http://mathworld.wolfram.com/FourierTransformGaussian.html
    scale_factor = numpy.pi**2 * beam**2 / (4.0 * numpy.log(2.0))
    prior = vis.imaging_weight[:, :]
    wt = numpy.exp(-scale_factor * uvdistsq)
    vis.data['imaging_weight'][:, :] = vis.imaging_weight[:, :] * wt[:, numpy.
                                                                     newaxis]

    return vis
コード例 #12
0
def import_visibility_from_oskar(oskar_file: str) -> Visibility:
    """ Import a visibility set from an OSKAR visibility file

    :param oskar_file: Name of OSKAR visibility file
    :returns: Visibility
    """
    
    # Extract data from Oskar file
    oskar_vis = OskarVis(oskar_file)
    ra, dec = oskar_vis.phase_centre()
    a1, a2 = oskar_vis.stations(flatten=True)
    
    # Make configuration
    location = EarthLocation(lon=oskar_vis.telescope_lon,
                             lat=oskar_vis.telescope_lat,
                             height=oskar_vis.telescope_alt)
    antxyz = numpy.transpose([oskar_vis.station_x,
                              oskar_vis.station_y,
                              oskar_vis.station_z])
    config = Configuration(
        name=oskar_vis.telescope_path,
        location=location,
        xyz=antxyz
    )
    
    # Construct visibilities
    return Visibility(
        frequency=[oskar_vis.frequency(i) for i in range(oskar_vis.num_channels)],
        phasecentre=SkyCoord(frame=ICRS, ra=ra, dec=dec, unit=u.deg),
        configuration=config,
        uvw=numpy.transpose(oskar_vis.uvw(flatten=True)),
        time=oskar_vis.times(flatten=True),
        antenna1=a1,
        antenna2=a2,
        vis=oskar_vis.amplitudes(flatten=True),
        weight=numpy.ones(a1.shape))
コード例 #13
0
def create_visibility(config: Configuration,
                      times: numpy.array,
                      frequency: numpy.array,
                      channel_bandwidth,
                      phasecentre: SkyCoord,
                      weight: float,
                      polarisation_frame=PolarisationFrame('stokesI'),
                      integration_time=1.0,
                      zerow=False) -> Visibility:
    """ Create a Visibility from Configuration, hour angles, and direction of source

    Note that we keep track of the integration time for BDA purposes

    :param config: Configuration of antennas
    :param times: hour angles in radians
    :param frequency: frequencies (Hz] [nchan]
    :param weight: weight of a single sample
    :param phasecentre: phasecentre of observation
    :param channel_bandwidth: channel bandwidths: (Hz] [nchan]
    :param integration_time: Integration time ('auto' or value in s)
    :param polarisation_frame: PolarisationFrame('stokesI')
    :return: Visibility
    """
    assert phasecentre is not None, "Must specify phase centre"

    if polarisation_frame is None:
        polarisation_frame = correlate_polarisation(config.receptor_frame)

    nch = len(frequency)
    ants_xyz = config.data['xyz']
    nants = len(config.data['names'])
    nbaselines = int(nants * (nants - 1) / 2)
    ntimes = len(times)
    npol = polarisation_frame.npol
    nrows = nbaselines * ntimes * nch
    nrowsperintegration = nbaselines * nch
    row = 0
    rvis = numpy.zeros([nrows, npol], dtype='complex')
    rweight = weight * numpy.ones([nrows, npol])
    rtimes = numpy.zeros([nrows])
    rfrequency = numpy.zeros([nrows])
    rchannel_bandwidth = numpy.zeros([nrows])
    rantenna1 = numpy.zeros([nrows], dtype='int')
    rantenna2 = numpy.zeros([nrows], dtype='int')
    ruvw = numpy.zeros([nrows, 3])

    # Do each hour angle in turn
    for iha, ha in enumerate(times):

        # Calculate the positions of the antennas as seen for this hour angle
        # and declination
        ant_pos = xyz_to_uvw(ants_xyz, ha, phasecentre.dec.rad)
        rtimes[row:row + nrowsperintegration] = ha * 43200.0 / numpy.pi

        # Loop over all pairs of antennas. Note that a2>a1
        for a1 in range(nants):
            for a2 in range(a1 + 1, nants):
                rantenna1[row:row + nch] = a1
                rantenna2[row:row + nch] = a2

                # Loop over all frequencies and polarisations
                for ch in range(nch):
                    # noinspection PyUnresolvedReferences
                    k = frequency[ch] / constants.c.value
                    ruvw[row, :] = (ant_pos[a2, :] - ant_pos[a1, :]) * k
                    rfrequency[row] = frequency[ch]
                    rchannel_bandwidth[row] = channel_bandwidth[ch]
                    row += 1

    if zerow:
        ruvw[..., 2] = 0.0
    assert row == nrows
    rintegration_time = numpy.full_like(rtimes, integration_time)
    vis = Visibility(uvw=ruvw,
                     time=rtimes,
                     antenna1=rantenna1,
                     antenna2=rantenna2,
                     frequency=rfrequency,
                     vis=rvis,
                     weight=rweight,
                     imaging_weight=rweight,
                     integration_time=rintegration_time,
                     channel_bandwidth=rchannel_bandwidth,
                     polarisation_frame=polarisation_frame)
    vis.phasecentre = phasecentre
    vis.configuration = config
    log.info("create_visibility: %s" % (vis_summary(vis)))
    assert isinstance(vis, Visibility), "vis is not a Visibility: %r" % vis
    return vis
コード例 #14
0
def create_visibility_from_ms(msname, channum=0, ack=False):
    """ Minimal MS to Visibility converter

    The MS format is much more general than the ARL Visibility so we cut many corners. This requires casacore to be
    installed. If not an exception ModuleNotFoundError is raised.

    Creates a list of Visibilities, one per phasecentre
    """
    try:
        from casacore.tables import table  # pylint: disable=import-error
    except ModuleNotFoundError:
        raise ModuleNotFoundError("casacore is not installed")

    tab = table(msname, ack=ack)
    log.debug("create_visibility_from_ms: %s" % str(tab.info()))
    fields = numpy.unique(tab.getcol('FIELD_ID'))
    log.debug("create_visibility_from_ms: Found unique field ids %s" %
              str(fields))
    vis_list = list()
    for field in fields:
        # First get the main table information
        ms = tab.query("FIELD_ID==%d" % field)
        log.debug("create_visibility_from_ms: Found %d rows for field %d" %
                  (ms.nrows(), field))
        time = ms.getcol('TIME')
        channels = len(numpy.transpose(ms.getcol('DATA'))[0])
        log.debug("create_visibility_from_ms: Found %d channels" % (channels))
        try:
            vis = ms.getcol('DATA')[:, channum, :]
        except IndexError:
            raise IndexError("channel number exceeds max. within ms")
        weight = ms.getcol('WEIGHT')
        uvw = -1 * ms.getcol('UVW')
        antenna1 = ms.getcol('ANTENNA1')
        antenna2 = ms.getcol('ANTENNA2')
        integration_time = ms.getcol('INTERVAL')
        ddid = ms.getcol('DATA_DESC_ID')

        # Now get info from the subtables
        spwtab = table('%s/SPECTRAL_WINDOW' % msname, ack=False)
        cfrequency = spwtab.getcol('CHAN_FREQ')
        frequency = numpy.array([cfrequency[dd] for dd in ddid])[:, channum]
        cchannel_bandwidth = spwtab.getcol('CHAN_WIDTH')
        channel_bandwidth = numpy.array(
            [cchannel_bandwidth[dd] for dd in ddid])[:, 0]

        uvw *= frequency[:, numpy.newaxis] / constants.c.to('m s^-1').value

        # Get polarisation info
        poltab = table('%s/POLARIZATION' % msname, ack=False)
        corr_type = poltab.getcol('CORR_TYPE')
        # These correspond to the CASA Stokes enumerations
        if numpy.array_equal(corr_type[0], [1, 2, 3, 4]):
            polarisation_frame = PolarisationFrame('stokesIQUV')
        elif numpy.array_equal(corr_type[0], [5, 6, 7, 8]):
            polarisation_frame = PolarisationFrame('circular')
        elif numpy.array_equal(corr_type[0], [9, 10, 11, 12]):
            polarisation_frame = PolarisationFrame('linear')
        else:
            raise KeyError("Polarisation not understood: %s" % str(corr_type))

        print("create_visibility_from_ms: polarisation %s" %
              polarisation_frame.type)

        # Get configuration
        anttab = table('%s/ANTENNA' % msname, ack=False)
        mount = anttab.getcol('MOUNT')
        names = anttab.getcol('NAME')
        diameter = anttab.getcol('DISH_DIAMETER')
        xyz = anttab.getcol('POSITION')
        configuration = Configuration(name='',
                                      data=None,
                                      location=None,
                                      names=names,
                                      xyz=xyz,
                                      mount=mount,
                                      frame=None,
                                      receptor_frame=ReceptorFrame("linear"),
                                      diameter=diameter)

        # Get phasecentres
        fieldtab = table('%s/FIELD' % msname, ack=False)
        pc = fieldtab.getcol('PHASE_DIR')[field, 0, :]
        phasecentre = SkyCoord(ra=[pc[0]] * u.rad,
                               dec=pc[1] * u.rad,
                               frame='icrs',
                               equinox='J2000')

        vis_list.append(
            Visibility(uvw=uvw,
                       time=time,
                       antenna1=antenna1,
                       antenna2=antenna2,
                       frequency=frequency,
                       vis=vis,
                       weight=weight,
                       imaging_weight=weight,
                       integration_time=integration_time,
                       channel_bandwidth=channel_bandwidth,
                       configuration=configuration,
                       phasecentre=phasecentre,
                       polarisation_frame=polarisation_frame))
    return vis_list
コード例 #15
0
def create_visibility_from_ms_maps(msname, poldef):
    """ Minimal MS to Visibility converter
        
        The MS format is much more general than the ARL Visibility so we cut many corners. This requires casacore to be
        installed. If not an exception ModuleNotFoundError is raised.
        
        Creates a list of Visibilities, one per phasecentre
    """
    
    try:
        from casacore.tables import table  # pylint: disable=import-error
    except ModuleNotFoundError:
        raise ModuleNotFoundError("casacore is not installed")
    
    tab = table(msname)
    print(tab.info())
    fields = numpy.unique(tab.getcol('FIELD_ID'))
    print("Found unique field ids %s" % fields)

    # for field in fields:
    # First get the main table information
    ms = tab.query("FIELD_ID==%d" % fields[0])
    print("Found %d rows for field %d" % (ms.nrows(), fields[0]))
    time = ms.getcol('TIME')
    weight = ms.getcol('WEIGHT')
    uvw = -1 * ms.getcol('UVW')
    antenna1 = ms.getcol('ANTENNA1')
    antenna2 = ms.getcol('ANTENNA2')
    integration_time = ms.getcol('INTERVAL')
    ddid = ms.getcol('DATA_DESC_ID')

    # Get polarisation info
    # poltab = table('%s/POLARIZATION' % msname, ack=False)
    # corr_type = poltab.getcol('CORR_TYPE')
    # TODO: Do interpretation correctly
    # polarisation_frame = PolarisationFrame('stokesIQUV')
    # Set the polarisation frame:
    if poldef == 'lin':
        polarisation_frame = PolarisationFrame('linear')
    if poldef == 'circ':
        polarisation_frame = PolarisationFrame('circular')

    # Get configuration
    anttab = table('%s/ANTENNA' % msname, ack=False)
    mount = anttab.getcol('MOUNT')
    names = anttab.getcol('NAME')
    diameter = anttab.getcol('DISH_DIAMETER')
    xyz = anttab.getcol('POSITION')
    configuration = Configuration(name='', data=None, location=None, names=names, xyz=xyz, mount=mount, frame=None, receptor_frame=ReceptorFrame("linear"), diameter=diameter)
    # Get phasecentres
    fieldtab = table('%s/FIELD' % msname, ack=False)
    pc = fieldtab.getcol('PHASE_DIR')[fields[0], 0, :]
    print(pc[0], pc[1])
    phasecentre = SkyCoord(ra=[pc[0]] * u.rad, dec=pc[1] * u.rad, frame='icrs', equinox='J2000')
    
    channels = len(numpy.transpose(ms.getcol('DATA'))[0])
    print("Found %d channels" % (channels))
    
    spwtab = table('%s/SPECTRAL_WINDOW' % msname, ack=False)
    cfrequency = spwtab.getcol('CHAN_FREQ')
    
    cchannel_bandwidth = spwtab.getcol('CHAN_WIDTH')
    channel_bandwidth = numpy.array([cchannel_bandwidth[dd] for dd in ddid])[:, 0]

    # Now get info from the subtables
    maps_data = list()
    for channum in range(channels):
        try:
            vis = ms.getcol('DATA')[:, channum, :]
        except IndexError:
            raise IndexError("channel number exceeds max. within ms")
    
        frequency = numpy.array([cfrequency[dd] for dd in ddid])[:, channum]
        uvw *= frequency[:, numpy.newaxis] / constants.c.to('m/s').value
        
        vis_list = Visibility(uvw=uvw, time=time, antenna1=antenna1, antenna2=antenna2,
                              frequency=frequency, vis=vis,
                              weight=weight, imaging_weight=weight,
                              integration_time=integration_time,
                              channel_bandwidth=channel_bandwidth,
                              configuration=configuration,
                              phasecentre=phasecentre,
                              polarisation_frame=polarisation_frame)

        maps_data.append(vis_list)

    return maps_data