def get_polarisation_map(vis: Visibility, im: Image = None):
""" Get the mapping of visibility polarisations to image polarisations
"""
assert image_is_canonical(im)
if vis.polarisation_frame == im.polarisation_frame:
if vis.polarisation_frame == PolarisationFrame('stokesI'):
return "stokesI->stokesI", lambda pol: 0
elif vis.polarisation_frame == PolarisationFrame('stokesIQUV'):
return "stokesIQUV->stokesIQUV", lambda pol: pol
return "unknown", lambda pol: pol
def read_convert(ms, ch):
start = time.time()
bvis = create_blockvisibility_from_ms(ms,
start_chan=ch[0],
end_chan=ch[1])[0]
# The following are not set in the MSes
bvis.configuration.location = EarthLocation(lon="116.76444824",
lat="-26.824722084",
height=300.0)
bvis.configuration.frame = ""
bvis.configuration.receptor_frame = ReceptorFrame("linear")
bvis.configuration.data['diameter'][...] = 35.0
print(bvis)
if bvis.polarisation_frame != PolarisationFrame('stokesI'):
log.info("Converting visibility to stokesI")
bvis = convert_blockvisibility_to_stokesI(bvis)
print(bvis)
if use_block:
log.info("Working with BlockVisibility's")
return bvis
else:
if time_coal > 0.0 or frequency_coal > 0.0:
vis = coalesce_visibility(bvis,
time_coal=time_coal,
frequency_coal=frequency_coal)
log.info(
"Time to read and convert %s, channels %d to %d = %.1f s" %
(ms, ch[0], ch[1], time.time() - start))
print('Size of visibility before compression %s, after %s' %
(vis_summary(bvis), vis_summary(vis)))
else:
vis = convert_blockvisibility_to_visibility(bvis)
log.info(
"Time to read and convert %s, channels %d to %d = %.1f s" %
(ms, ch[0], ch[1], time.time() - start))
print('Size of visibility before conversion %s, after %s' %
(vis_summary(bvis), vis_summary(vis)))
del bvis
return vis
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,
template_model_imagelist=model_list,
context=context,
vis_slices=vis_slices)
psf_list = invert_list_rsexecute_workflow(
vis_list,
template_model_imagelist=model_list,
context=context,
dopsf=True,
centre = numpy.mean(low.xyz, axis=0)
distance = numpy.hypot(low.xyz[:, 0] - centre[0],
low.xyz[:, 1] - centre[1],
low.xyz[:, 2] - centre[2])
lowouter = low.data[distance > 1000.0][::6]
lowcore = low.data[distance < 1000.0][::3]
low.data = numpy.hstack((lowcore, lowouter))
block_vis = create_blockvisibility(
low,
times,
frequency=frequency,
channel_bandwidth=channel_bandwidth,
weight=1.0,
phasecentre=phasecentre,
polarisation_frame=PolarisationFrame("stokesI"),
zerow=True)
vis = convert_blockvisibility_to_visibility(block_vis)
advice = advise_wide_field(vis, guard_band_image=2.0, delA=0.02)
cellsize = advice['cellsize']
vis_slices = advice['vis_slices']
npixel = advice['npixels2']
small_model = create_image_from_visibility(block_vis,
npixel=512,
frequency=frequency,
nchan=nfreqwin,
cellsize=cellsize,
phasecentre=phasecentre)
ntimes = 5
rmax = 750.0
centre = nfreqwin // 2
# Load data from previous simulation
vis_list = [
rsexecute.execute(create_blockvisibility_from_ms)(rascil_path(
'%s/ska-pipeline_simulation_vislist_%d.ms' % (results_dir, v)))[0]
for v in range(nfreqwin)
]
vis_list = rsexecute.persist(vis_list)
cellsize = 0.0005
npixel = 1024
pol_frame = PolarisationFrame("stokesI")
model_list = [
rsexecute.execute(create_image_from_visibility)(
v, npixel=npixel, cellsize=cellsize, polarisation_frame=pol_frame)
for v in vis_list
]
model_list = rsexecute.persist(model_list)
imaging_context = 'ng'
vis_slices = 1
dirty_list = invert_list_rsexecute_workflow(
vis_list,
template_model_imagelist=model_list,
context=imaging_context,
log.setLevel(logging.DEBUG)
log.addHandler(logging.StreamHandler(sys.stdout))
log.addHandler(logging.StreamHandler(sys.stderr))
if __name__ == '__main__':
results_dir = rascil_path('test_results')
bvt = create_blockvisibility_from_ms(rascil_path('data/vis/sim-2.ms'), start_chan=35, end_chan=39)[0]
bvt.configuration.diameter[...] = 35.0
vt = convert_blockvisibility_to_visibility(bvt)
vt = convert_visibility_to_stokes(vt)
a2r = numpy.pi / (180.0 * 3600.0)
model = create_image_from_visibility(vt, cellsize=20.0 * a2r, npixel=512,
polarisation_frame=PolarisationFrame('stokesIQUV'))
dirty, sumwt = invert_list_serial_workflow([vt], [model], context='2d')[0]
psf, sumwt = invert_list_serial_workflow([vt], [model], context='2d', dopsf=True)[0]
export_image_to_fits(dirty, '%s/rascil_imaging_sim_2_dirty.fits' % (results_dir))
export_image_to_fits(psf, '%s/rascil_imaging_sim_2_psf.fits' % (results_dir))
# Deconvolve using msclean
comp, residual = deconvolve_cube(dirty, psf, niter=10000, threshold=0.001,
fractional_threshold=0.001,
algorithm='msclean',
window_shape='quarter', gain=0.7,
scales=[0, 3, 10, 30])
restored = restore_cube(comp, psf, residual)
print(qa_image(restored))
def actualSetup(self, nsources=None, nvoronoi=None):
# Set up the observation: 10 minutes at transit, with 10s integration.
# Skip 5/6 points to avoid outstation redundancy
nfreqwin = 1
ntimes = 3
self.rmax = 2500.0
dec = -40.0 * u.deg
frequency = [1e8]
channel_bandwidth = [0.1e8]
times = numpy.linspace(-10.0, 10.0, ntimes) * numpy.pi / (3600.0 * 12.0)
phasecentre = SkyCoord(ra=+0.0 * u.deg, dec=dec, frame='icrs', equinox='J2000')
low = create_named_configuration('LOWBD2', rmax=self.rmax)
centre = numpy.mean(low.xyz, axis=0)
distance = numpy.hypot(low.xyz[:, 0] - centre[0],
low.xyz[:, 1] - centre[1],
low.xyz[:, 2] - centre[2])
lowouter = low.data[distance > 1000.0][::6]
lowcore = low.data[distance < 1000.0][::3]
low.data = numpy.hstack((lowcore, lowouter))
blockvis = create_blockvisibility(low, times, frequency=frequency, channel_bandwidth=channel_bandwidth,
weight=1.0, phasecentre=phasecentre,
polarisation_frame=PolarisationFrame("stokesI"), zerow=True)
vis = convert_blockvisibility_to_visibility(blockvis)
advice = advise_wide_field(vis, guard_band_image=2.0, delA=0.02)
cellsize = advice['cellsize']
npixel = 512
small_model = create_image_from_visibility(
blockvis,
npixel=512,
frequency=frequency,
nchan=nfreqwin,
cellsize=cellsize,
phasecentre=phasecentre)
vis.data['imaging_weight'][...] = vis.data['weight'][...]
vis = weight_list_serial_workflow([vis], [small_model])[0]
vis = taper_list_serial_workflow([vis], 3 * cellsize)[0]
blockvis = convert_visibility_to_blockvisibility(vis)
# ### Generate the model from the GLEAM catalog, including application of the primary beam.
beam = create_image_from_visibility(blockvis, npixel=npixel, frequency=frequency,
nchan=nfreqwin, cellsize=cellsize, phasecentre=phasecentre)
beam = create_low_test_beam(beam, use_local=False)
flux_limit = 0.5
original_gleam_components = create_low_test_skycomponents_from_gleam(flux_limit=flux_limit,
phasecentre=phasecentre,
frequency=frequency,
polarisation_frame=PolarisationFrame(
'stokesI'),
radius=0.15)
all_components = apply_beam_to_skycomponent(original_gleam_components, beam)
all_components = filter_skycomponents_by_flux(all_components, flux_min=flux_limit)
voronoi_components = filter_skycomponents_by_flux(all_components, flux_min=1.5)
def max_flux(elem):
return numpy.max(elem.flux)
voronoi_components = sorted(voronoi_components, key=max_flux, reverse=True)
if nsources is not None:
all_components = [all_components[0]]
if nvoronoi is not None:
voronoi_components = [voronoi_components[0]]
self.screen = import_image_from_fits(rascil_data_path('models/test_mpc_screen.fits'))
all_gaintables = create_gaintable_from_screen(blockvis, all_components,
self.screen)
gleam_skymodel_noniso = [SkyModel(components=[all_components[i]], gaintable=all_gaintables[i])
for i, sm in enumerate(all_components)]
# ### Now predict the visibility for each skymodel and apply the gaintable for that skymodel,
# returning a list of visibilities, one for each skymodel. We then sum these to obtain
# the total predicted visibility. All images and skycomponents in the same skymodel
# get the same gaintable applied which means that in this case each skycomponent has a separate gaintable.
self.all_skymodel_noniso_vis = convert_blockvisibility_to_visibility(blockvis)
ngroup = 8
future_vis = rsexecute.scatter(self.all_skymodel_noniso_vis)
chunks = [gleam_skymodel_noniso[i:i + ngroup] for i in range(0, len(gleam_skymodel_noniso), ngroup)]
for chunk in chunks:
result = predict_skymodel_list_rsexecute_workflow(future_vis, chunk, context='2d', docal=True)
work_vis = rsexecute.compute(result, sync=True)
for w in work_vis:
self.all_skymodel_noniso_vis.data['vis'] += w.data['vis']
assert numpy.max(numpy.abs(self.all_skymodel_noniso_vis.data['vis'])) > 0.0
self.all_skymodel_noniso_blockvis = convert_visibility_to_blockvisibility(self.all_skymodel_noniso_vis)
# ### Remove weaker of components that are too close (0.02 rad)
idx, voronoi_components = remove_neighbouring_components(voronoi_components, 0.02)
model = create_image_from_visibility(blockvis, npixel=npixel, frequency=frequency,
nchan=nfreqwin, cellsize=cellsize, phasecentre=phasecentre)
# Use the gaintable for the brightest component as the starting gaintable
all_gaintables[0].gain[...] = numpy.conjugate(all_gaintables[0].gain[...])
all_gaintables[0].gain[...] = 1.0 + 0.0j
self.theta_list = initialize_skymodel_voronoi(model, voronoi_components, all_gaintables[0])
def trial_case(results,
seed=180555,
context='wstack',
nworkers=8,
threads_per_worker=1,
memory=8,
processes=True,
order='frequency',
nfreqwin=7,
ntimes=3,
rmax=750.0,
facets=1,
wprojection_planes=1,
use_dask=True,
use_serial_imaging=True,
flux_limit=0.3,
nmajor=5,
dft_threshold=1.0,
use_serial_clean=True,
write_fits=False):
""" Single trial for performance-timings
Simulates visibilities from GLEAM including phase errors
Makes dirty image and PSF
Runs ICAL pipeline
The results are in a dictionary:
'context': input - a string describing concisely the purpose of the test
'time overall', overall execution time (s)
'time predict', time to execute GLEAM prediction graph
'time invert', time to make dirty image
'time invert graph', time to make dirty image graph
'time ICAL graph', time to create ICAL graph
'time ICAL', time to execute ICAL graph
'context', type of imaging e.g. 'wstack'
'nworkers', number of workers to create
'threads_per_worker',
'nnodes', Number of nodes,
'processes', 'order', Ordering of data_models
'nfreqwin', Number of frequency windows in simulation
'ntimes', Number of hour angles in simulation
'rmax', Maximum radius of stations used in simulation (m)
'facets', Number of facets in deconvolution and imaging
'wprojection_planes', Number of wprojection planes
'vis_slices', Number of visibility slices (per Visibbility)
'npixel', Number of pixels in image
'cellsize', Cellsize in radians
'seed', Random number seed
'dirty_max', Maximum in dirty image
'dirty_min', Minimum in dirty image
'restored_max',
'restored_min',
'deconvolved_max',
'deconvolved_min',
'residual_max',
'residual_min',
'git_info', GIT hash (not definitive since local mods are possible)
:param results: Initial state
:param seed: Random number seed (used in gain simulations)
:param context: imaging context
:param context: Type of context: '2d'|'timeslice'|'wstack'
:param nworkers: Number of dask workers to use
:param threads_per_worker: Number of threads per worker
:param processes: Use processes instead of threads 'processes'|'threads'
:param order: See simulate_list_list_rsexecute_workflow_workflowkflow
:param nfreqwin: See simulate_list_list_rsexecute_workflow_workflowkflow
:param ntimes: See simulate_list_list_rsexecute_workflow_workflowkflow
:param rmax: See simulate_list_list_rsexecute_workflow_workflowkflow
:param facets: Number of facets to use
:param wprojection_planes: Number of wprojection planes to use
:param use_dask: Use dask or immediate evaluation
:return: results dictionary
"""
if use_dask:
scheduler = os.getenv('RASCIL_DASK_SCHEDULER', None)
if scheduler is not None:
client = get_dask_client(n_workers=nworkers,
memory_limit=memory * 1024 * 1024 * 1024,
threads_per_worker=threads_per_worker)
rsexecute.set_client(client=client)
else:
rsexecute.set_client(threads_per_worker=threads_per_worker,
processes=threads_per_worker == 1,
memory_limit=memory * 1024 * 1024 * 1024,
n_workers=nworkers)
print("Defined %d workers" % (nworkers))
else:
rsexecute.set_client(use_dask=use_dask)
results['nnodes'] = 1
def init_logging():
logging.basicConfig(
filename='pipelines_rsexecute_timings.log',
filemode='w',
format='%(asctime)s,%(msecs)d %(name)s %(levelname)s %(message)s',
datefmt='%H:%M:%S',
level=logging.INFO)
init_logging()
log = logging.getLogger()
# Initialise logging on the workers. This appears to only work using the process scheduler.
rsexecute.run(init_logging)
def lprint(*args):
log.info(*args)
print(*args)
lprint("Starting pipelines_rsexecute_timings")
numpy.random.seed(seed)
results['seed'] = seed
start_all = time.time()
results['context'] = context
results['hostname'] = socket.gethostname()
results['git_hash'] = git_hash()
results['epoch'] = time.strftime("%Y-%m-%d %H:%M:%S")
lprint("Context is %s" % context)
results['nworkers'] = nworkers
results['threads_per_worker'] = threads_per_worker
results['processes'] = processes
results['memory'] = memory
results['order'] = order
results['nfreqwin'] = nfreqwin
results['ntimes'] = ntimes
results['rmax'] = rmax
results['facets'] = facets
results['wprojection_planes'] = wprojection_planes
results['dft threshold'] = dft_threshold
results['use_dask'] = use_dask
lprint("At start, configuration is:")
lprint(sort_dict(results))
# Parameters determining scale of simulation.
frequency = numpy.linspace(1.0e8, 1.2e8, nfreqwin)
centre = nfreqwin // 2
if nfreqwin > 1:
channel_bandwidth = numpy.array(nfreqwin *
[frequency[1] - frequency[0]])
else:
channel_bandwidth = numpy.array([1e6])
times = numpy.linspace(-numpy.pi / 4.0, numpy.pi / 4.0, ntimes)
phasecentre = SkyCoord(ra=+0.0 * u.deg,
dec=-40.0 * u.deg,
frame='icrs',
equinox='J2000')
lprint("****** Visibility creation ******")
# Create the empty BlockVisibility's and persist these on the cluster
tmp_bvis_list = simulate_list_rsexecute_workflow(
'LOWBD2',
frequency=frequency,
channel_bandwidth=channel_bandwidth,
times=times,
phasecentre=phasecentre,
order=order,
format='blockvis',
rmax=rmax)
tmp_vis_list = [
rsexecute.execute(convert_blockvisibility_to_visibility)(bv)
for bv in tmp_bvis_list
]
tmp_vis_list = rsexecute.client.compute(tmp_vis_list, sync=True)
vis_list = rsexecute.gather(tmp_vis_list)
import matplotlib.pyplot as plt
plt.clf()
plt.hist(vis_list[0].w, bins=100)
plt.title('Histogram of w samples: rms=%.1f (wavelengths)' %
numpy.std(vis_list[0].w))
plt.xlabel('W (wavelengths)')
#plt.show()
plt.clf()
plt.hist(vis_list[0].uvdist, bins=100)
plt.title('Histogram of uvdistance samples')
plt.xlabel('UV Distance (wavelengths)')
#plt.show()
rsexecute.client.cancel(tmp_vis_list)
future_vis_list = rsexecute.scatter(vis_list)
# Find the best imaging parameters but don't bring the vis_list back here
print("****** Finding wide field parameters ******")
future_advice = [
rsexecute.execute(advise_wide_field)(
v,
guard_band_image=6.0,
delA=0.1,
facets=facets,
wprojection_planes=wprojection_planes,
oversampling_synthesised_beam=4.0) for v in future_vis_list
]
future_advice = rsexecute.compute(future_advice)
advice = rsexecute.client.gather(future_advice)[-1]
rsexecute.client.cancel(future_advice)
# Deconvolution via sub-images requires 2^n
npixel = advice['npixels2']
results['npixel'] = npixel
cellsize = advice['cellsize']
results['cellsize'] = cellsize
lprint("Image will have %d by %d pixels, cellsize = %.6f rad" %
(npixel, npixel, cellsize))
# Create an empty model image
tmp_model_list = [
rsexecute.execute(create_image)(
npixel=npixel,
cellsize=cellsize,
frequency=[frequency[f]],
channel_bandwidth=[channel_bandwidth[f]],
phasecentre=phasecentre,
polarisation_frame=PolarisationFrame("stokesI"))
for f, freq in enumerate(frequency)
]
model_list = rsexecute.compute(tmp_model_list, sync=True)
future_model_list = rsexecute.scatter(model_list)
lprint("****** Setting up imaging parameters ******")
# Now set up the imaging parameters
template_model = create_image(
npixel=npixel,
cellsize=cellsize,
frequency=[frequency[centre]],
phasecentre=phasecentre,
channel_bandwidth=[channel_bandwidth[centre]],
polarisation_frame=PolarisationFrame("stokesI"))
gcfcf = [create_pswf_convolutionfunction(template_model)]
if context == 'timeslice':
vis_slices = ntimes
lprint("Using timeslice with %d slices" % vis_slices)
elif context == '2d':
vis_slices = 1
elif context == "wprojection":
wstep = advice['wstep']
nw = advice['wprojection_planes']
vis_slices = 1
support = advice['nwpixels']
results['wprojection_planes'] = nw
lprint("****** Starting W projection kernel creation ******")
lprint("Using wprojection with %d planes with wstep %.1f wavelengths" %
(nw, wstep))
lprint("Support of wprojection = %d pixels" % support)
gcfcf = [
create_awterm_convolutionfunction(template_model,
nw=nw,
wstep=wstep,
oversampling=4,
support=support,
use_aaf=True)
]
lprint("Size of W projection gcf, cf = %.2E bytes" % get_size(gcfcf))
else:
context = 'wstack'
vis_slices = advice['vis_slices']
lprint("Using wstack with %d slices" % vis_slices)
gcfcf = rsexecute.scatter(gcfcf, broadcast=True)
results['vis_slices'] = vis_slices
# Make a skymodel from gleam, with bright sources as components and weak sources in an image
lprint("****** Starting GLEAM skymodel creation ******")
future_skymodel_list = [
rsexecute.execute(create_low_test_skymodel_from_gleam)(
npixel=npixel,
cellsize=cellsize,
frequency=[frequency[f]],
phasecentre=phasecentre,
polarisation_frame=PolarisationFrame("stokesI"),
flux_limit=flux_limit,
flux_threshold=dft_threshold,
flux_max=5.0) for f, freq in enumerate(frequency)
]
# We use predict_skymodel so that we can use skycomponents as well as images
lprint("****** Starting GLEAM skymodel prediction ******")
predicted_vis_list = [
predict_skymodel_list_rsexecute_workflow(future_vis_list[f],
[future_skymodel_list[f]],
context=context,
vis_slices=vis_slices,
facets=facets,
gcfcf=gcfcf)[0]
for f, freq in enumerate(frequency)
]
# Corrupt the visibility for the GLEAM model
lprint("****** Visibility corruption ******")
tmp_corrupted_vis_list = corrupt_list_rsexecute_workflow(
predicted_vis_list, phase_error=1.0, seed=seed)
lprint("****** Weighting and tapering ******")
tmp_corrupted_vis_list = weight_list_rsexecute_workflow(
tmp_corrupted_vis_list, future_model_list)
tmp_corrupted_vis_list = taper_list_rsexecute_workflow(
tmp_corrupted_vis_list, 0.003 * 750.0 / rmax)
tmp_corrupted_vis_list = rsexecute.compute(tmp_corrupted_vis_list,
sync=True)
corrupted_vis_list = rsexecute.gather(tmp_corrupted_vis_list)
# rsexecute.client.cancel(predicted_vis_list)
rsexecute.client.cancel(tmp_corrupted_vis_list)
future_corrupted_vis_list = rsexecute.scatter(corrupted_vis_list)
# At this point the only futures are of scatter'ed data so no repeated calculations should be
# incurred.
lprint("****** Starting dirty image calculation ******")
start = time.time()
dirty_list = invert_list_rsexecute_workflow(
future_corrupted_vis_list,
future_model_list,
vis_slices=vis_slices,
context=context,
facets=facets,
use_serial_invert=use_serial_imaging,
gcfcf=gcfcf)
results['size invert graph'] = get_size(dirty_list)
lprint('Size of dirty graph is %.3E bytes' %
(results['size invert graph']))
end = time.time()
results['time invert graph'] = end - start
lprint("Construction of invert graph took %.3f seconds" % (end - start))
start = time.time()
dirty, sumwt = rsexecute.compute(dirty_list, sync=True)[centre]
end = time.time()
results['time invert'] = end - start
lprint("Dirty image invert took %.3f seconds" % (end - start))
lprint("Maximum in dirty image is %f, sumwt is %s" %
(numpy.max(numpy.abs(dirty.data)), str(sumwt)))
qa = qa_image(dirty)
results['dirty_max'] = qa.data['max']
results['dirty_min'] = qa.data['min']
if write_fits:
export_image_to_fits(
dirty, "pipelines_rsexecute_timings-%s-dirty.fits" % context)
lprint("****** Starting prediction ******")
start = time.time()
tmp_vis_list = predict_list_rsexecute_workflow(
future_corrupted_vis_list,
future_model_list,
vis_slices=vis_slices,
context=context,
facets=facets,
use_serial_predict=use_serial_imaging,
gcfcf=gcfcf)
result = rsexecute.compute(tmp_vis_list, sync=True)
# rsexecute.client.cancel(tmp_vis_list)
end = time.time()
results['time predict'] = end - start
lprint("Predict took %.3f seconds" % (end - start))
# Create the ICAL pipeline to run major cycles, starting selfcal at cycle 1. A global solution across all
# frequencies (i.e. Visibilities) is performed.
print("Using subimage clean")
deconvolve_facets = 8
deconvolve_overlap = 16
deconvolve_taper = 'tukey'
lprint("****** Starting ICAL graph creation ******")
controls = create_calibration_controls()
controls['T']['first_selfcal'] = 1
controls['T']['timeslice'] = 'auto'
start = time.time()
ical_list = ical_list_rsexecute_workflow(
future_corrupted_vis_list,
model_imagelist=future_model_list,
context=context,
vis_slices=vis_slices,
scales=[0, 3, 10],
algorithm='mmclean',
nmoment=3,
niter=1000,
fractional_threshold=0.1,
threshold=0.01,
nmajor=nmajor,
gain=0.25,
psf_support=64,
deconvolve_facets=deconvolve_facets,
deconvolve_overlap=deconvolve_overlap,
deconvolve_taper=deconvolve_taper,
timeslice='auto',
global_solution=True,
do_selfcal=True,
calibration_context='T',
controls=controls,
use_serial_predict=use_serial_imaging,
use_serial_invert=use_serial_imaging,
use_serial_clean=use_serial_clean,
gcfcf=gcfcf)
results['size ICAL graph'] = get_size(ical_list)
lprint('Size of ICAL graph is %.3E bytes' % results['size ICAL graph'])
end = time.time()
results['time ICAL graph'] = end - start
lprint("Construction of ICAL graph took %.3f seconds" % (end - start))
print("Current objects on cluster: ")
pp.pprint(rsexecute.client.who_has())
#
# Execute the graph
lprint("****** Executing ICAL graph ******")
start = time.time()
deconvolved, residual, restored, gaintables = rsexecute.compute(ical_list,
sync=True)
end = time.time()
results['time ICAL'] = end - start
lprint("ICAL graph execution took %.3f seconds" % (end - start))
qa = qa_image(deconvolved[centre])
results['deconvolved_max'] = qa.data['max']
results['deconvolved_min'] = qa.data['min']
deconvolved_cube = image_gather_channels(deconvolved)
if write_fits:
export_image_to_fits(
deconvolved_cube,
"pipelines_rsexecute_timings-%s-ical_deconvolved.fits" % context)
qa = qa_image(residual[centre][0])
results['residual_max'] = qa.data['max']
results['residual_min'] = qa.data['min']
residual_cube = remove_sumwt(residual)
residual_cube = image_gather_channels(residual_cube)
if write_fits:
export_image_to_fits(
residual_cube,
"pipelines_rsexecute_timings-%s-ical_residual.fits" % context)
qa = qa_image(restored[centre])
results['restored_max'] = qa.data['max']
results['restored_min'] = qa.data['min']
restored_cube = image_gather_channels(restored)
if write_fits:
export_image_to_fits(
restored_cube,
"pipelines_rsexecute_timings-%s-ical_restored.fits" % context)
#
rsexecute.close()
end_all = time.time()
results['time overall'] = end_all - start_all
lprint("At end, results are:")
results = sort_dict(results)
lprint(results)
return results
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 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)
channels = range(60 - 4, 60 + 4)
bvis_list = [
rsexecute.execute(create_blockvisibility_from_ms)(
"/Users/wangfeng/work/muserdata/output/selfmodel.ms",
start_chan=chan,
end_chan=chan)[0] for chan in channels
]
#
# Remove this to check out circularnp
# bvis_list = [rsexecute.execute(convert_blockvisibility_to_stokesI)(bv)
# for bv in bvis_list]
# image_stokes = PolarisationFrame("stokesI")
image_stokes = PolarisationFrame("stokesIV")
def flag(bvis):
bad = numpy.abs(bvis.vis) > 6e4
print(numpy.sum(bad))
bvis.flags[...][bad] = 1
bvis = flagging_blockvisibility(bvis, antenna=[8, 9, 10, 11, 27])
do_baselines = False
if do_baselines:
baseline = [[4, 0], [4, 1], [5, 4], [21, 4], [24, 4], [25, 4],
[26, 4], [27, 4], [28, 4], [29, 4], [30, 4], [31, 4],
[32, 4], [36, 4], [38, 4], [39, 4]]
baseline.append([[17, 4], [17, 13], [19, 17], [26, 17], [27, 17],
[28, 17], [29, 17], [30, 17], [31, 17], [39, 17]])
baseline.append([[19, 0], [19, 2], [19, 3], [19, 5], [19, 6],
log.setLevel(logging.DEBUG)
log.addHandler(logging.StreamHandler(sys.stdout))
results_dir = rascil_path('test_results')
# Construct LOW core configuration
lowr3 = create_named_configuration('LOWBD2', rmax=750.0)
# We create the visibility. This just makes the uvw, time, antenna1, antenna2, weight columns in a table
times = numpy.zeros([1])
frequency = numpy.array([1e8])
channel_bandwidth = numpy.array([1e6])
phasecentre = SkyCoord(ra=+15.0 * u.deg, dec=-45.0 * u.deg, frame='icrs', equinox='J2000')
vt = create_visibility(lowr3, times, frequency, channel_bandwidth=channel_bandwidth,
weight=1.0, phasecentre=phasecentre, polarisation_frame=PolarisationFrame('stokesI'))
# Find the recommended imaging parameters
advice = advise_wide_field(vt, guard_band_image=3.0, delA=0.1, facets=1, wprojection_planes=1,
oversampling_synthesised_beam=4.0)
cellsize = advice['cellsize']
# Read the venerable test image, constructing a RASCIL Image
m31image = create_test_image(frequency=frequency, cellsize=cellsize, phasecentre=vt.phasecentre)
# Predict the visibility for the Image
vt = predict_2d(vt, m31image, context='2d')
# Make the dirty image and point spread function
model = create_image_from_visibility(vt, cellsize=cellsize, npixel=512)
dirty, sumwt = invert_2d(vt, model, context='2d')