def test_create_list_spectral_average_arlexecute(self):
if not self.casacore_available:
return
msfile = arl_path("data/vis/ASKAP_example.ms")
from workflows.arlexecute.execution_support.arlexecute import arlexecute
arlexecute.set_client(use_dask=False)
nchan_ave = 16
nchan = 192
def create_and_average(schan):
max_chan = min(nchan, schan + nchan_ave)
bv = create_blockvisibility_from_ms(msfile, range(schan, max_chan))
return integrate_visibility_by_channel(bv[0])
vis_by_channel_workflow = \
[arlexecute.execute(create_and_average)(schan) for schan in range(0, nchan, nchan_ave)]
vis_by_channel = arlexecute.compute(vis_by_channel_workflow)
arlexecute.close()
assert len(vis_by_channel) == 12
for v in vis_by_channel:
assert v.vis.data.shape[-1] == 4
assert v.polarisation_frame.type == "linear"
assert v.vis.data.shape[-2] == 1
def test_useFunction(self):
def square(x):
return x**2
arlexecute.set_client(use_dask=False)
graph = arlexecute.execute(square)(numpy.arange(10))
assert (arlexecute.compute(graph) == numpy.array(
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81])).all()
arlexecute.close()
def test_create_simulate_vis_list(self):
arlexecute.set_client(use_dask=False)
vis_list = simulate_workflow(frequency=self.frequency,
channel_bandwidth=self.channel_bandwidth)
assert len(vis_list) == len(self.frequency)
vt = arlexecute.compute(vis_list[0])
assert isinstance(vt, BlockVisibility)
assert vt.nvis > 0
arlexecute.close()
def test_create_generic_image_workflow(self):
def imagerooter(im):
im.data = numpy.sqrt(numpy.abs(im.data))
return im
root = generic_image_workflow(imagerooter, self.image, facets=4)
root = arlexecute.compute(root, sync=True)
arlexecute.close()
numpy.testing.assert_array_almost_equal_nulp(root.data ** 2, numpy.abs(self.image.data), 7)
def test_useDaskSync(self):
def square(x):
return x**2
arlexecute.set_client(use_dask=True)
graph = arlexecute.execute(square)(numpy.arange(10))
result = arlexecute.compute(graph, sync=True)
assert (result == numpy.array([0, 1, 4, 9, 16, 25, 36, 49, 64,
81])).all()
arlexecute.close()
def test_create_generic_blockvisibility_workflow(self):
self.blockvis = [create_blockvisibility(self.lowcore, self.times, self.frequency,
phasecentre=self.phasecentre,
channel_bandwidth=self.channel_bandwidth,
weight=1.0,
polarisation_frame=PolarisationFrame('stokesI'))]
self.blockvis = generic_blockvisibility_workflow(predict_skycomponent_visibility,
vis_list=self.blockvis,
sc=self.comp)[0]
self.blockvis = arlexecute.compute(self.blockvis, sync=True)
arlexecute.close()
assert numpy.max(numpy.abs(self.blockvis[0].vis)) > 0.0
def tearDown(self):
arlexecute.close()
frequency=[frequency[f]],
channel_bandwidth=[channel_bandwidth[f]],
cellsize=cellsize,
phasecentre=phasecentre,
polarisation_frame=PolarisationFrame("stokesI"),
flux_limit=1.0,
applybeam=True) for f, freq in enumerate(frequency)
]
log.info('About to make GLEAM model')
gleam_model = arlexecute.compute(gleam_model, sync=True)
gleam_skymodel = SkyModel(images=gleam_model)
export_skymodel_to_hdf5(gleam_skymodel, 'gleam_simulation_skymodel.hdf')
future_gleam_model = arlexecute.scatter(gleam_model)
# In[ ]:
log.info('About to run predict to get predicted visibility')
future_vis_graph = arlexecute.scatter(vis_list)
predicted_vislist = predict_workflow(future_vis_graph,
gleam_model,
context='wstack',
vis_slices=vis_slices)
corrupted_vislist = corrupt_workflow(predicted_vislist, phase_error=1.0)
log.info('About to run corrupt to get corrupted visibility')
corrupted_vislist = arlexecute.compute(corrupted_vislist, sync=True)
export_blockvisibility_to_hdf5(corrupted_vislist,
'gleam_simulation_vislist.hdf')
arlexecute.close()
def main():
"""Run the workflow."""
init_logging()
LOG.info("Starting imaging-pipeline")
# Read parameters
PARFILE = 'parameters.json'
if len(sys.argv) > 1:
PARFILE = sys.argv[1]
LOG.info("JSON parameter file = %s", PARFILE)
try:
with open(PARFILE, "r") as par_file:
jspar = json.load(par_file)
except AssertionError as error:
LOG.critical('ERROR %s', error)
return
# We will use dask
arlexecute.set_client(get_dask_Client())
arlexecute.run(init_logging)
# Import visibility list from HDF5 file
vis_list = import_blockvisibility_from_hdf5(
'%s/%s' % (RESULTS_DIR, jspar["files"]["vis_list"]))
# Now read the BlockVisibilities constructed using a model drawn from GLEAM
predicted_vislist = import_blockvisibility_from_hdf5(
'%s/%s' % (RESULTS_DIR, jspar["files"]["predicted_vis_list"]))
corrupted_vislist = import_blockvisibility_from_hdf5(
'%s/%s' % (RESULTS_DIR, jspar["files"]["corrupted_vis_list"]))
# Reproduce parameters from the visibility data
ntimes = vis_list[0].nvis
phasecentre = vis_list[0].phasecentre
print(phasecentre)
polframe = vis_list[0].polarisation_frame.type
LOG.info("Polarisation Frame of vis_list: %s", polframe)
wprojection_planes = jspar["advice"]["wprojection_planes"]
guard_band_image = jspar["advice"]["guard_band_image"]
delA = jspar["advice"]["delA"]
advice_low = advise_wide_field(vis_list[0], guard_band_image=guard_band_image,
delA=delA,
wprojection_planes=wprojection_planes)
advice_high = advise_wide_field(vis_list[-1], guard_band_image=guard_band_image,
delA=delA,
wprojection_planes=wprojection_planes)
vis_slices = advice_low['vis_slices']
npixel = advice_high['npixels2']
cellsize = min(advice_low['cellsize'], advice_high['cellsize'])
# Recovering frequencies
fstart = vis_list[0].frequency
fend = vis_list[-1].frequency
num_freq_win = len(vis_list)
frequency = numpy.linspace(fstart, fend, num_freq_win)
# Recovering bandwidths
channel_bandwidth = numpy.array(num_freq_win * [vis_list[1].frequency - vis_list[0].frequency])
# Get the LSM. This is currently blank.
model_list = [
arlexecute.execute(create_image_from_visibility)(
vis_list[f],
npixel=npixel,
frequency=[frequency[f]],
channel_bandwidth=[channel_bandwidth[f]],
cellsize=cellsize,
phasecentre=phasecentre,
polarisation_frame=PolarisationFrame(polframe))
for f, freq in enumerate(frequency)
]
# future_predicted_vislist = arlexecute.scatter(predicted_vislist)
# Create and execute graphs to make the dirty image and PSF
# LOG.info('About to run invert to get dirty image')
# dirty_list = invert_component(future_predicted_vislist, model_list,
# context='wstack',
# vis_slices=vis_slices, dopsf=False)
# dirty_list = arlexecute.compute(dirty_list, sync=True)
# LOG.info('About to run invert to get PSF')
# psf_list = invert_component(future_predicted_vislist, model_list,
# context='wstack',
# vis_slices=vis_slices, dopsf=True)
# psf_list = arlexecute.compute(psf_list, sync=True)
# Now deconvolve using msclean
# LOG.info('About to run deconvolve')
# deconvolve_list, _ = deconvolve_component(
# dirty_list, psf_list,
# model_imagelist=model_list,
# deconvolve_facets=8,
# deconvolve_overlap=16,
# deconvolve_taper='tukey',
# scales=[0, 3, 10],
# algorithm='msclean',
# niter=1000,
# fractional_threshold=0.1,
# threshold=0.1,
# gain=0.1,
# psf_support=64)
# deconvolved = arlexecute.compute(deconvolve_list, sync=True)
LOG.info('About to run continuum imaging')
continuum_imaging_list = continuum_imaging_arlexecute(
predicted_vislist,
model_imagelist = model_list,
context = jspar["processing"]["continuum_imaging"]["context"] , #'wstack',
vis_slices = vis_slices,
scales = jspar["processing"]["continuum_imaging"]["scales"], #[0, 3, 10],
algorithm = jspar["processing"]["continuum_imaging"]["algorithm"], #'mmclean',
nmoment = jspar["processing"]["continuum_imaging"]["nmoment"], #3,
niter = jspar["processing"]["continuum_imaging"]["niter"], #1000,
fractional_threshold = jspar["processing"]["continuum_imaging"]["fractional_threshold"], #0.1,
threshold = jspar["processing"]["continuum_imaging"]["threshold"], #0.1,
nmajor = jspar["processing"]["continuum_imaging"]["nmajor"], #5,
gain = jspar["processing"]["continuum_imaging"]["gain"], #0.25,
deconvolve_facets = jspar["processing"]["continuum_imaging"]["deconvolve_facets"], #8,
deconvolve_overlap = jspar["processing"]["continuum_imaging"]["deconvolve_overlap"], #16,
deconvolve_taper = jspar["processing"]["continuum_imaging"]["deconvolve_taper"], #'tukey',
psf_support = jspar["processing"]["continuum_imaging"]["psf_support"] ) #64)
result = arlexecute.compute(continuum_imaging_list, sync=True)
deconvolved = result[0][0]
residual = result[1][0]
restored = result[2][0]
print(qa_image(deconvolved, context='Clean image - no selfcal'))
print(qa_image(restored, context='Restored clean image - no selfcal'))
export_image_to_fits(restored,
'%s/%s' % (RESULTS_DIR, jspar["files"]["continuum_imaging_restored"]))
print(qa_image(residual[0], context='Residual clean image - no selfcal'))
export_image_to_fits(residual[0],
'%s/%s' % (RESULTS_DIR, jspar["files"]["continuum_imaging_residual"]))
controls = create_calibration_controls()
controls['T']['first_selfcal'] = jspar["processing"]["controls"]["T"]["first_selfcal"]
controls['G']['first_selfcal'] = jspar["processing"]["controls"]["G"]["first_selfcal"]
controls['B']['first_selfcal'] = jspar["processing"]["controls"]["B"]["first_selfcal"]
controls['T']['timescale'] = jspar["processing"]["controls"]["T"]["timescale"]
controls['G']['timescale'] = jspar["processing"]["controls"]["G"]["timescale"]
controls['B']['timescale'] = jspar["processing"]["controls"]["B"]["timescale"]
PP.pprint(controls)
future_corrupted_vislist = arlexecute.scatter(corrupted_vislist)
ical_list = ical_arlexecute(future_corrupted_vislist,
model_imagelist = model_list,
context = jspar["processing"]["ical"]["context"] , #'wstack',
calibration_context = jspar["processing"]["ical"]["calibration_context"] , #'TG',
controls = controls,
vis_slices = ntimes,
scales = jspar["processing"]["ical"]["scales"], #[0, 3, 10],
timeslice = jspar["processing"]["ical"]["timeslice"], #'auto',
algorithm = jspar["processing"]["ical"]["algorithm"], #'mmclean',
nmoment = jspar["processing"]["ical"]["nmoment"], #3,
niter = jspar["processing"]["ical"]["niter"], #1000,
fractional_threshold = jspar["processing"]["ical"]["fractional_threshold"], #0.1,
threshold = jspar["processing"]["ical"]["threshold"], #0.1,
nmajor = jspar["processing"]["ical"]["nmajor"], #5,
gain = jspar["processing"]["ical"]["gain"], #0.25,
deconvolve_facets = jspar["processing"]["ical"]["deconvolve_facets"], #8,
deconvolve_overlap = jspar["processing"]["ical"]["deconvolve_overlap"], #16,
deconvolve_taper = jspar["processing"]["ical"]["deconvolve_taper"], #'tukey',
global_solution = jspar["processing"]["ical"]["global_solution"], #False,
do_selfcal = jspar["processing"]["ical"]["do_selfcal"], #True,
psf_support = jspar["processing"]["ical"]["psf_support"]) #64
LOG.info('About to run ical')
result = arlexecute.compute(ical_list, sync=True)
deconvolved = result[0][0]
residual = result[1][0]
restored = result[2][0]
print(qa_image(deconvolved, context='Clean image'))
print(qa_image(restored, context='Restored clean image'))
export_image_to_fits(restored, '%s/%s' % (RESULTS_DIR, jspar["files"]["ical_restored"]))
print(qa_image(residual[0], context='Residual clean image'))
export_image_to_fits(residual[0], '%s/%s' % (RESULTS_DIR, jspar["files"]["ical_residual"]))
arlexecute.close()
def main():
"""Workflow stage application."""
init_logging()
# Get Dask client
arlexecute.set_client(get_dask_Client())
arlexecute.run(init_logging)
LOG.info('Results dir = %s', RESULTS_DIR)
LOG.info("Starting imaging-modeling")
# Read parameters
PARFILE = 'parameters.json'
if len(sys.argv) > 1:
PARFILE = sys.argv[1]
LOG.info("JSON parameter file = %s", PARFILE)
try:
with open(PARFILE, "r") as par_file:
jspar = json.load(par_file)
except AssertionError as error:
LOG.critical('ERROR %s', error)
return
# Model parameters
configuration= jspar["modeling"]["configuration"]["name"]
num_freq_win = jspar["modeling"]["configuration"]["num_freq_win"] # 7
num_times = jspar["modeling"]["configuration"]["num_times"] # 11
r_max = jspar["modeling"]["configuration"]["r_max"] # 300.0
fstart = jspar["modeling"]["configuration"]["fstart"]
fend = jspar["modeling"]["configuration"]["fend"]
timestart_pi = jspar["modeling"]["configuration"]["timestart_pi"] # -1/3
timeend_pi = jspar["modeling"]["configuration"]["timeend_pi"] # 1/3
polframe = jspar["modeling"]["configuration"]["PolarisationFrame"] # StokesI
frequency = numpy.linspace(fstart, fend, num_freq_win)
channel_bw = numpy.array(num_freq_win * [frequency[1] - frequency[0]]) # 0.9e8 ... 1.1e8
times = numpy.linspace(numpy.pi * timestart_pi, numpy.pi * timeend_pi, num_times)
phase_centre = SkyCoord( ra =jspar["modeling"]["phasecentre"]["RA"] * u.deg,
dec =jspar["modeling"]["phasecentre"]["Dec"] * u.deg,
frame =jspar["modeling"]["phasecentre"]["frame"],
equinox=jspar["modeling"]["phasecentre"]["equinox"])
# Simulate visibilities
vis_list = simulate_arlexecute(configuration,
frequency=frequency,
channel_bandwidth=channel_bw,
times=times,
phasecentre=phase_centre,
order=jspar["modeling"]["simulate"]["order"],
rmax=r_max)
LOG.info('%d elements in vis_list', len(vis_list))
LOG.info('About to make visibility')
vis_list = arlexecute.compute(vis_list, sync=True)
LOG.debug('vis_list type: %s', type(vis_list))
LOG.debug('vis_list element type: %s', type(vis_list[0]))
try:
export_blockvisibility_to_hdf5(vis_list,
'%s/%s' % (RESULTS_DIR, jspar["files"]["vis_list"]))
except AssertionError as error:
LOG.critical('ERROR %s', error)
return
wprojection_planes = jspar["advice"]["wprojection_planes"]
guard_band_image = jspar["advice"]["guard_band_image"]
delA = jspar["advice"]["delA"]
advice_low = advise_wide_field(vis_list[0], guard_band_image=guard_band_image,
delA=delA,
wprojection_planes=wprojection_planes)
advice_high = advise_wide_field(vis_list[-1], guard_band_image=guard_band_image,
delA=delA,
wprojection_planes=wprojection_planes)
vis_slices = advice_low['vis_slices']
num_pixels = advice_high['npixels2']
cellsize = min(advice_low['cellsize'], advice_high['cellsize'])
# Create GLEAM model
gleam_model = [
arlexecute.execute(create_low_test_image_from_gleam)(
npixel=num_pixels,
frequency=[frequency[f]],
channel_bandwidth=[channel_bw[f]],
cellsize=cellsize,
phasecentre=phase_centre,
polarisation_frame=PolarisationFrame(polframe),
flux_limit=jspar["modeling"]["gleam_model"]["flux_limit"], # 1.0,
applybeam =jspar["modeling"]["gleam_model"]["applybeam"]) # True
for f, freq in enumerate(frequency)
]
LOG.info('About to make GLEAM model')
gleam_model = arlexecute.compute(gleam_model, sync=True)
# future_gleam_model = arlexecute.scatter(gleam_model)
# Get predicted visibilities for GLEAM model
LOG.info('About to run predict to get predicted visibility')
future_vis_graph = arlexecute.scatter(vis_list)
predicted_vis_list = predict_arlexecute(future_vis_graph, gleam_model,
context=jspar["modeling"]["predict"]["context"], #'wstack'
vis_slices=vis_slices)
predicted_vis_list = arlexecute.compute(predicted_vis_list, sync=True)
corrupted_vis_list = corrupt_arlexecute(predicted_vis_list, phase_error=jspar["modeling"]["corrupt"]["phase_error"]) #1.0
LOG.info('About to run corrupt to get corrupted visibility')
corrupted_vis_list = arlexecute.compute(corrupted_vis_list, sync=True)
LOG.info('About to output predicted_vislist.hdf')
export_blockvisibility_to_hdf5(predicted_vis_list,
'%s/%s' % (RESULTS_DIR,jspar["files"]["predicted_vis_list"]))
LOG.info('About to output corrupted_vislist.hdf')
export_blockvisibility_to_hdf5(corrupted_vis_list,
'%s/%s' % (RESULTS_DIR, jspar["files"]["corrupted_vis_list"]))
# Close Dask client
arlexecute.close()
def main():
"""Run the workflow."""
init_logging()
LOG.info("Starting imaging-pipeline")
# Read parameters
PARFILE = 'parameters.json'
if len(sys.argv) > 1:
PARFILE = sys.argv[1]
LOG.info("JSON parameter file = %s", PARFILE)
try:
with open(PARFILE, "r") as par_file:
jspar = json.load(par_file)
except AssertionError as error:
LOG.critical('ERROR %s', error)
return
# We will use dask
arlexecute.set_client(get_dask_Client())
arlexecute.run(init_logging)
# Import visibility list from HDF5 file
vis_list = import_blockvisibility_from_hdf5(
'%s/%s' % (RESULTS_DIR, jspar["files"]["vis_list"]))
# Now read the BlockVisibilities constructed using a model drawn from GLEAM
predicted_vislist = import_blockvisibility_from_hdf5(
'%s/%s' % (RESULTS_DIR, jspar["files"]["predicted_vis_list"]))
corrupted_vislist = import_blockvisibility_from_hdf5(
'%s/%s' % (RESULTS_DIR, jspar["files"]["corrupted_vis_list"]))
# Reproduce parameters from the visibility data
ntimes = vis_list[0].nvis
phasecentre = vis_list[0].phasecentre
print(phasecentre)
polframe = vis_list[0].polarisation_frame.type
LOG.info("Polarisation Frame of vis_list: %s", polframe)
wprojection_planes = jspar["advice"]["wprojection_planes"]
guard_band_image = jspar["advice"]["guard_band_image"]
delA = jspar["advice"]["delA"]
advice_low = advise_wide_field(vis_list[0],
guard_band_image=guard_band_image,
delA=delA,
wprojection_planes=wprojection_planes)
advice_high = advise_wide_field(vis_list[-1],
guard_band_image=guard_band_image,
delA=delA,
wprojection_planes=wprojection_planes)
vis_slices = advice_low['vis_slices']
npixel = advice_high['npixels2']
cellsize = min(advice_low['cellsize'], advice_high['cellsize'])
# Recovering frequencies
fstart = vis_list[0].frequency
fend = vis_list[-1].frequency
num_freq_win = len(vis_list)
frequency = numpy.linspace(fstart, fend, num_freq_win)
# Recovering bandwidths
channel_bandwidth = numpy.array(
num_freq_win * [vis_list[1].frequency - vis_list[0].frequency])
# Get the LSM. This is currently blank.
model_list = [
arlexecute.execute(create_image_from_visibility)(
vis_list[f],
npixel=npixel,
frequency=[frequency[f]],
channel_bandwidth=[channel_bandwidth[f]],
cellsize=cellsize,
phasecentre=phasecentre,
polarisation_frame=PolarisationFrame(polframe))
for f, freq in enumerate(frequency)
]
# future_predicted_vislist = arlexecute.scatter(predicted_vislist)
# Create and execute graphs to make the dirty image and PSF
# LOG.info('About to run invert to get dirty image')
# dirty_list = invert_component(future_predicted_vislist, model_list,
# context='wstack',
# vis_slices=vis_slices, dopsf=False)
# dirty_list = arlexecute.compute(dirty_list, sync=True)
# LOG.info('About to run invert to get PSF')
# psf_list = invert_component(future_predicted_vislist, model_list,
# context='wstack',
# vis_slices=vis_slices, dopsf=True)
# psf_list = arlexecute.compute(psf_list, sync=True)
# Now deconvolve using msclean
# LOG.info('About to run deconvolve')
# deconvolve_list, _ = deconvolve_component(
# dirty_list, psf_list,
# model_imagelist=model_list,
# deconvolve_facets=8,
# deconvolve_overlap=16,
# deconvolve_taper='tukey',
# scales=[0, 3, 10],
# algorithm='msclean',
# niter=1000,
# fractional_threshold=0.1,
# threshold=0.1,
# gain=0.1,
# psf_support=64)
# deconvolved = arlexecute.compute(deconvolve_list, sync=True)
LOG.info('About to run continuum imaging')
continuum_imaging_list = continuum_imaging_arlexecute(
predicted_vislist,
model_imagelist=model_list,
context=jspar["processing"]["continuum_imaging"]
["context"], #'wstack',
vis_slices=vis_slices,
scales=jspar["processing"]["continuum_imaging"]
["scales"], #[0, 3, 10],
algorithm=jspar["processing"]["continuum_imaging"]
["algorithm"], #'mmclean',
nmoment=jspar["processing"]["continuum_imaging"]["nmoment"], #3,
niter=jspar["processing"]["continuum_imaging"]["niter"], #1000,
fractional_threshold=jspar["processing"]["continuum_imaging"]
["fractional_threshold"], #0.1,
threshold=jspar["processing"]["continuum_imaging"]["threshold"], #0.1,
nmajor=jspar["processing"]["continuum_imaging"]["nmajor"], #5,
gain=jspar["processing"]["continuum_imaging"]["gain"], #0.25,
deconvolve_facets=jspar["processing"]["continuum_imaging"]
["deconvolve_facets"], #8,
deconvolve_overlap=jspar["processing"]["continuum_imaging"]
["deconvolve_overlap"], #16,
deconvolve_taper=jspar["processing"]["continuum_imaging"]
["deconvolve_taper"], #'tukey',
psf_support=jspar["processing"]["continuum_imaging"]
["psf_support"]) #64)
result = arlexecute.compute(continuum_imaging_list, sync=True)
deconvolved = result[0][0]
residual = result[1][0]
restored = result[2][0]
print(qa_image(deconvolved, context='Clean image - no selfcal'))
print(qa_image(restored, context='Restored clean image - no selfcal'))
export_image_to_fits(
restored,
'%s/%s' % (RESULTS_DIR, jspar["files"]["continuum_imaging_restored"]))
print(qa_image(residual[0], context='Residual clean image - no selfcal'))
export_image_to_fits(
residual[0],
'%s/%s' % (RESULTS_DIR, jspar["files"]["continuum_imaging_residual"]))
controls = create_calibration_controls()
controls['T']['first_selfcal'] = jspar["processing"]["controls"]["T"][
"first_selfcal"]
controls['G']['first_selfcal'] = jspar["processing"]["controls"]["G"][
"first_selfcal"]
controls['B']['first_selfcal'] = jspar["processing"]["controls"]["B"][
"first_selfcal"]
controls['T']['timescale'] = jspar["processing"]["controls"]["T"][
"timescale"]
controls['G']['timescale'] = jspar["processing"]["controls"]["G"][
"timescale"]
controls['B']['timescale'] = jspar["processing"]["controls"]["B"][
"timescale"]
PP.pprint(controls)
future_corrupted_vislist = arlexecute.scatter(corrupted_vislist)
ical_list = ical_arlexecute(
future_corrupted_vislist,
model_imagelist=model_list,
context=jspar["processing"]["ical"]["context"], #'wstack',
calibration_context=jspar["processing"]["ical"]
["calibration_context"], #'TG',
controls=controls,
vis_slices=ntimes,
scales=jspar["processing"]["ical"]["scales"], #[0, 3, 10],
timeslice=jspar["processing"]["ical"]["timeslice"], #'auto',
algorithm=jspar["processing"]["ical"]["algorithm"], #'mmclean',
nmoment=jspar["processing"]["ical"]["nmoment"], #3,
niter=jspar["processing"]["ical"]["niter"], #1000,
fractional_threshold=jspar["processing"]["ical"]
["fractional_threshold"], #0.1,
threshold=jspar["processing"]["ical"]["threshold"], #0.1,
nmajor=jspar["processing"]["ical"]["nmajor"], #5,
gain=jspar["processing"]["ical"]["gain"], #0.25,
deconvolve_facets=jspar["processing"]["ical"]
["deconvolve_facets"], #8,
deconvolve_overlap=jspar["processing"]["ical"]
["deconvolve_overlap"], #16,
deconvolve_taper=jspar["processing"]["ical"]
["deconvolve_taper"], #'tukey',
global_solution=jspar["processing"]["ical"]
["global_solution"], #False,
do_selfcal=jspar["processing"]["ical"]["do_selfcal"], #True,
psf_support=jspar["processing"]["ical"]["psf_support"]) #64
LOG.info('About to run ical')
result = arlexecute.compute(ical_list, sync=True)
deconvolved = result[0][0]
residual = result[1][0]
restored = result[2][0]
print(qa_image(deconvolved, context='Clean image'))
print(qa_image(restored, context='Restored clean image'))
export_image_to_fits(
restored, '%s/%s' % (RESULTS_DIR, jspar["files"]["ical_restored"]))
print(qa_image(residual[0], context='Residual clean image'))
export_image_to_fits(
residual[0], '%s/%s' % (RESULTS_DIR, jspar["files"]["ical_residual"]))
arlexecute.close()
def main():
"""Workflow stage application."""
init_logging()
# Get Dask client
arlexecute.set_client(get_dask_Client())
arlexecute.run(init_logging)
LOG.info('Results dir = %s', RESULTS_DIR)
LOG.info("Starting imaging-modeling")
# Read parameters
PARFILE = 'parameters.json'
if len(sys.argv) > 1:
PARFILE = sys.argv[1]
LOG.info("JSON parameter file = %s", PARFILE)
try:
with open(PARFILE, "r") as par_file:
jspar = json.load(par_file)
except AssertionError as error:
LOG.critical('ERROR %s', error)
return
# Model parameters
configuration = jspar["modeling"]["configuration"]["name"]
num_freq_win = jspar["modeling"]["configuration"]["num_freq_win"] # 7
num_times = jspar["modeling"]["configuration"]["num_times"] # 11
r_max = jspar["modeling"]["configuration"]["r_max"] # 300.0
fstart = jspar["modeling"]["configuration"]["fstart"]
fend = jspar["modeling"]["configuration"]["fend"]
timestart_pi = jspar["modeling"]["configuration"]["timestart_pi"] # -1/3
timeend_pi = jspar["modeling"]["configuration"]["timeend_pi"] # 1/3
polframe = jspar["modeling"]["configuration"][
"PolarisationFrame"] # StokesI
frequency = numpy.linspace(fstart, fend, num_freq_win)
channel_bw = numpy.array(num_freq_win *
[frequency[1] - frequency[0]]) # 0.9e8 ... 1.1e8
times = numpy.linspace(numpy.pi * timestart_pi, numpy.pi * timeend_pi,
num_times)
phase_centre = SkyCoord(
ra=jspar["modeling"]["phasecentre"]["RA"] * u.deg,
dec=jspar["modeling"]["phasecentre"]["Dec"] * u.deg,
frame=jspar["modeling"]["phasecentre"]["frame"],
equinox=jspar["modeling"]["phasecentre"]["equinox"])
# Simulate visibilities
vis_list = simulate_arlexecute(
configuration,
frequency=frequency,
channel_bandwidth=channel_bw,
times=times,
phasecentre=phase_centre,
order=jspar["modeling"]["simulate"]["order"],
rmax=r_max)
LOG.info('%d elements in vis_list', len(vis_list))
LOG.info('About to make visibility')
vis_list = arlexecute.compute(vis_list, sync=True)
LOG.debug('vis_list type: %s', type(vis_list))
LOG.debug('vis_list element type: %s', type(vis_list[0]))
try:
export_blockvisibility_to_hdf5(
vis_list, '%s/%s' % (RESULTS_DIR, jspar["files"]["vis_list"]))
except AssertionError as error:
LOG.critical('ERROR %s', error)
return
wprojection_planes = jspar["advice"]["wprojection_planes"]
guard_band_image = jspar["advice"]["guard_band_image"]
delA = jspar["advice"]["delA"]
advice_low = advise_wide_field(vis_list[0],
guard_band_image=guard_band_image,
delA=delA,
wprojection_planes=wprojection_planes)
advice_high = advise_wide_field(vis_list[-1],
guard_band_image=guard_band_image,
delA=delA,
wprojection_planes=wprojection_planes)
vis_slices = advice_low['vis_slices']
num_pixels = advice_high['npixels2']
cellsize = min(advice_low['cellsize'], advice_high['cellsize'])
# Create GLEAM model
gleam_model = [
arlexecute.execute(create_low_test_image_from_gleam)(
npixel=num_pixels,
frequency=[frequency[f]],
channel_bandwidth=[channel_bw[f]],
cellsize=cellsize,
phasecentre=phase_centre,
polarisation_frame=PolarisationFrame(polframe),
flux_limit=jspar["modeling"]["gleam_model"]["flux_limit"], # 1.0,
applybeam=jspar["modeling"]["gleam_model"]["applybeam"]) # True
for f, freq in enumerate(frequency)
]
LOG.info('About to make GLEAM model')
gleam_model = arlexecute.compute(gleam_model, sync=True)
# future_gleam_model = arlexecute.scatter(gleam_model)
# Get predicted visibilities for GLEAM model
LOG.info('About to run predict to get predicted visibility')
future_vis_graph = arlexecute.scatter(vis_list)
predicted_vis_list = predict_arlexecute(
future_vis_graph,
gleam_model,
context=jspar["modeling"]["predict"]["context"], #'wstack'
vis_slices=vis_slices)
predicted_vis_list = arlexecute.compute(predicted_vis_list, sync=True)
corrupted_vis_list = corrupt_arlexecute(
predicted_vis_list,
phase_error=jspar["modeling"]["corrupt"]["phase_error"]) #1.0
LOG.info('About to run corrupt to get corrupted visibility')
corrupted_vis_list = arlexecute.compute(corrupted_vis_list, sync=True)
LOG.info('About to output predicted_vislist.hdf')
export_blockvisibility_to_hdf5(
predicted_vis_list,
'%s/%s' % (RESULTS_DIR, jspar["files"]["predicted_vis_list"]))
LOG.info('About to output corrupted_vislist.hdf')
export_blockvisibility_to_hdf5(
corrupted_vis_list,
'%s/%s' % (RESULTS_DIR, jspar["files"]["corrupted_vis_list"]))
# Close Dask client
arlexecute.close()
