def flag_ms(visname): # , rawname1, rawname2, rawname3):
print("Flagging antennas affected by shadowing...")
# importatca(
# vis=visname, files=[rawname1, rawname2, rawname3], options="birdie,noac", edge=4
# )
flagmanager(vis=visname, mode="save", versionname="before_online_flagging")
print("Flagging antennas affected by shadowing...")
flagdata(vis=visname, mode="shadow", tolerance=0.0, flagbackup=False)
print("Flagging visibilities with zero amplitudes...")
flagdata(vis=visname, mode="clip", clipzeros=True, flagbackup=False)
print("Quacking visibilities ...")
flagdata(
vis=visname, mode="quack", quackinterval=5.0, quackmode="beg", flagbackup=False
)
flagmanager(vis=visname, mode="save", versionname="after_online_flagging")
flagdata(
vis=visname,
mode="tfcrop",
datacolumn="data",
action="apply",
display="report",
flagbackup=True,
extendpols=True,
correlation="",
flagdimension="freqtime",
growtime=95.0,
growfreq=95.0,
timecutoff=4.0,
timefit="line",
freqfit="poly",
maxnpieces=5,
combinescans=False,
ntime="scan",
extendflags=False,
)
print("Extending flags to all correlations")
flagdata(
vis=visname,
mode="extend",
action="apply",
display="report",
flagbackup=False,
extendpols=True,
correlation="",
growtime=95.0,
growfreq=95.0,
growaround=True,
flagneartime=False,
flagnearfreq=False,
combinescans=False,
ntime="scan",
)
return
def flagcal_ms(img_dir, msname, ATCA_band, pri, sec):
flagmanager(vis=msname, mode="save", versionname="before_rflag")
flagdata(
vis=msname,
mode="rflag",
field=pri,
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,
)
flagdata(
vis=msname,
mode="rflag",
field=sec,
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,
)
flagdata(
vis=msname,
mode="extend",
field=pri + "," + sec,
action="apply",
display="report",
flagbackup=False,
extendpols=True,
correlation="",
growtime=95.0,
growfreq=95.0,
growaround=True,
flagneartime=False,
flagnearfreq=False,
combinescans=True,
ntime="9999999min",
)
return
def apply_apriori_flagging(project: project.Project):
"""Applies the flags stored in the file associated with the project.
"""
return
casatasks.flagdata(vis=str(project.msfile),
inpfile=str(project.caldir /
f"{project.project_name}.flag"),
reason='any',
action='apply',
flagbackup=False,
savepars=False)
casatasks.flagmanager(vis=str(project.msfile),
mode='save',
versionname='apriori_flags',
comment='A-priori flags prior to any calibration.')
def split_ms(src_dir, img_dir, visname, msname, ATCA_band, pri, sec, tar, n_spw):
os.system(f"rm -r {msname}")
os.system(f"rm -r {msname}.flagversions")
os.system("rm -r *.last")
# have removed n_spw for mstransform and included it in the split just before imaging
mstransform(
vis=visname,
outputvis=msname,
datacolumn="data",
field=f"{pri},{sec},{tar}",
# nspw=n_spw,
regridms=True,
# field=f"{sec},{tar}",
# scan="3,>90"
)
listobs(
vis=msname,
listfile=f"{src_dir}/listobs_{ATCA_band}_{tar}.dat",
overwrite=True,
)
flagmanager(vis=msname, mode="save", versionname="after_transform")
return
def avg_cont(
msfile,
outputvis,
flagchannels="",
maxchanwidth=125,
datacolumn="data",
spws=None,
width_array=None,
):
"""
Produce spectrally averaged continuum measurement sets
Args:
msfile (string): input file name
outputvis (string): output file name
flagchannels: Argument to be passed for flagchannels parameter in
flagdata task
maxchanwidth: Maximum width of channel (MHz). This is the value
recommended by ALMA for Band 6 to avoid bandwidth smearing
datacolumn: Column to pull from for continuum averaging (usually will
be 'data', but may sometimes be 'corrected' if there was flux
rescaling applied)
width_array (array): Argument to be passed to CASA for the width
parameter in split. If not set, all SPWs will be selected by default.
Returns:
None
"""
tb = table()
tb.open(msfile + "/SPECTRAL_WINDOW")
total_bw = tb.getcol("TOTAL_BANDWIDTH")
num_chan = tb.getcol("NUM_CHAN")
tb.close()
timebin = "0s" # default in CASA
if os.path.isdir(msfile + ".flagversions/flags.before_cont_flags"):
# clear out old versions of the flags
flagmanager(vis=msfile, mode="delete", versionname="before_cont_flags")
# save flag state before flagging spectral lines
flagmanager(
vis=msfile,
mode="save",
versionname="before_cont_flags",
comment="Flag states before spectral lines are flagged",
)
# flag spectral lines
flagdata(
vis=msfile,
mode="manual",
spw=flagchannels,
flagbackup=False,
)
os.system("rm -rf " + outputvis)
split(
vis=msfile,
outputvis=outputvis,
spw=spws,
width=width_array,
timebin=timebin,
datacolumn=datacolumn,
intent="OBSERVE_TARGET#ON_SOURCE",
keepflags=False,
)
# restore flagged spectral line channels
flagmanager(vis=msfile, mode="restore", versionname="before_cont_flags")
print("#Averaged continuum dataset saved to %s" % outputvis)
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 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 calibrate_ms(src_dir, msname, ATCA_band, ref, pri, sec, tar):
os.system(f"rm -r {src_dir}/cal_tables/cal_{pri}_{ATCA_band}.F0")
setjy(
vis=msname,
field=pri,
scalebychan=True,
standard="Perley-Butler 2010",
usescratch=True,
)
print(f"Performing gain calibration on {pri}")
gaincal(
vis=msname,
caltable=f"{src_dir}/cal_tables/cal_{pri}_{ATCA_band}.G0",
field=pri,
refant=ref,
gaintype="G",
calmode="p",
parang=True,
# minblperant=3,
solint="60s",
)
print(f"Performing bandpass calibration on {pri}")
bandpass(
vis=msname,
caltable=f"{src_dir}/cal_tables/cal_{pri}_{ATCA_band}.B0",
field=pri,
refant=ref,
solnorm=True,
solint="120s",
bandtype="B",
gaintable=[f"{src_dir}/cal_tables/cal_{pri}_{ATCA_band}.G0"],
parang=True,
)
print(f"Determining gains on {sec}")
gaincal(
vis=msname,
caltable=f"{src_dir}/cal_tables/cal_{pri}_{ATCA_band}.G1",
field=pri + "," + sec,
refant=ref,
gaintype="G",
calmode="ap",
parang=True,
solint="120s",
gaintable=[f"{src_dir}/cal_tables/cal_{pri}_{ATCA_band}.B0"],
)
bandpass(
vis=msname,
caltable=f"{src_dir}/cal_tables/cal_{pri}_{ATCA_band}.B1",
field=pri,
refant=ref,
solnorm=True,
solint="120s",
bandtype="B",
gaintable=[f"{src_dir}/cal_tables/cal_{pri}_{ATCA_band}.G1"],
parang=True,
)
print(f"Deriving gain calibration using {pri}")
gaincal(
vis=msname,
caltable=f"{src_dir}/cal_tables/cal_{pri}_{ATCA_band}.G2",
field=pri,
refant=ref,
gaintype="G",
calmode="ap",
parang=True,
solint="60s",
# minblperant=3,
gaintable=[f"{src_dir}/cal_tables/cal_{pri}_{ATCA_band}.B1"],
)
print(f"Deriving gain calibration using {sec}")
gaincal(
vis=msname,
caltable=f"{src_dir}/cal_tables/cal_{pri}_{ATCA_band}.G2",
field=sec,
refant=ref,
gaintype="G",
calmode="ap",
parang=True,
solint="60s",
# minblperant=3,
gaintable=[f"{src_dir}/cal_tables/cal_{pri}_{ATCA_band}.B1"],
append=True,
)
print(
"Correcting the flux scale using comparison between the primary and secondary calibrator."
)
fluxscale(
vis=msname,
caltable=f"{src_dir}/cal_tables/cal_{pri}_{ATCA_band}.G2",
fluxtable=f"{src_dir}/cal_tables/cal_{pri}_{ATCA_band}.F0",
reference=pri,
)
flagmanager(vis=msname, mode="save", versionname="before_applycal")
return
def flag_hi_foreground(myvis,
calibrator_line_range_kms,
hi_spw_num,
cal_intents=["CALIBRATE*"],
test_print=False,
test_run=False):
'''
Define velocity regions to flag for all (or chosen) calibration
fields based on intent.
Parameters
----------
myvis : str
MS name.
calibrator_line_range_kms : dict
Dictionary with velocity range (in LSRK; radio) to flag.
hi_spw_num : int
The SPW of HI in the MS. If None is given, the context is used to
identify the SPW overlapping the HI line (where we can ignore wideband
continuum SPWs).
cal_intents : list, optional
List of the calibrator field intents to apply flagging to.
test_print : bool, optional
Print out additional information for testing purposes.
'''
# Check context for the calibration sources given the list of intents
# to flag.
# Loop through calibrator sources, calling target_foreground_hi_ranges
# Flag the requested range.
# Make a new flagging version marking these calls at the end.
# from taskinit import msmdtool, mstool
from casatools import ms
from casatasks import flagdata, flagmanager
# msmd = msmdtool()
# ms = mstool()
# mymsmd = msmd()
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(myvis)
myms.open(myvis)
mymsmd = myms.metadata()
# Loop through field intents. Default is all calibrators.
field_nums = []
for cal_intent in cal_intents:
field_num = mymsmd.fieldsforintent(cal_intent)
field_nums.extend(list(field_num))
# Unique mapping
field_nums = np.array(list(set(field_nums)))
field_names = np.asarray(mymsmd.fieldnames())[field_nums]
mymsmd.close()
# Loop through the field names, identify in calibrator_line_range_kms,
# and convert mapping from velocity -> freq (LSRK) -> channel.
# myms.open(myvis)
freqs_lsrk = myms.cvelfreqs(spwids=[hi_spw_num], outframe='LSRK')
myms.close()
# in Hz
hi_restfreq = 1.420405752e9
vels_lsrk = lines_freq2vels(freqs_lsrk, hi_restfreq)
for field in field_names:
if field not in calibrator_line_range_kms:
casalog.post('Unable to locate calibrator {} in calibrator list.'.format(field))
casalog.post('Check `calibrator_setup.py` to see if this source is missing')
continue
vel_start = calibrator_line_range_kms[field]['HI'][0]
vel_stop = calibrator_line_range_kms[field]['HI'][1]
# Keep red to blue shifted order.
if vel_start < vel_stop:
vel_stop, vel_start = vel_start, vel_stop
chan_start = np.abs(vels_lsrk - vel_start).argmin()
chan_stop = np.abs(vels_lsrk - vel_stop).argmin()
# Do the flagging and save a new version
if test_print:
print('Field {0} flagging region {1}:{2}~{3}'.format(field, hi_spw_num,
chan_start, chan_stop))
print('Velocity: {0}, {1}'.format(vel_start, vel_stop))
if test_run:
continue
flagdata(myvis, mode='manual', field=field,
spw='{0}:{1}~{2}'.format(hi_spw_num, chan_start, chan_stop),
flagbackup=False)
if not test_run:
flagmanager(myvis, mode='save', versionname='MW_HI_abs_flagging',
comment='Flag Milky Way HI absorption for calibrators.')