def test_gridding(self): """Test building a image from a visibility data set.""" for filename, type in zip((idiFile, idiAltFile, uvFile), ('FITS-IDI', 'Alt. FITS-IDI', 'UVFITS')): with self.subTest(filetype=type): # Open the file idi = utils.CorrelatedData(filename) # Build the image ds = idi.get_data_set(1) junk = utils.build_gridded_image(ds, verbose=False) # Error checking self.assertRaises(RuntimeError, utils.build_gridded_image, ds, pol='XY') # # VisibilityData test # ds2 = VisibilityData() ds2.append(ds) junk = utils.build_gridded_image(ds, verbose=False) idi.close()
def test_image_coordinates(self): """Test getting per-pixel image coordinates.""" for filename, type in zip((idiFile, idiAltFile, uvFile), ('FITS-IDI', 'Alt. FITS-IDI', 'UVFITS')): with self.subTest(filetype=type): uv = utils.CorrelatedData(filename) # Build the image ds = uv.get_data_set(1) junk = utils.build_gridded_image(ds, verbose=False) radec = utils.get_image_radec(junk, uv.get_antennaarray()) azalt = utils.get_image_azalt(junk, uv.get_antennaarray()) uv.close()
def test_plotting(self): """Test drawing an image.""" # Setup antennas = lwa1.antennas[0:20] freqs = numpy.arange(30e6, 50e6, 1e6) aa = vis.build_sim_array(lwa1, antennas, freqs) # Build the data dictionary out = vis.build_sim_data(aa, vis.SOURCES, jd=2458962.16965) # Build an image img = utils.build_gridded_image(out) # Plot fig = plt.figure() ax = fig.gca() utils.plot_gridded_image(ax, img)
def test_clean_leastsq(self): """Test CLEANing using least squares in the image plane""" # Setup antennas = lwa1.antennas[0:20] freqs = numpy.arange(30e6, 50e6, 1e6) aa = vis.build_sim_array(lwa1, antennas, freqs) # Build the data dictionary out = vis.build_sim_data(aa, vis.SOURCES, jd=2458962.16965) with lsl.testing.SilentVerbose(): # Build an image img = utils.build_gridded_image(out) # CLEAN deconv.lsq(aa, out, img, max_iter=2, verbose=False, plot=run_plotting_tests)
def test_plotting_graticules(self): """Test adding a graticule to an image.""" # Setup antennas = lwa1.antennas[0:20] freqs = numpy.arange(30e6, 50e6, 1e6) aa = vis.build_sim_array(lwa1, antennas, freqs) # Build the data dictionary out = vis.build_sim_data(aa, vis.SOURCES, jd=2458962.16965) # Build an image img = utils.build_gridded_image(out) # Plot fig = plt.figure() ax = fig.gca() utils.plot_gridded_image(ax, img) with self.subTest(type='RA/Dec.'): overlay.graticule_radec(ax, aa) with self.subTest(type='az/alt'): overlay.graticule_azalt(ax, aa) del fig
def grid_visibilities(bl, freqs, vis, tx_freq, station, valid_ants=None, size=80, res=0.5, wres=0.10, use_pol=0, jd=None): ''' Resamples the baseline-sampled visibilities on to a regular grid. arguments: bl = pairs of antenna objects representing baselines (list) freqs = frequency channels for which we have correlations (list) vis = visibility samples corresponding to the baselines (numpy array) tx_freq = the frequency of the signal we want to locate valid_ants = which antennas we actually want to use (list) station = lsl station object - usually stations.lwasv according to LSL docstring: size = number of wavelengths which the UV matrix spans (this determines the image resolution). res = resolution of the UV matrix (determines image field of view). wres: the gridding resolution of sqrt(w) when projecting to w=0. use_pol = which polarization to use (only 0 is supported right now) returns: gridded_image ''' # In order to do the gridding, we need to build a VisibilityDataSet using # lsl.imaging.data.VisibilityDataSet. We have to build a bunch of stuff to # pass to its constructor. if valid_ants is None: valid_ants, n_baselines = select_antennas(station.antennas, use_pol) # we only want the bin nearest to our frequency target_bin = np.argmin([abs(tx_freq - f) for f in freqs]) # Build antenna array freqs = np.array(freqs) antenna_array = simVis.build_sim_array(station, valid_ants, freqs / 1e9, jd=jd, force_flat=True) uvw = np.empty((len(bl), 3, len(freqs))) for i, f in enumerate(freqs): # wavelength = 3e8/f # TODO this should be fixed. What is currently happening is not true. Well it is, but only if you're looking for a specific transmitter frequency. Which I guess we are. I just mean it's not generalized. wavelength = 3e8 / tx_freq uvw[:, :, i] = uvw_from_antenna_pairs(bl, wavelength=wavelength) dataSet = VisibilityDataSet(jd=jd, freq=freqs, baselines=bl, uvw=uvw, antennarray=antenna_array) if use_pol == 0: pol_string = 'XX' else: raise RuntimeError("Only pol. XX supported right now.") polDataSet = PolarizationDataSet(pol_string, data=vis) dataSet.append(polDataSet) # Use lsl.imaging.utils.build_gridded_image (takes a VisibilityDataSet) gridded_image = build_gridded_image(dataSet, pol=pol_string, chan=target_bin, size=size, res=res, wres=wres) return gridded_image
def main(args): h5fi = h5py.File(args.input_file, 'r') h5fo = h5py.File(args.output_file,'w') # Copy over important attributes for key in h5fi.attrs.keys(): h5fo.attrs[key]=h5fi.attrs[key] # Copy over important datasets for key in h5fi.keys(): temp_arr = h5fi[key] h5fo.create_dataset('vis_{}'.format(key),data=temp_arr) h5fo.attrs['grid_size']=args.size h5fo.attrs['grid_res']=args.res h5fo.attrs['grid_wres']=args.wres h5fo.create_dataset('l_est', (len(h5fo['vis_l_est']),)) h5fo.create_dataset('m_est', (len(h5fo['vis_l_est']),)) h5fo.create_dataset('extent', (len(h5fo['vis_l_est']),4)) h5fo.create_dataset('elevation', (len(h5fo['vis_l_est']),)) h5fo.create_dataset('azimuth', (len(h5fo['vis_l_est']),)) h5fo.create_dataset('height', (len(h5fo['vis_l_est']),)) h5fi.close() # done with input data now ## Begin doing stuff antennas = station.antennas valid_ants, n_baselines = select_antennas(antennas, h5fo.attrs['use_pol'], exclude=[256]) # to exclude outrigger tx_coords = h5fo.attrs['tx_coordinates'] rx_coords = [station.lat * 180/np.pi, station.lon * 180/np.pi] ## Build freqs (same for every 'integration') freqs = np.empty((h5fo.attrs['fft_len'],),dtype=np.float64) #! Need to think of intelligent way of doing this. #! target_bin will probably not matter since all vis is the same freqs5 = [5284999.9897182, 5291249.9897182, 5297499.9897182, 5303749.9897182, 5309999.9897182, 5316249.9897182, 5322499.9897182, 5328749.9897182, 5334999.9897182, 5341249.9897182, 5347499.9897182, 5353749.9897182, 5359999.9897182, 5366249.9897182, 5372499.9897182, 5378749.9897182] for i in range(len(freqs)): freqs[i]=freqs5[i] ## Build bl (same for every 'integration') pol_string = 'xx' if h5fo.attrs['use_pol'] == 0 else 'yy' pol1, pol2 = pol_to_pols(pol_string) antennas1 = [a for a in valid_ants if a.pol == pol1] antennas2 = [a for a in valid_ants if a.pol == pol2] nStands = len(antennas1) baselines = uvutils.get_baselines(antennas1, antennas2=antennas2, include_auto=False, indicies=True) antennaBaselines = [] for bl in range(len(baselines)): antennaBaselines.append( (antennas1[baselines[bl][0]], antennas2[baselines[bl][1]]) ) bl = antennaBaselines uvw_m = np.array([np.array([b[0].stand.x - b[1].stand.x, b[0].stand.y - b[1].stand.y, b[0].stand.z - b[1].stand.z]) for b in bl]) uvw = np.empty((len(bl), 3, len(freqs))) for i, f in enumerate(freqs): # wavelength = 3e8/f # TODO this should be fixed. What is currently happening is not true. Well it is, but only if you're looking for a specific transmitter frequency. Which I guess we are. I just mean it's not generalized. wavelength = 3e8/h5fo.attrs['tx_freq'] uvw[:,:,i] = uvw_m/wavelength # Build antenna array (gets used in the VisibilityDataSet) # jd can't matter, right? jd = 2458847.2362531545 antenna_array = simVis.build_sim_array(station, valid_ants, freqs/1e9, jd=jd, force_flat=True) # we only want the bin nearest to our frequency target_bin = np.argmin([abs(h5fo.attrs['tx_freq'] - f) for f in freqs]) # Needed for PolarizationDataSet if h5fo.attrs['use_pol'] == 0: pol_string = 'XX' p=0 # this is related to the enumerate in lsl.imaging.utils.CorrelatedIDI().get_data_set() (for when there are multiple pols in a single dataset) else: raise RuntimeError("Only pol. XX supported right now.") if args.all_sky: fig, ax = plt.subplots() for k in np.arange(len(h5fo['vis_l_est'])): l_in = h5fo['vis_l_est'][k] m_in = h5fo['vis_m_est'][k] ## Build vis vismodel = point_source_visibility_model_uv(uvw[:,0,0],uvw[:,1,0],l_in,m_in) vis = np.empty((len(vismodel), len(freqs)), dtype=np.complex64) for i in np.arange(vis.shape[1]): vis[:,i] = vismodel if args.export_npy: print(args.export_npy) print("Exporting modelled u, v, w, and visibility") np.save('model-uvw{}.npy'.format(k), uvw) np.save('model-vis{}.npy'.format(k), vis) ## Start to build up the data structure for VisibilityDataSet dataSet = VisibilityDataSet(jd=jd, freq=freqs, baselines=bl, uvw=uvw, antennarray=antenna_array) polDataSet = PolarizationDataSet(pol_string, data=vis) dataSet.append(polDataSet) print('| Gridding and imaging with size={}, res={}, wres={}'.format(args.size, args.res, args.wres)) gridded_image = build_gridded_image(dataSet, pol=pol_string, chan=target_bin, size=args.size, res=args.res, wres=args.wres) if args.export_npy: print("Exporting gridded u, v, and visibility") u,v = gridded_image.get_uv() np.save('gridded-u{}.npy'.format(k), u) np.save('gridded-v{}.npy'.format(k), v) np.save('gridded-vis{}.npy'.format(k), gridded_image.uv) l,m,img,extent=get_gimg_max(gridded_image, return_img=True) # Compute other values of interest elev, az = lm_to_ea(l, m) height = flatmirror_height(tx_coords, rx_coords, elev) h5fo['l_est'][k] = l h5fo['m_est'][k] = m h5fo['extent'][k] = extent h5fo['elevation'][k] = elev h5fo['azimuth'][k] = az h5fo['height'][k] = height if args.all_sky: ax.imshow(img, extent=extent, origin='lower', interpolation='nearest') ax.set_title('size={}, res={}, wres={}, iteration={}'.format(args.size,args.res,args.wres,k)) ax.set_xlabel('l') ax.set_ylabel('m') ax.plot(l,m,marker='o', color='k', label='Image Max.') ax.plot(l_in,m_in,marker='x', color='r', label='Model (input)') plt.legend(loc='lower right') plt.savefig('allsky{}.png'.format(k)) plt.cla() save_pkl_gridded = args.pkl_gridded and k in args.pkl_gridded if save_pkl_gridded: quickDict={'image':img, 'extent':extent} with open('gridded{}.pkl'.format(k), 'wb') as f: pickle.dump(quickDict, f, protocol=pickle.HIGHEST_PROTOCOL) h5fo.close()
def main(args): filename = args.filename idi = utils.CorrelatedData(filename) aa = idi.get_antennaarray() lo = idi.get_observer() lo.date = idi.date_obs.strftime("%Y/%m/%d %H:%M:%S") jd = lo.date + astro.DJD_OFFSET lst = str(lo.sidereal_time()) nStand = len(idi.stands) nchan = len(idi.freq) freq = idi.freq print("Raw Stand Count: %i" % nStand) print("Final Baseline Count: %i" % (nStand * (nStand - 1) // 2, )) print( "Spectra Coverage: %.3f to %.3f MHz in %i channels (%.2f kHz/channel)" % (freq[0] / 1e6, freq[-1] / 1e6, nchan, (freq[-1] - freq[0]) / 1e3 / nchan)) print("Polarization Products: %i starting with %i" % (len(idi.pols), idi.pols[0])) print("JD: %.3f" % jd) # Pull out something reasonable toWork = numpy.where((freq >= args.lower) & (freq <= args.upper))[0] print("Reading in FITS IDI data") nSets = idi.total_baseline_count // (nStand * (nStand + 1) // 2) for set in range(1, nSets + 1): print("Set #%i of %i" % (set, nSets)) fullDict = idi.get_data_set(set) dataDict = fullDict.get_uv_range(min_uv=14.0) dataDict.sort() # Gather up the polarizations and baselines pols = dataDict['jd'].keys() bls = dataDict['bls'][pols[0]] print("The reduced list has %i baselines and %i channels" % (len(bls), len(toWork))) # Build a list of unique JDs for the data jdList = [] for jd in dataDict['jd'][pols[0]]: if jd not in jdList: jdList.append(jd) # Build the simulated visibilities print("Building Model") simDict = simVis.build_sim_data(aa, simVis.SOURCES, jd=[ jdList[0], ], pols=pols, baselines=bls) print("Running self cal.") simDict = simDict.sort() dataDict = dataDict.sort() fixedDataXX, delaysXX = selfcal.delay_only(aa, dataDict, simDict, toWork, 'xx', ref_ant=args.reference, max_iter=60) fixedDataYY, delaysYY = selfcal.delay_only(aa, dataDict, simDict, toWork, 'yy', ref_ant=args.reference, max_iter=60) fixedFullXX = simVis.scale_data(fullDict, delaysXX * 0 + 1, delaysXX) fixedFullYY = simVis.scale_data(fullDict, delaysYY * 0 + 1, delaysYY) print(" Saving results") outname = os.path.split(filename)[1] outname = os.path.splitext(outname)[0] outname = "%s.sc" % outname fh = open(outname, 'w') fh.write("################################\n") fh.write("# #\n") fh.write("# Columns: #\n") fh.write("# 1) Stand number #\n") fh.write("# 2) X pol. amplitude #\n") fh.write("# 3) X pol. delay (ns) #\n") fh.write("# 4) Y pol. amplitude #\n") fh.write("# 5) Y pol. delay (ns) #\n") fh.write("# #\n") fh.write("################################\n") for i in xrange(delaysXX.size): fh.write("%3i %.6g %.6g %.6g %.6g\n" % (idi.stands[i], 1.0, delaysXX[i], 1.0, delaysYY[i])) fh.close() # Build up the images for each polarization if args.plot: print(" Gridding") toWork = numpy.where((freq >= 80e6) & (freq <= 82e6))[0] try: imgXX = utils.build_gridded_image(fullDict, size=80, res=0.5, pol='xx', chan=toWork) except: imgXX = None try: imgYY = utils.build_gridded_image(fullDict, size=80, res=0.5, pol='yy', chan=toWork) except: imgYY = None try: simgXX = utils.build_gridded_image(simDict, size=80, res=0.5, pol='xx', chan=toWork) except: simgXX = None try: simgYY = utils.build_gridded_image(simDict, size=80, res=0.5, pol='yy', chan=toWork) except: simgYY = None try: fimgXX = utils.build_gridded_image(fixedFullXX, size=80, res=0.5, pol='xx', chan=toWork) except: fimgXX = None try: fimgYY = utils.build_gridded_image(fixedFullYY, size=80, res=0.5, pol='yy', chan=toWork) except: fimgYY = None # Plots print(" Plotting") fig = plt.figure() ax1 = fig.add_subplot(3, 2, 1) ax2 = fig.add_subplot(3, 2, 2) ax3 = fig.add_subplot(3, 2, 3) ax4 = fig.add_subplot(3, 2, 4) ax5 = fig.add_subplot(3, 2, 5) ax6 = fig.add_subplot(3, 2, 6) for ax, img, pol in zip( [ax1, ax2, ax3, ax4, ax5, ax6], [imgXX, imgYY, simgXX, simgYY, fimgXX, fimgYY], ['XX', 'YY', 'simXX', 'simYY', 'scalXX', 'scalYY']): # Skip missing images if img is None: ax.text(0.5, 0.5, 'Not found in file', color='black', size=12, horizontalalignment='center') ax.xaxis.set_major_formatter(NullFormatter()) ax.yaxis.set_major_formatter(NullFormatter()) ax.set_title("%s @ %s LST" % (pol, lst)) continue # Display the image and label with the polarization/LST out = img.image(center=(80, 80)) print(pol, out.min(), out.max()) #if pol == 'scalXX': #out = numpy.rot90(out) #out = numpy.rot90(out) cb = ax.imshow(out, extent=(1, -1, -1, 1), origin='lower', vmin=img.image().min(), vmax=img.image().max()) fig.colorbar(cb, ax=ax) ax.set_title("%s @ %s LST" % (pol, lst)) # Turn off tick marks ax.xaxis.set_major_formatter(NullFormatter()) ax.yaxis.set_major_formatter(NullFormatter()) # Compute the positions of major sources and label the images compSrc = {} ax.plot(0, 0, marker='+', markersize=10, markeredgecolor='w') for name, src in simVis.SOURCES.items(): src.compute(aa) top = src.get_crds(crdsys='top', ncrd=3) az, alt = aipy.coord.top2azalt(top) compSrc[name] = [az, alt] if alt <= 0: continue ax.plot(top[0], top[1], marker='x', markerfacecolor='None', markeredgecolor='w', linewidth=10.0, markersize=10) ax.text(top[0], top[1], name, color='white', size=12) # Add lines of constant RA and dec. graticle(ax, lo.sidereal_time(), lo.lat) plt.show() print("...Done")
def lsq(aa, dataDict, aipyImg, input_image=None, size=80, res=0.50, wres=0.10, pol='XX', chan=None, gain=0.05, max_iter=150, rtol=1e-9, verbose=True, plot=False): """ Given a AIPY antenna array instance, a data dictionary, and an AIPY ImgW instance filled with data, return a deconvolved image. This function implements a least squares deconvolution. Least squares tuning parameters: * gain - least squares loop gain (default 0.05) * max_iter - Maximum number of iteration (default 150) * rtol - Minimum change in the residual RMS between iterations (default 1e-9) """ # Sort out the channels to work on if chan is None: chan = range(dataDict.freq.size) # Get a grid of right ascensions and dec values for the image we are working with xyz = aipyImg.get_eq(aa.sidereal_time(), aa.lat, center=(size, size)) ra, dec = eq2radec(xyz) # Get the list of baselines to generate visibilites for baselines = dataDict.baselines # Estimate the zenith beam response psfSrc = { 'z': RadioFixedBody(aa.sidereal_time(), aa.lat, jys=1.0, index=0, epoch=aa.date) } psfDict = build_sim_data(aa, psfSrc, jd=aa.get_jultime(), pols=[ pol, ], chan=chan, baselines=baselines, flat_response=True) psf = utils.build_gridded_image(psfDict, size=size, res=res, wres=wres, chan=chan, pol=pol, verbose=verbose) psf = psf.image(center=(size, size)) psf /= psf.max() # Fit a Guassian to the zenith beam response and use that for the restore beam beamCutout = psf[size // 2:3 * size // 2, size // 2:3 * size // 2] beamCutout = numpy.where(beamCutout > 0.0, beamCutout, 0.0) h, cx, cy, sx, sy = _fit_gaussian(beamCutout) gauGen = gaussian2d(1.0, size / 2 + cx, size / 2 + cy, sx, sy) FWHM = int(round((sx + sy) / 2.0 * 2.0 * numpy.sqrt(2.0 * numpy.log(2.0)))) beamClean = psf * 0.0 for i in range(beamClean.shape[0]): for j in range(beamClean.shape[1]): beamClean[i, j] = gauGen(i, j) beamClean /= beamClean.sum() convMask = xyz.mask[0, :, :] # Get the actual image out of the ImgW instance if input_image is None: img = aipyImg.image(center=(size, size)) else: img = input_image * 1.0 # Build the initial model mdl = img * 0 + img.max() mdl[numpy.where(mdl < 0)] = 0 mdl[numpy.where(ra.mask == 1)] = 0 # Determine the overall image->model scale factor bSrcs = {} rChan = [chan[0], chan[-1]] bSrcs['zenith'] = RadioFixedBody(aa.sidereal_time(), aa.lat, name='zenith', jys=1, index=0) simDict = build_sim_data(aa, bSrcs, jd=aa.get_jultime(), pols=[ pol, ], chan=rChan, baselines=baselines, flat_response=True) simImg = utils.build_gridded_image(simDict, size=size, res=res, wres=wres, chan=rChan, pol=pol, verbose=verbose) simImg = simImg.image(center=(size, size)) simToModel = 1.0 / simImg.max() modelToSim = simImg.max() / 1.0 # Go! if plot: import pylab from matplotlib import pyplot as plt pylab.ion() rChan = [chan[0], chan[-1]] mdl *= modelToSim diff = img - mdl diffScaled = 0.0 * diff / gain oldModel = mdl oldRMS = diff.std() * 1e6 oldDiff = diff * 0.0 rHist = [] exitStatus = 'iteration' for k in range(max_iter): ## Update the model image but don't allow negative flux mdl += diffScaled * gain mdl[numpy.where(mdl <= 0)] = 0.0 ## Convert the model image to an ensemble of point sources for forward ## modeling bSrcs = {} for i in range(mdl.shape[0]): for j in range(mdl.shape[1]): if dec.mask[i, j]: continue if mdl[i, j] <= 0: continue nm = '%i-%i' % (i, j) bSrcs[nm] = RadioFixedBody(ra[i, j], dec[i, j], name=nm, jys=mdl[i, j], index=0, epoch=aa.date) ## Model the visibilities simDict = build_sim_data(aa, bSrcs, jd=aa.get_jultime(), pols=[ pol, ], chan=rChan, baselines=baselines, flat_response=True) ## Form the simulated image simImg = utils.build_gridded_image(simDict, size=size, res=res, wres=wres, chan=rChan, pol=pol, verbose=verbose) simImg = simImg.image(center=(size, size)) ## Difference the image and the simulated image and scale it to the ## model's peak flux diff = img - simImg diff2 = _minor_cycle(diff, beamClean, gain=0.1, max_iter=2000) ## Compute the RMS and create an appropriately scaled version of the model RMS = diff.std() mdl2 = mdl * modelToSim ## Status report if verbose: print("Iteration %i: %i sources used, RMS is %.4e" % (k + 1, len(bSrcs.keys()), RMS)) print(" -> maximum residual: %.4e (%.3f%% of peak)" % (diff.max(), 100.0 * diff.max() / img.max())) print(" -> minimum residual: %.4e (%.3f%% of peak)" % (diff.min(), 100.0 * diff.min() / img.max())) print(" -> delta RMS: %.4e (%.3f%%)" % (RMS - oldRMS, 100.0 * (RMS - oldRMS) / RMS)) ## Make the cleaned residuals map ready for updating the model diff = diff2 diffScaled = diff * simToModel ## Has the RMS gone up? If so, it is time to exit. But first, restore ## the previous iteration if RMS - oldRMS > 0: mdl = oldModel diff = oldDiff exitStatus = 'residuals' break ## Is the RMS still changing in an acceptable manner? if abs(RMS - oldRMS) < rtol: # No need to go back a step #mdl = oldModel #diff = oldDiff exitStatus = 'tolerance' break ## Save the current iteration as the previous state rHist.append(RMS) oldRMS = RMS oldModel = mdl oldDiff = diff if plot: pylab.subplot(3, 2, 1) pylab.imshow(img, origin='lower', interpolation='nearest', vmin=img.min(), vmax=img.max()) pylab.subplot(3, 2, 2) pylab.imshow(simImg, origin='lower', interpolation='nearest', vmin=img.min(), vmax=img.max()) pylab.subplot(3, 2, 3) pylab.imshow(diff, origin='lower', interpolation='nearest') pylab.subplot(3, 2, 4) pylab.imshow(mdl, origin='lower', interpolation='nearest') pylab.subplot(3, 1, 3) pylab.cla() pylab.plot(rHist) pylab.draw() # Summary print("Exited after %i iterations with status '%s'" % (k + 1, exitStatus)) # Restore conv = convolve(mdl2, beamClean, mode='same') conv = numpy.ma.array(conv, mask=convMask) if plot: # Make an image for comparison purposes if we are verbose fig = plt.figure() ax1 = fig.add_subplot(2, 2, 1) ax2 = fig.add_subplot(2, 2, 2) ax3 = fig.add_subplot(2, 2, 3) ax4 = fig.add_subplot(2, 2, 4) c = ax1.imshow(img, extent=(1, -1, -1, 1), origin='lower', interpolation='nearest') fig.colorbar(c, ax=ax1) ax1.set_title('Input') d = ax2.imshow(simImg, extent=(1, -1, -1, 1), origin='lower', interpolation='nearest') fig.colorbar(d, ax=ax2) ax2.set_title('Realized Model') e = ax3.imshow(diff, extent=(1, -1, -1, 1), origin='lower', interpolation='nearest') fig.colorbar(e, ax=ax3) ax3.set_title('Residuals') f = ax4.imshow(conv + diff, extent=(1, -1, -1, 1), origin='lower', interpolation='nearest') fig.colorbar(f, ax=ax4) ax4.set_title('Final') plt.show() if plot: pylab.ioff() return conv + diff
def clean_sources(aa, dataDict, aipyImg, srcs, input_image=None, size=80, res=0.50, wres=0.10, pol='XX', chan=None, gain=0.1, max_iter=150, sigma=2.0, verbose=True, plot=False): """ Given a AIPY antenna array instance, a data dictionary, an AIPY ImgW instance filled with data, and a dictionary of sources, return the CLEAN components and the residuals map. This function uses a CLEAN-like method that computes the array beam for each peak in the flux. Thus the CLEAN loop becomes: 1. Find the peak flux in the residual image 2. Compute the systems response to a point source at that location 3. Remove the scaled porition of this beam from the residuals 4. Go to 1. This function differs from clean() in that it only cleans localized regions around each source rather than the whole image. This is intended to help the mem() function along. CLEAN tuning parameters: * gain - CLEAN loop gain (default 0.1) * max_iter - Maximum number of iterations (default 150) * sigma - Threshold in sigma to stop cleaning (default 2.0) """ # Sort out the channels to work on if chan is None: chan = range(dataDict.freq.size) # Get a grid of right ascensions and dec values for the image we are working with xyz = aipyImg.get_eq(0.0, aa.lat, center=(size, size)) RA, dec = eq2radec(xyz) RA += aa.sidereal_time() RA %= (2 * numpy.pi) top = aipyImg.get_top(center=(size, size)) az, alt = top2azalt(top) # Get the list of baselines to generate visibilites for baselines = dataDict.baselines # Get the actual image out of the ImgW instance if input_image is None: img = aipyImg.image(center=(size, size)) else: img = input_image * 1.0 # Setup the arrays to hold the point sources and the residual. cleaned = numpy.zeros_like(img) working = numpy.zeros_like(img) working += img # Setup the dictionary that will hold the beams as they are computed prevBeam = {} # Estimate the zenith beam response psfSrc = { 'z': RadioFixedBody(aa.sidereal_time(), aa.lat, jys=1.0, index=0, epoch=aa.date) } psfDict = build_sim_data(aa, psfSrc, jd=aa.get_jultime(), pols=[ pol, ], chan=chan, baselines=baselines, flat_response=True) psf = utils.build_gridded_image(psfDict, size=size, res=res, wres=wres, chan=chan, pol=pol, verbose=verbose) psf = psf.image(center=(size, size)) psf /= psf.max() # Fit a Guassian to the zenith beam response and use that for the restore beam beamCutout = psf[size // 2:3 * size // 2, size // 2:3 * size // 2] beamCutout = numpy.where(beamCutout > 0.0, beamCutout, 0.0) h, cx, cy, sx, sy = _fit_gaussian(beamCutout) gauGen = gaussian2d(1.0, size / 2 + cx, size / 2 + cy, sx, sy) FWHM = int(round((sx + sy) / 2.0 * 2.0 * numpy.sqrt(2.0 * numpy.log(2.0)))) beamClean = psf * 0.0 for i in range(beamClean.shape[0]): for j in range(beamClean.shape[1]): beamClean[i, j] = gauGen(i, j) beamClean /= beamClean.sum() convMask = xyz.mask[0, :, :] # Go! if plot: import pylab from matplotlib import pyplot as plt pylab.ion() for name, src in srcs.items(): # Make sure the source is up src.compute(aa) if verbose: print('Source: %s @ %s degrees elevation' % (name, src.alt)) if src.alt <= 10 * numpy.pi / 180.0: continue # Locate the approximate position of the source srcDist = (src.ra - RA)**2 + (src.dec - dec)**2 srcPeak = numpy.where(srcDist == srcDist.min()) # Define the clean box - this is fixed at 2*FWHM in width on each side rx0 = max([0, srcPeak[0][0] - FWHM // 2]) rx1 = min([rx0 + FWHM + 1, img.shape[0]]) ry0 = max([0, srcPeak[1][0] - FWHM // 2]) ry1 = min([ry0 + FWHM + 1, img.shape[1]]) # Define the background box - this lies outside the clean box and serves # as a reference for the background X, Y = numpy.indices(working.shape) R = numpy.sqrt((X - srcPeak[0][0])**2 + (Y - srcPeak[1][0])**2) bpad = 3 background = numpy.where((R <= FWHM + bpad) & (R > FWHM)) while len(background[0]) == 0 and bpad < img.shape[0]: bpad += 1 background = numpy.where((R <= FWHM + bpad) & (R > FWHM)) px0 = min(background[0]) - 1 px1 = max(background[0]) + 2 py0 = min(background[1]) - 1 py1 = max(background[1]) + 2 exitStatus = 'iteration' for i in range(max_iter): # Find the location of the peak in the flux density peak = numpy.where(working[rx0:rx1, ry0:ry1] == working[rx0:rx1, ry0:ry1].max()) peak_x = peak[0][0] + rx0 peak_y = peak[1][0] + ry0 peakV = working[peak_x, peak_y] # Optimize the location try: peakParams = _fit_gaussian( working[peak_x - FWHM // 2:peak_x + FWHM // 2 + 1, peak_y - FWHM // 2:peak_y + FWHM // 2 + 1]) except IndexError: peakParams = [peakV, FWHM // 2, FWHM // 2] peakVO = peakParams[0] peak_xO = peak_x - FWHM // 2 + peakParams[1] peak_yO = peak_y - FWHM // 2 + peakParams[2] # Quantize to try and keep the computation down without over-simplifiying things subpixelationLevel = 5 peak_xO = round( peak_xO * subpixelationLevel) / float(subpixelationLevel) peak_yO = round( peak_yO * subpixelationLevel) / float(subpixelationLevel) # Pixel coordinates to right ascension, dec. try: peakRA = _interpolate(RA, peak_xO, peak_yO) except IndexError: peak_xO, peak_yO = peak_x, peak_y peakRA = RA[peak_x, peak_y] try: peakDec = _interpolate(dec, peak_xO, peak_yO) except IndexError: peakDec = dec[peak_x, peak_y] # Pixel coordinates to az, el try: peakAz = _interpolate(az, peak_xO, peak_yO) except IndexError: peak_xO, peak_yO = peak_x, peak_y peakAz = az[peak_x, peak_y] try: peakEl = _interpolate(alt, peak_x, peak_y) except IndexError: peakEl = alt[peak_x, peak_y] if verbose: currRA = deg_to_hms(peakRA * 180 / numpy.pi) currDec = deg_to_dms(peakDec * 180 / numpy.pi) currAz = deg_to_dms(peakAz * 180 / numpy.pi) currEl = deg_to_dms(peakEl * 180 / numpy.pi) print( "%s - Iteration %i: Log peak of %.3f at row: %i, column: %i" % (name, i + 1, numpy.log10(peakV), peak_x, peak_y)) print(" -> RA: %s, Dec: %s" % (currRA, currDec)) print(" -> az: %s, el: %s" % (currAz, currEl)) # Check for the exit criteria if peakV < 0: exitStatus = 'peak value is negative' break # Find the beam index and see if we need to compute the beam or not beamIndex = (int(peak_xO * subpixelationLevel), int(peak_yO * subpixelationLevel)) try: beam = prevBeam[beamIndex] except KeyError: if verbose: print(" -> Computing beam(s)") beamSrc = { 'Beam': RadioFixedBody(peakRA, peakDec, jys=1.0, index=0, epoch=aa.date) } beamDict = build_sim_data(aa, beamSrc, jd=aa.get_jultime(), pols=[ pol, ], chan=chan, baselines=baselines, flat_response=True) beam = utils.build_gridded_image(beamDict, size=size, res=res, wres=wres, chan=chan, pol=pol, verbose=verbose) beam = beam.image(center=(size, size)) beam /= beam.max() if verbose: print(" ", beam.mean(), beam.min(), beam.max(), beam.sum()) prevBeam[beamIndex] = beam if verbose: print(" -> Beam cache contains %i entries" % len(prevBeam.keys())) # Calculate how much signal needs to be removed... toRemove = gain * peakV * beam working -= toRemove asum = 0.0 for l in range(int(peak_xO), int(peak_xO) + 2): if l > peak_xO: side1 = (peak_xO + 0.5) - (l - 0.5) else: side1 = (l + 0.5) - (peak_xO - 0.5) for m in range(int(peak_yO), int(peak_yO) + 2): if m > peak_yO: side2 = (peak_yO + 0.5) - (m - 0.5) else: side2 = (m + 0.5) - (peak_yO - 0.5) area = side1 * side2 asum += area #print('II', l, m, area, asum) cleaned[l, m] += gain * area * peakV if plot: try: pylab.subplot(2, 2, 1) pylab.imshow((working + toRemove)[px0:px1, py0:py1], origin='lower', interpolation='nearest') pylab.title('Before') pylab.subplot(2, 2, 2) pylab.imshow(working[px0:px1, py0:py1], origin='lower', interpolation='nearest') pylab.title('After') pylab.subplot(2, 2, 3) pylab.imshow(toRemove[px0:px1, py0:py1], origin='lower', interpolation='nearest') pylab.title('Removed') pylab.subplot(2, 2, 4) pylab.imshow(convolve(cleaned, beamClean, mode='same')[px0:px1, py0:py1], origin='lower', interpolation='nearest') pylab.title('CLEAN Comps.') except: pass try: st.set_text('%s @ %i' % (name, i + 1)) except NameError: st = pylab.suptitle('%s @ %i' % (name, i + 1)) pylab.draw() if numpy.abs( numpy.max(working[rx0:rx1, ry0:ry1]) - numpy.median(working[background])) / rStd( working[background]) <= sigma: exitStatus = 'peak is less than %.3f-sigma' % sigma break # Summary print("Exited after %i iterations with status '%s'" % (i + 1, exitStatus)) # Restore conv = convolve(cleaned, beamClean, mode='same') conv = numpy.ma.array(conv, mask=convMask) conv *= ((img - working).max() / conv.max()) if plot: # Make an image for comparison purposes if we are verbose fig = plt.figure() ax1 = fig.add_subplot(2, 2, 1) ax2 = fig.add_subplot(2, 2, 2) ax3 = fig.add_subplot(2, 2, 3) ax4 = fig.add_subplot(2, 2, 4) c = ax1.imshow(img, extent=(1, -1, -1, 1), origin='lower', interpolation='nearest') fig.colorbar(c, ax=ax1) ax1.set_title('Input') d = ax2.imshow(conv, extent=(1, -1, -1, 1), origin='lower', interpolation='nearest') fig.colorbar(d, ax=ax2) ax2.set_title('CLEAN Comps.') e = ax3.imshow(working, extent=(1, -1, -1, 1), origin='lower', interpolation='nearest') fig.colorbar(e, ax=ax3) ax3.set_title('Residuals') f = ax4.imshow(conv + working, extent=(1, -1, -1, 1), origin='lower', interpolation='nearest') fig.colorbar(f, ax=ax4) ax4.set_title('Final') plt.show() if plot: pylab.ioff() # Return return conv, working
def main(args): ## Check we should bother doing anything if not args.export_npy and not args.export_h5 and not args.all_sky and not args.pkl_gridded: raise RuntimeError( "You have not selected a data output of any type. Read the docstring and pick something for me to do." ) # Normalize all inputs to the same length sizes = [int(item) for item in args.size.split(',')] reses = [float(item) for item in args.res.split(',')] wreses = [float(item) for item in args.wres.split(',')] maxinputlen = max(len(sizes), len(reses), len(wreses)) if len(sizes) not in [1, maxinputlen] or len(reses) not in [ 1, maxinputlen ] or len(wreses) not in [1, maxinputlen]: raise RuntimeError(" \ For size, res and wres you must pass either the same number of values as the max or a single value.\n \ For example:\n \ ALLOWED -> sizes=175,180,190, res=0.5, wres=0.5\n \ -> sizes=175,180,190, res=0.5, wres=0.5,0.6,0.7\n \ NOT ALLOWED -> sizes=175,180,190, res=0.5, wres=0.5,0.6 \ ") if len( sizes ) != maxinputlen: # You'd think there must be a good way to do this with list comprehension. sizes = sizes * maxinputlen if len(reses) != maxinputlen: reses = reses * maxinputlen if len(wreses) != maxinputlen: wreses = wreses * maxinputlen all_grid_params = [] while len(sizes) > 0: all_grid_params.append({ 'size': sizes.pop(), 'res': reses.pop(), 'wres': wreses.pop() }) ## Begin doing stuff tx_coords = known_transmitters.parse_args(args) if not transmitter_coords: print("Please specify a transmitter location") return rx_coords = [station.lat * 180 / np.pi, station.lon * 180 / np.pi] antennas = station.antennas valid_ants, n_baselines = select_antennas(antennas, args.use_pol) if args.export_h5: h5fname = "simulation-results.h5" print("Output will be written to {}".format(h5fname)) h5f = h5py.File(h5fname, 'w') ats = h5f.attrs ats['transmitter'] = args.transmitter ats['tx_freq'] = args.tx_freq ats['valid_ants'] = [a.id for a in valid_ants] ats['n_baselines'] = n_baselines ats['fft_len'] = args.fft_len ats['use_pol'] = args.use_pol ats['int_length'] = args.integration_length ats['l_model'] = args.l_model ats['m_model'] = args.m_model h5f.create_dataset('l_est', (len(all_grid_params), )) h5f.create_dataset('m_est', (len(all_grid_params), )) h5f.create_dataset('wres', (len(all_grid_params), )) h5f.create_dataset('res', (len(all_grid_params), )) h5f.create_dataset('size', (len(all_grid_params), )) h5f.create_dataset('extent', (len(all_grid_params), 4)) h5f.create_dataset('elevation', (len(all_grid_params), )) h5f.create_dataset('azimuth', (len(all_grid_params), )) h5f.create_dataset('height', (len(all_grid_params), )) ## Build freqs freqs = np.empty((args.fft_len, ), dtype=np.float64) #! Need to think of intelligent way of doing this. #! target_bin will probably not matter since all vis is the same freqs5 = [ 5284999.9897182, 5291249.9897182, 5297499.9897182, 5303749.9897182, 5309999.9897182, 5316249.9897182, 5322499.9897182, 5328749.9897182, 5334999.9897182, 5341249.9897182, 5347499.9897182, 5353749.9897182, 5359999.9897182, 5366249.9897182, 5372499.9897182, 5378749.9897182 ] for i in range(len(freqs)): freqs[i] = freqs5[i] ## Build bl pol_string = 'xx' if args.use_pol == 0 else 'yy' pol1, pol2 = pol_to_pols(pol_string) antennas1 = [a for a in valid_ants if a.pol == pol1] antennas2 = [a for a in valid_ants if a.pol == pol2] nStands = len(antennas1) baselines = uvutils.get_baselines(antennas1, antennas2=antennas2, include_auto=False, indicies=True) antennaBaselines = [] for bl in range(len(baselines)): antennaBaselines.append( (antennas1[baselines[bl][0]], antennas2[baselines[bl][1]])) bl = antennaBaselines uvw_m = np.array([ np.array([ b[0].stand.x - b[1].stand.x, b[0].stand.y - b[1].stand.y, b[0].stand.z - b[1].stand.z ]) for b in bl ]) uvw = np.empty((len(bl), 3, len(freqs))) for i, f in enumerate(freqs): # wavelength = 3e8/f # TODO this should be fixed. What is currently happening is not true. Well it is, but only if you're looking for a specific transmitter frequency. Which I guess we are. I just mean it's not generalized. wavelength = 3e8 / args.tx_freq uvw[:, :, i] = uvw_m / wavelength ## Build vis vismodel = point_source_visibility_model_uv(uvw[:, 0, 0], uvw[:, 1, 0], args.l_model, args.m_model) vis = np.empty((len(vismodel), len(freqs)), dtype=np.complex64) for i in np.arange(vis.shape[1]): vis[:, i] = vismodel if args.export_npy: print(args.export_npy) print("Exporting modelled u, v, w, and visibility") np.save('model-uvw.npy', uvw) np.save('model-vis.npy', vis) ## Start to build up the data structure for VisibilityDataSet # we only want the bin nearest to our frequency target_bin = np.argmin([abs(args.tx_freq - f) for f in freqs]) # This can't matter, right? # jd = tbnf.get_info('start_time').jd jd = 2458847.2362531545 # Build antenna array antenna_array = simVis.build_sim_array(station, antennas, freqs / 1e9, jd=jd, force_flat=True) dataSet = VisibilityDataSet(jd=jd, freq=freqs, baselines=bl, uvw=uvw, antennarray=antenna_array) if args.use_pol == 0: pol_string = 'XX' p = 0 # this is related to the enumerate in lsl.imaging.utils.CorrelatedIDI().get_data_set() (for when there are multiple pols in a single dataset) else: raise RuntimeError("Only pol. XX supported right now.") polDataSet = PolarizationDataSet(pol_string, data=vis) dataSet.append(polDataSet) if args.all_sky: fig, ax = plt.subplots() # Iterate over size/res/wres and generate multiple grids/images k = 0 for grid_params in all_grid_params: print('| Gridding and imaging with size={}, res={}, wres={}'.format( grid_params['size'], grid_params['res'], grid_params['wres'])) gridded_image = build_gridded_image(dataSet, pol=pol_string, chan=target_bin, size=grid_params['size'], res=grid_params['res'], wres=grid_params['wres']) if args.export_npy: print("Exporting gridded u, v, and visibility") u, v = gridded_image.get_uv() np.save( 'gridded-u-size-{}-res-{}-wres-{}.npy'.format( grid_params['size'], grid_params['res'], grid_params['wres']), u) np.save( 'gridded-v-size-{}-res-{}-wres-{}.npy'.format( grid_params['size'], grid_params['res'], grid_params['wres']), v) np.save( 'gridded-vis-size-{}-res-{}-wres-{}.npy'.format( grid_params['size'], grid_params['res'], grid_params['wres']), gridded_image.uv) l, m, img, extent = get_gimg_max(gridded_image, return_img=True) # Compute other values of interest elev, az = lm_to_ea(l, m) height = flatmirror_height(tx_coords, rx_coords, elev) if args.export_h5: h5f['l_est'][k] = l h5f['m_est'][k] = m h5f['wres'][k] = grid_params['wres'] h5f['res'][k] = grid_params['res'] h5f['size'][k] = grid_params['size'] h5f['extent'][k] = extent h5f['elevation'][k] = elev h5f['azimuth'][k] = az h5f['height'][k] = height if args.all_sky: ax.imshow(img, extent=extent, origin='lower', interpolation='nearest') ax.set_title('size={}, res={}, wres={}'.format( grid_params['size'], grid_params['res'], grid_params['wres'])) ax.set_xlabel('l') ax.set_ylabel('m') ax.plot(l, m, marker='o', color='k', label='Image Max.') ax.plot(args.l_model, args.m_model, marker='x', color='r', label='Model (input)') plt.legend(loc='lower right') plt.savefig('allsky_size_{}_res_{}_wres_{}.png'.format( grid_params['size'], grid_params['res'], grid_params['wres'])) plt.cla() save_pkl_gridded = args.pkl_gridded and k in args.pkl_gridded if save_pkl_gridded: quickDict = {'image': img, 'extent': extent} with open( 'gridded_size_{}_res_{}_wres_{}.pkl'.format( grid_params['size'], grid_params['res'], grid_params['wres']), 'wb') as f: pickle.dump(quickDict, f, protocol=pickle.HIGHEST_PROTOCOL) k += 1 if args.export_h5: h5f.close()
def main(args): filename = args.filename idi = utils.CorrelatedData(filename) aa = idi.get_antennaarray() lo = idi.get_observer() nStand = len(idi.stands) nchan = len(idi.freq) freq = idi.freq print("Raw Stand Count: %i" % nStand) print("Final Baseline Count: %i" % (nStand*(nStand-1)/2,)) print("Spectra Coverage: %.3f to %.3f MHz in %i channels (%.2f kHz/channel)" % (freq[0]/1e6, freq[-1]/1e6, nchan, (freq[1] - freq[0])/1e3)) try: print("Polarization Products: %s" % ' '.join([NUMERIC_STOKES[p] for p in idi.pols])) except KeyError: # Catch for CASA MS that use a different numbering scheme NUMERIC_STOKESMS = {1:'I', 2:'Q', 3:'U', 4:'V', 9:'XX', 10:'XY', 11:'YX', 12:'YY'} print("Polarization Products: %s" % ' '.join([NUMERIC_STOKESMS[p] for p in idi.pols])) print("Reading in FITS IDI data") nSets = idi.integration_count for set in range(1, nSets+1): if args.dataset != -1 and args.dataset != set: continue print("Set #%i of %i" % (set, nSets)) dataDict = idi.get_data_set(set, min_uv=args.uv_min) # Build a list of unique JDs for the data pols = dataDict.pols jdList = [dataDict.mjd + astro.MJD_OFFSET,] # Find the LST lo.date = jdList[0] - astro.DJD_OFFSET utc = str(lo.date) lst = str(lo.sidereal_time()) # pylint:disable=no-member # Pull out the right channels toWork = numpy.where( (freq >= args.freq_start) & (freq <= args.freq_stop) )[0] if len(toWork) == 0: raise RuntimeError("Cannot find data between %.2f and %.2f MHz" % (args.freq_start/1e6, args.freq_stop/1e6)) # Integration report print(" Date Observed: %s" % utc) print(" LST: %s" % lst) print(" Selected Frequencies: %.3f to %.3f MHz" % (freq[toWork[0]]/1e6, freq[toWork[-1]]/1e6)) # Prune out what needs to go if args.include != 'all' or args.exclude != 'none': print(" Processing include/exclude lists") dataDict = dataDict.get_antenna_subset(include=args.include, exclude=args.exclude, indicies=False) ## Report for pol in dataDict.pols: print(" %s now has %i baselines" % (pol, len(dataDict.baselines))) # Build up the images for each polarization print(" Gridding") img1 = None lbl1 = 'XX' for p in ('XX', 'RR', 'I'): try: img1 = utils.build_gridded_image(dataDict, size=NPIX_SIDE//2, res=0.5, pol=p, chan=toWork) lbl1 = p.upper() except: pass img2 = None lbl2 = 'YY' for p in ('YY', 'LL', 'Q'): try: img2 = utils.build_gridded_image(dataDict, size=NPIX_SIDE//2, res=0.5, pol=p, chan=toWork) lbl2 = p.upper() except: pass img3 = None lbl3 = 'XY' for p in ('XY', 'RL', 'U'): try: img3 = utils.build_gridded_image(dataDict, size=NPIX_SIDE//2, res=0.5, pol=p, chan=toWork) lbl3 = p.upper() except: pass img4 = None lbl4 = 'YX' for p in ('YX', 'LR', 'V'): try: img4 = utils.build_gridded_image(dataDict, size=NPIX_SIDE//2, res=0.5, pol=p, chan=toWork) lbl4 = p.upper() except: pass # Plots print(" Plotting") fig = plt.figure() ax1 = fig.add_subplot(2, 2, 1) ax2 = fig.add_subplot(2, 2, 2) ax3 = fig.add_subplot(2, 2, 3) ax4 = fig.add_subplot(2, 2, 4) for ax, img, pol in zip([ax1, ax2, ax3, ax4], [img1, img2, img3, img4], [lbl1, lbl2, lbl3, lbl4]): # Skip missing images if img is None: ax.text(0.5, 0.5, 'Not found in file', color='black', size=12, horizontalalignment='center') ax.xaxis.set_major_formatter( NullFormatter() ) ax.yaxis.set_major_formatter( NullFormatter() ) if not args.utc: ax.set_title("%s @ %s LST" % (pol, lst)) else: ax.set_title("%s @ %s UTC" % (pol, utc)) continue # Display the image and label with the polarization/LST cb = utils.plot_gridded_image(ax, img) fig.colorbar(cb, ax=ax) if not args.utc: ax.set_title("%s @ %s LST" % (pol, lst)) else: ax.set_title("%s @ %s UTC" % (pol, utc)) junk = img.image(center=(NPIX_SIDE//2,NPIX_SIDE//2)) print("%s: image is %.4f to %.4f with mean %.4f" % (pol, junk.min(), junk.max(), junk.mean())) # Turn off tick marks ax.xaxis.set_major_formatter( NullFormatter() ) ax.yaxis.set_major_formatter( NullFormatter() ) # Compute the positions of major sources and label the images overlay.sources(ax, aa, simVis.SOURCES, label=not args.no_labels) # Add in the horizon overlay.horizon(ax, aa) # Add lines of constant RA and dec. if not args.no_grid: if not args.topo: overlay.graticule_radec(ax, aa) else: overlay.graticule_azalt(ax, aa) plt.show() if args.fits is not None: ## Loop over the images to build up the FITS file hdulist = [astrofits.PrimaryHDU(),] for img,pol in zip((img1,img2,img3,img4), (lbl1,lbl2,lbl3,lbl4)): if img is None: continue ### Create the HDU try: hdu = astrofits.ImageHDU(data=img.image(center=(NPIX_SIDE//2,NPIX_SIDE//2)), name=pol) except AttributeError: hdu = astrofits.ImageHDU(data=img, name=pol) ### Add in the coordinate information hdu.header['EPOCH'] = 2000.0 + (jdList[0] - 2451545.0) / 365.25 hdu.header['CTYPE1'] = 'RA---SIN' hdu.header['CRPIX1'] = NPIX_SIDE//2+1 hdu.header['CDELT1'] = -360.0/NPIX_SIDE/numpy.pi hdu.header['CRVAL1'] = lo.sidereal_time()*180/numpy.pi # pylint:disable=no-member hdu.header['CTYPE2'] = 'DEC--SIN' hdu.header['CRPIX2'] = NPIX_SIDE//2+1 hdu.header['CDELT2'] = 360.0/NPIX_SIDE/numpy.pi hdu.header['CRVAL2'] = lo.lat*180/numpy.pi hdu.header['LONPOLE'] = 180.0 hdu.header['LATPOLE'] = 90.0 ### Add the HDU to the list hdulist.append(hdu) ## Save the FITS file to disk hdulist = astrofits.HDUList(hdulist) overwrite = False if os.path.exists(args.fits): yn = input("WARNING: '%s' exists, overwrite? [Y/n]" % args.fits) if yn not in ('n', 'N'): overwrite = True try: hdulist.writeto(args.fits, overwrite=overwrite) except IOError as e: print("WARNING: FITS image file not saved") print("...Done")