def test_deconvolve_and_restore_cube_mmclean_facets(self): self.actualSetUp(add_errors=True) dirty_imagelist = invert_list_rsexecute_workflow(self.vis_list, self.model_imagelist, context='2d', dopsf=False, normalize=True) psf_imagelist = invert_list_rsexecute_workflow(self.vis_list, self.model_imagelist, context='2d', dopsf=True, normalize=True) dirty_imagelist = rsexecute.persist(dirty_imagelist) psf_imagelist = rsexecute.persist(psf_imagelist) dec_imagelist = deconvolve_list_rsexecute_workflow(dirty_imagelist, psf_imagelist, self.model_imagelist, niter=1000, fractional_threshold=0.1, scales=[0, 3, 10], algorithm='mmclean', nmoment=3, nchan=self.freqwin, threshold=0.01, gain=0.7, deconvolve_facets=8, deconvolve_overlap=8, deconvolve_taper='tukey') dec_imagelist = rsexecute.persist(dec_imagelist) residual_imagelist = residual_list_rsexecute_workflow(self.vis_list, model_imagelist=dec_imagelist, context='2d') residual_imagelist = rsexecute.persist(residual_imagelist) restored_list = restore_list_rsexecute_workflow(model_imagelist=dec_imagelist, psf_imagelist=psf_imagelist, residual_imagelist=residual_imagelist, empty=self.model_imagelist) restored = rsexecute.compute(restored_list, sync=True)[0] if self.persist: export_image_to_fits(restored, '%s/test_imaging_%s_overlap_mmclean_restored.fits' % (self.dir, rsexecute.type()))
def test_deconvolve_spectral(self): self.actualSetUp(add_errors=True) dirty_imagelist = invert_list_rsexecute_workflow(self.vis_list, self.model_imagelist, context='2d', dopsf=False, normalize=True) psf_imagelist = invert_list_rsexecute_workflow(self.vis_list, self.model_imagelist, context='2d', dopsf=True, normalize=True) dirty_imagelist = rsexecute.persist(dirty_imagelist) psf_imagelist = rsexecute.persist(psf_imagelist) deconvolved = deconvolve_list_rsexecute_workflow(dirty_imagelist, psf_imagelist, self.model_imagelist, niter=1000, fractional_threshold=0.1, scales=[0, 3, 10], threshold=0.1, gain=0.7) deconvolved = rsexecute.persist(deconvolved) deconvolved = rsexecute.compute(deconvolved, sync=True) if self.persist: export_image_to_fits(deconvolved[0], '%s/test_imaging_%s_deconvolve_spectral.fits' % (self.dir, rsexecute.type()))
# Define a function to be executed by Dask to load the data, combine it, and select # only the short baselines. We load each channel separately. def load_ms(c): v1 = create_visibility_from_ms(input_vis[0], start_chan=c, end_chan=c)[0] v2 = create_visibility_from_ms(input_vis[1], start_chan=c, end_chan=c)[0] vf = append_visibility(v1, v2) vf = convert_visibility_to_stokes(vf) vf.configuration.diameter[...] = 35.0 rows = vis_select_uvrange(vf, 0.0, uvmax=uvmax) return create_visibility_from_rows(vf, rows) # Construct the graph to load the data and persist the graph on the Dask cluster. vis_list = [rsexecute.execute(load_ms)(c) for c in range(nchan)] vis_list = rsexecute.persist(vis_list) # Construct the graph to define the model images and persist the graph to the cluster model_list = [ rsexecute.execute(create_image_from_visibility)( v, npixel=npixel, cellsize=cellsize, polarisation_frame=PolarisationFrame("stokesIQUV"), nchan=1) for v in vis_list ] model_list = rsexecute.persist(model_list) # Construct the graphs to make the dirty image and psf, and persist these to the cluster dirty_list = invert_list_rsexecute_workflow( vis_list,
def weight_list_rsexecute_workflow(vis_list, model_imagelist, gcfcf=None, weighting='uniform', **kwargs): """ Weight the visibility data This is done collectively so the weights are summed over all vis_lists and then corrected :param vis_list: :param model_imagelist: Model required to determine weighting parameters :param weighting: Type of weighting :param kwargs: Parameters for functions in graphs :return: List of vis_graphs For example:: vis_list = weight_list_rsexecute_workflow(vis_list, model_list, weighting='uniform') """ centre = len(model_imagelist) // 2 if gcfcf is None: gcfcf = [rsexecute.execute(create_pswf_convolutionfunction)(model_imagelist[centre])] def to_vis(v): if isinstance(v, BlockVisibility): av = convert_blockvisibility_to_visibility(v) return av else: return v avis_list = [rsexecute.execute(to_vis, nout=1)(vis) for vis in vis_list] def grid_wt(vis, model, g): if vis is not None: if model is not None: griddata = create_griddata_from_image(model) griddata = grid_weight_to_griddata(vis, griddata, g[0][1]) return griddata else: return None else: return None weight_list = [rsexecute.execute(grid_wt, pure=True, nout=1)(avis_list[i], model_imagelist[i], gcfcf) for i in range(len(vis_list))] merged_weight_grid = rsexecute.execute(griddata_merge_weights, nout=1)(weight_list) merged_weight_grid = rsexecute.persist(merged_weight_grid, broadcast=True) def re_weight(vis, model, gd, g): if gd is not None: if vis is not None: # Ensure that the griddata has the right axes so that the convolution # function mapping works agd = create_griddata_from_image(model) agd.data = gd[0].data vis = griddata_reweight(vis, agd, g[0][1]) return vis else: return None else: return vis avis_list = [rsexecute.execute(re_weight, nout=1)(v, model_imagelist[i], merged_weight_grid, gcfcf) for i, v in enumerate(avis_list)] def to_bvis(v, ov): if isinstance(ov, BlockVisibility): av = convert_visibility_to_blockvisibility(v) return av else: return v result = [rsexecute.execute(to_bvis, nout=1)(vis, ovis) for vis, ovis in zip(avis_list, vis_list)] return rsexecute.optimize(result)
blockvis_list = simulate_list_rsexecute_workflow( 'LOWBD2', rmax=rmax, frequency=frequency, channel_bandwidth=channel_bandwidth, times=times, phasecentre=phasecentre, order='frequency', format='blockvis') print('%d elements in vis_list' % len(blockvis_list)) print('About to make visibility') vis_list = [ rsexecute.execute(convert_blockvisibility_to_visibility, nout=1)(bv) for bv in blockvis_list ] vis_list = rsexecute.persist(vis_list) # The vis data are on the workers so we run the advice function on the workers # without transfering the data back to the host. advice_list = [ rsexecute.execute(advise_wide_field)(v, guard_band_image=8.0, delA=0.02, wprojection_planes=1) for _, v in enumerate(vis_list) ] advice_list = rsexecute.compute(advice_list, sync=True) advice_low = advice_list[0] advice_high = advice_list[-1]
channel_bandwidth = [1e7] phasecentre = SkyCoord(ra=ra * u.deg, dec=declination * u.deg, frame='icrs', equinox='J2000') bvis_graph = create_standard_mid_simulation_rsexecute_workflow( band, rmax, phasecentre, time_range, time_chunk, integration_time, zerow=zerow) future_bvis_list = rsexecute.persist(bvis_graph) bvis_list0 = rsexecute.compute(bvis_graph[0], sync=True) nchunks = len(bvis_graph) memory_use['bvis_list'] = nchunks * bvis_list0.size() memory_use['vis_list'] = nchunks * bvis_list0.size() # We need the HWHM of the primary beam, and the location of the nulls HWHM_deg, null_az_deg, null_el_deg = find_pb_width_null(pbtype, frequency) HWHM = HWHM_deg * numpy.pi / 180.0 FOV_deg = 4.0 * 1.36e9 / frequency[0] print('%s: HWHM beam = %g deg' % (pbtype, HWHM_deg)) advice_list = rsexecute.execute(advise_wide_field)(bvis_list0,
def actualSetUp(self, add_errors=False, freqwin=7, block=False, dospectral=True, dopol=False, zerow=True): self.npixel = 256 self.low = create_named_configuration('LOWBD2', rmax=750.0) self.freqwin = freqwin self.vis_list = list() self.ntimes = 5 cellsize = 0.001 self.times = numpy.linspace(-3.0, +3.0, self.ntimes) * numpy.pi / 12.0 self.frequency = numpy.linspace(0.8e8, 1.2e8, self.freqwin) if freqwin > 1: self.channelwidth = numpy.array(freqwin * [self.frequency[1] - self.frequency[0]]) else: self.channelwidth = numpy.array([1e6]) if dopol: self.vis_pol = PolarisationFrame('linear') self.image_pol = PolarisationFrame('stokesIQUV') f = numpy.array([100.0, 20.0, -10.0, 1.0]) else: self.vis_pol = PolarisationFrame('stokesI') self.image_pol = PolarisationFrame('stokesI') f = numpy.array([100.0]) if dospectral: flux = numpy.array([f * numpy.power(freq / 1e8, -0.7) for freq in self.frequency]) else: flux = numpy.array([f]) self.phasecentre = SkyCoord(ra=+180.0 * u.deg, dec=-60.0 * u.deg, frame='icrs', equinox='J2000') self.vis_list = [rsexecute.execute(ingest_unittest_visibility)(self.low, [self.frequency[freqwin]], [self.channelwidth[freqwin]], self.times, self.vis_pol, self.phasecentre, block=block, zerow=zerow) for freqwin, _ in enumerate(self.frequency)] self.model_imagelist = [rsexecute.execute(create_unittest_model, nout=freqwin)(self.vis_list[freqwin], self.image_pol, cellsize=cellsize, npixel=self.npixel) for freqwin, _ in enumerate(self.frequency)] self.componentlist = [rsexecute.execute(create_unittest_components)(self.model_imagelist[freqwin], flux[freqwin, :][numpy.newaxis, :]) for freqwin, _ in enumerate(self.frequency)] self.model_imagelist = [rsexecute.execute(insert_skycomponent, nout=1)(self.model_imagelist[freqwin], self.componentlist[freqwin]) for freqwin, _ in enumerate(self.frequency)] self.vis_list = [rsexecute.execute(predict_skycomponent_visibility)(self.vis_list[freqwin], self.componentlist[freqwin]) for freqwin, _ in enumerate(self.frequency)] # Calculate the model convolved with a Gaussian. self.model_imagelist = rsexecute.compute(self.model_imagelist, sync=True) model = self.model_imagelist[0] self.cmodel = smooth_image(model) if self.persist: export_image_to_fits(model, '%s/test_imaging_rsexecute_deconvolved_model.fits' % self.dir) if self.persist: export_image_to_fits(self.cmodel, '%s/test_imaging_rsexecute_deconvolved_cmodel.fits' % self.dir) if add_errors and block: self.vis_list = [rsexecute.execute(insert_unittest_errors)(self.vis_list[i]) for i, _ in enumerate(self.frequency)] # self.vis_list = rsexecute.compute(self.vis_list, sync=True) self.vis_list = rsexecute.persist(self.vis_list) self.model_imagelist = rsexecute.scatter(self.model_imagelist)
elif band == 'B2': frequency = [1.36e9] elif band == 'Ku': frequency = [12.179e9] else: raise ValueError("Unknown band %s" % band) channel_bandwidth = [1e7] phasecentre = SkyCoord(ra=ra * u.deg, dec=declination * u.deg, frame='icrs', equinox='J2000') bvis_graph = create_standard_mid_simulation_rsexecute_workflow( band, rmax, phasecentre, time_range, time_chunk, integration_time) future_bvis_list = rsexecute.persist(bvis_graph) bvis_list0 = rsexecute.compute(bvis_graph[0], sync=True) nchunks = len(bvis_graph) memory_use['bvis_list'] = nchunks * bvis_list0.size() vis_graph = [ rsexecute.execute(convert_blockvisibility_to_visibility)(bv) for bv in future_bvis_list ] future_vis_list = rsexecute.persist(vis_graph, sync=True) vis_list0 = rsexecute.compute(vis_graph[0], sync=True) memory_use['vis_list'] = nchunks * vis_list0.size() # We need the HWHM of the primary beam, and the location of the nulls HWHM_deg, null_az_deg, null_el_deg = find_pb_width_null(pbtype, frequency)
def simulate(parameters): """Simulate visibility data. :param parameters: pipeline parameters (dict) """ # Get parameters, setting default value if not present freq_min = parameters.get("freq_min", 0.9e8) freq_max = parameters.get("freq_max", 1.1e8) nfreqwin = parameters.get("nfreqwin", 8) ntimes = parameters.get("ntimes", 5) rmax = parameters.get("rmax", 750.0) ra = parameters.get("ra", 0.0) dec = parameters.get("dec", -30.0) dir_vis = "/buffer/" + parameters.get("buffer_vis") frequency = numpy.linspace(freq_min, freq_max, nfreqwin) channel_bandwidth = numpy.array(nfreqwin * [frequency[1] - frequency[0]]) times = numpy.linspace(-numpy.pi / 6.0, numpy.pi / 6.0, ntimes) phasecentre = SkyCoord(ra=ra * u.deg, dec=dec * u.deg, frame="icrs", equinox="J2000") npixel = 1024 cellsize = 0.0005 rsexecute.run(init_logging) vis_list = simulate_list_rsexecute_workflow( "LOWBD2", rmax=rmax, frequency=frequency, channel_bandwidth=channel_bandwidth, times=times, phasecentre=phasecentre, order="frequency", format="blockvis", ) vis_list = rsexecute.persist(vis_list) model_list = [ rsexecute.execute(create_low_test_image_from_gleam)( npixel=npixel, frequency=[frequency[f]], channel_bandwidth=[channel_bandwidth[f]], cellsize=cellsize, phasecentre=phasecentre, polarisation_frame=PolarisationFrame("stokesI"), flux_limit=3.0, applybeam=True, ) for f in range(nfreqwin) ] def print_max(v): print(numpy.max(numpy.abs(v.vis))) return v imaging_context = "ng" vis_slices = 1 print("Using {}".format(imaging_context)) predicted_vislist = predict_list_rsexecute_workflow( vis_list, model_list, context=imaging_context, vis_slices=vis_slices, verbosity=2, ) corrupted_vislist = corrupt_list_rsexecute_workflow(predicted_vislist, phase_error=1.0, seed=180555) corrupted_vislist = [ rsexecute.execute(print_max)(v) for v in corrupted_vislist ] export_list = [ rsexecute.execute(export_blockvisibility_to_ms)( "{}/ska_pipeline_simulation_vislist_{}.ms".format(dir_vis, v), [corrupted_vislist[v]], ) for v, _ in enumerate(corrupted_vislist) ] print( "About to run predict and corrupt to get corrupted visibility, and write files" ) rsexecute.compute(export_list, sync=True)
def simulation(self, args, time_series='wind', band='B2', context='singlesource', vp_directory=''): ra = args.ra declination = args.declination use_radec = args.use_radec == "True" integration_time = args.integration_time time_range = args.time_range time_chunk = args.time_chunk offset_dir = args.offset_dir pbtype = args.pbtype pbradius = args.pbradius rmax = args.rmax flux_limit = args.flux_limit npixel = args.npixel shared_directory = args.shared_directory vp_directory = args.vp_directory # Simulation specific parameters global_pe = numpy.array(args.global_pe) static_pe = numpy.array(args.static_pe) dynamic_pe = args.dynamic_pe seed = args.seed basename = os.path.basename(os.getcwd()) use_dask = False rsexecute.set_client(use_dask=use_dask) # Set up details of simulated observation nfreqwin = 1 if band == 'B1': frequency = [0.765e9] elif band == 'B2': frequency = [1.36e9] elif band == 'Ku': frequency = [12.179e9] else: raise ValueError("Unknown band %s" % band) phasecentre = SkyCoord(ra=ra * u.deg, dec=declination * u.deg, frame='icrs', equinox='J2000') bvis_graph = create_standard_mid_simulation_rsexecute_workflow( band, rmax, phasecentre, time_range, time_chunk, integration_time, shared_directory) future_bvis_list = rsexecute.persist(bvis_graph) vis_graph = [ rsexecute.execute(convert_blockvisibility_to_visibility)(bv) for bv in future_bvis_list ] future_vis_list = rsexecute.persist(vis_graph, sync=True) # We need the HWHM of the primary beam, and the location of the nulls HWHM_deg, null_az_deg, null_el_deg = find_pb_width_null( pbtype, frequency) HWHM = HWHM_deg * numpy.pi / 180.0 FOV_deg = 8.0 * 1.36e9 / frequency[0] advice_list = rsexecute.execute(advise_wide_field)( future_vis_list[0], guard_band_image=1.0, delA=0.02, verbose=False) advice = rsexecute.compute(advice_list, sync=True) pb_npixel = 1024 d2r = numpy.pi / 180.0 pb_cellsize = d2r * FOV_deg / pb_npixel cellsize = advice['cellsize'] # Now construct the components original_components, offset_direction = create_simulation_components( context, phasecentre, frequency, pbtype, offset_dir, flux_limit, pbradius * HWHM, pb_npixel, pb_cellsize) vp_list = [ rsexecute.execute(create_image_from_visibility)( bv, npixel=pb_npixel, frequency=frequency, nchan=nfreqwin, cellsize=pb_cellsize, phasecentre=phasecentre, override_cellsize=False) for bv in future_bvis_list ] vp_list = [ rsexecute.execute(create_vp)(vp, pbtype, pointingcentre=phasecentre, use_local=not use_radec) for vp in vp_list ] future_vp_list = rsexecute.persist(vp_list) # Make one image per component future_model_list = [ rsexecute.execute(create_image_from_visibility)( future_vis_list[0], npixel=npixel, frequency=frequency, nchan=nfreqwin, cellsize=cellsize, phasecentre=offset_direction, polarisation_frame=PolarisationFrame("stokesI")) for i, _ in enumerate(original_components) ] a2r = numpy.pi / (3600.0 * 1800) no_error_gtl = None error_gtl = None if time_series == '': global_pointing_error = global_pe static_pointing_error = static_pe pointing_error = dynamic_pe no_error_gtl, error_gtl = \ create_pointing_errors_gaintable_rsexecute_workflow(future_bvis_list, original_components, sub_vp_list=future_vp_list, use_radec=use_radec, pointing_error=a2r * pointing_error, static_pointing_error=a2r * static_pointing_error, global_pointing_error=a2r * global_pointing_error, seed=seed, show=False, basename=basename) elif time_series == 'wind': no_error_gtl, error_gtl = \ create_pointing_errors_gaintable_rsexecute_workflow(future_bvis_list, original_components, sub_vp_list=future_vp_list, use_radec=use_radec, time_series=time_series, time_series_type='precision', seed=seed, show=False, basename=basename) elif time_series == 'gravity': no_error_gtl, error_gtl = \ create_surface_errors_gaintable_rsexecute_workflow(band, future_bvis_list, original_components, vp_directory=vp_directory, use_radec=use_radec, show=False, basename=basename) else: raise ValueError("Unknown type of error %s" % time_series) # Now make all the residual images vis_comp_chunk_dirty_list = \ calculate_residual_from_gaintables_rsexecute_workflow(future_bvis_list, original_components, future_model_list, no_error_gtl, error_gtl) # Add the resulting images error_dirty_list = sum_invert_results_rsexecute( vis_comp_chunk_dirty_list) # Actually compute the graph assembled above error_dirty, sumwt = rsexecute.compute(error_dirty_list, sync=True) return error_dirty, sumwt
def ical(parameters): """Iterative self-calibration. Calibrate visibilities and produce continuum image. :param parameters: pipeline parameters (dict) """ # Get parameters, setting default value if not present nfreqwin = parameters.get("nfreqwin", 8) dir_vis = "/buffer/" + parameters.get("buffer_vis") dir_img = "/buffer/" + parameters.get("buffer_img") cellsize = 0.0005 npixel = 1024 pol_frame = PolarisationFrame("stokesI") centre = nfreqwin // 2 rsexecute.run(init_logging) # Load data from simulation vis_list = [ rsexecute.execute(create_blockvisibility_from_ms)( "{}/ska_pipeline_simulation_vislist_{}.ms".format(dir_vis, v))[0] for v in range(nfreqwin) ] print("Reading visibilities") vis_list = rsexecute.persist(vis_list) model_list = [ rsexecute.execute(create_image_from_visibility)( v, npixel=npixel, cellsize=cellsize, polarisation_frame=pol_frame) for v in vis_list ] print("Creating model images") model_list = rsexecute.persist(model_list) imaging_context = "ng" vis_slices = 1 controls = create_calibration_controls() controls["T"]["first_selfcal"] = 1 controls["T"]["phase_only"] = True controls["T"]["timeslice"] = "auto" controls["G"]["first_selfcal"] = 3 controls["G"]["timeslice"] = "auto" controls["B"]["first_selfcal"] = 4 controls["B"]["timeslice"] = 1e5 ical_list = ical_list_rsexecute_workflow( vis_list, model_imagelist=model_list, context=imaging_context, vis_slice=vis_slices, scales=[0, 3, 10], algorithm="mmclean", nmoment=2, niter=1000, fractional_threshold=0.1, threshold=0.1, nmajor=5, gain=0.25, deconvolve_facets=1, deconvolve_overlap=0, restore_facets=8, timeslice="auto", psf_support=128, global_solution=False, calibration_context="T", do_selfcal=True, ) print("About to run ICAL workflow") result = rsexecute.compute(ical_list, sync=True) print("Writing images") deconvolved = result[0][centre] residual = result[1][centre][0] restored = result[2][centre] export_form = "{}/ska_pipeline_ical_{}.fits" export_list = [ rsexecute.execute(export_image_to_fits)(deconvolved, export_form.format( dir_img, "deconvolved")), rsexecute.execute(export_image_to_fits)(residual, export_form.format( dir_img, "residual")), rsexecute.execute(export_image_to_fits)(restored, export_form.format( dir_img, "restored")), ] rsexecute.compute(export_list, sync=True)
times = numpy.linspace(-numpy.pi / 3.0, numpy.pi / 3.0, ntimes) phasecentre = SkyCoord(ra=+30.0 * u.deg, dec=-45.0 * u.deg, frame='icrs', equinox='J2000') vis_list = simulate_list_rsexecute_workflow( 'LOWBD2', rmax=rmax, frequency=frequency, channel_bandwidth=channel_bandwidth, times=times, phasecentre=phasecentre, order='frequency', format='blockvis') vis_list = rsexecute.persist(vis_list) npixel = 1024 cellsize = 0.0005 dprepb_model = [ rsexecute.execute(create_low_test_image_from_gleam)( npixel=npixel, frequency=[frequency[f]], channel_bandwidth=[channel_bandwidth[f]], cellsize=cellsize, phasecentre=phasecentre, polarisation_frame=PolarisationFrame("stokesI"), flux_limit=3.0, applybeam=True) for f, freq in enumerate(frequency) ]
def test_apply_voltage_pattern_image_pointsource(self): self.createVis(rmax=1e3) telescope = 'MID_FEKO_B2' vpol = PolarisationFrame("linear") self.times = numpy.linspace(-4, +4, 8) * numpy.pi / 12.0 bvis = create_blockvisibility(self.config, self.times, self.frequency, channel_bandwidth=self.channel_bandwidth, phasecentre=self.phasecentre, weight=1.0, polarisation_frame=vpol, zerow=True) cellsize = advise_wide_field(bvis)['cellsize'] pbmodel = create_image_from_visibility( bvis, cellsize=self.cellsize, npixel=self.npixel, override_cellsize=False, polarisation_frame=PolarisationFrame("stokesIQUV")) vpbeam = create_vp(pbmodel, telescope=telescope, use_local=False) vpbeam.wcs.wcs.ctype[0] = 'RA---SIN' vpbeam.wcs.wcs.ctype[1] = 'DEC--SIN' vpbeam.wcs.wcs.crval[0] = pbmodel.wcs.wcs.crval[0] vpbeam.wcs.wcs.crval[1] = pbmodel.wcs.wcs.crval[1] s3_components = create_test_skycomponents_from_s3( flux_limit=0.1, phasecentre=self.phasecentre, frequency=self.frequency, polarisation_frame=PolarisationFrame('stokesI'), radius=1.5 * numpy.pi / 180.0) for comp in s3_components: comp.polarisation_frame = PolarisationFrame('stokesIQUV') comp.flux = numpy.array([[comp.flux[0, 0], 0.0, 0.0, 0.0]]) s3_components = filter_skycomponents_by_flux(s3_components, 0.0, 10.0) from rascil.processing_components.image import show_image import matplotlib.pyplot as plt plt.clf() show_image(vpbeam, components=s3_components) plt.show(block=False) vpcomp = apply_voltage_pattern_to_skycomponent(s3_components, vpbeam) bvis.data['vis'][...] = 0.0 + 0.0j bvis = dft_skycomponent_visibility(bvis, vpcomp) rec_comp = idft_visibility_skycomponent(bvis, vpcomp)[0] stokes_comp = list() for comp in rec_comp: stokes_comp.append( convert_pol_frame(comp.flux[0], PolarisationFrame("linear"), PolarisationFrame("stokesIQUV"))) stokesI = numpy.abs( numpy.array([comp_flux[0] for comp_flux in stokes_comp]).real) stokesQ = numpy.abs( numpy.array([comp_flux[1] for comp_flux in stokes_comp]).real) stokesU = numpy.abs( numpy.array([comp_flux[2] for comp_flux in stokes_comp]).real) stokesV = numpy.abs( numpy.array([comp_flux[3] for comp_flux in stokes_comp]).real) plt.clf() plt.loglog(stokesI, stokesQ, '.', label='Q') plt.loglog(stokesI, stokesU, '.', label='U') plt.loglog(stokesI, stokesV, '.', label='V') plt.xlabel("Stokes Flux I (Jy)") plt.ylabel("Flux (Jy)") plt.legend() plt.savefig('%s/test_primary_beams_pol_rsexecute_stokes_errors.png' % self.dir) plt.show(block=False) split_times = False if split_times: bvis_list = list() for rows in vis_timeslice_iter(bvis, vis_slices=8): bvis_list.append(create_visibility_from_rows(bvis, rows)) else: bvis_list = [bvis] bvis_list = rsexecute.scatter(bvis_list) model_list = \ [rsexecute.execute(create_image_from_visibility, nout=1)(bv, cellsize=cellsize, npixel=4096, phasecentre=self.phasecentre, override_cellsize=False, polarisation_frame=PolarisationFrame("stokesIQUV")) for bv in bvis_list] model_list = rsexecute.persist(model_list) bvis_list = weight_list_rsexecute_workflow(bvis_list, model_list) continuum_imaging_list = \ continuum_imaging_list_rsexecute_workflow(bvis_list, model_list, context='2d', algorithm='hogbom', facets=1, niter=1000, fractional_threshold=0.1, threshold=1e-4, nmajor=5, gain=0.1, deconvolve_facets=4, deconvolve_overlap=32, deconvolve_taper='tukey', psf_support=64, restore_facets=4, psfwidth=1.0) clean, residual, restored = rsexecute.compute(continuum_imaging_list, sync=True) centre = 0 if self.persist: export_image_to_fits( clean[centre], '%s/test_primary_beams_pol_rsexecute_clean.fits' % self.dir) export_image_to_fits( residual[centre][0], '%s/test_primary_beams_pol_rsexecute_residual.fits' % self.dir) export_image_to_fits( restored[centre], '%s/test_primary_beams_pol_rsexecute_restored.fits' % self.dir) plt.clf() show_image(restored[centre]) plt.show(block=False) qa = qa_image(restored[centre]) assert numpy.abs(qa.data['max'] - 0.9953017707113947) < 1.0e-7, str(qa) assert numpy.abs(qa.data['min'] + 0.0036396480874570846) < 1.0e-7, str(qa)
return vis channels = [] for i in range(0, len(ochannels) - 1, ngroup): channels.append([ochannels[i], ochannels[i + ngroup - 1]]) print(channels) if single: channels = [channels[0]] log.info("Will read single range of channels %s" % channels) vis_list = [ rsexecute.execute(read_convert)(target_ms, group_chan) for group_chan in channels ] vis_list = rsexecute.persist(vis_list) #################################################################################################################### log.info("\nSetup of images") phasecentre = SkyCoord(ra=0.0 * u.deg, dec=-27.0 * u.deg) advice = [ rsexecute.execute(advise_wide_field)(v, guard_band_image=fov, delA=dela, verbose=(iv == 0)) for iv, v in enumerate(vis_list) ] advice = rsexecute.compute(advice, sync=True)
def _test(self, time_range=None, flux=None, test_vp=False, name=""): # Set up details of simulated observation npixel = 1024 band = 'B2' frequency = [1.36e9] rmax = 1e3 self.createVis(rmax=rmax) if time_range is None: time_range = [-0.01, 0.01] time_chunk = 1800.0 integration_time = 1800.0 imaging_context = "2d" cellsize = 1e-05 vis_slices = 1 telescope = "MID_FEKO_B2" result = dict() if flux is None: flux = [[1.0, 0.0, 0.0, 0.0]] else: flux = [flux] cellsize_deg = 180.0 * cellsize / numpy.pi offset = [0.0, 0.25 - 0.3309316221544 * cellsize_deg] ra = self.phasecentre.ra.deg dec = self.phasecentre.dec.deg print(ra, dec) odirection = SkyCoord( ra=(ra + offset[0] / numpy.cos(numpy.pi * dec / 180.0)) * u.deg, dec=(dec + offset[1]) * u.deg, frame='icrs', equinox='J2000') print(self.phasecentre) print(odirection) original_components = [ Skycomponent(direction=odirection, frequency=frequency, flux=flux, polarisation_frame=PolarisationFrame('stokesIQUV')) ] for method in ["fft", "dft"]: bvis_graph = create_standard_mid_simulation_rsexecute_workflow( band, rmax, self.phasecentre, time_range, time_chunk, integration_time, polarisation_frame=PolarisationFrame("linear"), zerow=True) #imaging_context == "2d") bvis_graph = rsexecute.persist(bvis_graph) def find_vp_actual(telescope, normalise=True): vp = create_vp(telescope=telescope) if test_vp: vp.data[:, 0, ...] = 1.0 vp.data[:, 1, ...] = 0.0 vp.data[:, 2, ...] = 0.0 vp.data[:, 3, ...] = 1.0 if normalise: g = numpy.zeros([4]) g[0] = numpy.max(numpy.abs(vp.data[:, 0, ...])) g[3] = numpy.max(numpy.abs(vp.data[:, 3, ...])) g[1] = g[2] = numpy.sqrt(g[0] * g[3]) for chan in range(4): vp.data[:, chan, ...] /= g[chan] return vp future_model_list = [ rsexecute.execute(create_image_from_visibility)( bvis, npixel=npixel, frequency=frequency, nchan=1, cellsize=cellsize, phasecentre=self.phasecentre, polarisation_frame=PolarisationFrame("stokesIQUV")) for bvis in bvis_graph ] centre_model = \ [rsexecute.execute(create_image_from_visibility)(v, npixel=npixel, nchan=1, cellsize=cellsize, phasecentre=self.phasecentre, polarisation_frame=PolarisationFrame("stokesIQUV")) for v in bvis_graph] centre_model = rsexecute.persist(centre_model) # Now make all the residual images: if method == "dft": # The parallactic angle rotation is done when the voltage pattern is # converted to a gaintable def make_ejterm(model): vp = find_vp_actual(telescope=telescope) return vp vp_list = [ rsexecute.execute(make_ejterm)(centre_model[ibvis]) for ibvis, bvis in enumerate(bvis_graph) ] vp_list = rsexecute.persist(vp_list) gt_list = [ rsexecute.execute(simulate_gaintable_from_voltage_pattern)( bvis, original_components, vp_list[ibv], use_radec=False) for ibv, bvis in enumerate(bvis_graph) ] gt_list = rsexecute.persist(gt_list) dirty_list = \ calculate_residual_dft_rsexecute_workflow(bvis_graph, original_components, future_model_list, gt_list=gt_list, context=imaging_context, vis_slices=vis_slices, do_wstacking=False) dirty_list = rsexecute.persist(dirty_list) else: def make_ejterm_rotated(model, bvis): vp = find_vp_actual(telescope=telescope) pa = numpy.average( calculate_blockvisibility_parallactic_angles(bvis)) vp_rotated = convert_azelvp_to_radec(vp, model, -pa) return vp_rotated vp_list = [ rsexecute.execute(make_ejterm_rotated)(centre_model[ibvis], bvis) for ibvis, bvis in enumerate(bvis_graph) ] vp_list = rsexecute.persist(vp_list) dirty_list = \ calculate_residual_fft_rsexecute_workflow(bvis_graph, original_components, future_model_list, vp_list=vp_list, context=imaging_context, vis_slices=vis_slices, do_wstacking=False) dirty_list = rsexecute.persist(dirty_list) dirty_list = rsexecute.compute(dirty_list, sync=True) for ipol, pol in enumerate(["I", "Q", "U", "V"]): result["model_{}".format(pol)] = flux[0][ipol] polimage = copy_image(dirty_list[0]) polimage.data = polimage.data[:, ipol, ...][:, numpy.newaxis, ...] qa = qa_image(polimage, context="Stokes " + pol) result["peak_{}_{}".format(method, pol)] = max(qa.data['min'], qa.data['max'], key=abs) export_image_to_fits( dirty_list[0], "{}/test_voltage_pattern_pol_rsexecute_{}_{}.fits".format( self.dir, name, method)) if self.verbose: print(name) for ipol, pol in enumerate(["I", "Q", "U", "V"]): result["peak_diff_{}".format(pol)] = result["peak_fft_{}".format( pol)] - result["peak_dft_{}".format(pol)] result["peak_modeldiff_{}".format(pol)] = result[ "peak_dft_{}".format(pol)] - result["model_{}".format(pol)] if self.verbose: print( "{} model: {:.2f} fft: {:.6f} dft: {:.6f} fft - dft: {:.6f} dft - model: {:.6f}" .format(pol, result["model_{}".format(pol)], result["peak_fft_{}".format(pol)], result["peak_dft_{}".format(pol)], result["peak_diff_{}".format(pol)], result["peak_modeldiff_{}".format(pol)])) return result