def flagcaltar_ms(src_dir, msname, ATCA_band, pri, sec, tar):
applycal(
vis=msname,
gaintable=[
f"{src_dir}/cal_tables/cal_{pri}_{ATCA_band}.B1",
f"{src_dir}/cal_tables/cal_{pri}_{ATCA_band}.F0",
],
gainfield=[pri, pri, sec],
field=tar,
parang=True,
flagbackup=False,
)
flagdata(
vis=msname,
mode="rflag",
field=tar,
datacolumn="corrected",
action="apply",
display="report",
correlation="ABS_ALL",
timedevscale=3.0,
freqdevscale=3.0,
winsize=3,
combinescans=True,
ntime="9999999min",
extendflags=False,
flagbackup=False,
)
return
def kc_cal(msin, model_cl):
"""Get gain and delay calibration solutions
:param msin: Visibility dataset in measurement set format path
:type msin: str
:param model_cl: Point source model path
:type model_cl: str
:return: Calibration solutions tables
:rtype: list
"""
# Fill the model column
ft(msin, complist=model_cl, usescratch=True)
kc = calname(msin, 'K') # Delays
gc = calname(msin, 'G') # Gains
gaincal(vis=msin,
caltable=kc,
gaintype='K',
solint='inf',
refant='11',
minsnr=1)
# Ensure reference antenna exists and isn't faulty
gaincal(vis=msin,
caltable=gc,
gaintype='G',
solint='inf',
refant='11',
minsnr=1,
calmode='ap',
gaintable=kc)
applycal(msin, gaintable=[kc, gc])
return [kc, gc]
def apply_calibration(project: project.Project):
"""Applies the current calibration by using the tables written in the callib.
"""
casatasks.applycal(vis=str(project.msfile),
docallib=True,
callib=str(project.caldir / "cal_library.txt"),
parang=True)
def bandpass_cal(msin):
"""Bandpass calbration
:param msin: Visibility dataset in measurement set format path
:type msin: str
:return: Calibration solutions table
:type: str
"""
bc = calname(msin, 'B')
bandpass(vis=msin, minsnr=1, solnorm=False, bandtype='B', caltable=bc)
applycal(msin, gaintable=[bc])
return bc
def applycal(msfile,
gaintables,
gainfield=None,
targetfield=None,
interp=None,
spw=None,
spwmap=None):
"""
Apply CASA calibration using calibration tables
Example Usage:
applycal(msfile0, gaintables, targetfield=targetfield,
gainfield=['', '', '', '', '', '', '', ''],
interp=['linear', 'linear', 'linear', 'linear', 'linear,linearflag', 'linear', 'linear', 'linear'])
"""
if not gainfield:
gainfield = ['' for _ in range(len(gaintables))]
if not interp:
interp = ['' for _ in range(len(gaintables))]
if not targetfield:
targetfield = '1'
if not spw:
spw = ''
print(spw)
if not spwmap:
spwmap = []
tasks.applycal(vis=msfile,
gaintable=gaintables,
gainfield=gainfield,
field=targetfield,
interp=interp,
calwt=[False],
spw=spw,
spwmap=spwmap)
def self_calibration_from_final_pcal_model(project: project.Project,
src_model: Path):
raise NotImplementedError
# Assumes the model is a CASA image
for a_cal in project.phase_calibrators:
calsc = project.caldir / f"{project.project_name.lower()}.{a_cal}.sc_final"
# TODO: check if ft is in casatools or casatasks
casatools.ft(vis=str(project.msfile),
field=a_cal,
model=str(src_model),
usescratch=True)
casatasks.gaincal(vis=str(project.msfile),
caltable=str(calsc),
field=a_cal,
solint='3min',
refant=','.join(project.refants),
gaintype='G',
calmode='ap',
interp=['nearest'],
parang=True)
casatasks.applycal()
def applycal_ms(src_dir, msname, ATCA_band, pri, sec, tar):
applycal(
vis=msname,
gaintable=[
f"{src_dir}/cal_tables/cal_{pri}_{ATCA_band}.B1",
f"{src_dir}/cal_tables/cal_{pri}_{ATCA_band}.F0",
],
gainfield=[pri, pri, pri],
field=f"{pri}",
parang=True,
flagbackup=False,
)
applycal(
vis=msname,
gaintable=[
f"{src_dir}/cal_tables/cal_{pri}_{ATCA_band}.B1",
f"{src_dir}/cal_tables/cal_{pri}_{ATCA_band}.F0",
],
gainfield=[pri, pri, sec],
field=f"{sec},{tar}",
parang=True,
flagbackup=False,
)
return
def run_all_uvstats(myvis,
out_path,
uv_threshold=3,
uv_nsigma=3,
try_phase_selfcal=True,
cleanup_calsplit=True,
cleanup_phaseselfcal=True,
remake_split=True):
if not os.path.isdir(out_path):
os.mkdir(out_path)
from casatasks import split, gaincal, applycal
from casaplotms import plotms
# from taskinit import msmdtool, casalog
# from taskinit import msmdtool, casalog
from casatools import ms
myms = ms()
# msmd = msmdtool()
# get metadata
myms.open(myvis)
mymsmd = myms.metadata()
# mymsmd.open(myvis)
cal_fields = np.unique(mymsmd.fieldsforintent('CALIBRATE*'))
field_names = mymsmd.namesforfields(cal_fields)
myms.close()
# split calibrator visibilities
field_str = ','.join([str(f) for f in cal_fields])
output_cal_ms = out_path + '/cal_fields.ms'
if os.path.exists(output_cal_ms) and remake_split:
os.system('rm -r {0}'.format(output_cal_ms))
if not os.path.exists(output_cal_ms):
split(vis=myvis,
field=field_str,
keepflags=True,
timebin='0s',
outputvis=output_cal_ms)
# There are the flux cals which have built in models in CASA.
skip_fields = ['3C286', '3C48', '3C147', '3C138']
gaincal_tables = []
for field_name in field_names:
if np.any([field_name in skip1 for skip1 in skip_fields]):
continue
plotms_outfile = out_path + '/plotms_amp_uvwave_field_{0}.txt'.format(
field_name)
casalog.post(
message='Exporting from plotms: {0}'.format(plotms_outfile),
origin='run_all_uvstats')
if not os.path.exists(plotms_outfile):
plotms(vis=out_path + '/cal_fields.ms',
field=field_name,
xaxis='UVwave',
yaxis='Amp',
ydatacolumn='data',
averagedata=True,
scalar=False,
avgchannel='4096',
avgtime='1000',
avgscan=False,
correlation='RR,LL',
plotfile=plotms_outfile,
showgui=False,
overwrite=True)
else:
casalog.post(message='File {0} already exists. Skipping'.format(
plotms_outfile),
origin='run_all_uvstats')
infile = out_path + '/plotms_amp_uvwave_field_{0}.txt'.format(
field_name)
casalog.post(message='Analyzing UV stats for {0}'.format(infile),
origin='run_all_uvstats')
# Read in txt from plotms
dat, median_flux = get_uvdata(infile)
# n_scans = len(np.unique(dat['scan']))
binned_dat = bin_uvdata(dat)
binned_dat_perscan = bin_uvdata_perscan(dat)
if binned_dat.shape[1] == 0:
continue
if binned_dat_perscan.shape[1] == 0:
continue
plot_uvdata_perscan(binned_dat_perscan,
binned_dat,
infile,
bin_type='combined')
# try phase-only selfcal
if try_phase_selfcal:
gaincal_table = out_path + '/cal_field_{0}.g'.format(field_name)
try:
gaincal(vis=output_cal_ms,
caltable=gaincal_table,
field=field_name,
solint='int',
refant='',
calmode='p')
applycal(vis=output_cal_ms,
gaintable=gaincal_table,
field=field_name,
calwt=False)
gaincal_tables.append(gaincal_table)
plotms_outfile = out_path + '/plotms_amp_uvwave_cal_field_{0}.txt'.format(
field_name)
casalog.post(message='Exporting from plotms: {0}'.format(
plotms_outfile),
origin='run_all_uvstats')
if not os.path.exists(plotms_outfile):
plotms(vis=output_cal_ms,
field=field_name,
xaxis='UVwave',
yaxis='Amp',
ydatacolumn='corrected',
averagedata=True,
scalar=False,
avgchannel='4096',
avgtime='1000',
avgscan=False,
correlation='RR,LL',
plotfile=plotms_outfile,
showgui=False,
overwrite=True)
else:
casalog.post(
message='File {0} already exists. Skipping'.format(
plotms_outfile),
origin='run_all_uvstats')
infile = out_path + '/plotms_amp_uvwave_cal_field_{0}.txt'.format(
field_name)
casalog.post(
message='Analyzing UV stats for {0}'.format(infile),
origin='run_all_uvstats')
dat, median_flux = get_uvdata(infile)
# n_scans = len(np.unique(dat['scan']))
binned_dat = bin_uvdata(dat)
binned_dat_perscan = bin_uvdata_perscan(dat)
if binned_dat.shape[1] == 0:
continue
if binned_dat_perscan.shape[1] == 0:
continue
plot_uvdata_perscan(binned_dat_perscan,
binned_dat,
infile,
bin_type='combined')
except:
casalog.post(
message='Problem calibrating field {0}'.format(field_name),
origin='run_all_uvstats')
# Delete calibrator split
if cleanup_calsplit:
os.system("rm -r {}".format(output_cal_ms))
os.system("rm -r {}.flagversions".format(output_cal_ms))
# Delete gaincal tables
if cleanup_phaseselfcal:
for gaincal_table in gaincal_tables:
os.system("rm -r {}".format(gaincal_table))
def flagcal(msfile, params, niters=1, flagger='default', interactive=False):
'''
This function takes an initially flagged msfile and goes through the flagging and calibration loops. It does delaycal, bandpass and a amplitude and phase cals. It then flags the data and then continues to the calibration cycle. The loops continue till niters end or in the interactive mode when the user is satisfied. The calibration in then applied to the source and it is mildly flagged using Rflag and splitted in a seperate msfile.
'''
fcals = ','.join(fluxcal) # joining the fluxcals in a casa readable format
# Main flagcal loops begin
flagcal_fin = 'n' # a flag to denote finished flagging
loop = 1 # Keeping a track of number of iterations
while flagcal_fin == 'n':
# Beginning with an empty gaintable list, which will be succesively appended after every calibration.
gaintables = []
params['calibration'].update({'gaintables': gaintables})
prms.write(params, 'parameters.yaml') # writes the gaintables column in the parameters file.
cts.setjy(msfile, field=fcals, scalebychan=True, standard='Perley-Butler 2017', listmodels=False, usescratch=False)
clb.delaycal(msfile, params, field=fcals)
#append the caltable and save the params file
params['calibration']['gaintables'].append(params['calibration']['delaytable'])
prms.write(params, 'parameters.yaml')
if interactive:
caltable = params['calibration']['delaytable']
subprocess.run('casaplotms vis={} field={}'.format(caltable, fcals), shell=True, check=True)
antflag = input("Do you want to flag any antenna(s) ? [y/n] \n If yes, append the bad antennas in the params file now.")
if antflag == 'y':
flg.badantflag(msfile, params)
else:
print('No flagging after delaycal.')
else:
None
clb.bpasscal(msfile, params, field=fcals) # Using fluxcals for bandpass calibration
params['calibration']['gaintables'].append(params['calibration']['bpasstable'])
prms.write(params, 'parameters.yaml')
# Joining all the calibrators and doing amplitutde and phase calibration
phasecal = params['general']['phasecal']
print('Phasecal is ', phasecal)
allcals = fluxcal + [phasecal]
#for i in allcals:
# clb.apcal(msfile, params, field=i)
allcals2 = ','.join(allcals)
clb.apcal(msfile, params, field=allcals2)
# Adding the amplitude and phase calibration tables in gaintables
params['calibration']['gaintables'].append(params['calibration']['apgaintable'])
prms.write(params, 'parameters.yaml')
uvran = params['general']['uvran']
# GETJY
print('Setting the absolute fluxscale for ', phasecal)
fluxtbl = params['calibration']['fluxscaletable']
phasecal_flux = cts.fluxscale(msfile, caltable=params['calibration']['apgaintable'], fluxtable=fluxtbl, reference=fcals, transfer=phasecal, incremental=False, append=False)
print('The flux density of {}'.format(phasecal)+'is',phasecal_flux['1']['0']['fluxd'][0], '+/-', phasecal_flux['1']['0']['fluxdErr'][0] )
#Replace the apgaintable with fluxscale table
params['calibration']['gaintables'].remove(params['calibration']['apgaintable'])
params['calibration']['gaintables'].append(fluxtbl)
prms.write(params, 'parameters.yaml')
subprocess.run('rm -r {}'.format(params['calibration']['apgaintable']), shell=True, check=True)
# Applying the calibrations on flux cal
for i in fluxcal:
print('Applying the calibration table to ', i)
cts.applycal(msfile, field=i, spw=spw, gaintable=gaintables, gainfield=['','',i], uvrange=uvran, interp=['','','linear'], calwt=[False], parang=False)
# Apply the calibration on phase cal
cts.applycal(msfile, field=phasecal, uvrange=uvran, gaintable=gaintables, gainfield=['','',phasecal], interp=['','','linear'], calwt=[False], parang=False)
# Flagging after calibration
def clip_est(fluxscale, nsigma, loop, beta):
return [fluxscale - nsigma/loop**beta, fluxscale + nsigma/loop**beta]
fluxscale_list = [15, 22.5, 3.3]
uplims_list = [20, 20, 20]
beta=[0.5, 0.6, 0.6]
tcut_list = [6, 6, 10]
fcut_list = [6, 6, 10]
if flagger == 'default':
for j,i in enumerate(allcals):
flg.clipper(msfile, params, field=i, cliplevel=clip_est(fluxscale_list[j], uplims_list[j], loop, beta[j]), instance='postcal')
flg.tfcropper(msfile, params, field=i, tcut=tcut_list[j], fcut=fcut_list[j], instance='postcal')
flg.extend(msfile, params, field=i, grow=80, instance='postcal')
print('Flagged', i, 'postcalibration.')
# Flag the phasecal using rflag
flg.rflagger(msfile, params, field=phasecal, tcut=10, fcut=10, instance='postcal')
flg.extend(msfile, params, field=phasecal, grow=80, instance='postcal')
else:
print('No flagging.')
if interactive:
subprocess.run('casaplotms vis={} field={}'.format(msfile, fluxcal[0]), shell=True, check=True)
flagcal_fin = input('Are you satisfied with the calibration?[y/n] ')
# Remove the old cal tables before continuing
for i in gaintables:
subprocess.run('rm -r {}'.format(i), shell=True, check=True)
continue
else:
print('Flagcal running in automode.')
niters = niters - 1
loop = loop + 1
if niters < 1:
print('Flagcal loops finished.')
break
else:
# Remove all the old cal tables before continuing.
print('Clearing the corrected column and fluxcal model...')
cts.clearcal(msfile) # Removes the corrected datacolumn
cts.delmod(msfile) # Removes the setjy model
print('Clearing all the gaintables...')
for i in gaintables:
subprocess.run('rm -r {}'.format(i), shell=True, check=True)
continue
else:
print('Calibration of flux and phase calibrators done.')
# apply the calibrations on the target
target = params['general']['target']
print('Applying the calibration tables to the target...')
cts.applycal(msfile, field=target, uvrange=uvran, gaintable=gaintables, gainfield=['','',phasecal], interp=['','','linear'], calwt=[False], parang=False)
# rflag the data
print('Mildly Rflagging the target at cutoff of 10 sigma...')
flg.rflagger(msfile, params, field=target, tcut=10, fcut=10, instance='postcal')
flg.extend(msfile, params, field=target, grow=80, instance='postcal')
# split the calibrated target data
out_cal_file = params['general']['targetcalfile']
print('Splitting the target...')
cts.mstransform(msfile, field=target, spw=spw, chanaverage=False, datacolumn='corrected', outputvis=out_cal_file)
return print('Flagcal script done.')
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
# Display the new residual image
dispImage('try3.residual')
# This image shows artifacts from gain errors (different from the pure noise-like errors in the previous simulation)
#
# Calculate gain solutions (since we have already saved the model)
# In[498]:
bandpass(vis='sim_data.ms', caltable='sc.tab', solint='int')
# Apply gain solutions
# In[499]:
applycal(vis='sim_data.ms', gaintable='sc.tab')
# In[500]:
## Plot Calibrated data
plotData(myplot='corr_spectrum')
# Compare with the above uncalibrated data. Also, compare with visibilities simulated just with noise. Subsequent imaging should use the corrected_data column.
# In[501]:
# Call tclean to image the corrected data
os.system('rm -rf try4.*')
tclean(
vis='sim_data.ms',
