def __correct_feed_convention(ms):
from pyrap.tables import table as tbl
import numpy as np
with tbl("%s::FEED" % ms, readonly=False) as t:
ang = t.getcol("RECEPTOR_ANGLE")
ang[:, 0] = -np.pi / 2
ang[:, 1] = -np.pi / 2
t.putcol("RECEPTOR_ANGLE", ang)
log.info("Receptor angle rotated by -90deg")
def test_flag_count(flagged_ms, tol):
""" Tests for flag count less than tolerance """
with tbl("::".join((flagged_ms, "FIELD"))) as t:
fnames = t.getcol("NAME")
with tbl(flagged_ms) as t:
fid = t.getcol("FIELD_ID")
flag = t.getcol("FLAG")
flag_sel = flag[fid == fnames.index("3C286")]
count_flagged_3c286 = np.nansum(flag_sel, axis=(0, 1, 2))
flagged_ratio = count_flagged_3c286 / flag_sel.size
print("Percent flagged for 3C286: %.3f%%" % (100. * flagged_ratio))
assert flagged_ratio < tol
flag_sel = flag[fid == fnames.index("PKS1934-63")]
count_flagged_1934 = np.nansum(flag_sel, axis=(0, 1, 2))
flagged_ratio = count_flagged_1934 / flag_sel.size
print("Percent flagged for PKS1934-63: %.3f%%" % (100. * flagged_ratio))
assert flagged_ratio < tol
def __extract_fields(ms, field_list, field_ids):
from pyrap.tables import table as tbl
with tbl("%s/%s::FIELD" % (MSDIR, ms)) as fields:
fnames = fields.getcol("NAME")
if len(set([field_list[f]
for f in field_list]).difference(set(fnames))) != 0:
raise ValueError(
"Fields {0:s} selected but only {1:s} available.".format(
", ".join(
["'{0:s}'".format(field_list[f]) for f in field_list]),
", ".join(["'{0:s}'".format(f) for f in fnames])))
field_ids += [fnames.index(field_list[f]) for f in field_list]
def test_bandwidth_flagged(flagged_ms, tol):
""" Tests for total bandwidth flagged less than tolerance """
with tbl("::".join((flagged_ms, "FIELD"))) as t:
fnames = t.getcol("NAME")
with tbl(flagged_ms) as t:
fid = t.getcol("FIELD_ID")
data = t.getcol("DATA")
data_sel = data[fid == fnames.index("3C286"), :, 0]
count_flagged_3c286 = np.nansum(data_sel, axis=0) > 0
flagged_ratio = count_flagged_3c286.sum() / data_sel.shape[1]
print("Percent bandwidth flagged for 3C286: %.3f%%" %
(100. * flagged_ratio))
assert flagged_ratio < tol
data_sel = data[fid == fnames.index("PKS1934-63"), :, 0]
count_flagged_1934 = np.nansum(data_sel, axis=0) > 0
flagged_ratio = count_flagged_1934.sum() / data_sel.shape[1]
print("Percent bandwidth flagged for PKS1934-63: %.3f%%" %
(100. * flagged_ratio))
assert flagged_ratio < tol
def test_max_chisq(flagged_ms, tol):
""" Tests for improvement in max chisq per correlation """
with tbl("::".join((flagged_ms, "FIELD"))) as t:
fnames = t.getcol("NAME")
with tbl(flagged_ms) as t:
fid = t.getcol("FIELD_ID")
flag = t.getcol("FLAG")
data = t.getcol("DATA")
abs_data_sel = np.abs(data[fid == fnames.index("3C286")])
diff = (abs_data_sel - np.nanmean(abs_data_sel, axis=0))**2
chisq_unflagged_3c286 = np.nanmax(diff, axis=(0, 1))
corrs_str = ",".join(["{0:.3f}".format(f) for f in chisq_unflagged_3c286])
print("Max Chi^2 unflagged 3C286: [%s]" % corrs_str)
abs_data_sel = np.abs(data[fid == fnames.index("PKS1934-63")])
diff = (abs_data_sel - np.nanmean(abs_data_sel, axis=0))**2
chisq_unflagged_1934 = np.nanmax(diff, axis=(0, 1))
corrs_str = ",".join(["{0:.3f}".format(f) for f in chisq_unflagged_1934])
print("Max Chi^2 unflagged PKS B1934-638: [%s]" % corrs_str)
# flag data
data[flag] = np.nan
abs_data_sel = np.abs(data[fid == fnames.index("3C286")])
diff = (abs_data_sel - np.nanmean(abs_data_sel, axis=0))**2
chisq_flagged_3c286 = np.nanmax(diff, axis=(0, 1))
corrs_str = ",".join(["{0:.3f}".format(f) for f in chisq_flagged_3c286])
print("Max Chi^2 flagged 3C286: [%s]" % corrs_str)
abs_data_sel = np.abs(data[fid == fnames.index("PKS1934-63")])
diff = (abs_data_sel - np.nanmean(abs_data_sel, axis=0))**2
chisq_flagged_1934 = np.nanmax(diff, axis=(0, 1))
corrs_str = ",".join(["{0:.3f}".format(f) for f in chisq_flagged_1934])
print("Max Chi^2 flagged PKS B1934-638: [%s]" % corrs_str)
assert all(chisq_unflagged_3c286 > chisq_flagged_3c286 * tol)
assert all(chisq_unflagged_1934 > chisq_flagged_1934 * tol)
def clip_delays(vis, clipminmax):
with tbl(os.path.join(OUTPUT, vis), readonly=False) as t:
fl = t.getcol("FLAG")
d = t.getcol("FPARAM")
prevflagged = np.sum(fl) * 100.0 / fl.size
fl = np.logical_or(
fl,
np.logical_or(d.real > np.max(clipminmax),
d.real < np.min(clipminmax)))
t.putcol("FLAG", fl)
currentflagged = np.sum(fl) * 100.0 / fl.size
vermeerkat.log.info(
"Flagged {0:.2f}%, up from previous {1:.2f}%".format(
currentflagged, prevflagged))
def taper_weigh(ms):
from pyrap.tables import table as tbl
with tbl(ms, readonly=False) as t:
uvw = t.getcol("UVW")
max_uv = np.sqrt(np.max(uvw[:, 0]**2 + uvw[:, 1]**2))
taper = lambda u, v, a, b, gamma: (1.0 / (1 + np.exp(
(np.sqrt(u**2 + v**2) - b) /
(2.0 * max_uv / gamma))) + 1.0 / (1 + np.exp(
(-np.sqrt(u**2 + v**2) + a) /
(2.0 * max_uv / gamma))) + 1.0 / (1 + np.exp(
(-np.sqrt(u**2 + v**2) - b) /
(2.0 * max_uv / gamma))) + 1.0 / (1 + np.exp(
(np.sqrt(u**2 + v**2) + a) /
(2.0 * max_uv / gamma)))) - 2.0
weight = t.getcol("WEIGHT")
weight_new = weight.copy()
tp_weight = taper(
uvw[:, 0],
uvw[:, 1],
taper_inner_cut, # inner cut
taper_outer_cut, # outer cut
taper_gamma)
weight_new *= tp_weight[:, None]
import matplotlib
matplotlib.use('Agg')
from matplotlib import pyplot as plt
import os
from scipy.interpolate import griddata
plt.figure()
x = np.linspace(np.min(uvw), np.max(uvw), 1024)
xx, xy = np.meshgrid(x, x, sparse=False)
###grid = griddata(uvw[:, 0:2], tp_weight, (xx, xy), method="linear")
grid = taper(xx, xy, taper_inner_cut, taper_outer_cut,
taper_gamma)
plt.imshow(grid,
cmap="magma",
extent=[
np.min(xx),
np.max(xx),
np.max(xx),
np.min(xx)
])
plt.xlabel("u (m)")
plt.ylabel("v (m)")
plt.savefig(
os.path.join(OUTPUT, "uvtaper_{0:d}.png".format(ti)))
t.putcol("WEIGHT", weight_new)
t.close()
MSDIR = args.msdir_directory
OUTPUT = args.output_directory
vermeerkat.log.info(
"Directory '{0:s}' is used as input directory".format(INPUT))
vermeerkat.log.info(
"Directory '{0:s}' is used as output directory".format(OUTPUT))
vermeerkat.log.info(
"Directory '{0:s}' is used as msdir directory".format(MSDIR))
PREFIX = args.msprefix
ZEROGEN_DATA = PREFIX + ".ms"
vermeerkat.log.info(
"Dataset '{0:s}' to be used throughout".format(ZEROGEN_DATA))
with tbl(os.path.join(MSDIR, ZEROGEN_DATA) + "::FIELD", ack=False) as t:
field_names = t.getcol("NAME")
FDB = {fn: str(fni) for fni, fn in enumerate(field_names)}
def flistr():
vermeerkat.log.info("The following fields are available:")
for f in FDB:
vermeerkat.log.info("\t '{0:s}' index {1:s}".format(f, FDB[f]))
sys.exit(0)
vermeerkat.init_inputdir(INPUT,
dont_prompt=args.dont_prompt,
dont_clean=args.dont_reinitialize_input_dir)
def create_K_table(cls, db, gname, outname="K"):
"""
Write real-valued K-Jones table
Args:
db: a cubical pickled_db instance
gname: name of pickled_db solutions to export
outname: suffix of exported CASA gaintable
"""
if six.PY3:
log.error(
"Gaintables cannot be written in Python 3 mode due to current casacore implementation issues"
)
return
if np.prod(db[gname].shape) == 0:
log.warn("No %s solutions. Will not write CASA table" % gname)
return
paramerrs = cls.__check_param_err(db, gname)
assert db[gname].axis_labels == (
'dir', 'time', 'freq', 'ant',
'corr'), "DB table in unrecognized format"
ddids = db.sel_ddids
ndir = len(db[gname].grid[db[gname].ax.dir])
ntime = len(db[gname].grid[db[gname].ax.time])
nant = len(db[gname].grid[db[gname].ax.ant])
ncorr = len(db[gname].grid[db[gname].ax.corr])
nddids = len(db.sel_ddids)
nrow = ndir * ntime * \
nant * len(ddids)
assert ncorr == 2, "Expected diagnonal Jones matrix"
cls.init_empty(db,
db.filename + ".%s.casa" % outname,
db[gname].grid[db[gname].ax.freq],
db[gname].grid[db[gname].ax.ant],
field_ndir=ndir,
is_complex=False,
viscal_label="K Jones")
with tbl(str(db.filename + ".%s.casa" % outname),
ack=False,
readonly=False) as t:
t.addrows(nrows=nrow)
for iddid, ddid in enumerate(db.sel_ddids):
spwid = db.ddid_spw_map[ddid]
minfreq = np.min(db.spwchanfreq[spwid] -
0.5 * db.spwchanwidth[spwid])
maxfreq = np.max(db.spwchanfreq[spwid] +
0.5 * db.spwchanwidth[spwid])
ddsolfreqindx = np.argwhere(
np.logical_and(
db[gname].grid[db[gname].ax.freq] >= minfreq,
db[gname].grid[db[gname].ax.freq] <= maxfreq))
# note -- CASA K table delays are in nanoseconds. This presumes delays in the cubical tables are already denormalized into seconds
params = np.swapaxes(
db[gname].get_cube()[:, :, ddsolfreqindx, :, :], 2,
3).reshape(ndir * ntime * nant, len(ddsolfreqindx),
ncorr) * 1.0e9
paramerrs = np.swapaxes(
paramerrs[:, :, ddsolfreqindx, :, :], 2, 3).reshape(
ndir * ntime * nant, len(ddsolfreqindx), ncorr) * 1.0e9
flags = np.ma.getmaskarray(params)
fieldid = np.repeat(
np.arange(ndir),
ntime * nant) # dir (marked as field) is slowest varying
time = np.repeat(
np.tile(db[gname].grid[db[gname].ax.time], ndir), nant)
ant1 = np.tile(np.arange(nant),
ndir * ntime) # FK ndir * ntime blocks
#ant2 can be the same - it is not used unless specifying mueller matricies
nrowsdd = ntime * nant * ndir
t.putcol("TIME", time, startrow=nrowsdd * iddid)
t.putcol("FIELD_ID", fieldid, startrow=nrowsdd * iddid)
t.putcol(
"SPECTRAL_WINDOW_ID",
np.ones(ant1.shape) * iddid,
startrow=nrowsdd * iddid
) # new spectral window with freq range for these sols
t.putcol("ANTENNA1", ant1, startrow=nrowsdd * iddid)
t.putcol("ANTENNA2",
np.ones(ant1.shape) * -1,
startrow=nrowsdd * iddid)
t.putcol("INTERVAL",
np.zeros(ant1.shape),
startrow=nrowsdd *
iddid) #TODO: unclear from MEMO 229
t.putcol("SCAN_NUMBER",
np.ones(ant1.shape) * -1,
startrow=nrowsdd *
iddid) #TODO this FK info is not available yet @oms
t.putcol("OBSERVATION_ID",
np.ones(ant1.shape) * -1,
startrow=nrowsdd *
iddid) #TODO this FK info is not available yet @oms
t.putcol("FPARAM",
np.ma.getdata(params),
startrow=nrowsdd * iddid)
t.putcol("PARAMERR",
np.ma.getdata(paramerrs),
startrow=nrowsdd * iddid)
t.putcol("FLAG", flags, startrow=nrowsdd * iddid)
t.putcol("SNR",
np.ones(params.shape) * np.inf,
startrow=nrowsdd *
iddid) #TODO this is not available @oms
t.putcol("WEIGHT",
np.ones(params.shape),
startrow=nrowsdd *
iddid) #TODO this is not available @oms
def init_empty(cls,
db,
filename,
solfreqs,
solants,
field_ndir=1,
is_complex=True,
viscal_label="B Jones"):
"""
Initialize empty calibration table with metadata
Args:
db: a cubical pickled_db instance
filename: filename of CASA gaintable to be written
solfreqs: centre frequencies of solutions to be stored in table
solants: Names from Cubical database antenna axis, used to order solutions
field_ndir: Number of solvable directions in field
is_complex: Solutions are complex or real-valued
viscal_label: Sets viscal property of CASA table - used as identifier in CASA
"""
if six.PY3:
log.error(
"Gaintables cannot be written in Python 3 mode due to current casacore implementation issues"
)
return
if os.path.exists(filename):
if os.path.isfile(filename):
log.error(
"CASA calibration table destination already exists but is not a directory. Will not remove."
)
return
else:
log.info(
"Destination CASA gain table '%s' exists. Will overwrite."
% filename)
shutil.rmtree(filename) # CASA convention is to overwrite
basedir = os.path.dirname(filename) or '.'
subprocess.check_output(
["tar", "zxvf", BLANK_TABLE_TARBALL, "-C", basedir])
os.rename(os.path.join(basedir, BLANK_TABLE_NAME), filename)
antorder = [db.antnames.index(an) for an in solants]
with tbl("%s::ANTENNA" % str(filename), ack=False,
readonly=False) as t:
t.addrows(nrows=len(db.anttype))
t.putcol("OFFSET", db.antoffset[antorder])
t.putcol("POSITION", db.antpos[antorder])
t.putcol("TYPE", np.array(db.anttype)[antorder])
t.putcol("DISH_DIAMETER", db.antdishdiam[antorder])
t.putcol("FLAG_ROW", db.antflagrow[antorder])
t.putcol("MOUNT", np.array(db.antmount)[antorder])
t.putcol("NAME", np.array(db.antnames)[antorder])
t.putcol("STATION", np.array(db.antstation)[antorder])
assert "field" in db.metadata, "Solver field not passed in metadata. This is a bug"
assert type(db.metadata["field"]
) is int, "Currently only supports single field"
selfield = np.arange(len(db.fieldname)) == db.metadata["field"]
with tbl("%s::FIELD" % str(filename), ack=False, readonly=False) as t:
t.addrows(nrows=field_ndir)
t.putcol("DELAY_DIR",
np.tile(db.fielddelaydirs[selfield], (field_ndir, 1)))
t.putcol("PHASE_DIR",
np.tile(db.fieldphasedirs[selfield], (field_ndir, 1)))
t.putcol("REFERENCE_DIR",
np.tile(db.fieldrefdir[selfield], (field_ndir, 1)))
t.putcol(
"CODE",
np.tile(np.array(db.fieldcode)[selfield], (field_ndir, 1)))
t.putcol("FLAG_ROW",
np.tile(db.fieldflagrow[selfield], (field_ndir, 1)))
t.putcol(
"NAME",
np.array(
map(str, [
"%s_DIR_%d" % (f, fdi) for fdi, f in
enumerate([db.fieldname[np.where(selfield)[0][0]]] *
field_ndir)
])).T)
t.putcol(
"SOURCE_ID",
np.tile(db.fieldsrcid[selfield],
(field_ndir, 1)) + np.arange(field_ndir).T)
t.putcol("TIME", np.tile(db.fieldtime[selfield], (field_ndir, 1)))
with tbl("%s::OBSERVATION" % str(filename), ack=False,
readonly=False) as t:
t.addrows(nrows=len(db.obsobserver))
(len(db.obstimerange) != 0) and t.putcol("TIME_RANGE",
db.obstimerange)
(len(db.obslog) != 0) and t.putcol("LOG", db.obslog)
(len(db.obsschedule) != 0) and t.putcol("SCHEDULE", db.obsschedule)
(len(db.obsflagrow) != 0) and t.putcol("FLAG_ROW", db.obsflagrow)
(len(db.obsobserver) != 0) and t.putcol("OBSERVER", db.obsobserver)
(len(db.obsproject) != 0) and t.putcol("PROJECT", db.obsproject)
(len(db.obsreleasedate) != 0) and t.putcol("RELEASE_DATE",
db.obsreleasedate)
(len(db.obstelescopename) != 0) and t.putcol(
"TELESCOPE_NAME", db.obstelescopename)
with tbl("%s::SPECTRAL_WINDOW" % str(filename),
ack=False,
readonly=False) as t:
t.addrows(nrows=len(db.sel_ddids))
# Per DDID determine solution spacing in frequency
for iddid, ddid in enumerate(db.sel_ddids):
spwid = db.ddid_spw_map[ddid]
minfreq = np.min(db.spwchanfreq[spwid] -
0.5 * db.spwchanwidth[spwid])
maxfreq = np.max(db.spwchanfreq[spwid] +
0.5 * db.spwchanwidth[spwid])
ddsolfreqs = solfreqs[np.logical_and(solfreqs >= minfreq,
solfreqs <= maxfreq)]
# assume linearly-spaced solutions for N - 1 solutions along grid and last solution
# may have different spacing if solution interval does not exactly divide number of channels
if ddsolfreqs.size > 1:
ch0 = np.min(db.spwchanfreq)
chN = np.max(db.spwchanfreq)
ddsolwidthmax = 2 * (ddsolfreqs[0] - ch0)
ddsolwidth = np.ones(ddsolfreqs.size) * ddsolwidthmax
ddsolwidth[-1] = ddsolwidthmax + (
chN - (ddsolfreqs.size * ddsolwidthmax + ch0))
else:
ddsolwidth = db.spwtotalbandwidth
t.putcell("MEAS_FREQ_REF", iddid, db.spwmeasfreq[spwid])
t.putcell("CHAN_FREQ", iddid, ddsolfreqs)
t.putcell("REF_FREQUENCY", iddid, db.spwreffreq[spwid])
t.putcell("CHAN_WIDTH", iddid, ddsolwidth)
t.putcell("EFFECTIVE_BW", iddid,
ddsolwidth) # TODO: this may not be true
t.putcell("RESOLUTION", iddid, db.spwresolution[spwid])
t.putcell("FLAG_ROW", iddid, db.spwflagrow[spwid])
t.putcell("FREQ_GROUP", iddid, db.spwfreqgroup[spwid])
t.putcell("FREQ_GROUP_NAME", iddid, db.spwfreqgroupname[spwid])
t.putcell("IF_CONV_CHAIN", iddid, db.spwifconvchain[spwid])
t.putcell("NAME", iddid, str(db.spwname[spwid]))
t.putcell("NET_SIDEBAND", iddid, db.spwnetsideband[spwid])
t.putcell("NUM_CHAN", iddid, ddsolfreqs.size)
t.putcell("TOTAL_BANDWIDTH", iddid, maxfreq - minfreq)
with tbl(str(filename), ack=False, readonly=False) as t:
t.putkeyword("ParType", "Complex" if is_complex else "Float")
t.putkeyword("VisCal", viscal_label)
if not is_complex:
cdesc = t.getcoldesc("CPARAM")
cdesc["valueType"] = "float"
t.addcols({"FPARAM": cdesc})
t.removecols("CPARAM")
def fixms(msname):
"""
Runs an operation similar to the CASA fixvis task
Recomputes UVW coordinates with casacore for the predicted
az-elev delay projections given a dataset with antenna ICRS
positions and a time centroid column.
Note: This operation CANNOT be applied blockwise due
to a casacore.measures threadsafety issue
"""
with tbl(msname + "::ANTENNA", ack=False) as t:
apos = t.getcol("POSITION")
aposcoldesc = t.getcoldesc("POSITION")
posunits = aposcoldesc["keywords"]["QuantumUnits"]
posframe = aposcoldesc["keywords"]["MEASINFO"]["Ref"]
with tbl(msname + "::FIELD", ack=False) as t:
if not np.all(t.getcol("NUM_POLY") == 0):
raise RuntimeError(
"Does not support time-variable reference centres")
fnames = t.getcol("NAME")
field_stop_ctrs = t.getcol("PHASE_DIR")
fieldcoldesc = t.getcoldesc("PHASE_DIR")
stopctr_units = fieldcoldesc["keywords"]["QuantumUnits"]
stopctr_epoch = fieldcoldesc["keywords"]["MEASINFO"]["Ref"]
with tbl(msname, ack=False) as t:
a1 = t.getcol("ANTENNA1")
a2 = t.getcol("ANTENNA2")
uvw = t.getcol("UVW")
field_id = t.getcol("FIELD_ID")
ddid = t.getcol("DATA_DESC_ID")
time = t.getcol("TIME_CENTROID")
timecoldesc = t.getcoldesc("TIME_CENTROID")
time_TZ = timecoldesc["keywords"]["MEASINFO"]["Ref"]
time_unit = timecoldesc["keywords"]["QuantumUnits"][0]
logger.info("Computing UVW coordinates for output dataset... WAIT")
new_uvw = np.zeros_like(uvw, dtype=uvw.dtype)
for fi in range(len(fnames)):
fsel = field_id == fi
padded_uvw = synthesize_uvw(station_ECEF=apos,
time=time[fsel],
a1=a1[fsel],
a2=a2[fsel],
phase_ref=field_stop_ctrs[fi],
stopctr_units=stopctr_units,
time_TZ=time_TZ,
time_unit=time_unit,
stopctr_epoch=stopctr_epoch,
posframe=posframe,
posunits=posunits)
new_uvw[fsel] = dense2sparce_uvw(a1=a1[fsel],
a2=a2[fsel],
time=time[fsel],
ddid=ddid[fsel],
padded_uvw=padded_uvw["UVW"])
logger.info("\t {} / {} fields completed".format(fi + 1, len(fnames)))
logger.info("Writing computed UVW coordinates to output dataset")
with tbl(msname, ack=False, readonly=False) as t:
t.lock() # workaround dask-ms bug not releasing user locks
t.putcol("UVW", new_uvw)
t.unlock()
def create_B_table(cls, db, gname, outname = "B", diag=True):
"""
Write diagonal B-Jones caltable
Args:
db: a cubical pickled_db instance
gname: name of pickled_db solutions to export
outname: suffix of exported CASA gaintable
diag: Write out diagonal of Jones matrix if true, off-diagonal (leakage) terms otherwise.
"""
if np.prod(db[gname].shape) == 0:
log.warn("No %s solutions. Will not write CASA table" % gname)
return
assert db[gname].shape == db[gname + ".err"].shape, "PARAM err shape does not match PARAM shape, this is a bug"
assert db[gname].axis_labels == ('dir', 'time', 'freq', 'ant', 'corr1', 'corr2'), "DB table in unrecognized format"
ddids = db.sel_ddids
ndir = len(db[gname].grid[db[gname].ax.dir])
ntime = len(db[gname].grid[db[gname].ax.time])
nant = len(db[gname].grid[db[gname].ax.ant])
ncorr1 = len(db[gname].grid[db[gname].ax.corr1])
ncorr2 = len(db[gname].grid[db[gname].ax.corr2])
nddids = len(db.sel_ddids)
nrow = ndir * ntime * \
nant * len(ddids)
assert ncorr1 == ncorr2 and ncorr1 == 2, "Expected 2x2 solution, this is a bug"
cls.init_empty(db,
db.filename + ".%s.casa" % outname,
db[gname].grid[db[gname].ax.freq],
db[gname].grid[db[gname].ax.ant],
field_ndir=ndir,
viscal_label="B Jones" if diag else "D Jones")
with tbl(db.filename + ".%s.casa" % outname, ack=False, readonly=False) as t:
t.addrows(nrows=nrow)
for iddid, ddid in enumerate(db.sel_ddids):
spwid = db.ddid_spw_map[ddid]
minfreq = np.min(db.spwchanfreq[spwid] - 0.5 * db.spwchanwidth[spwid])
maxfreq = np.max(db.spwchanfreq[spwid] + 0.5 * db.spwchanwidth[spwid])
ddsolfreqindx = np.argwhere(np.logical_and(db[gname].grid[db[gname].ax.freq] >= minfreq,
db[gname].grid[db[gname].ax.freq] <= maxfreq))
jones_entries = [0, 3] if diag else [1, 2] # diagonal or crosshands
params = np.swapaxes(db[gname].get_cube()[:, :, ddsolfreqindx, :, :],
2, 3).reshape(ndir * ntime * nant, len(ddsolfreqindx), ncorr1 * ncorr2)[:, :, jones_entries]
paramerrs = np.swapaxes(db[gname + ".err"].get_cube()[:, :, ddsolfreqindx, :, :],
2, 3).reshape(ndir * ntime * nant, len(ddsolfreqindx), ncorr1 * ncorr2)[:, :, jones_entries]
flags = np.ma.getmaskarray(params)
fieldid = np.repeat(np.arange(ndir), ntime * nant) # dir (marked as field) is slowest varying
time = np.repeat(np.tile(db[gname].grid[db[gname].ax.time], ndir), nant)
ant1 = np.tile(np.arange(nant), ndir * ntime) # FK ndir * ntime blocks
#ant2 can be the same - it is not used unless specifying mueller matricies
nrowsdd = ntime * nant * ndir
t.putcol("TIME", time, startrow=nrowsdd * iddid)
t.putcol("FIELD_ID", fieldid, startrow=nrowsdd * iddid)
t.putcol("SPECTRAL_WINDOW_ID", np.ones(ant1.shape) * iddid, startrow=nrowsdd * iddid) # new spectral window with freq range for these sols
t.putcol("ANTENNA1", ant1, startrow=nrowsdd * iddid)
t.putcol("ANTENNA2", np.ones(ant1.shape) * -1, startrow=nrowsdd * iddid)
t.putcol("INTERVAL", np.zeros(ant1.shape), startrow=nrowsdd * iddid) #TODO: unclear from MEMO 229
t.putcol("SCAN_NUMBER", np.ones(ant1.shape) * -1, startrow=nrowsdd * iddid) #TODO this FK info is not available yet @oms
t.putcol("OBSERVATION_ID", np.ones(ant1.shape) * -1, startrow=nrowsdd * iddid) #TODO this FK info is not available yet @oms
t.putcol("CPARAM", np.ma.getdata(params), startrow=nrowsdd * iddid)
t.putcol("PARAMERR", np.ma.getdata(paramerrs), startrow=nrowsdd * iddid)
t.putcol("FLAG", flags, startrow=nrowsdd * iddid)
t.putcol("SNR", np.ones(params.shape) * np.inf, startrow=nrowsdd * iddid) #TODO this is not available @oms
t.putcol("WEIGHT", np.ones(params.shape), startrow=nrowsdd * iddid) #TODO this is not available @oms
#!/usr/bin/python
from pyrap.tables import table as tbl
from pyrap import tables as tbls
import re
import numpy as np
with open("/southern_calibrators.txt") as f, \
tbl("/casa-release-4.7.0-el6/data/nrao/VLA/standards/fluxcalibrator.data", readonly=False) as fc, \
tbl("/casa-release-4.7.0-el6/data/nrao/VLA/standards/PerleyButler2013Coeffs", readonly=False) as pb:
line = f.readline()
ln_no = 1
while line:
#discard comments
command = line.split("//")[0]
#empty line ?
if command.strip() == "":
print "Skipping line: '%s'" % line
line = f.readline()
ln_no += 1
continue
#source ?
valset = re.match(
r"^name=(?P<name>[0-9A-Za-z\-+_]+)[ ]+"
r"epoch=(?P<epoch>[0-9]+)[ ]+"
r"ra=(?P<ra>[+\-]?[0-9]+h[0-9]+m[0-9]+(?:.[0-9]+)?s)[ ]+"
r"dec=(?P<decl>[+\-]?[0-9]+d[0-9]+m[0-9]+(?:.[0-9]+)?s)[ ]+"
r"a=(?P<a>[+\-]?[0-9]+(?:.[0-9]+)?)[ ]+"
r"b=(?P<b>[+\-]?[0-9]+(?:.[0-9]+)?)[ ]+"
r"c=(?P<c>[+\-]?[0-9]+(?:.[0-9]+)?)[ ]+"
INPUT = args.input_directory
MSDIR = args.msdir_directory
OUTPUT = args.output_directory
vermeerkat.log.info(
"Directory '{0:s}' is used as input directory".format(INPUT))
vermeerkat.log.info(
"Directory '{0:s}' is used as output directory".format(OUTPUT))
vermeerkat.log.info(
"Directory '{0:s}' is used as msdir directory".format(MSDIR))
PREFIX = args.msprefix
DATASET = PREFIX + ".ms"
vermeerkat.log.info("Dataset '{0:s}' to be used throughout".format(DATASET))
with tbl(os.path.join(MSDIR, DATASET) + "::FIELD", ack=False) as t:
field_names = t.getcol("NAME")
FDB = {fn: str(fni) for fni, fn in enumerate(field_names)}
vermeerkat.init_inputdir(INPUT,
dont_prompt=args.dont_prompt,
dont_clean=args.dont_reinitialize_input_dir)
TARGET = [f[0] if isinstance(f, list) else f for f in args.target_field]
if len(TARGET) < 1: raise ValueError("No target specified")
vermeerkat.log.info("Will be self calibrating:")
for t in TARGET:
vermeerkat.log.info("\t{} (field id {})".format(t, FDB[t]))
REFANT = args.ref_ant
'path prefix')
args = parser.parse_args(sys.argv[2:])
INPUT = args.input_directory
MSDIR = args.msdir_directory
OUTPUT = args.output_directory
vermeerkat.log.info(
"Directory '{0:s}' is used as input directory".format(INPUT))
vermeerkat.log.info(
"Directory '{0:s}' is used as output directory".format(OUTPUT))
vermeerkat.log.info(
"Directory '{0:s}' is used as msdir directory".format(MSDIR))
PREFIX = args.msprefix
ZEROGEN_DATA = PREFIX + ".ms"
vermeerkat.log.info(
"Dataset '{0:s}' to be used throughout".format(ZEROGEN_DATA))
with tbl(os.path.join(MSDIR, ZEROGEN_DATA) + "::ANTENNA", ack=False) as t:
name = t.getcol("NAME")
pos = t.getcol("POSITION")
vermeerkat.log.info("The following antennae are available:")
for ni, (n, p) in enumerate(zip(name, pos)):
vermeerkat.log.info("\t {0:d}: '{1:s}' with position [{2:s}]".format(
ni, n, ",".join(map(str, p))))
vermeerkat.log.info("---End of listr---")
MSDIR = args.msdir_directory
OUTPUT = args.output_directory
vermeerkat.log.info(
"Directory '{0:s}' is used as input directory".format(INPUT))
vermeerkat.log.info(
"Directory '{0:s}' is used as output directory".format(OUTPUT))
vermeerkat.log.info(
"Directory '{0:s}' is used as msdir directory".format(MSDIR))
PREFIX = args.msprefix
ZEROGEN_DATA = PREFIX + ".ms"
vermeerkat.log.info(
"Dataset '{0:s}' to be used throughout".format(ZEROGEN_DATA))
with tbl(os.path.join(MSDIR, ZEROGEN_DATA) + "::SOURCE", ack=False) as t:
codes = t.getcol("CODE")
intents = t.getcol("CALIBRATION_GROUP")
SCODE = {sni: c for sni, c in enumerate(codes)}
SINTENT = {sni: intent for sni, intent in enumerate(intents)}
with tbl(os.path.join(MSDIR, ZEROGEN_DATA) + "::STATE", ack=False) as t:
states = t.getcol("OBS_MODE")
with tbl(os.path.join(MSDIR, ZEROGEN_DATA) + "::FIELD", ack=False) as t:
field_names = t.getcol("NAME")
code = t.getcol("CODE")
sid = t.getcol("SOURCE_ID")
FDB = {fn: str(fni) for fni, fn in enumerate(field_names)}
FCODE = {
