def cleanfinal(msin, cal_source): """Second CLEANing round and imaging :param msin: Visibility dataset in measurement set format path :type msin: str :param cal_source: Calibration source for masking :type cal_source: str """ imgname = os.path.basename(msin) + '.fin.img' if cal_source in cal_source_dct.keys(): clean_mask = cal_source_dct[cal_source]['mask'] else: cal_source = '' # TODO create mask for arbitrary point source given clean_mask = None tclean(vis=msin, imagename=imgname, spw='0:60~745', niter=3000, weighting='briggs', robust=-1, imsize=[512, 512], cell=['250arcsec'], specmode='mfs', nterms=1, mask=clean_mask) imggal = cal_source + 'combined.galcord' imregrid(imagename=imgname + '.image', output=imggal, template='GALACTIC')
def cleaninit(msin, cal_source): """First CLEANing round :param msin: Visibility dataset in measurement set format path :type msin: str :param cal_source: Calibration source for masking :type cal_source: str TODO: Argument to specify mask """ imgname = os.path.basename(msin) + '.init.img' if cal_source in cal_source_dct.keys(): clean_mask = cal_source_dct[cal_source]['mask'] else: clean_mask = None tclean(vis=msin, imagename=imgname, niter=500, weighting='briggs', robust=0, imsize=[512, 512], cell=['250arcsec'], specmode='mfs', nterms=1, spw='0:150~900', mask=clean_mask)
def predictImager(msname='sim_data.ms', imname_true='sim_onepoint_true.im', gridder='standard'): os.system('rm -rf sim_predict.*') # Run tclean in predictModel mode. tclean( vis=msname, startmodel=imname_true, imagename='sim_predict', savemodel='modelcolumn', imsize=256, cell='8.0arcsec', specmode='cube', interpolation='nearest', start='1.0GHz', width='0.1GHz', nchan=10, reffreq='1.5Hz', gridder=gridder, normtype='flatsky', # sky model is flat-sky cfcache='sim_predict.cfcache', wbawp= True, # ensure that gridders='mosaic' and 'awproject' do freq-dep PBs pblimit=0.05, conjbeams=False, calcres=False, calcpsf=True, niter=0, wprojplanes=1)
def tclean_wrapper(vis, imagename, imsize=None, cellsize=None, interactive=False, robust=0.5, niter=50000, pbcor=True, **kwargs): for ext in [ ".image", ".mask", ".model", ".pb", ".psf", ".residual", ".sumwt", ".image.pbcor", ]: fname = imagename + ext if os.path.exists(fname): shutil.rmtree(fname) tclean( vis=vis, imagename=imagename, weighting="briggs", robust=robust, imsize=imsize, cell=cellsize, niter=niter, # we want to end on the threshold interactive=interactive, pbcor=pbcor, **kwargs)
def tcleaner(targetcalfile, params, threshold='1.0mJy', niter=1000, outimage=None, interactive=False): ''' This tcleaner is specifically written for imaging during the self-calibration round. For a general purpose imaging, use the casa task tclean outside of yarrp. ''' imaging_params = params['imagecal'] #outimage = imaging_params['outimage'] target = params['general']['target'] imsize = imaging_params['imsize'] cell = imaging_params['cell'] robust = imaging_params['robust'] weighting = imaging_params['weighting'] uvran = imaging_params['uvran'] uvtaper = imaging_params['uvtaper'] nterms = imaging_params['nterms'] #niter = imaging_params['niter'] #threshold = imaging_params['threshold'] wprojplanes = imaging_params['wprojplanes'] scales = imaging_params['scales'] cts.tclean(targetcalfile, imagename=outimage, field=target, spw='0', imsize=imsize, cell=cell, robust=robust, weighting=weighting, uvrange=uvran, uvtaper=uvtaper, specmode='mfs', nterms=nterms, niter=niter, usemask='auto-multithresh', minbeamfrac=0.1, sidelobethreshold=1.5, smallscalebias=0.6, threshold=threshold, aterm=True, pblimit=-1, deconvolver='mtmfs', gridder='wproject', wprojplanes=wprojplanes, scales=scales, wbawp=False, restoration=True, savemodel='modelcolumn', cyclefactor=0.5, parallel=False, interactive=interactive) return print('tcleaned the {}'.format(targetcalfile), 'file.')
def imageAnts(vis='sim_data_ALMA.ms', imname='try_ALMA', field='0', antsel='', tel='ALMA', vptable=''): """ Run imager..... TODO set pblimit=-1 ... or set the image stats method to look inside the PB region only. """ antsels = getBaselineTypes(tel=tel) if antsel not in antsels.keys(): print('Pick an antenna selection from ' + str(antsels)) return if tel == 'ALMA': cell = '0.4arcsec' imsize = 1024 phasecenter = 'J2000 +19h59m28.5s -40d44m21.5s' if (tel == 'NGVLA'): cell = '1.0arcsec' imsize = 1024 phasecenter = 'J2000 +19h59m28.5s +40d44m21.5s' if field == '0' or field == '1': ftype = 'single' else: ftype = 'mosaic' imname1 = imname + '_' + antsel + '_' + ftype os.system('rm -rf ' + imname1 + '.*') # Run tclean tclean(vis=vis, antenna=antsels[antsel], field=field, imagename=imname1, imsize=imsize, cell=cell, phasecenter=phasecenter, specmode='cube', interpolation='nearest', nchan=-1, gridder='mosaic', vptable=vptable, normtype='flatnoise', wbawp=True, pblimit=0.05, conjbeams=False, niter=1000, nsigma=3.0, datacolumn='data', weighting='natural')
def makeimage(msfile, field, outname='tmp.', niter=50, cell=0.5, npix=4096, spw='', antenna='*', uvrange='>0lambda', weighting='natural', gridder='standard', robust=0.5, uvtaper=[], deconvolver='hogbom', conjbeams=False, wprojplanes=-1): """ Tclean on the data to generate the image Example Usage: makeimage(msfile1, fieldnames[0], outname='IMNAME', spw='5~8', niter=100, cell=0.5, npix=4096) spw range is end inclusive """ # To remove earlier products? # %sx rm -rf $msfile?* wprojplanes = -1 if 'project' in gridder else 1 tasks.tclean(vis=msfile, imagename=outname, field=field, niter=niter, stokes='I', antenna=antenna, uvrange=uvrange, weighting=weighting, cell=cell, imsize=[npix, npix], spw=spw, gridder=gridder, robust=robust, uvtaper=uvtaper, deconvolver=deconvolver, conjbeams=conjbeams, wprojplanes=wprojplanes)
def predictImager(msname='sim_data_ALMA.ms', imname_true='sim_onepoint_true.im', gridder='mosaic', tel='ALMA', vptable=''): if tel=='ALMA': cell='0.2arcsec' imsize=2048 if tel=='VLA': cell='12.0arcsec' imsize=512 if (tel=='NGVLA'): cell='0.5arcsec' imsize=2048 os.system('rm -rf sim_predict.*') # Run tclean in predictModel mode. tclean(vis=msname, startmodel=imname_true, vptable = vptable, imagename='sim_predict', savemodel='modelcolumn', imsize=imsize, cell=cell, specmode='cube', interpolation='nearest', nchan=-1, #start='90.0GHz', #width='1.0GHz', #nchan=10, #reffreq='95.0GHz', gridder=gridder, normtype='flatsky', # sky model is flat-sky #cfcache='sim_predict.cfcache', wbawp=True, # ensure that gridders='mosaic' and 'awproject' do freq-dep PBs pblimit=0.05, conjbeams=False, calcres=False, calcpsf=True, niter=0, wprojplanes=1)
import os, warnings warnings.simplefilter( "ignore", category=RuntimeWarning) # suppress warnings about nan-slices from casatasks import tclean from casatasks import immoments from cngi.conversion import convert_image from cngi.image import implot from cngi.image import moments import os import numpy as np #tclean returns error for some reason 2020 1013 ''' tclean(vis='sis14_twhya_calibrated_flagged.ms', imagename='sis14_twhya_calibrated_flagged', field='5', spw='', specmode='cube', deconvolver='hogbom', nterms=1, imsize=[250,250], gridder='standard', cell=['0.1arcsec'], nchan=10, weighting='natural', threshold='0mJy', niter=5000, interactive=False, savemodel='modelcolumn', usemask='auto-multithresh') ''' #load image instead of running tclean. Change the file path when test it in your local machine Casa6ImageFileName = '/Users/wxiong/NRAO/dev/cngi_prototype/data/sis14_twhya_calibrated_flagged/sis14_twhya_calibrated_flagged.image' # casa6 os.system('rm -rf casa6.immoments.image*') immoments(Casa6ImageFileName, axis='spectral', moments=[-1, 0, 1, 2, 3, 5, 6, 7, 8, 9, 10, 11], outfile='casa6.immoments.image') casa_xds = convert_image('casa6.immoments.image.average', artifacts=[ 'average', 'median', 'integrated', 'maximum',
def imagecal(targetcalfile, params, nloops=1, ploops=5, aploops=2, flagger='default', interactive=False): ''' This function takes in a calibrated target file (usually the channel averaged file) and goes through "niters" of imagecal loops. A imagecal loop is defined as first making a image using imgr.tcleaner. Then "ploops" of phase-only self-cal and "aploops" of a&p selfcal. Then the continuum image is subtracted from the UV data and the residuals are flagged. After having gone through all the "niters" loop it spits out a final continuum image. ''' imaging_params = params['imagecal'] outimage = imaging_params['outimage'] target = params['general']['target'] threshold_range = imaging_params['threshold_range'] threshold_final = imaging_params['threshold_final'] solints = imaging_params['solints'] niter_range = imaging_params['niter_range'] #temp_dir = params['general']['temp'] # Preparing the ranges of different parameters for the loops solint_range = np.linspace(solints[0], solints[1], ploops) solint_range = [str(i)+'min' for i in solint_range] threshold_range = np.linspace(threshold_range[0], threshold_range[1], ploops) threshold_range = [str(i)+'mJy' for i in threshold_range] niter_range = np.linspace(niter_range[0], niter_range[1], ploops) niter_range = [int(i) for i in niter_range] while nloops >= 1: #subprocess.run('rm -r {}'.format(temp_dir), shell=True, check=True) # Clearing the temp directory #subprocess.run('mkdir {}'.format(temp_dir), shell=True, check=True) ploop_index = 1 + np.arange(ploops) #This gives the index to the cont image and cal files created later sc_p_msfile = targetcalfile # Initially begin with the avspc file, and then change this file name to the running self-cal file for pindex in ploop_index: # Run all the ploops print('Self-cal phase-only loop', pindex) imgr.tcleaner(sc_p_msfile, params, threshold=threshold_range[pindex - 1], niter=niter_range[pindex - 1], outimage='../RGG_5_sc_p.'+str(pindex), interactive=interactive) clb.selfcal(sc_p_msfile, params, mode='p', in_gaintable=[], out_gaintable='sc_p.gcal.'+str(pindex), solint=solint_range[pindex - 1], solnorm = False) gaintable = ['sc_p.gcal.'+str(pindex)] # Change the gaintable to the latest cts.applycal(sc_p_msfile, gaintable=gaintable, field='', gainfield='', applymode='calonly', interp=['linear'], calwt=False, parang=False) cts.mstransform(sc_p_msfile, field='0', spw='0', datacolumn='corrected', outputvis='sc_p_'+str(pindex)+'.ms') sc_p_msfile = 'sc_p_'+str(pindex)+'.ms' aploop_index = 1 + np.arange(aploops) #This gives the index to the cont image and cal files created later sc_ap_msfile = sc_p_msfile # Initially begin with the avspc file, and then change this file name to the running self-cal file niter_ap = niter_range[-1] # The last object in pcal niters threshold_ap = threshold_range[-1] solint_ap = solint_range[-1] for apindex in aploop_index: # Run all the aploops print('Self-cal a&p loop', apindex) imgr.tcleaner(sc_ap_msfile, params, threshold=threshold_ap, niter=niter_ap, outimage='../RGG5_sc_ap.'+str(apindex), interactive=interactive) clb.selfcal(sc_ap_msfile, params, mode='a&p', in_gaintable=[], out_gaintable='sc_ap.gcal.'+str(apindex), solint=solint_ap, solnorm=True) gaintable = ['sc_ap.gcal.'+str(apindex)] # Change the gaintable to the latest cts.applycal(sc_ap_msfile, gaintable=gaintable, field='', gainfield='', applymode='calonly', interp=['linear'], calwt=False, parang=False) cts.mstransform(sc_ap_msfile, field='0', spw='0', datacolumn='corrected', outputvis='sc_ap_'+str(apindex)+'.ms') sc_ap_msfile = 'sc_ap_'+str(apindex)+'.ms' # Add some r-flagging on the residuals and then continue the loops. nloops = nloops - 1 else: print('Self-cal loops over.') print('Making a final continuum image...') imaging_params = params['imagecal'] outimage = imaging_params['outimage'] target = params['general']['target'] imsize = imaging_params['imsize'] cell = imaging_params['cell'] robust = imaging_params['robust'] weighting = imaging_params['weighting'] uvran = imaging_params['uvran'] uvtaper = imaging_params['uvtaper'] nterms = imaging_params['nterms'] niter = 5000 #niter_ap threshold = threshold_final wprojplanes = imaging_params['wprojplanes'] scales = imaging_params['scales'] cts.tclean(sc_ap_msfile, imagename=outimage+'_final', field=target, spw='0', imsize=imsize, cell=cell, robust=robust, weighting=weighting, uvrange=uvran, uvtaper=uvtaper, specmode='mfs', nterms=nterms, niter=niter, usemask='auto-multithresh', minbeamfrac=0.1, sidelobethreshold = 1.5, smallscalebias=0.6, threshold= threshold, aterm =True, pblimit=-1, deconvolver='mtmfs', gridder='wproject', wprojplanes=wprojplanes, scales=scales,wbawp=False, restoration = True, savemodel='modelcolumn', cyclefactor = 0.5, parallel=False, interactive=False) print('Imaging and self-calibration done.') return gaintable
def slefcal_ms(src_dir, imagems, imagename, ATCA_band, n_spw): print( "+ + + + + + + + + + + + + + + + +\n+ Self Cal Round 1 +\n+ + + + + + + + + + + + + + + + +" ) mode = "mfs" nterms = 2 niter = 3000 antenna = "0~6,0~6" n_spw = n_spw if ATCA_band == "L": imsize = 2250 solint = "60s" minsnr = 3.0 cell = "1arcsec" minblperant = 3 if ATCA_band == "C": imsize = 2250 solint = "60s" minsnr = 3.0 minblperant = 3 cell = "0.5arcsec" if ATCA_band == "X": imsize = 1152 solint = "60s" minsnr = 3.0 minblperant = 3 cell = "0.2arcsec" uvrange = "" stokes = "I" weighting = "briggs" robust = 0.5 interactive = False gain = 0.01 threshold = "5e-4Jy" # if os.path.exists(f"{src_dir}/cal_tables/pcal1_{imagename}"): rmtables(f"{src_dir}/cal_tables/pcal1_{imagename}") gaincal( vis=imagems, caltable=f"{src_dir}/cal_tables/pcal1_{imagename}", combine="scan,spw", spwmap=[0] * n_spw, gaintype="G", calmode="p", solint=solint, minsnr=minsnr, minblperant=minblperant, ) applycal( vis=imagems, gaintable=f"{src_dir}/cal_tables/pcal1_{imagename}", spwmap=[0] * n_spw, parang=True, applymode="calonly", flagbackup=False, ) flagmanager(vis=imagems, mode="save", versionname="post self1") for i in range(0, n_spw): spw = str(i) # if os.path.exists(f"{src_dir}/casa_files/{imagename}_{spw}_self1*"): os.system( f"rm -r {src_dir}/casa_files/{imagename}_{spw}_self1*" ) print("Cleaning on band: " + str(spw)) tclean( vis=imagems, imagename=f"{src_dir}/casa_files/{imagename}_{spw}_self1", selectdata=True, mask=f"{src_dir}/casa_files/{imagename}_mfs.mask", spw=spw, startmodel=f"{src_dir}/casa_files/{imagename}_{spw}_preself.model", gain=gain, specmode=mode, nterms=nterms, niter=niter, threshold=threshold, imsize=imsize, cell=cell, stokes=stokes, weighting=weighting, robust=robust, antenna=antenna, interactive=interactive, savemodel="modelcolumn", pbcor=False, uvrange=uvrange, ) tclean( vis=imagems, imagename=f"{src_dir}/casa_files/{imagename}_{spw}_self1", selectdata=True, mask="", spw=spw, gain=gain, specmode=mode, nterms=nterms, niter=0, threshold=threshold, imsize=imsize, cell=cell, stokes=stokes, weighting=weighting, robust=robust, antenna=antenna, interactive=interactive, pbcor=False, savemodel="modelcolumn", calcres=False, calcpsf=False, uvrange=uvrange, ) threshold = "5e-5Jy" # if os.path.exists(f"{src_dir}/cal_tables/pcal2_{imagename}"): rmtables(f"{src_dir}/cal_tables/pcal2_{imagename}") print( "+ + + + + + + + + + + + + + + + +\n+ Self Cal Round 2 +\n+ + + + + + + + + + + + + + + + +" ) gaincal( vis=imagems, caltable=f"{src_dir}/cal_tables/pcal2_{imagename}", gaintable=f"{src_dir}/cal_tables/pcal1_{imagename}", combine="scan,spw", spwmap=[0] * n_spw, gaintype="G", calmode="p", solint=solint, minsnr=minsnr, minblperant=minblperant, ) applycal( vis=imagems, gaintable=[ f"{src_dir}/cal_tables/pcal1_{imagename}", f"{src_dir}/cal_tables/pcal2_{imagename}", ], spwmap=[[0] * n_spw, [0] * n_spw], parang=True, applymode="calonly", flagbackup=False, ) flagmanager(vis=imagems, mode="save", versionname="post self2") for i in range(0, n_spw): spw = str(i) # if os.path.exists(f"{src_dir}/casa_files/{imagename}_{spw}_self2*"): os.system(f"rm -r {src_dir}/casa_files/{imagename}_{spw}_self2*") print("Cleaning on band: " + str(spw)) tclean( vis=imagems, imagename=f"{src_dir}/casa_files/{imagename}_{spw}_self2", selectdata=True, mask=f"{src_dir}/casa_files/{imagename}_mfs.mask", spw=spw, startmodel=f"{src_dir}/casa_files/{imagename}_{spw}_self1.model", gain=gain, specmode=mode, nterms=nterms, niter=niter, threshold=threshold, imsize=imsize, cell=cell, stokes=stokes, weighting=weighting, robust=robust, antenna=antenna, interactive=interactive, savemodel="modelcolumn", pbcor=False, uvrange=uvrange, ) tclean( vis=imagems, imagename=f"{src_dir}/casa_files/{imagename}_{spw}_self2", selectdata=True, mask="", spw=spw, gain=gain, specmode=mode, nterms=nterms, niter=0, threshold=threshold, imsize=imsize, cell=cell, stokes=stokes, weighting=weighting, robust=robust, antenna=antenna, interactive=interactive, pbcor=False, savemodel="modelcolumn", calcres=False, calcpsf=False, uvrange=uvrange, ) threshold = "5e-6Jy" print( "+ + + + + + + + + + + + + + + + +\n+ Self Cal Round 3 +\n+ + + + + + + + + + + + + + + + +" ) rmtables(f"{src_dir}/cal_tables/pcal3_{imagename}") gaincal( vis=imagems, caltable=f"{src_dir}/cal_tables/pcal3_{imagename}", gaintable=[ f"{src_dir}/cal_tables/pcal1_{imagename}", f"{src_dir}/cal_tables/pcal2_{imagename}", ], combine="scan,spw", spwmap=[[0] * n_spw, [0] * n_spw], gaintype="G", calmode="p", solint=solint, minsnr=minsnr, minblperant=minblperant, ) applycal( vis=imagems, gaintable=[ f"{src_dir}/cal_tables/pcal1_{imagename}", f"{src_dir}/cal_tables/pcal2_{imagename}", f"{src_dir}/cal_tables/pcal3_{imagename}", ], spwmap=[[0] * n_spw, [0] * n_spw, [0] * n_spw], parang=True, applymode="calonly", flagbackup=False, ) flagmanager(vis=imagems, mode="save", versionname="post self3") for i in range(0, n_spw): spw = str(i) # if os.path.exists(f"{src_dir}/casa_files/{imagename}_{spw}_self3*"): os.system(f"rm -r {src_dir}/casa_files/{imagename}_{spw}_self3*") print("Cleaning on band: " + str(spw)) # imagename = f"{src_dir}/casa_files/{imagename}_{spw}" tclean( vis=imagems, imagename=f"{src_dir}/casa_files/{imagename}_{spw}_self3", selectdata=True, mask=f"{src_dir}/casa_files/{imagename}_mfs.mask", startmodel=f"{src_dir}/casa_files/{imagename}_{spw}_self2.model", spw=spw, gain=gain, specmode=mode, nterms=nterms, niter=niter, threshold=threshold, imsize=imsize, cell=cell, stokes=stokes, weighting=weighting, robust=robust, antenna=antenna, interactive=interactive, savemodel="modelcolumn", pbcor=False, uvrange=uvrange, ) tclean( vis=imagems, imagename=f"{src_dir}/casa_files/{imagename}_{spw}_self3", selectdata=True, mask="", spw=spw, gain=gain, specmode=mode, nterms=nterms, niter=0, threshold=threshold, imsize=imsize, cell=cell, stokes=stokes, weighting=weighting, robust=robust, antenna=antenna, interactive=interactive, pbcor=False, savemodel="modelcolumn", calcres=False, calcpsf=False, uvrange=uvrange, ) return
def img_ms(src_dir, imagems, imagename, ATCA_band, n_spw): print( "+ + + + + + + + + + + + + + + + +\n+ Preself Imaging +\n+ + + + + + + + + + + + + + + + +" ) antenna = "0~6,0~6" mode = "mfs" nterms = 1 niter = 3000 n_spw = n_spw if ATCA_band == "L": imsize = 2250 cell = "1arcsec" if ATCA_band == "C": imsize = 2250 cell = "0.5arcsec" if ATCA_band == "X": imsize = 1152 cell = "0.2arcsec" stokes = "I" weighting = "briggs" robust = 0.5 interactive = False gain = 0.01 threshold = "5e-3Jy" uvrange = "" # flagmanager(vis=imagems, mode="save", versionname="preself") for i in range(0, n_spw): spw = str(i) print("Cleaning on band: " + str(spw)) # if os.path.exists(f"{src_dir}/casa_files/{imagename}_{spw}_preself*"): os.system( f"rm -r {src_dir}/casa_files/{imagename}_{spw}_preself*" ) tclean( vis=imagems, imagename=f"{src_dir}/casa_files/{imagename}_{spw}_preself", selectdata=True, mask=f"{src_dir}/casa_files/{imagename}_mfs.mask", spw=spw, gain=gain, specmode=mode, nterms=nterms, niter=niter, threshold=threshold, imsize=imsize, cell=cell, stokes=stokes, weighting=weighting, robust=robust, antenna=antenna, interactive=interactive, savemodel="modelcolumn", pbcor=False, uvrange=uvrange, ) tclean( vis=imagems, imagename=f"{src_dir}/casa_files/{imagename}_{spw}_preself", selectdata=True, mask="", spw=spw, gain=gain, specmode=mode, nterms=nterms, niter=0, threshold=threshold, imsize=imsize, cell=cell, stokes=stokes, weighting=weighting, robust=robust, antenna=antenna, interactive=interactive, pbcor=False, savemodel="modelcolumn", calcres=False, calcpsf=False, uvrange=uvrange, ) return
def imgmfs_ms(src_dir, imagems, imagename, ATCA_band, n_spw): mode = "mfs" nterms = 1 niter = 3000 antenna = "0~6,0~6" uvrange = "" n_spw = n_spw if ATCA_band == "L": imsize = 2250 cell = "1arcsec" threshold = "2e-2Jy" if ATCA_band == "C": imsize = 2250 cell = "0.5arcsec" threshold = "2e-2Jy" if ATCA_band == "X": imsize = 2250 cell = "0.2arcsec" threshold = "2e-2Jy" stokes = "I" weighting = "briggs" robust = 0.5 interactive = True gain = 0.01 # if os.path.exists(f"{src_dir}/casa_files/{imagename}_mfs*"): os.system(f"rm -r {src_dir}/casa_files/{imagename}_mfs*") flagmanager(vis=imagems, mode="save", versionname="before_selfcal") print("Initiating interactive cleaning on {0}".format(imagename)) tclean( vis=imagems, imagename=f"{src_dir}/casa_files/{imagename}_mfs", gain=gain, specmode=mode, nterms=nterms, niter=niter, threshold=threshold, imsize=imsize, cell=cell, stokes=stokes, weighting=weighting, robust=robust, antenna=antenna, interactive=interactive, savemodel="modelcolumn", pbcor=False, uvrange=uvrange, ) tclean( vis=imagems, imagename=f"{src_dir}/casa_files/{imagename}_mfs", gain=gain, specmode=mode, nterms=nterms, niter=0, threshold=threshold, imsize=imsize, cell=cell, stokes=stokes, weighting=weighting, robust=robust, antenna=antenna, interactive=interactive, savemodel="modelcolumn", pbcor=False, calcres=False, calcpsf=False, uvrange=uvrange, ) return
def test_casa_masking(): with tempfile.TemporaryDirectory() as tmpdir: # SIMULATE SOME DATA SET # Define antennas diam = [25, 25, 25, 25, 25] xx = [50, 100, 150, 200, 250] yy = [2, -5, -20, -50, -100] zz = [-0.5, -1.0, -1.5, -2.0, -2.5] sm = simulator() sm.open(tmpdir + '/SIM.ms') # do configuration posvla = me.observatory('VLA') sm.setconfig(telescopename='VLA', x=xx, y=yy, z=zz, dishdiameter=diam, mount='alt-az', antname='VLA', coordsystem='local', referencelocation=posvla) # Initialize the spectral windows sm.setspwindow(spwname='CBand', freq='5GHz', deltafreq='50MHz', freqresolution='50MHz', nchannels=1, stokes='RR RL LR LL') # Initialize the source and calibrater sm.setfield(sourcename='My cal', sourcedirection=['J2000', '00h0m0.0', '+45.0.0.000'], calcode='A') sm.setfield(sourcename='My source', sourcedirection=['J2000', '01h0m0.0', '+47.0.0.000']) sm.setlimits(shadowlimit=0.001, elevationlimit='8.0deg') sm.setauto(autocorrwt=0.0) sm.settimes(integrationtime='10s', usehourangle=False, referencetime=me.epoch('utc', 'today')) sm.observe('My cal', 'CBand', starttime='720s', stoptime='1020s') sm.observe('My source', 'CBand', starttime='1030s', stoptime='1500s') sm.close() # Create mask to use during clean reg = EllipseSkyRegion(center=coordinates.SkyCoord(0.0 * u.deg, 45.0 * u.deg, frame='fk5'), width=1.0 * u.arcmin, height=2.0 * u.arcmin, angle=45 * u.deg) write_crtf([reg], tmpdir + '/SIM.crtf', 'fk5', '.6f', 'deg') # Image the dataset tclean(vis=tmpdir + '/SIM.ms', imagename=tmpdir + '/SIM', imsize=100, cell='5arcsec', niter=1, mask=tmpdir + '/SIM.crtf', interactive=False) ia = image() ia.open(tmpdir + '/SIM.mask') mask_array = ia.getregion() ia.close() with open('data/binary_mask.pkl', 'rb') as f: ref_mask = pickle.load(f) assert all(mask_array == ref_mask)
def pipeline(msfile, params, doinitial_flagging=True, doflagcal=True, doimagecal=True, douvsub=True, docubeimage=False): ''' This function takes combines several recipes to construct a pipeline. In particular here it follows a simple procedure. initial flagging --> setjy+delay calibration --> amplitude calibration + flagging loops on calibrators --> bandpass calibration + flagging loops --> imaging+selfcal loops --> final image --> UVSUB+CVEL --> Cube image with source finder. ''' with open('yarp_art.txt', 'r') as f: for line in f: print(line.rstrip()) print('Running the yarp pipeline on {}'.format(msfile)) if doinitial_flagging: flag_spw = params['flagging']['spw'] bad_ants = params['flagging']['badants'] flagcmd = params['flagging']['flagcmd'] if len(bad_ants) != 0: flg.badantflag(msfile, params) else: print('No bad antennas found.') if flagcmd != False: print('Flagging based on user defined commands ...') cts.flagdata(msfile, mode='list', inpfile=flagcmd) else: None cts.flagdata(msfile, mode='quack', field='', spw='0', antenna='', correlation='', timerange='', quackinterval=10, quackmode='beg', action='apply', savepars=True, cmdreason='quackbeg') cts.flagdata(msfile, mode='quack', field='', spw='0', antenna='', correlation='', timerange='', quackinterval=10, quackmode='endb', action='apply', savepars=True, cmdreason='quackendb') if flag_spw != False: cts.flagdata(msfile, mode='manual', field='', spw=flag_spw, antenna='', correlation='', timerange='', action='apply', savepars=True, cmdreason='badchannels') else: print('Not flagging edge channels') flg.tfcropper(msfile, params, field='', tcut=6, fcut=6, instance='initial') # Flag very long baselines as that can affect the calibration cts.flagdata(msfile, mode='manual', uvrange='>100klambda') flg.extend(msfile, params, instance='initial') #flg.aoflagger(msfile, params) else: print('No initial flagging this time.') # Flagcal begins if doflagcal: print('Running the flagcal script...') nloops = params['calibration']['nloops'] flagcal2(msfile, params, niters=nloops, flagger='default', interactive=False) else: print('No flagcal this time.') if doimagecal: print('Doing image and self-calibration...') target = params['general']['target'] targetcalfile = params['general']['targetcalfile'] avspcfile = targetcalfile[:-3]+'_avspc.ms' print('Flagging all data above uvran 100klambda ...') cts.flagdata(targetcalfile, mode='manual', uvrange='>100klambda') print('Averaging the channels to 1 MHz...') chanbin = params['imagecal']['chanbin'] cts.mstransform(targetcalfile, field=target, spw='0', chanaverage=True, chanbin=chanbin, datacolumn='data', outputvis=avspcfile) print('Rflagging the channel averaged file...') flg.rflagger(avspcfile, params, field=target, tcut=10, fcut=10, instance='initial') print('Flagging the line spws...') flag_spw = params['imagecal']['spec_line_spw'] cts.flagdata(avspcfile, mode='manual', spw=flag_spw) print('Doing imaging and self-calibration...') nloops = params['imagecal']['nloops'] ploops = params['imagecal']['ploops'] aploops = params['imagecal']['aploops'] print('Running {} cycles of self-cal with {} ploops and {} aploops in each cycle...'.format( str(nloops), str(ploops), str(aploops))) final_image, selfcaltable = imagecal_dev( avspcfile, params, nloops=nloops, ploops=ploops, aploops=aploops, flagger='default', interactive=False) print('Final self-cal table is', selfcaltable) else: print('No imaging and self-calibration this time.') if douvsub: print('Doing uvsub...') target = params['general']['target'] targetcalfile = params['general']['targetcalfile'] avspcfile = targetcalfile[:-3]+'_avspc.ms' nloops = params['imagecal']['nloops'] ploops = params['imagecal']['ploops'] aploops = params['imagecal']['aploops'] outdir = params['general']['outdir'] # apply self-cal table to the full chan resolution file # selfcaltable = [outdir+'sc_p.gcal.' + # str(nloops)+str(ploops), outdir+'sc_ap.gcal.'+str(nloops)+str(aploops)] ''' selfcaltable = [outdir+'sc_p.gcal.' + str(1)+str(5)] print(selfcaltable) cts.applycal(targetcalfile, gaintable=selfcaltable, field='', gainfield='', applymode='calonly', interp=['linearperobs'], calwt=False, parang=False) print('Rflagging the self-calibrated data') ''' linefreespw = params['uvsub']['linefreespw'] linespw = params['uvsub']['linespw'] ''' flg.rflagger(targetcalfile, params, spw=linefreespw, field=target, tcut=6, fcut=6, instance='postcal') # deep flag the line free channels flg.rflagger(targetcalfile, params, spw=linespw, field=target, tcut=10, fcut=10, instance='postcal') # Be more conservative on the line channels flg.extend(targetcalfile, params, field=target, grow=80, instance='postcal') ''' # UVLIN the full chan resolution file print('Doing uvcontsub...') fitorder = params['uvsub']['fitorder'] # print(linefreespw) cts.uvcontsub(targetcalfile, fitspw=linefreespw, fitorder=fitorder, solint='int', combine='scan') #tempdir = params['general']['temp'] #uvsubber(targetcalfile, params, fitspw=linefreespw, fitorder=fitorder, nterms=1, # model_image=[tempdir+'AGC203001_cont_sc_p.15.model']) targetcalfile = params['general']['targetcalfile'] cont_sub_file = targetcalfile+'.uvsub.contsub' # subprocess.run('mv {} {}'.format(cont_sub_file, outdir), # shell=True, check=True) else: print('No uvsub this time.') if docubeimage: print('Doing cube image...') # image the cube outdir = params['general']['outdir'] target = params['general']['target'] targetcalfile = params['general']['targetcalfile'] restfreq = '1.420405752GHz' #cont_sub_file = targetcalfile+'.contsub' #cont_sub_file = cont_sub_file cont_sub_file = targetcalfile+'.contsub' weighting = params['cube']['weighting'] robust = params['cube']['robust'] deconvolver = params['cube']['deconvolver'] # uvran_list = ['0.5~5klambda', '0.5~10klambda', '0.5~20klambda','0.5~40klambda'] # list of uvranges to image the cube #uvtaper_list = ['4.5klambda', '6klambda', '12klambda', '30klambda'] #imsize_list = [256, 512, 540, 1024] #cellsize_list = ['8arcsec', '4arcsec', '3arcsec', '1arcsec'] #threshold_list = ['0.44mJy', '1.0mJy', '1.0mJy', '1.0mJy'] uvran_list = ['0.5~6klambda'] uvtaper_list = ['5.5klambda'] imsize_list = [128] cellsize_list = ['8arcsec'] threshold_list = ['1mJy'] vel_res1 = params['cube']['vel_res'] vel_res = str(vel_res1)+'km/s' #vel_res = '-14km/s' file_name = str(vel_res1)+'kmps' for i in range(len(uvran_list)): cts.tclean(cont_sub_file, imagename=outdir+target+'_cube_' + str(file_name)+'/'+'uvran_'+str(uvran_list[i]), field='0', spw='0', specmode='cube', nchan=-1, width=vel_res, outframe='bary', veltype='optical', restfreq=restfreq, deconvolver='hogbom', gridder='standard', uvrange=uvran_list[i], uvtaper=uvtaper_list[i], imsize=imsize_list[i], cell=cellsize_list[i], threshold=threshold_list[i], weighting=weighting, robust=robust, restoringbeam='common', interactive=False, usemask='pb', pbmask=0.2, # usemask='auto-multithresh', # minbeamfrac=0.1, #sidelobethreshold = 1.5, # smallscalebias=0.6, niter=100000 ) else: print('No cube image this time.') outdir = general_params['outdir'] subprocess.run('cp {} {}'.format( 'parameters.yaml', outdir), shell=True, check=True) return print('yarp pipeline ended.')
import mpoldatasets.image import casatasks ms_path = "logo_cube.noise.ms" imname = "logo_cube.dirty" mpoldatasets.image.clear_extensions(imname) imsize = 512 # produce a dirty image casatasks.tclean( vis=ms_path, imagename=imname, specmode="cube", weighting="briggs", robust=0.5, imsize=800, cell="0.007arcsec", niter=0, interactive=False, perchanweightdensity=False, restoringbeam="common", ) # produce a cleaned image mpoldatasets.image.exportfits(imname + ".image", imname + ".fits")
# # A few Imaging and Calibration examples # # ## Image one channel # In[481]: # Call tclean os.system('rm -rf try0.*') tclean( vis='sim_data.ms', imagename='try0', datacolumn='data', spw='0:5', # pick channel 5 and image it imsize=300, cell='8.0arcsec', specmode='mfs', gridder='standard', niter=200, gain=0.3) # In[482]: # Display the output restored image dispImage('try0.image') # In[483]: # Display the point spread function dispImage('try0.psf')
def quicklook_line_imaging( myvis, thisgal, linespw_dict, nchan_vel=5, # channel_width_kms=20., niter=0, nsigma=5., imsize_max=800, overwrite_imaging=False, export_fits=True): if not os.path.exists("quicklook_imaging"): os.mkdir("quicklook_imaging") this_vsys = target_vsys_kms[thisgal] # Pick our line range based on the HI for all lines. this_velrange = target_line_range_kms[thisgal]['HI'] # We have a MW foreground window on some targets. Skip this for the galaxy range. if isinstance(this_velrange[0], list): for this_range in this_velrange: if min(this_range) < this_vsys < max(this_range): this_velrange = this_range break # Check that the search for the right velocity range didn't fail if isinstance(this_velrange[0], list): raise ValueError( f"Unable to find range with target vsys ({this_vsys}) from {this_velrange}." f" Check the velocity ranges defined in target_setup.py for {thisgal}" ) # width_vel = channel_width_kms # width_vel_str = f"{width_vel}km/s" start_vel = f"{int(min(this_velrange))}km/s" # nchan_vel = int(abs(this_velrange[0] - this_velrange[1]) / width_vel) width_vel = int( round(abs(this_velrange[0] - this_velrange[1]) / float(nchan_vel))) width_vel_str = f"{width_vel}km/s" # Select only the non-continuum SPWs line_spws = [] for thisspw in linespw_dict: if "continuum" not in linespw_dict[thisspw]['label']: # Our 20A-346 tracks have a combined OH1665/1667 SPW. Split into separate cubes in this case line_labels = linespw_dict[thisspw]['label'].split("-") for line_label in line_labels: line_spws.append([str(thisspw), line_label]) # Select our target fields. We will loop through # to avoid the time + memory needed for mosaics. synthutil = synthesisutils() myms = ms() # if no fields are provided use observe_target intent # I saw once a calibrator also has this intent so check carefully # mymsmd.open(vis) myms.open(myvis) mymsmd = myms.metadata() target_fields = mymsmd.fieldsforintent("*TARGET*", True) mymsmd.close() myms.close() t0 = datetime.datetime.now() # Loop through targets and line SPWs for target_field in target_fields: casalog.post(f"Quick look imaging of field {target_field}") # Loop through the SPWs to identify the biggest image size needed. # For ease downstream, we will use the same imsize for all SPWs. # NOTE: for L-band, that's a factor of ~2 difference. It may be more pronounced in other # bands cell_size = {} imsizes = [] for thisspw_info in line_spws: thisspw, line_name = thisspw_info # Ask for cellsize this_im = imager() this_im.selectvis(vis=myvis, field=target_field, spw=str(thisspw)) image_settings = this_im.advise() this_im.close() # When all data is flagged, uvmax = 0 so cellsize = 0. # Check for that case to avoid tclean failures # if image_settings[2]['value'] == 0.: # casalog.post(f"All data flagged for {this_imagename}. Skipping") # continue # NOTE: Rounding will only be reasonable for arcsec units with our L-band setup. # Could easily fail on ~<0.1 arcsec cell sizes. cell_size[thisspw] = [ image_settings[2]['value'], image_settings[2]['unit'] ] # No point in estimating image size for an empty SPW. if image_settings[2]['value'] == 0.: continue # For the image size, we will do an approx scaling was # theta_PB = 45 / nu (arcmin) this_msmd = msmetadata() this_msmd.open(myvis) mean_freq = this_msmd.chanfreqs( int(thisspw)).mean() / 1.e9 # Hz to GHz this_msmd.close() approx_pbsize = 1.2 * (45. / mean_freq) * 60 # arcsec approx_imsize = synthutil.getOptimumSize( int(approx_pbsize / image_settings[2]['value'])) imsizes.append(approx_imsize) if len(imsizes) == 0: casalog.post(f"{target_field} is fully flagged. Skipping.") continue this_imsize = min(imsize_max, max(imsizes)) for thisspw_info in line_spws: thisspw, line_name = thisspw_info casalog.post( f"Quick look imaging of field {target_field} SPW {thisspw}") target_field_label = target_field.replace('-', '_') this_imagename = f"quicklook_imaging/quicklook-{target_field_label}-spw{thisspw}-{line_name}-{myvis}" if export_fits: check_exists = os.path.exists(f"{this_imagename}.image.fits") else: check_exists = os.path.exists(f"{this_imagename}.image") if check_exists: if overwrite_imaging: rmtables(f"{this_imagename}*") os.remove(f"{this_imagename}.image.fits") else: casalog.post(f"Found {this_imagename}. Skipping imaging.") continue if cell_size[thisspw][0] == 0: casalog.post( f"All data flagged for {this_imagename}. Skipping") continue this_cellsize = f"{round(cell_size[thisspw][0] * 0.8, 1)}{cell_size[thisspw][1]}" this_pblim = 0.5 this_nsigma = nsigma this_niter = niter # Clean up any possible imaging remnants first rmtables(f"{this_imagename}*") tclean(vis=myvis, field=target_field, spw=str(thisspw), cell=this_cellsize, imsize=this_imsize, specmode='cube', weighting='briggs', robust=0.0, start=start_vel, width=width_vel_str, nchan=nchan_vel, niter=this_niter, nsigma=this_nsigma, imagename=this_imagename, restfreq=f"{linerest_dict_GHz[line_name]}GHz", pblimit=this_pblim) if export_fits: exportfits(imagename=f"{this_imagename}.image", fitsimage=f"{this_imagename}.image.fits", history=False, overwrite=True) # Clean-up extra imaging products if they are not needed. cleanup_misc_quicklook(this_imagename, remove_psf=True, remove_residual=this_niter == 0, remove_image=True if export_fits else False) t1 = datetime.datetime.now() casalog.post(f"Quicklook line imaging took {t1 - t0}")
def quicklook_continuum_imaging(myvis, contspw_dict, niter=0, nsigma=5., imsize_max=800, overwrite_imaging=False, export_fits=True): ''' Per-SPW MFS, nterm=1, dirty images of the targets ''' if not os.path.exists("quicklook_imaging"): os.mkdir("quicklook_imaging") # Select only the continuum SPWs (in case there are any line SPWs). continuum_spws = [] for thisspw in contspw_dict: if "continuum" in contspw_dict[thisspw]['label']: continuum_spws.append(str(thisspw)) # Select our target fields. We will loop through # to avoid the time + memory needed for mosaics. synthutil = synthesisutils() myms = ms() # if no fields are provided use observe_target intent # I saw once a calibrator also has this intent so check carefully # mymsmd.open(vis) myms.open(myvis) mymsmd = myms.metadata() target_fields = mymsmd.fieldsforintent("*TARGET*", True) mymsmd.close() myms.close() t0 = datetime.datetime.now() # Loop through targets and line SPWs for target_field in target_fields: casalog.post(f"Quick look imaging of field {target_field}") cell_size = {} imsizes = [] for thisspw in continuum_spws: # Ask for cellsize this_im = imager() this_im.selectvis(vis=myvis, field=target_field, spw=str(thisspw)) image_settings = this_im.advise() this_im.close() # When all data is flagged, uvmax = 0 so cellsize = 0. # Check for that case to avoid tclean failures # if image_settings[2]['value'] == 0.: # casalog.post(f"All data flagged for {this_imagename}. Skipping") # continue # NOTE: Rounding will only be reasonable for arcsec units with our L-band setup. # Could easily fail on ~<0.1 arcsec cell sizes. cell_size[thisspw] = [ image_settings[2]['value'], image_settings[2]['unit'] ] # No point in estimating image size for an empty SPW. if image_settings[2]['value'] == 0.: continue # For the image size, we will do an approx scaling was # theta_PB = 45 / nu (arcmin) this_msmd = msmetadata() this_msmd.open(myvis) mean_freq = this_msmd.chanfreqs( int(thisspw)).mean() / 1.e9 # Hz to GHz this_msmd.close() approx_pbsize = 1.2 * (45. / mean_freq) * 60 # arcsec approx_imsize = synthutil.getOptimumSize( int(approx_pbsize / image_settings[2]['value'])) imsizes.append(approx_imsize) if len(imsizes) == 0: casalog.post(f"{target_field} is fully flagged. Skipping.") continue this_imsize = min(imsize_max, max(imsizes)) for thisspw in continuum_spws: casalog.post( f"Quick look imaging of field {target_field} SPW {thisspw}") target_field_label = target_field.replace('-', '_') this_imagename = f"quicklook_imaging/quicklook-{target_field_label}-spw{thisspw}-continuum-{myvis}" if export_fits: check_exists = os.path.exists(f"{this_imagename}.image.fits") else: check_exists = os.path.exists(f"{this_imagename}.image") if check_exists: if overwrite_imaging: rmtables(f"{this_imagename}*") os.remove(f"{this_imagename}.image.fits") else: casalog.post(f"Found {this_imagename}. Skipping imaging.") continue if cell_size[thisspw][0] == 0: casalog.post( f"All data flagged for {this_imagename}. Skipping") continue this_cellsize = f"{round(cell_size[thisspw][0] * 0.8, 1)}{cell_size[thisspw][1]}" this_pblim = 0.5 this_nsigma = nsigma this_niter = niter # Clean up any possible imaging remnants first rmtables(f"{this_imagename}*") tclean(vis=myvis, field=target_field, spw=str(thisspw), cell=this_cellsize, imsize=this_imsize, specmode='mfs', nterms=1, weighting='briggs', robust=0.0, niter=this_niter, nsigma=this_nsigma, fastnoise=True, imagename=this_imagename, pblimit=this_pblim) if export_fits: exportfits(imagename=f"{this_imagename}.image", fitsimage=f"{this_imagename}.image.fits", history=False, overwrite=True) # Clean-up extra imaging products if they are not needed. cleanup_misc_quicklook(this_imagename, remove_psf=True, remove_residual=this_niter == 0, remove_image=True if export_fits else False) t1 = datetime.datetime.now() casalog.post(f"Quicklook continuum imaging took {t1 - t0}")
def runtclean(vis, imname, startmodel='', spw='', field='', specmode='mfs', imsize=[], cell='', phasecenter='', start=0, width=1, nchan=-1, restfreq=None, threshold='', niter=0, usemask='auto-multithresh', sidelobethreshold=2.0, noisethreshold=4.25, lownoisethreshold=1.5, minbeamfrac=0.3, growiterations=75, negativethreshold=0.0, mask='', pbmask=0.4, interactive=True): """ runtclean (A. Plunkett, NRAO) a wrapper around the CASA task "TCLEAN," vis - the MS containing the interferometric data imname - the root name of the output images startmodel - start model for cleaning default: '' i.e. no start model, example: 'TP.scaled.image' spw - the standard selection parameter spw of tclean default: '' i.e. all SPWs field - the standard selection parameter field of tclean default: '' i.e. all fields specmode - the standard tclean specmode parameter: supported are msf or cube default: msf imsize - (optional) the standard tclean imsize parameter should correspond to the imagesize for the most extended interferometer config. default: determine from the input MS with aU.pickCellSize cell - (optional) the standard tclean cell parameter should correspond to the cell size for the most extended interferometer config, i.e. smallest beam / 5. default: determine from the input MS with aU.pickCellSize phasecenter - the standard tclean phasecenter parameter e.g. 'J2000 12:00:00 -35.00.00.0000' default: '' - determine from the input MS with aU.pickCellSize start - the standard tclean start parameter default: 0 width - the standard tclean width parameter default: 1 nchan - the standard tclean nchan parameter default: -1 restfreq - the restfrequency to write to the image for velocity calculations default: None, example: '115.271GHz' threshold - the threshold for cleaning default: None, example: '12mJy' niter - the standard tclean niter parameter default: 0, example: niter=1000000 usemask - the standard tclean mask parameter. If usemask='auto-multithresh', can specify: sidelobethreshold, noisethreshold, lownoisethreshold, minbeamfrac, growiterations - if usemask='user', must specify mask='maskname.mask' if usemask='pb', can specify pbmask=0.4, or some level. default: 'auto-multithresh' interactive - the standard tclean interactive option default: True Example: runtclean('gmc_120L.alma.all_int-weighted.ms', 'gmc_120L', phasecenter='J2000 12:00:00 -35.00.00.0000', spw='0', field='0~68', imsize=[1120,1120], cell='0.21arcsec', threshold='12mJy',niter=100000, usemask='auto-multithresh') """ if os.path.exists(vis): myvis = vis else: print(vis + ' does not exist') return False mymaskname = '' if usemask == 'auto-multithresh': mymask = usemask print('Run with {0} mask'.format(mymask)) elif usemask == 'pb': mymask = usemask pbmask = pbmask print('Run with {0} mask {1}'.format(mymask, pbmask)) elif usemask == 'user': if os.path.exists(maskname): mymask = usemask mymaskname = mask print('Run with {0} mask {1} '.format(mymask, maskname)) else: print('mask ' + maskname + ' does not exist, or not specified') return False else: print('check the mask options') return False os.system('rm -rf ' + imname + '.TCLEAN.*') tclean( vis=myvis, imagename=imname + '.TCLEAN', startmodel=startmodel, field=field, intent='OBSERVE_TARGET#ON_SOURCE', phasecenter=phasecenter, stokes='I', spw=spw, outframe='LSRK', specmode=specmode, nterms=1, imsize=imsize, cell=cell, deconvolver='hogbom', niter=niter, cycleniter=niter, cyclefactor=2.0, weighting='briggs', robust=0.5, gridder='mosaic', pbcor=True, threshold=threshold, interactive=interactive, # Masking Parameters below this line # --> Should be updated depending on dataset usemask=mymask, sidelobethreshold=sidelobethreshold, noisethreshold=noisethreshold, lownoisethreshold=lownoisethreshold, minbeamfrac=minbeamfrac, growiterations=growiterations, negativethreshold=negativethreshold, mask=mask, pbmask=pbmask, verbose=True) print('Exporting final pbcor image to FITS ...') exportfits(imname + '.TCLEAN.image.pbcor', imname + '.TCLEAN.pbcor.fits') return True
cts.tclean( cont_sub_file, #imagename = outdir+target+'_cube_multiscale_'+str(file_name)+'/'+'uvran_'+str(uvran_list[i]), imagename=outdir + target + '_cube_' + str(file_name) + '/' + 'uvran_' + str(uvran_list[i]), field='0', spw='0', specmode='cube', nchan=-1, width=vel_res, outframe='bary', veltype='optical', restfreq=restfreq, deconvolver='hogbom', # 'multiscale', #scales = [0, 5, 15], gridder='standard', uvrange=uvran_list[i], uvtaper=uvtaper_list[i], imsize=imsize_list[i], cell=cellsize_list[i], threshold=threshold_list[i], weighting='briggs', robust=0, restoringbeam='common', interactive=False, usemask='pb', pbmask=0.05, #usemask='auto-multithresh', #minbeamfrac=0.1, #sidelobethreshold = 1.5, #smallscalebias=0.6, niter=100000)
mpoldatasets.image.clear_extensions(imagename) casatasks.delmod(vis=vis) tic = time.perf_counter() casatasks.tclean( vis=vis, imagename=imagename, specmode="mfs", deconvolver="multiscale", scales=[0, 5, 30, 75], weighting="briggs", robust=0.0, gain=0.3, imsize=3000, cell=".003arcsec", niter=50000, threshold="0.05mJy", cycleniter=300, cyclefactor=1, uvtaper=[".042arcsec", ".020arcsec", "172.1deg"], mask=common_mask, nterms=1, savemodel="modelcolumn", ) toc = time.perf_counter() print("tclean elapsed time {:}s".format(toc - tic)) mpoldatasets.image.exportfits(imagename + ".image", imagename + ".fits")
imname = "logo_cube.tclean" mpoldatasets.image.clear_extensions(imname) imsize = 512 tic = time.perf_counter() # produce a dirty image casatasks.tclean( vis=ms_path, imagename=imname, specmode="cube", weighting="briggs", deconvolver="multiscale", scales=[0, 5, 30, 75], robust=1.5, imsize=800, cell="0.007arcsec", niter=10000, threshold="0.5mJy", interactive=False, perchanweightdensity=False, restoringbeam="common", savemodel="modelcolumn", ) toc = time.perf_counter() print("tclean elapsed time {:}s".format(toc - tic)) # produce a cleaned image mpoldatasets.image.exportfits(imname + ".image", imname + ".fits")