def test_coalesce_decoalesce_with_iter(self): for rows in vis_timeslice_iter(self.blockvis): visslice = create_visibility_from_rows(self.blockvis, rows) cvisslice = convert_blockvisibility_to_visibility(visslice) assert numpy.min(cvisslice.frequency) == numpy.min(self.frequency) assert numpy.min(cvisslice.frequency) > 0.0 dvisslice = decoalesce_visibility(cvisslice) assert dvisslice.nvis == visslice.nvis
def test_vis_timeslice_iterator(self): self.actualSetUp() nchunks = vis_timeslices(self.vis, timeslice='auto') log.debug('Found %d chunks' % (nchunks)) assert nchunks > 1 total_rows = 0 for chunk, rows in enumerate(vis_timeslice_iter(self.vis, nchunks)): visslice = create_visibility_from_rows(self.vis, rows) total_rows += visslice.nvis assert visslice.vis[0].real == visslice.time[0] assert len(rows) assert numpy.sum(rows) < self.vis.nvis assert total_rows == self.vis.nvis, "Total rows iterated %d, Original rows %d" % (total_rows, self.vis.nvis)
def create_gaintable_from_screen(vis, sc, screen, height=3e5, vis_slices=None, scale=1.0, **kwargs): """ Create gaintables from a screen calculated using ARatmospy Screen axes are ['XX', 'YY', 'TIME', 'FREQ'] :param vis: :param sc: Sky components for which pierce points are needed :param screen: :param height: Height (in m) of screen above telescope e.g. 3e5 :param scale: Multiply the screen by this factor :return: """ assert isinstance(vis, BlockVisibility) station_locations = vis.configuration.xyz # Convert to TEC # phase = image[pixel] * -8.44797245e9 / frequency nant = station_locations.shape[0] t2r = numpy.pi / 43200.0 gaintables = [ create_gaintable_from_blockvisibility(vis, **kwargs) for i in sc ] # The time in the Visibility is hour angle in seconds! for iha, rows in enumerate(vis_timeslice_iter(vis, vis_slices=vis_slices)): v = create_visibility_from_rows(vis, rows) ha = numpy.average(v.time) tec2phase = -8.44797245e9 / numpy.array(vis.frequency) number_bad = 0 number_good = 0 for icomp, comp in enumerate(sc): pp = find_pierce_points(station_locations, (comp.direction.ra.rad + t2r * ha) * u.rad, comp.direction.dec, height=height, phasecentre=vis.phasecentre) scr = numpy.zeros([nant]) for ant in range(nant): pp0 = pp[ant][0:2] worldloc = [pp0[0], pp0[1], ha, 1e8] try: pixloc = screen.wcs.wcs_world2pix([worldloc], 0)[0].astype('int') scr[ant] = scale * screen.data[pixloc[3], pixloc[2], pixloc[1], pixloc[0]] number_good += 1 except: number_bad += 1 scr[ant] = 0.0 scr = scr[:, numpy.newaxis] * tec2phase[numpy.newaxis, :] # axes of gaintable.gain are time, ant, nchan, nrec gaintables[icomp].gain[iha, :, :, :] = numpy.exp( 1j * scr[..., numpy.newaxis, numpy.newaxis]) gaintables[icomp].phasecentre = comp.direction if number_bad > 0: log.warning( "create_gaintable_from_screen: %d pierce points are inside the screen image" % (number_good)) log.warning( "create_gaintable_from_screen: %d pierce points are outside the screen image" % (number_bad)) return gaintables
def apply_gaintable(vis: BlockVisibility, gt: GainTable, inverse=False, vis_slices=None, **kwargs) -> BlockVisibility: """Apply a gain table to a block visibility The corrected visibility is:: V_corrected = {g_i * g_j^*}^-1 V_obs If the visibility data are polarised e.g. polarisation_frame("linear") then the inverse operator represents an actual inverse of the gains. :param vis: Visibility to have gains applied :param gt: Gaintable to be applied :param inverse: Apply the inverse (default=False) :return: input vis with gains applied """ assert isinstance( vis, BlockVisibility), "vis is not a BlockVisibility: %r" % vis assert isinstance(gt, GainTable), "gt is not a GainTable: %r" % gt assert_vis_gt_compatible(vis, gt) if inverse: log.debug('apply_gaintable: Apply inverse gaintable') else: log.debug('apply_gaintable: Apply gaintable') is_scalar = gt.gain.shape[-2:] == (1, 1) if is_scalar: log.debug('apply_gaintable: scalar gains') for chunk, rows in enumerate(vis_timeslice_iter(vis, vis_slices=vis_slices)): if numpy.sum(rows) > 0: vistime = numpy.average(vis.time[rows]) gaintable_rows = abs(gt.time - vistime) < gt.interval / 2.0 # Lookup the gain for this set of visibilities gain = gt.data['gain'][gaintable_rows] gainwt = gt.data['weight'][gaintable_rows] # The shape of the mueller matrix is ntimes, nant, nchan, nrec, _ = gain.shape original = vis.vis[rows] originalwt = vis.weight[rows] applied = copy.deepcopy(original) appliedwt = copy.deepcopy(originalwt) for time in range(ntimes): antantwt = numpy.outer(gainwt, gainwt) if is_scalar: if inverse: lgain = numpy.ones_like(gain) lgain[numpy.abs(gain) > 0.0] = 1.0 / gain[numpy.abs(gain) > 0.0] else: lgain = gain clgain = numpy.conjugate(lgain) for chan in range(nchan): smueller = numpy.ma.outer( lgain[time, :, chan, 0], clgain[time, :, chan, 0]).reshape([nant, nant]) applied[time, :, :, chan, 0] = original[time, :, :, chan, 0] * smueller antantwt = numpy.outer(gainwt[time, :, chan, 0, 0], gainwt[time, :, chan, 0, 0]) applied[time, :, :, chan, 0][antantwt == 0.0] = 0.0 appliedwt[time, :, :, chan, 0][antantwt == 0.0] = 0.0 else: for a1 in range(vis.nants - 1): for a2 in range(a1 + 1, vis.nants): for chan in range(nchan): mueller = numpy.kron( gain[time, a1, chan, :, :], numpy.conjugate(gain[time, a2, chan, :, :])) if inverse: # If the Mueller is singular, ignore it try: mueller = numpy.linalg.inv(mueller) applied[time, a2, a1, chan, :] = \ numpy.matmul(mueller, original[time, a2, a1, chan, :]) except numpy.linalg.linalg.LinAlgError: applied[time, a2, a1, chan, :] = \ original[time, a2, a1, chan, :] else: applied[time, a2, a1, chan, :] = \ numpy.matmul(mueller, original[time, a2, a1, chan, :]) if (gainwt[time, a1, chan, 0, 0] <= 0.0) or ( gainwt[time, a1, chan, 0, 0] <= 0.0): applied[time, a2, a1, chan, 0] = 0.0 appliedwt[time, a2, a1, chan, 0] = 0.0 vis.data['vis'][rows] = applied return vis
def create_gaintable_from_screen(vis, sc, screen, height=3e5, vis_slices=None, scale=1.0, r0=5e3, type_atmosphere='ionosphere', **kwargs): """ Create gaintables from a screen calculated using ARatmospy Screen axes are ['XX', 'YY', 'TIME', 'FREQ'] :param vis: :param sc: Sky components for which pierce points are needed :param screen: :param height: Height (in m) of screen above telescope e.g. 3e5 :param r0: r0 in meters :param type_atmosphere: 'ionosphere' or 'troposphere' :param scale: Multiply the screen by this factor :return: """ assert isinstance(vis, BlockVisibility) station_locations = vis.configuration.xyz scale = numpy.power(r0 / 5000.0, -5.0 / 3.0) if type_atmosphere == 'troposphere': # In troposphere files, the units are phase in radians. screen_to_phase = scale else: # In the ionosphere file, the units are dTEC. screen_to_phase = -scale * 8.44797245e9 / numpy.array(vis.frequency) nant = station_locations.shape[0] t2r = numpy.pi / 43200.0 gaintables = [ create_gaintable_from_blockvisibility(vis, **kwargs) for i in sc ] number_bad = 0 number_good = 0 ha_zero = numpy.average(calculate_blockvisibility_hourangles(vis)) for iha, rows in enumerate(vis_timeslice_iter(vis, vis_slices=vis_slices)): v = create_visibility_from_rows(vis, rows) ha = numpy.average(calculate_blockvisibility_hourangles(v) - ha_zero).to('rad').value for icomp, comp in enumerate(sc): pp = find_pierce_points(station_locations, (comp.direction.ra.rad + t2r * ha) * units.rad, comp.direction.dec, height=height, phasecentre=vis.phasecentre) scr = numpy.zeros([nant]) for ant in range(nant): pp0 = pp[ant][0:2] # Using narrow band approach - we should loop over frequency try: worldloc = [ pp0[0], pp0[1], ha, numpy.average(vis.frequency) ] pixloc = screen.wcs.wcs_world2pix([worldloc], 0)[0].astype('int') if type_atmosphere == 'troposphere': pixloc[3] = 0 scr[ant] = screen_to_phase * screen.data[ pixloc[3], pixloc[2], pixloc[1], pixloc[0]] number_good += 1 except (ValueError, IndexError): number_bad += 1 scr[ant] = 0.0 # axes of gaintable.gain are time, ant, nchan, nrec gaintables[icomp].gain[iha, :, :, :] = numpy.exp( 1j * scr)[..., numpy.newaxis, numpy.newaxis, numpy.newaxis] gaintables[icomp].phasecentre = comp.direction assert number_good > 0, "create_gaintable_from_screen: There are no pierce points inside the atmospheric screen image" if number_bad > 0: log.warning( "create_gaintable_from_screen: %d pierce points are inside the atmospheric screen image" % (number_good)) log.warning( "create_gaintable_from_screen: %d pierce points are outside the atmospheric screen image" % (number_bad)) return gaintables
def grid_gaintable_to_screen(vis, gaintables, screen, height=3e5, gaintable_slices=None, scale=1.0, r0=5e3, type_atmosphere='ionosphere', vis_slices=None, **kwargs): """ Grid a gaintable to a screen image Screen axes are ['XX', 'YY', 'TIME', 'FREQ'] The phases are just averaged per grid cell, no phase unwrapping is performed. :param vis: :param gaintables: input gaintables :param screen: :param height: Height (in m) of screen above telescope e.g. 3e5 :param r0: r0 in meters :param type_atmosphere: 'ionosphere' or 'troposphere' :param scale: Multiply the screen by this factor :return: gridded screen image, weights image """ assert isinstance(vis, BlockVisibility) station_locations = vis.configuration.xyz nant = station_locations.shape[0] t2r = numpy.pi / 43200.0 newscreen = create_empty_image_like(screen) weights = create_empty_image_like(screen) nchan, ntimes, ny, nx = screen.shape number_no_weight = 0 for gaintable in gaintables: ha_zero = numpy.average(calculate_blockvisibility_hourangles(vis)) for iha, rows in enumerate( vis_timeslice_iter(vis, vis_slices=vis_slices)): v = create_visibility_from_rows(vis, rows) ha = numpy.average( calculate_blockvisibility_hourangles(v) - ha_zero).to('rad').value pp = find_pierce_points(station_locations, (gaintable.phasecentre.ra.rad + t2r * ha) * units.rad, gaintable.phasecentre.dec, height=height, phasecentre=vis.phasecentre) scr = numpy.angle(gaintable.gain[0, :, 0, 0, 0]) wt = gaintable.weight[0, :, 0, 0, 0] for ant in range(nant): pp0 = pp[ant][0:2] for freq in vis.frequency: scale = numpy.power(r0 / 5000.0, -5.0 / 3.0) if type_atmosphere == 'troposphere': # In troposphere files, the units are phase in radians. screen_to_phase = scale else: # In the ionosphere file, the units are dTEC. screen_to_phase = -scale * 8.44797245e9 / freq worldloc = [pp0[0], pp0[1], ha, freq] pixloc = newscreen.wcs.wcs_world2pix([worldloc], 0)[0].astype('int') assert pixloc[0] >= 0 assert pixloc[0] < nx assert pixloc[1] >= 0 assert pixloc[1] < ny pixloc[3] = 0 newscreen.data[ pixloc[3], pixloc[2], pixloc[1], pixloc[0]] += wt[ant] * scr[ant] / screen_to_phase weights.data[pixloc[3], pixloc[2], pixloc[1], pixloc[0]] += wt[ant] if wt[ant] == 0.0: number_no_weight += 1 if number_no_weight > 0: log.warning( "grid_gaintable_to_screen: %d pierce points are have no weight" % (number_no_weight)) assert numpy.max(weights.data) > 0.0, "No points were gridded" newscreen.data[weights.data > 0.0] = newscreen.data[ weights.data > 0.0] / weights.data[weights.data > 0.0] return newscreen, weights
def simulate_gaintable_from_voltage_pattern(vis, sc, vp, vis_slices=None, scale=1.0, order=3, use_radec=False, elevation_limit=15.0 * numpy.pi / 180.0, **kwargs): """ Create gaintables from a list of components and voltagr patterns :param elevation_limit: :param use_radec: :param vis_slices: :param vis: :param sc: Sky components for which pierce points are needed :param vp: Voltage pattern in AZELGEO frame :param scale: Multiply the screen by this factor :param order: order of spline (default is 3) :return: """ nant = vis.vis.shape[1] gaintables = [ create_gaintable_from_blockvisibility(vis, **kwargs) for i in sc ] nchan, npol, ny, nx = vp.data.shape real_spline = [ RectBivariateSpline(range(ny), range(nx), vp.data[0, pol, ...].real, kx=order, ky=order) for pol in range(npol) ] imag_spline = [ RectBivariateSpline(range(ny), range(nx), vp.data[0, pol, ...].imag, kx=order, ky=order) for pol in range(npol) ] if not use_radec: assert isinstance(vis, BlockVisibility) assert vp.wcs.wcs.ctype[0] == 'AZELGEO long', vp.wcs.wcs.ctype[0] assert vp.wcs.wcs.ctype[1] == 'AZELGEO lati', vp.wcs.wcs.ctype[1] assert vis.configuration.mount[ 0] == 'azel', "Mount %s not supported yet" % vis.configuration.mount[ 0] number_bad = 0 number_good = 0 # For each hourangle, we need to calculate the location of a component # in AZELGEO. With that we can then look up the relevant gain from the # voltage pattern for iha, rows in enumerate( vis_timeslice_iter(vis, vis_slices=vis_slices)): v = create_visibility_from_rows(vis, rows) if v is not None: utc_time = Time([numpy.average(v.time) / 86400.0], format='mjd', scale='utc') azimuth_centre, elevation_centre = calculate_azel( v.configuration.location, utc_time, vis.phasecentre) azimuth_centre = azimuth_centre[0].to('deg').value elevation_centre = elevation_centre[0].to('deg').value # Calculate the az el for this time wcs_azel = vp.wcs.sub(2).deepcopy() for icomp, comp in enumerate(sc): if elevation_centre >= elevation_limit: antgain = numpy.zeros([nant, npol], dtype='complex') antwt = numpy.zeros([nant, npol]) # Calculate the azel of this component azimuth_comp, elevation_comp = calculate_azel( v.configuration.location, utc_time, comp.direction) cosel = numpy.cos(elevation_comp[0]).value azimuth_comp = azimuth_comp[0].to('deg').value elevation_comp = elevation_comp[0].to('deg').value if azimuth_comp - azimuth_centre > 180.0: azimuth_centre += 360.0 elif azimuth_comp - azimuth_centre < -180.0: azimuth_centre -= 360.0 try: worldloc = [[ (azimuth_comp - azimuth_centre) * cosel, elevation_comp - elevation_centre ]] # radius = numpy.sqrt(((azimuth_comp-azimuth_centre)*cosel)**2 + # (elevation_comp-elevation_centre)**2) pixloc = wcs_azel.wcs_world2pix(worldloc, 1)[0] assert pixloc[0] > 2 assert pixloc[0] < nx - 3 assert pixloc[1] > 2 assert pixloc[1] < ny - 3 for pol in range(npol): gain = real_spline[pol].ev(pixloc[1], pixloc[0]) \ + 1j * imag_spline[pol].ev(pixloc[1], pixloc[0]) antgain[:, pol] = gain for ant in range(nant): ag = antgain[ant, :].reshape([2, 2]) ag = numpy.linalg.inv(ag) antgain[ant, :] = ag.reshape([4]) number_good += 1 except (ValueError, AssertionError): number_bad += 1 antgain[...] = 0.0 antwt[...] = 0.0 gaintables[icomp].gain[ iha, :, :, :] = antgain[:, numpy.newaxis, :].reshape( [nant, nchan, 2, 2]) gaintables[icomp].weight[ iha, :, :, :] = antwt[:, numpy.newaxis, :].reshape( [nant, nchan, 2, 2]) gaintables[icomp].phasecentre = comp.direction else: gaintables[icomp].gain[...] = 1.0 + 0.0j gaintables[icomp].weight[iha, :, :, :] = 0.0 gaintables[icomp].phasecentre = comp.direction number_bad += nant else: assert isinstance(vis, BlockVisibility) assert vp.wcs.wcs.ctype[0] == 'RA---SIN', vp.wcs.wcs.ctype[0] assert vp.wcs.wcs.ctype[1] == 'DEC--SIN', vp.wcs.wcs.ctype[1] # The time in the Visibility is hour angle in seconds! number_bad = 0 number_good = 0 d2r = numpy.pi / 180.0 ra_centre = vp.wcs.wcs.crval[0] * d2r dec_centre = vp.wcs.wcs.crval[1] * d2r r2d = 180.0 / numpy.pi s2r = numpy.pi / 43200.0 # For each hourangle, we need to calculate the location of a component # in AZELGEO. With that we can then look up the relevant gain from the # voltage pattern for iha, rows in enumerate( vis_timeslice_iter(vis, vis_slices=vis_slices)): v = create_visibility_from_rows(vis, rows) ha = numpy.average(v.time) for icomp, comp in enumerate(sc): antgain = numpy.zeros([nant, npol], dtype='complex') antwt = numpy.zeros([nant, npol]) # Calculate the location of the component in AZELGEO, then add the pointing offset # for each antenna ra_comp = comp.direction.ra.rad dec_comp = comp.direction.dec.rad for ant in range(nant): wcs_azel = vp.wcs.deepcopy() ra_pointing = ra_centre * r2d dec_pointing = dec_centre * r2d # We use WCS sensible coordinate handling by labelling the axes misleadingly wcs_azel.wcs.crval[0] = ra_pointing wcs_azel.wcs.crval[1] = dec_pointing wcs_azel.wcs.ctype[0] = 'RA---SIN' wcs_azel.wcs.ctype[1] = 'DEC--SIN' for pol in range(npol): worldloc = [ ra_comp * r2d, dec_comp * r2d, vp.wcs.wcs.crval[2], vp.wcs.wcs.crval[3] ] try: pixloc = wcs_azel.sub(2).wcs_world2pix( [worldloc[:2]], 1)[0] assert pixloc[0] > 2 assert pixloc[0] < nx - 3 assert pixloc[1] > 2 assert pixloc[1] < ny - 3 gain = real_spline[pol].ev( pixloc[1], pixloc[0] ) + 1j * imag_spline[pol].ev(pixloc[1], pixloc[0]) if numpy.abs(gain) > 0.0: antgain[ant, pol] = 1.0 / (scale * gain) antwt[ant, pol] = 1.0 else: antgain[ant, pol] = 0.0 antwt[ant, pol] = 0.0 antwt[ant, pol] = 1.0 number_good += 1 except (ValueError, AssertionError): number_bad += 1 antgain[ant, pol] = 1e15 antwt[ant, pol] = 0.0 gaintables[icomp].gain[ iha, :, :, :] = antgain[:, numpy.newaxis, :].reshape( [nant, nchan, 2, 2]) gaintables[icomp].weight[ iha, :, :, :] = antwt[:, numpy.newaxis, :].reshape( [nant, nchan, 2, 2]) gaintables[icomp].phasecentre = comp.direction assert number_good > 0, "simulate_gaintable_from_voltage_pattern: No points inside the voltage pattern image" if number_bad > 0: log.warning( "simulate_gaintable_from_voltage_pattern: %d points are inside the voltage pattern image" % (number_good)) log.warning( "simulate_gaintable_from_voltage_pattern: %d points are outside the voltage pattern image" % (number_bad)) return gaintables
def simulate_gaintable_from_zernikes(vis, sc, vp_list, vp_coeffs, vis_slices=None, order=3, use_radec=False, elevation_limit=15.0 * numpy.pi / 180.0, **kwargs): """ Create gaintables for a set of zernikes :param vis: :param sc: Sky components for which pierce points are needed :param vp: List of Voltage patterns in AZELGEO frame :param vp_coeffs: Fractional contribution [nants, nvp] :param order: order of spline (default is 3) :return: """ ntimes, nant = vis.vis.shape[0:2] vp_coeffs = numpy.array(vp_coeffs) gaintables = [ create_gaintable_from_blockvisibility(vis, **kwargs) for i in sc ] if not use_radec: assert isinstance(vis, BlockVisibility) assert vis.configuration.mount[ 0] == 'azel', "Mount %s not supported yet" % vis.configuration.mount[ 0] # The time in the Visibility is hour angle in seconds! number_bad = 0 number_good = 0 # Cache the splines, one per voltage pattern real_splines = list() imag_splines = list() for ivp, vp in enumerate(vp_list): assert vp.wcs.wcs.ctype[0] == 'AZELGEO long', vp.wcs.wcs.ctype[0] assert vp.wcs.wcs.ctype[1] == 'AZELGEO lati', vp.wcs.wcs.ctype[1] nchan, npol, ny, nx = vp.data.shape real_splines.append( RectBivariateSpline(range(ny), range(nx), vp.data[0, 0, ...].real, kx=order, ky=order)) imag_splines.append( RectBivariateSpline(range(ny), range(nx), vp.data[0, 0, ...].imag, kx=order, ky=order)) latitude = vis.configuration.location.lat.rad r2d = 180.0 / numpy.pi s2r = numpy.pi / 43200.0 # For each hourangle, we need to calculate the location of a component # in AZELGEO. With that we can then look up the relevant gain from the # voltage pattern for iha, rows in enumerate( vis_timeslice_iter(vis, vis_slices=vis_slices)): v = create_visibility_from_rows(vis, rows) ha = numpy.average( calculate_blockvisibility_hourangles(v).to('rad').value) # Calculate the az el for this hourangle and the phasecentre declination utc_time = Time([numpy.average(v.time) / 86400.0], format='mjd', scale='utc') azimuth_centre, elevation_centre = calculate_azel( v.configuration.location, utc_time, vis.phasecentre) azimuth_centre = azimuth_centre[0].to('deg').value elevation_centre = elevation_centre[0].to('deg').value for icomp, comp in enumerate(sc): if elevation_centre >= elevation_limit: antgain = numpy.zeros([nant], dtype='complex') # Calculate the location of the component in AZELGEO, then add the pointing offset # for each antenna hacomp = comp.direction.ra.rad - vis.phasecentre.ra.rad + ha deccomp = comp.direction.dec.rad azimuth_comp, elevation_comp = hadec_to_azel( hacomp, deccomp, latitude) for ant in range(nant): for ivp, vp in enumerate(vp_list): nchan, npol, ny, nx = vp.data.shape wcs_azel = vp.wcs.deepcopy() # We use WCS sensible coordinate handling by labelling the axes misleadingly wcs_azel.wcs.crval[0] = azimuth_centre wcs_azel.wcs.crval[1] = elevation_centre wcs_azel.wcs.ctype[0] = 'RA---SIN' wcs_azel.wcs.ctype[1] = 'DEC--SIN' worldloc = [ azimuth_comp * r2d, elevation_comp * r2d, vp.wcs.wcs.crval[2], vp.wcs.wcs.crval[3] ] try: pixloc = wcs_azel.sub(2).wcs_world2pix( [worldloc[:2]], 1)[0] assert pixloc[0] > 2 assert pixloc[0] < nx - 3 assert pixloc[1] > 2 assert pixloc[1] < ny - 3 gain = real_splines[ivp].ev(pixloc[1], pixloc[0]) \ + 1j * imag_splines[ivp](pixloc[1], pixloc[0]) antgain[ant] += vp_coeffs[ant, ivp] * gain number_good += 1 except (ValueError, AssertionError): number_bad += 1 antgain[ant] = 1.0 antgain[ant] = 1.0 / antgain[ant] gaintables[icomp].gain[ iha, :, :, :] = antgain[:, numpy.newaxis, numpy.newaxis, numpy.newaxis] gaintables[icomp].phasecentre = comp.direction else: gaintables[icomp].gain[...] = 1.0 + 0.0j gaintables[icomp].phasecentre = comp.direction number_bad += nant else: assert isinstance(vis, BlockVisibility) number_bad = 0 number_good = 0 # Cache the splines, one per voltage pattern real_splines = list() imag_splines = list() for ivp, vp in enumerate(vp_list): nchan, npol, ny, nx = vp.data.shape real_splines.append( RectBivariateSpline(range(ny), range(nx), vp.data[0, 0, ...].real, kx=order, ky=order)) imag_splines.append( RectBivariateSpline(range(ny), range(nx), vp.data[0, 0, ...].imag, kx=order, ky=order)) for iha, rows in enumerate( vis_timeslice_iter(vis, vis_slices=vis_slices)): # The time in the Visibility is hour angle in seconds! r2d = 180.0 / numpy.pi # For each hourangle, we need to calculate the location of a component # in AZELGEO. With that we can then look up the relevant gain from the # voltage pattern v = create_visibility_from_rows(vis, rows) ha = numpy.average(calculate_blockvisibility_hourangles(v)) for icomp, comp in enumerate(sc): antgain = numpy.zeros([nant], dtype='complex') antwt = numpy.zeros([nant]) ra_comp = comp.direction.ra.rad dec_comp = comp.direction.dec.rad for ant in range(nant): for ivp, vp in enumerate(vp_list): assert vp.wcs.wcs.ctype[ 0] == 'RA---SIN', vp.wcs.wcs.ctype[0] assert vp.wcs.wcs.ctype[ 1] == 'DEC--SIN', vp.wcs.wcs.ctype[1] worldloc = [ ra_comp * r2d, dec_comp * r2d, vp.wcs.wcs.crval[2], vp.wcs.wcs.crval[3] ] nchan, npol, ny, nx = vp.data.shape try: pixloc = vp.wcs.sub(2).wcs_world2pix( [worldloc[:2]], 1)[0] assert pixloc[0] > 2 assert pixloc[0] < nx - 3 assert pixloc[1] > 2 assert pixloc[1] < ny - 3 gain = real_splines[ivp].ev(pixloc[1], pixloc[0]) \ + 1j * imag_splines[ivp](pixloc[1], pixloc[0]) antgain[ant] += vp_coeffs[ant, ivp] * gain antwt[ant] = 1.0 number_good += 1 except (ValueError, AssertionError): number_bad += 1 antgain[ant] = 1e15 antwt[ant] = 0.0 antgain[ant] = 1.0 / antgain[ant] gaintables[icomp].gain[ iha, :, :, :] = antgain[:, numpy.newaxis, numpy.newaxis, numpy.newaxis] gaintables[icomp].weight[ iha, :, :, :] = antwt[:, numpy.newaxis, numpy.newaxis, numpy.newaxis] gaintables[icomp].phasecentre = comp.direction if number_bad > 0: log.warning( "simulate_gaintable_from_zernikes: %d points are inside the voltage pattern image" % (number_good)) log.warning( "simulate_gaintable_from_zernikes: %d points are outside the voltage pattern image" % (number_bad)) return gaintables
def test_vis_timeslice_iterator_single(self): self.actualSetUp(times=numpy.zeros([1])) nchunks = vis_timeslices(self.vis, timeslice='auto') log.debug('Found %d chunks' % (nchunks)) for chunk, rows in enumerate(vis_timeslice_iter(self.vis)): assert len(rows)