def makefits(myimagebase, cleanup=True):
impbcor(imagename=myimagebase + '.image',
pbimage=myimagebase + '.pb',
outfile=myimagebase + '.image.pbcor',
overwrite=True) # perform PBcorr
exportfits(imagename=myimagebase + '.image.pbcor',
fitsimage=myimagebase + '.image.pbcor.fits',
dropdeg=True,
overwrite=True) # export the corrected image
exportfits(imagename=myimagebase + '.image',
fitsimage=myimagebase + '.image.fits',
dropdeg=True,
overwrite=True) # export the corrected image
exportfits(imagename=myimagebase + '.pb',
fitsimage=myimagebase + '.pb.fits',
dropdeg=True,
overwrite=True) # export the PB image
exportfits(imagename=myimagebase + '.model',
fitsimage=myimagebase + '.model.fits',
dropdeg=True,
overwrite=True) # export the PB image
exportfits(imagename=myimagebase + '.residual',
fitsimage=myimagebase + '.residual.fits',
dropdeg=True,
overwrite=True) # export the PB image
if cleanup:
for suffix in ('pb', 'weight', 'sumwt', 'psf', 'model', 'mask',
'image', 'residual', 'alpha', 'alpha.error'):
os.system('rm -rf {0}.{1}'.format(myimagebase, suffix))
def do_clean(settings_file=None):
params = get_params(configfile=settings_file, section='clean')
print params.imagename
clean(vis=params.vis,
imagename=params.imagename,
mode=params.mode,
niter=int(params.niter),
threshold=params.threshold,
psfmode=params.psfmode,
imagermode=params.imagermode,
ftmachine=params.ftmachine,
imsize=int(params.imsize),
cell=params.cell,
stokes=params.stokes,
weighting=params.weighting,
robust=float(params.robust))
im = params.imagename + '.image'
exportfits(imagename=im, fitsimage=im + '.fits', overwrite=True)
im = params.imagename + '.psf'
exportfits(imagename=im, fitsimage=im + '.fits', overwrite=True)
scales=[0,3,9,27],
deconvolver='mtmfs',
specmode='mfs',
nterms=2,
weighting='briggs',
pblimit=0.2,
interactive=False,
outframe='LSRK',
savemodel='none',
)
makefits(imagename)
# create a mask based on region selection (no thresholding here)
dirtyimagename = imagename+".image.tt0.pbcor"
exportfits(dirtyimagename, dirtyimagename+".fits", overwrite=True)
reg = pyregion.open('cleanbox_regions_SgrB2.reg')
imghdu = fits.open(dirtyimagename+".fits")[0]
#mask = reg.get_mask(imghdu)[None, None, :, :]
mask = reg.get_mask(header=wcs.WCS(imghdu.header).celestial.to_header(),
shape=imghdu.data.shape[2:])
imghdu.data = mask.astype('int16')
imghdu.header['BITPIX'] = 16
imghdu.writeto('cleanbox_mask_SgrB2.fits', clobber=True)
cleanbox_mask_image = 'cleanbox_mask_SgrB2.image'
importfits(fitsimage='cleanbox_mask_SgrB2.fits',
imagename=cleanbox_mask_image,
overwrite=True)
ia.open(cleanbox_mask_image)
ia.calcmask(mask=cleanbox_mask_image+" > 0.5",
name='cleanbox_mask')
**impars_thisiter)
test_tclean_success()
ia.open(imname + ".image.tt0")
ia.sethistory(origin='almaimf_cont_selfcal',
history=[
"{0}: {1}".format(key, val)
for key, val in impars.items()
])
ia.sethistory(origin='almaimf_cont_imaging',
history=[
"git_version: {0}".format(git_version),
"git_date: {0}".format(git_date)
])
ia.close()
exportfits(imname + ".image.tt0", imname + ".image.tt0.fits")
exportfits(imname + ".image.tt0.pbcor",
imname + ".image.tt0.pbcor.fits")
else:
# populate the model column (should be from data on disk matching
# this format, but we don't need to - and can't - specify it)
# If you want to use `ft`, you need to specify this:
# modelname = [contimagename+"_robust{0}.model.tt0".format(robust),
# contimagename+"_robust{0}.model.tt1".format(robust)]
populate_model_column(imname, selfcal_ms, field, impars_thisiter,
phasecenter, maskname, cellsize, imsize,
antennae)
logprint("Skipped completed file {0} (dirty),"
" populated model column".format(imname),
def make_model(settings_file=None):
if settings_file == None:
print "Please provide settings file."
sys.exit(0)
else:
settings = get_params('dummy-settings.txt', 'observation')
sources = get_sources('dummy-settings.txt')
observation = get_params("dummy-settings.txt", 'observation')
cl.done()
ra, dec, flux, bmaj, bmin, bpa = get_sources("dummy-settings.txt")
for i in range(0, len(ra)):
direction = "J2000 " + ra[i] + " " + dec[i]
cl.addcomponent(dir=direction,
flux=float(flux[i]),
freq='1420MHz',
shape="Gaussian",
majoraxis=str(bmaj[i]) + 'arcmin',
minoraxis=str(bmin[i]) + 'arcmin',
positionangle=str(bpa[i]) + 'deg')
ia.fromshape(observation.filename + '.im',
[int(observation.imsize),
int(observation.imsize), 1, 1],
overwrite=True)
cs = ia.coordsys()
cs.setunits(['rad', 'rad', '', 'Hz'])
cell_rad = qa.convert(qa.quantity(observation.pixelsize),
"rad")['value']
cs.setincrement([-cell_rad, cell_rad], 'direction')
cs.setreferencevalue([
qa.convert(observation.ra, 'rad')['value'],
qa.convert(observation.dec, 'rad')['value']
],
type="direction")
cs.setreferencevalue(observation.reffreq, 'spectral')
cs.setincrement(observation.freqint, 'spectral')
ia.setcoordsys(cs.torecord())
ia.setbrightnessunit("Jy/pixel")
ia.modify(cl.torecord(), subtract=False)
#exportfits(imagename=observation.filename+'.im',fitsimage=observation.filename+'.fits',overwrite=True)
exportfits(imagename=observation.filename + '.im',
fitsimage=observation.filename + '.fits',
velocity=False,
optical=False,
bitpix=-32,
minpix=0,
maxpix=-1,
overwrite=True,
dropstokes=False,
stokeslast=True,
history=True,
dropdeg=False)
else:
mask = ''
tclean(vis=concatvis,
imagename=lineimagename,
restoringbeam='',
calcres=True,
**impars)
impars['niter'] = niter
impars['startmodel'] = smod
impars['mask'] = mask
sethistory(lineimagename, nsigma=nsigma, impars=impars)
impbcor(imagename=lineimagename + '.image',
pbimage=lineimagename + '.pb',
outfile=lineimagename + '.image.pbcor',
cutoff=0.2,
overwrite=True)
if do_export_fits:
exportfits(lineimagename + ".image",
lineimagename + ".image.fits",
overwrite=True)
exportfits(lineimagename + ".image.pbcor",
lineimagename + ".image.pbcor.fits",
overwrite=True)
logprint("Completed {0}->{1}".format(vis, concatvis),
origin='almaimf_line_imaging')
logprint("Completed line_imaging.py run", origin='almaimf_line_imaging')
def reg_to_mask(regfile, baseimage):
"""
This is like makemask(mode='copy', inpimage=baseimage, inpmask=regfile)
"""
casalog.post("Creating mask from regions {0} into base image {1}".format(
regfile, baseimage),
origin='reg_to_mask')
assert baseimage.endswith('.image') or baseimage.endswith('.image.tt0')
cleanbox_mask = baseimage.replace(".image.tt0",
".image").replace(".image", ".mask")
cleanbox_mask_image = baseimage
if not os.path.exists(cleanbox_mask) or not os.path.exists(
cleanbox_mask_image):
# create a mask based on region selection (no thresholding here)
dirtyimagename = baseimage
exportfits(dirtyimagename, dirtyimagename + ".fits", overwrite=True)
reg = regions.read_ds9(regfile)
imghdu = fits.open(dirtyimagename + ".fits")[0]
assert imghdu.data.shape[-1] != 1
assert imghdu.data.shape[-2] != 1
mask = get_mask(reg, imghdu)
assert mask.shape[0] > 1
assert mask.shape[1] > 1
assert mask.size > 1
imghdu.data = mask.astype('int16')
imghdu.header['BITPIX'] = 16
imghdu.writeto(cleanbox_mask + '.fits', clobber=True)
importfits(fitsimage=cleanbox_mask + '.fits',
imagename=cleanbox_mask_image,
overwrite=True)
ia.open(cleanbox_mask_image)
ia.calcmask(mask="'{0}' > 0.5".format(cleanbox_mask_image),
name='cleanbox_mask')
ia.close()
makemask(mode='copy',
inpimage=cleanbox_mask_image,
inpmask=cleanbox_mask_image + ":cleanbox_mask",
output=cleanbox_mask,
overwrite=True)
mask = cleanbox_mask
ia.open(mask)
stats = ia.statistics()
ia.close()
casalog.post("Resulting mask file is {0}".format(mask),
origin='reg_to_mask')
casalog.post("Mask sum = {0} out of {1}, or {2}%".format(
stats['sum'], stats['npts'], stats['sum'] / stats['npts'] * 100),
origin='reg_to_mask')
return mask
else:
raise IOError("Missing dirty image file & dirty FITS image")
ia.open(dirtyimage)
ia.calcmask(mask=dirtyimage +
" > {0}".format(mask_threshold[field] / 1e3),
name='dirty_mask_{0}'.format(field_nospace))
ia.close()
makemask(mode='copy',
inpimage=dirtyimage,
inpmask=dirtyimage + ":dirty_mask_{0}".format(field_nospace),
output='dirty_mask_{0}.mask'.format(field_nospace),
overwrite=True)
mask = 'dirty_mask_{0}.mask'.format(field_nospace)
exportfits(mask, mask + '.fits', dropdeg=True, overwrite=True)
exportfits(dirtyimage, dirtyimage + ".fits", overwrite=True)
reg = pyregion.open('cleanbox_regions_SgrB2.reg')
imghdu = fits.open(dirtyimage + ".fits")[0]
hdr = wcs.WCS(imghdu).celestial.to_header()
mask = reg.get_mask(header=hdr,
shape=imghdu.data.squeeze().shape)[None,
None, :, :]
imghdu.data = mask.astype('int16')
imghdu.header['BITPIX'] = 16
imghdu.writeto('cleanbox_mask_{0}.fits'.format(field_nospace),
overwrite=True)
importfits(fitsimage='cleanbox_mask_{0}.fits'.format(field_nospace),
imagename=cleanbox_mask_image,
overwrite=True)
def makefits(myimagebase, cleanup=True):
if os.path.exists(myimagebase + '.image.tt0'):
try:
impbcor(imagename=myimagebase + '.image.tt0',
pbimage=myimagebase + '.pb.tt0',
outfile=myimagebase + '.image.tt0.pbcor',
overwrite=True) # perform PBcorr
exportfits(imagename=myimagebase + '.image.tt0.pbcor',
fitsimage=myimagebase + '.image.tt0.pbcor.fits',
dropdeg=False,
overwrite=True) # export the corrected image
except AttributeError as ex:
print(ex)
exportfits(imagename=myimagebase + '.image.tt1',
fitsimage=myimagebase + '.image.tt1.fits',
dropdeg=False,
overwrite=True) # export the corrected image
exportfits(imagename=myimagebase + '.pb.tt0',
fitsimage=myimagebase + '.pb.tt0.fits',
dropdeg=False,
overwrite=True) # export the PB image
exportfits(imagename=myimagebase + '.model.tt0',
fitsimage=myimagebase + '.model.tt0.fits',
dropdeg=False,
overwrite=True) # export the PB image
exportfits(imagename=myimagebase + '.model.tt1',
fitsimage=myimagebase + '.model.tt1.fits',
dropdeg=False,
overwrite=True) # export the PB image
exportfits(imagename=myimagebase + '.residual.tt0',
fitsimage=myimagebase + '.residual.tt0.fits',
dropdeg=False,
overwrite=True) # export the PB image
exportfits(imagename=myimagebase + '.alpha',
fitsimage=myimagebase + '.alpha.fits',
dropdeg=False,
overwrite=True)
exportfits(imagename=myimagebase + '.alpha.error',
fitsimage=myimagebase + '.alpha.error.fits',
dropdeg=False,
overwrite=True)
if cleanup:
for ttsuffix in ('.tt0', '.tt1', '.tt2'):
for suffix in ('pb{tt}', 'weight', 'sumwt{tt}', 'psf{tt}',
'model{tt}', 'mask', 'image{tt}',
'residual{tt}', 'alpha', 'alpha.error'):
# keep the model around
if not suffix.format(tt=ttsuffix) == 'model.tt0':
os.system('rm -rf {0}.{1}'.format(
myimagebase, suffix).format(tt=ttsuffix))
elif os.path.exists(myimagebase + '.image'):
try:
impbcor(imagename=myimagebase + '.image',
pbimage=myimagebase + '.pb',
outfile=myimagebase + '.image.pbcor',
overwrite=True) # perform PBcorr
exportfits(imagename=myimagebase + '.image.pbcor',
fitsimage=myimagebase + '.image.pbcor.fits',
dropdeg=False,
overwrite=True) # export the corrected image
except AttributeError as ex:
print(ex)
exportfits(imagename=myimagebase + '.pb',
fitsimage=myimagebase + '.pb.fits',
dropdeg=False,
overwrite=True) # export the PB image
exportfits(imagename=myimagebase + '.model',
fitsimage=myimagebase + '.model.fits',
dropdeg=False,
overwrite=True) # export the PB image
exportfits(imagename=myimagebase + '.residual',
fitsimage=myimagebase + '.residual.fits',
dropdeg=False,
overwrite=True) # export the PB image
if cleanup:
ttsuffix = ''
for suffix in ('pb{tt}', 'weight', 'sumwt{tt}', 'psf{tt}',
'model{tt}', 'mask', 'image{tt}', 'residual{tt}',
'alpha', 'alpha.error'):
os.system('rm -rf {0}.{1}'.format(myimagebase,
suffix).format(tt=ttsuffix))
else:
raise IOError("No image file found matching {0}".format(myimagebase))