def ical_wrapper(conf):
""" Wrap ICAL pipeline
:param conf: Configuration from JSON file
:return:
"""
vis_list = BufferBlockVisibility(conf["buffer"], conf['inputs']['vis_list']).memory_data_model
cellsize = json_to_quantity(conf["image"]["cellsize"]).to("rad").value
npixel = conf["image"]["npixel"]
pol_frame = PolarisationFrame(conf["image"]["polarisation_frame"])
model_imagelist = [arlexecute.execute(create_image_from_visibility)(v, npixel=npixel, cellsize=cellsize,
polarisation_frame=pol_frame)
for v in vis_list]
future_vis_list = arlexecute.scatter(vis_list)
result = ical_workflow(vis_list=future_vis_list,
model_imagelist=model_imagelist,
context=conf["imaging"]["context"],
scales=conf["deconvolution"]["scales"],
algorithm=conf["deconvolution"]["algorithm"],
nmoment=conf["deconvolution"]["nmoment"],
niter=conf["deconvolution"]["niter"],
fractional_threshold=conf["deconvolution"]["fractional_threshold"],
threshold=conf["deconvolution"]["threshold"],
nmajor=conf["deconvolution"]["nmajor"],
gain=conf["deconvolution"]["gain"],
deconvolve_facets=conf["deconvolution"]["deconvolve_facets"],
deconvolve_overlap=conf["deconvolution"]["deconvolve_overlap"],
deconvolve_taper=conf["deconvolution"]["deconvolve_taper"],
vis_slices=conf["imaging"]["vis_slices"],
psf_support=conf["deconvolution"]["psf_support"])
def output_images(result):
BufferSkyModel(conf["buffer"], conf['outputs']['skymodel'], SkyModel(images=result[0])).sync()
deconvolved = image_gather_channels(result[0])
residual = image_gather_channels(remove_sumwt(result[1]))
restored = image_gather_channels(result[2])
BufferImage(conf["buffer"], conf['outputs']['deconvolved'], deconvolved).sync()
BufferImage(conf["buffer"], conf['outputs']['residual'], residual).sync()
BufferImage(conf["buffer"], conf['outputs']['restored'], restored).sync()
return result
return arlexecute.execute(output_images)(result)
def test_readwriteblockvisibility(self):
self.vis = create_blockvisibility(
self.midcore,
self.times,
self.frequency,
channel_bandwidth=self.channel_bandwidth,
phasecentre=self.phasecentre,
polarisation_frame=PolarisationFrame("linear"),
weight=1.0,
meta={"ARL": 0.0})
self.vis = predict_skycomponent_visibility(self.vis, self.comp)
config = {
"buffer": {
"directory": self.dir
},
"vislist": {
"name": "test_bufferblockvisibility.hdf",
"data_model": "BlockVisibility"
}
}
bdm = BufferBlockVisibility(config["buffer"], config["vislist"],
self.vis)
bdm.sync()
new_bdm = BufferBlockVisibility(config["buffer"], config["vislist"])
new_bdm.sync()
newvis = bdm.memory_data_model
assert isinstance(newvis, BlockVisibility)
assert numpy.array_equal(newvis.frequency, self.vis.frequency)
assert newvis.data.shape == self.vis.data.shape
assert numpy.max(numpy.abs(self.vis.vis - newvis.vis)) < 1e-15
assert numpy.max(numpy.abs(self.vis.uvw - newvis.uvw)) < 1e-15
assert numpy.abs(newvis.configuration.location.x.value -
self.vis.configuration.location.x.value) < 1e-15
assert numpy.abs(newvis.configuration.location.y.value -
self.vis.configuration.location.y.value) < 1e-15
assert numpy.abs(newvis.configuration.location.z.value -
self.vis.configuration.location.z.value) < 1e-15
assert numpy.max(
numpy.abs(newvis.configuration.xyz -
self.vis.configuration.xyz)) < 1e-15
assert newvis.meta == self.vis.meta
def predict_vislist_wrapper(conf):
"""Wrapper for prediction
:param conf: Configuration from JSON file
:return:
"""
vis_list = BufferBlockVisibility(conf["buffer"], conf['inputs']['vis_list']).memory_data_model
skymodel = BufferSkyModel(conf["buffer"], conf["inputs"]["skymodel"]).memory_data_model
flux_limit = conf['primary_beam']['flux_limit']
if conf["primary_beam"]["apply"]:
def apply_pb_image(vt, model):
telescope = vt.configuration.name
pb = create_pb(model, telescope)
model.data *= pb.data
return model
def apply_pb_comp(vt, model, comp):
telescope = vt.configuration.name
pb = create_pb(model, telescope)
return apply_beam_to_skycomponent(comp, pb, flux_limit)
image_list = [arlexecute.execute(apply_pb_image, nout=1)(v, skymodel.images[i]) for i, v in enumerate(vis_list)]
if len(skymodel.components) > 1:
component_list = [arlexecute.execute(apply_pb_comp, nout=1)(v, skymodel.images[i], skymodel.components)
for i, v in enumerate(vis_list)]
else:
component_list = []
else:
image_list = [skymodel.images[0] for v in vis_list]
component_list = skymodel.components
future_vis_list = arlexecute.scatter(vis_list)
predicted_vis_list = [arlexecute.execute(predict_skycomponent_visibility)(v, component_list)
for v in future_vis_list]
predicted_vis_list = predict_workflow(predicted_vis_list, image_list,
context=conf['imaging']['context'],
vis_slices=conf['imaging']['vis_slices'])
def output_vislist(v):
bdm = BufferBlockVisibility(conf["buffer"], conf["outputs"]["vis_list"], v)
bdm.sync()
return arlexecute.execute(output_vislist)(predicted_vis_list)
def corrupt_vislist_wrapper(conf):
"""Wrapper for corruption
:param conf:
:return:
"""
vis_list = BufferBlockVisibility(conf["buffer"], conf['inputs']['vis_list']).memory_data_model
phase_error = json_to_quantity(conf['corrupt_vislist']['phase_error']).to('rad').value
corrupted_vislist = corrupt_workflow(vis_list,
phase_error=phase_error,
amplitude_error=conf['corrupt_vislist']['amplitude_error'])
def output_vislist(v):
bdm = BufferBlockVisibility(conf["buffer"], conf["outputs"]["vis_list"], v)
bdm.sync()
return arlexecute.execute(output_vislist)(corrupted_vislist)
def output_vislist(v):
bdm = BufferBlockVisibility(conf["buffer"], conf["outputs"]["vis_list"], v)
bdm.sync()