def test_same(self):
antpos = linear_array(NANTS)
reds = om.get_reds(antpos, pols=['xx'], pol_mode='1pol')
info = redcal.RedundantCalibratorGPU(reds)
shape = (NDATA, 1)
gains, true_vis, d = sim_red_data(reds,
gain_scatter=.0099999,
shape=shape)
w = dict([(k, 1.) for k in d.keys()])
sol0 = dict([(k, np.ones_like(v)) for k, v in gains.items()])
sol0.update(info.compute_ubls(d, sol0))
for precision in (1, 2):
conv_crit = 1e-12
kwargs = {
'maxiter': 100,
'check_after': 10,
'check_every': 4,
'gain': 0.3,
'conv_crit': conv_crit
}
meta_gpu, sol_gpu = info.omnical_gpu(d,
sol0,
precision=precision,
**kwargs)
meta_cpu, sol_cpu = info.omnical(d, sol0, **kwargs)
for k in sol_cpu:
np.testing.assert_almost_equal(sol_gpu[k],
sol_cpu[k],
decimal=5 * precision)
def test_wrap(self):
shape = (NDATA, 1)
antpos = linear_array(NANTS)
reds = om.get_reds(antpos, pols=['xx'], pol_mode='1pol')
info = redcal.RedundantCalibratorGPU(reds)
gains, true_vis, d = sim_red_data(reds,
gain_scatter=.0099999,
shape=shape)
w = dict([(k, 1.) for k in d.keys()])
sol0 = dict([(k, np.ones_like(v)) for k, v in gains.items()])
sol0.update(info.compute_ubls(d, sol0))
meta, sol = info.omnical_gpu(d,
sol0,
conv_crit=1e-12,
gain=.5,
maxiter=500,
check_after=30,
check_every=6)
# Leaving a reference to standard (non-GPU) omnical here in
# case we want to compare GPU vs non-GPU for speed/accuracy.
#meta, sol = info.omnical(d, sol0, conv_crit=1e-12, gain=.5, maxiter=500, check_after=30, check_every=6)
for i in range(NANTS):
assert sol[(i, 'Jxx')].shape == shape
for bls in reds:
ubl = sol[bls[0]]
assert ubl.shape == shape
for bl in bls:
d_bl = d[bl]
mdl = sol[(bl[0], 'Jxx')] * sol[(bl[1], 'Jxx')].conj() * ubl
np.testing.assert_almost_equal(np.abs(d_bl),
np.abs(mdl),
decimal=10)
np.testing.assert_almost_equal(np.angle(d_bl * mdl.conj()),
0,
decimal=10)
def generate_residual_IDR2_2(uvh5_file,
omni_vis,
omni_calfits,
abs_calfits,
outfile,
clobber=False):
# reading uvh5 data file
hd = HERAData(uvh5_file)
data, flags, nsamples = hd.read(polarizations=['ee', 'nn'])
# reading omnical model visibilities
hd_oc = HERAData(omni_vis)
omnivis, omnivis_flags, _ = hd_oc.read()
uvo = pyuvdata.UVData()
uvo.read_uvh5(omni_vis)
# reading calfits file
hc = HERACal(omni_calfits)
oc_gains, oc_flags, oc_quals, oc_total_quals = hc.read()
hc = HERACal(abs_calfits)
ac_gains, ac_flags, ac_quals, ac_total_quals = hc.read()
# calibrating the data
abscal_data, abscal_flags = copy.deepcopy(data), copy.deepcopy(flags)
calibrate_in_place(abscal_data,
ac_gains,
data_flags=abscal_flags,
cal_flags=ac_flags)
res_data, res_flags = copy.deepcopy(hd.data_array), copy.deepcopy(
hd.flag_array)
resdata, resflags = copy.deepcopy(abscal_data), copy.deepcopy(abscal_flags)
for i, p in enumerate(['ee', 'nn']):
# reading omnical model visibilities
hd_oc = HERAData(omni_vis)
omnivis, omnivis_flags, _ = hd_oc.read(polarizations=[p])
mod_bls = list(omnivis.keys())
red_bls = get_reds(hd.antpos, pols=p)
red = gr.RBL(red_bls)
for mbl in mod_bls:
bl_grp = red[tuple(mbl[0:2]) + ('J{}'.format(p), )]
for blp in bl_grp:
bl = (blp[0], blp[1], p)
inds = hd.antpair2ind(bl)
omnivis_scaled = omnivis[mbl] * oc_gains[(blp[0], 'J{}'.format(
p))] * np.conj(oc_gains[(blp[1], 'J{}'.format(p))])
omnivis_scaled /= (
ac_gains[(blp[0], 'J{}'.format(p))] *
np.conj(ac_gains[(blp[1], 'J{}'.format(p))]))
resdata[bl] = abscal_data[bl] - omnivis_scaled
resflags[bl] = abscal_flags[bl]
res_data[inds, 0, :, i] = resdata[bl]
res_flags[inds, 0, :, i] = resflags[bl]
# writing to file
hd.data_array = res_data
hd.flag_array = res_flags
hd.write_uvh5(outfile, clobber=clobber)
def build_reds_hex(hexNum, sep=14.7):
antpos, i = {}, 0
for row in range(hexNum - 1, -(hexNum), -1):
for col in range(2 * hexNum - abs(row) - 1):
xPos = ((-(2 * hexNum - abs(row)) + 2) / 2.0 + col) * sep
yPos = row * sep * 3**.5 / 2
antpos[i] = np.array([xPos, yPos, 0])
i += 1
return redcal.get_reds(antpos), antpos
def test_build_eq(self):
antpos = build_linear_array(3)
reds = om.get_reds(antpos, pols=['xx'], pol_mode='1pol')
gains, true_vis, data = om.sim_red_data(reds)
info = om.RedundantCalibrator(reds)
eqs = info.build_eqs(data.keys())
self.assertEqual(len(eqs), 3)
self.assertEqual(eqs['g0x * g1x_ * u0xx'], (0, 1, 'xx'))
self.assertEqual(eqs['g1x * g2x_ * u0xx'], (1, 2, 'xx'))
self.assertEqual(eqs['g0x * g2x_ * u1xx'], (0, 2, 'xx'))
reds = om.get_reds(antpos,
pols=['xx', 'yy', 'xy', 'yx'],
pol_mode='4pol')
gains, true_vis, data = om.sim_red_data(reds)
info = om.RedundantCalibrator(reds)
eqs = info.build_eqs(data.keys())
self.assertEqual(len(eqs), 3 * 4)
self.assertEqual(eqs['g0x * g1y_ * u4xy'], (0, 1, 'xy'))
self.assertEqual(eqs['g1x * g2y_ * u4xy'], (1, 2, 'xy'))
self.assertEqual(eqs['g0x * g2y_ * u5xy'], (0, 2, 'xy'))
self.assertEqual(eqs['g0y * g1x_ * u6yx'], (0, 1, 'yx'))
self.assertEqual(eqs['g1y * g2x_ * u6yx'], (1, 2, 'yx'))
self.assertEqual(eqs['g0y * g2x_ * u7yx'], (0, 2, 'yx'))
reds = om.get_reds(antpos,
pols=['xx', 'yy', 'xy', 'yx'],
pol_mode='4pol_minV')
gains, true_vis, data = om.sim_red_data(reds)
info = om.RedundantCalibrator(reds)
eqs = info.build_eqs(data.keys())
self.assertEqual(len(eqs), 3 * 4)
self.assertEqual(eqs['g0x * g1y_ * u4xy'], (0, 1, 'xy'))
self.assertEqual(eqs['g1x * g2y_ * u4xy'], (1, 2, 'xy'))
self.assertEqual(eqs['g0x * g2y_ * u5xy'], (0, 2, 'xy'))
self.assertEqual(eqs['g0y * g1x_ * u4xy'], (0, 1, 'yx'))
self.assertEqual(eqs['g1y * g2x_ * u4xy'], (1, 2, 'yx'))
self.assertEqual(eqs['g0y * g2x_ * u5xy'], (0, 2, 'yx'))
def test_logcal(self):
NANTS = 18
antpos = build_linear_array(NANTS)
reds = om.get_reds(antpos, pols=['xx'], pol_mode='1pol')
info = om.RedundantCalibrator(reds)
gains, true_vis, d = om.sim_red_data(reds, gain_scatter=.05)
w = dict([(k, 1.) for k in d.keys()])
sol = info.logcal(d)
for i in xrange(NANTS):
self.assertEqual(sol[(i, 'x')].shape, (10, 10))
for bls in reds:
ubl = sol[bls[0]]
self.assertEqual(ubl.shape, (10, 10))
for bl in bls:
d_bl = d[bl]
mdl = sol[(bl[0], 'x')] * sol[(bl[1], 'x')].conj() * ubl
np.testing.assert_almost_equal(np.abs(d_bl), np.abs(mdl), 10)
np.testing.assert_almost_equal(np.angle(d_bl * mdl.conj()), 0,
10)
def test_solver(self):
antpos = build_linear_array(3)
reds = om.get_reds(antpos, pols=['xx'], pol_mode='1pol')
info = om.RedundantCalibrator(reds)
gains, true_vis, d = om.sim_red_data(reds)
w = {}
w = dict([(k, 1.) for k in d.keys()])
def solver(data, wgts, sparse, **kwargs):
np.testing.assert_equal(data['g0x * g1x_ * u0xx'], d[0, 1, 'xx'])
np.testing.assert_equal(data['g1x * g2x_ * u0xx'], d[1, 2, 'xx'])
np.testing.assert_equal(data['g0x * g2x_ * u1xx'], d[0, 2, 'xx'])
if len(wgts) == 0: return
np.testing.assert_equal(wgts['g0x * g1x_ * u0xx'], w[0, 1, 'xx'])
np.testing.assert_equal(wgts['g1x * g2x_ * u0xx'], w[1, 2, 'xx'])
np.testing.assert_equal(wgts['g0x * g2x_ * u1xx'], w[0, 2, 'xx'])
return
info._solver(solver, d)
info._solver(solver, d, w)
def test_omnilogcal(self):
NANTS = 18
antpos = build_linear_array(NANTS)
hcreds = om.get_reds(antpos, pols=['xx'], pol_mode='1pol')
pols = ['x']
antpos_ideal = np.array(antpos.values())
xs, ys, zs = antpos_ideal.T
layout = np.arange(len(xs))
antpos = -np.ones((NANTS * len(pols), 3))
for ant, x, y in zip(layout.flatten(), xs.flatten(), ys.flatten()):
for z, pol in enumerate(pols):
z = 2**z # exponential ensures diff xpols aren't redundant w/ each other
i = hera_cal.omni.Antpol(ant, pol, NANTS)
antpos[int(i), 0], antpos[int(i), 1], antpos[int(i), 2] = x, y, z
reds = hera_cal.omni.compute_reds(NANTS, pols, antpos[:NANTS], tol=.01)
# reds = hera_cal.omni.filter_reds(reds, **kwargs)
info = hera_cal.omni.RedundantInfo(NANTS)
info.init_from_reds(reds, antpos_ideal)
# info = om.RedundantCalibrator(reds)
# gains, true_vis, d = om.sim_red_data(hcreds, shape=SHAPE, gain_scatter=.05)
data = {}
for key in d.keys():
if not data.has_key(key[:2]):
data[key[:2]] = {}
data[key[:2]][key[-1]] = d[key].astype(np.complex64)
t0 = time.time()
for i in xrange(1):
m1, g1, v1 = omnical.calib.logcal(data, info)
# print('omnilogcal', time.time() - t0)
for i in xrange(NANTS):
self.assertEqual(g1['x'][i].shape, SHAPE)
for bls in reds:
ubl = v1['xx'][(int(bls[0][0]), int(bls[0][1]))]
self.assertEqual(ubl.shape, SHAPE)
for bl in bls:
d_bl = data[(int(bl[0]), int(bl[1]))]['xx']
mdl = g1['x'][bl[0]] * g1['x'][bl[1]].conj() * ubl
np.testing.assert_almost_equal(np.abs(d_bl), np.abs(mdl), 5)
np.testing.assert_almost_equal(np.angle(d_bl * mdl.conj()), 0, 5)
def calfits_to_flags(JD_time, cal_type, pol='ee', add_bad_ants=None):
"""Returns flags array from calfits file
:param JD_time: Fractional Julian date
:type JD_time: float, str
:param cal_type: Calibration process that produced the calfits file {"first",
"omni", "abs", "flagged_abs", "smooth_abs"}
:type cal_type: str
:param pol: Polarization of data
:type pol: str
:param add_bad_ants: Additional bad antennas
:type add_bad_ants: None, int, list, ndarray
:return: Flags array
:rtype: ndarray
"""
zen_fn = find_zen_file(JD_time)
flags_fn = find_flag_file(JD_time, cal_type)
bad_ants = get_bad_ants(zen_fn)
if add_bad_ants is not None:
bad_ants = numpy.sort(numpy.append(bad_ants,
numpy.array(add_bad_ants)))
hc = HERACal(flags_fn)
_, cal_flags, _, _ = hc.read()
hd = HERAData(zen_fn)
reds = get_reds(hd.antpos, pols=[pol])
reds = fltBad(reds, bad_ants)
redg = groupBls(reds)
antpairs = redg[:, 1:]
cflag = numpy.empty((hd.Nfreqs, hd.Ntimes, redg.shape[0]), dtype=bool)
for g in range(redg.shape[0]):
cflag[:, :, g] = cal_flags[(int(antpairs[g, 0]), 'J{}'.format(pol)) or \
(int(antpairs[g, 1]), 'J{}'.format(pol))].transpose()
return cflag
def test_lincal(self):
NANTS = 18
antpos = build_linear_array(NANTS)
reds = om.get_reds(antpos, pols=['xx'], pol_mode='1pol')
info = om.RedundantCalibrator(reds)
gains, true_vis, d = om.sim_red_data(reds, gain_scatter=.0099999)
w = dict([(k, 1.) for k in d.keys()])
sol0 = dict([(k, np.ones_like(v)) for k, v in gains.items()])
sol0.update(info.compute_ubls(d, sol0))
#sol0 = info.logcal(d)
#for k in sol0: sol0[k] += .01*capo.oqe.noise(sol0[k].shape)
meta, sol = info.lincal(d, sol0)
for i in xrange(NANTS):
self.assertEqual(sol[(i, 'x')].shape, (10, 10))
for bls in reds:
ubl = sol[bls[0]]
self.assertEqual(ubl.shape, (10, 10))
for bl in bls:
d_bl = d[bl]
mdl = sol[(bl[0], 'x')] * sol[(bl[1], 'x')].conj() * ubl
np.testing.assert_almost_equal(np.abs(d_bl), np.abs(mdl), 10)
np.testing.assert_almost_equal(np.angle(d_bl * mdl.conj()), 0,
10)
def test_logcal(self):
NANTS = 18
antpos = build_linear_array(NANTS)
reds = om.get_reds(antpos, pols=['xx'], pol_mode='1pol')
info = om.RedundantCalibrator(reds)
gains, true_vis, d = om.sim_red_data(reds, shape=SHAPE, gain_scatter=.05)
d = {key: value.astype(np.complex64) for key, value in d.items()}
w = dict([(k, 1.) for k in d.keys()])
t0 = time.time()
for i in xrange(1):
sol = info.logcal(d)
# print('logcal', time.time() - t0)
for i in xrange(NANTS):
self.assertEqual(sol[(i, 'x')].shape, SHAPE)
for bls in reds:
ubl = sol[bls[0]]
self.assertEqual(ubl.shape, SHAPE)
for bl in bls:
d_bl = d[bl]
mdl = sol[(bl[0], 'x')] * sol[(bl[1], 'x')].conj() * ubl
# np.testing.assert_almost_equal(np.abs(d_bl), np.abs(mdl), 10)
# np.testing.assert_almost_equal(np.angle(d_bl * mdl.conj()), 0, 10)
np.testing.assert_almost_equal(np.abs(d_bl), np.abs(mdl), 5)
np.testing.assert_almost_equal(np.angle(d_bl * mdl.conj()), 0, 5)
def test_omnical(self):
NANTS = 18
antpos = build_linear_array(NANTS)
reds = om.get_reds(antpos, pols=['xx'], pol_mode='1pol')
info = om.RedundantCalibrator(reds)
# gains, true_vis, d = om.sim_red_data(reds, shape=SHAPE, gain_scatter=.0099999)
# d = {key:value.astype(np.complex64) for key,value in d.items()}
w = dict([(k, 1.) for k in d.keys()])
sol0 = dict([(k, np.ones_like(v)) for k, v in gains.items()])
sol0.update(info.compute_ubls(d, sol0))
sol0 = {k: v.astype(np.complex64) for k, v in sol0.items()}
meta, sol = info.omnical(d, sol0, gain=.5, maxiter=500, check_after=30, check_every=6)
# meta, sol = info.omnical(d, sol0, gain=.5, maxiter=50, check_after=1, check_every=1)
# print(meta)
for i in xrange(NANTS):
self.assertEqual(sol[(i, 'x')].shape, SHAPE)
for bls in reds:
ubl = sol[bls[0]]
self.assertEqual(ubl.shape, SHAPE)
for bl in bls:
d_bl = d[bl]
mdl = sol[(bl[0], 'x')] * sol[(bl[1], 'x')].conj() * ubl
np.testing.assert_almost_equal(np.abs(d_bl), np.abs(mdl), 5)
np.testing.assert_almost_equal(np.angle(d_bl * mdl.conj()), 0, 5)
import numpy as np
import cPickle as cp
from hera_cal import redcal
print 'Initializing variables..'
fqs = .15 #GHz
lsts = np.pi/4
Nsim = 2**16
Nant = 37
# Setup all variables
ants = np.loadtxt('antenna_positions_37.dat')
antpos = {k:v for k,v in zip(range(37),ants)}
reds = redcal.get_reds(antpos)
subreds = [reds[0], reds[1], reds[2]]
input_gains = {}
allbl_gains = {}
subbl_gains = {}
for a in range(Nant):
input_gains[(a,'x')] = []
allbl_gains[(a,'x')] = []
subbl_gains[(a,'x')] = []
# Run simulation
print 'Starting simulation..'
for i in range(Nsim):
print i
gains, vis, data = redcal.sim_red_data(reds, shape=(1,1))
import numpy as np
import time
np.random.seed(0)
SHAPE = (10,2048)
NOISE = 1e-3
for Nants in [37, 128, 243, 350]:
ants = np.loadtxt('antenna_positions_%d.dat'%Nants)
idxs = np.arange(Nants)
antpos = {}
for k,v in zip(idxs,ants):
antpos[k] = v
reds = om.get_reds(antpos, pols=['xx'], pol_mode='1pol')
info = om.RedundantCalibrator(reds)
gains, true_vis, d = om.sim_red_data(reds, shape=SHAPE, gain_scatter=.01)
d = {key: value.astype(np.complex64) for key,value in d.items()}
d_nos = {key: value + NOISE * om.noise(value.shape) for key,value in d.items()}
d_nos = {key: value.astype(np.complex64) for key,value in d_nos.items()}
w = dict([(k, np.float32(1.)) for k in d.keys()])
sol0 = dict([(k, np.ones_like(v)) for k, v in gains.items()])
sol0.update(info.compute_ubls(d, sol0))
sol0 = {k:v.astype(np.complex64) for k,v in sol0.items()}
print('NANTS: %d'%Nants)
def test_sim_red_data(self):
antpos = build_linear_array(10)
reds = om.get_reds(antpos, pols=['xx'], pol_mode='1pol')
gains, true_vis, data = om.sim_red_data(reds)
self.assertEqual(len(gains), 10)
self.assertEqual(len(data), 45)
for bls in reds:
bl0 = bls[0]
ai, aj, pol = bl0
ans0 = data[bl0] / (gains[(ai, 'x')] * gains[(aj, 'x')].conj())
for bl in bls[1:]:
ai, aj, pol = bl
ans = data[bl] / (gains[(ai, 'x')] * gains[(aj, 'x')].conj())
np.testing.assert_almost_equal(ans0, ans, 7)
reds = om.get_reds(antpos,
pols=['xx', 'yy', 'xy', 'yx'],
pol_mode='4pol')
gains, true_vis, data = om.sim_red_data(reds)
self.assertEqual(len(gains), 20)
self.assertEqual(len(data), 4 * (45))
for bls in reds:
bl0 = bls[0]
ai, aj, pol = bl0
ans0xx = data[(
ai,
aj,
'xx',
)] / (gains[(ai, 'x')] * gains[(aj, 'x')].conj())
ans0xy = data[(
ai,
aj,
'xy',
)] / (gains[(ai, 'x')] * gains[(aj, 'y')].conj())
ans0yx = data[(
ai,
aj,
'yx',
)] / (gains[(ai, 'y')] * gains[(aj, 'x')].conj())
ans0yy = data[(
ai,
aj,
'yy',
)] / (gains[(ai, 'y')] * gains[(aj, 'y')].conj())
for bl in bls[1:]:
ai, aj, pol = bl
ans_xx = data[(
ai,
aj,
'xx',
)] / (gains[(ai, 'x')] * gains[(aj, 'x')].conj())
ans_xy = data[(
ai,
aj,
'xy',
)] / (gains[(ai, 'x')] * gains[(aj, 'y')].conj())
ans_yx = data[(
ai,
aj,
'yx',
)] / (gains[(ai, 'y')] * gains[(aj, 'x')].conj())
ans_yy = data[(
ai,
aj,
'yy',
)] / (gains[(ai, 'y')] * gains[(aj, 'y')].conj())
np.testing.assert_almost_equal(ans0xx, ans_xx, 7)
np.testing.assert_almost_equal(ans0xy, ans_xy, 7)
np.testing.assert_almost_equal(ans0yx, ans_yx, 7)
np.testing.assert_almost_equal(ans0yy, ans_yy, 7)
reds = om.get_reds(antpos,
pols=['xx', 'yy', 'xy', 'yx'],
pol_mode='4pol_minV')
gains, true_vis, data = om.sim_red_data(reds)
self.assertEqual(len(gains), 20)
self.assertEqual(len(data), 4 * (45))
for bls in reds:
bl0 = bls[0]
ai, aj, pol = bl0
ans0xx = data[(
ai,
aj,
'xx',
)] / (gains[(ai, 'x')] * gains[(aj, 'x')].conj())
ans0xy = data[(
ai,
aj,
'xy',
)] / (gains[(ai, 'x')] * gains[(aj, 'y')].conj())
ans0yx = data[(
ai,
aj,
'yx',
)] / (gains[(ai, 'y')] * gains[(aj, 'x')].conj())
ans0yy = data[(
ai,
aj,
'yy',
)] / (gains[(ai, 'y')] * gains[(aj, 'y')].conj())
np.testing.assert_almost_equal(ans0xy, ans0yx, 7)
for bl in bls[1:]:
ai, aj, pol = bl
ans_xx = data[(
ai,
aj,
'xx',
)] / (gains[(ai, 'x')] * gains[(aj, 'x')].conj())
ans_xy = data[(
ai,
aj,
'xy',
)] / (gains[(ai, 'x')] * gains[(aj, 'y')].conj())
ans_yx = data[(
ai,
aj,
'yx',
)] / (gains[(ai, 'y')] * gains[(aj, 'x')].conj())
ans_yy = data[(
ai,
aj,
'yy',
)] / (gains[(ai, 'y')] * gains[(aj, 'y')].conj())
np.testing.assert_almost_equal(ans0xx, ans_xx, 7)
np.testing.assert_almost_equal(ans0xy, ans_xy, 7)
np.testing.assert_almost_equal(ans0yx, ans_yx, 7)
np.testing.assert_almost_equal(ans0yy, ans_yy, 7)
def test_sim_red_data(self):
# Test that redundant baselines are redundant up to the gains in single pol mode
from hera_cal import redcal as om
antpos = linear_array(5)
reds = om.get_reds(antpos, pols=['nn'], pol_mode='1pol')
gains, true_vis, data = vis.sim_red_data(reds)
assert len(gains) == 5
assert len(data) == 10
for bls in reds:
bl0 = bls[0]
ai, aj, pol = bl0
ans0 = data[bl0] / (gains[(ai, 'Jnn')] * gains[(aj, 'Jnn')].conj())
for bl in bls[1:]:
ai, aj, pol = bl
ans = data[bl] / (gains[(ai, 'Jnn')] *
gains[(aj, 'Jnn')].conj())
# compare calibrated visibilities knowing the input gains
np.testing.assert_almost_equal(ans0, ans, decimal=7)
# Test that redundant baselines are redundant up to the gains in 4-pol mode
reds = om.get_reds(antpos,
pols=['xx', 'yy', 'xy', 'yx'],
pol_mode='4pol')
gains, true_vis, data = vis.sim_red_data(reds)
assert len(gains) == 2 * (5)
assert len(data) == 4 * (10)
for bls in reds:
bl0 = bls[0]
ai, aj, pol = bl0
ans0xx = data[(
ai,
aj,
'xx',
)] / (gains[(ai, 'Jxx')] * gains[(aj, 'Jxx')].conj())
ans0xy = data[(
ai,
aj,
'xy',
)] / (gains[(ai, 'Jxx')] * gains[(aj, 'Jyy')].conj())
ans0yx = data[(
ai,
aj,
'yx',
)] / (gains[(ai, 'Jyy')] * gains[(aj, 'Jxx')].conj())
ans0yy = data[(
ai,
aj,
'yy',
)] / (gains[(ai, 'Jyy')] * gains[(aj, 'Jyy')].conj())
for bl in bls[1:]:
ai, aj, pol = bl
ans_xx = data[(
ai,
aj,
'xx',
)] / (gains[(ai, 'Jxx')] * gains[(aj, 'Jxx')].conj())
ans_xy = data[(
ai,
aj,
'xy',
)] / (gains[(ai, 'Jxx')] * gains[(aj, 'Jyy')].conj())
ans_yx = data[(
ai,
aj,
'yx',
)] / (gains[(ai, 'Jyy')] * gains[(aj, 'Jxx')].conj())
ans_yy = data[(
ai,
aj,
'yy',
)] / (gains[(ai, 'Jyy')] * gains[(aj, 'Jyy')].conj())
# compare calibrated visibilities knowing the input gains
np.testing.assert_almost_equal(ans0xx, ans_xx, decimal=7)
np.testing.assert_almost_equal(ans0xy, ans_xy, decimal=7)
np.testing.assert_almost_equal(ans0yx, ans_yx, decimal=7)
np.testing.assert_almost_equal(ans0yy, ans_yy, decimal=7)
# Test that redundant baselines are redundant up to the gains in 4-pol minV mode (where
# Vxy = Vyx)
reds = om.get_reds(antpos,
pols=['xx', 'yy', 'xy', 'yX'],
pol_mode='4pol_minV')
gains, true_vis, data = vis.sim_red_data(reds)
assert len(gains) == 2 * (5)
assert len(data) == 4 * (10)
for bls in reds:
bl0 = bls[0]
ai, aj, pol = bl0
ans0xx = data[(
ai,
aj,
'xx',
)] / (gains[(ai, 'Jxx')] * gains[(aj, 'Jxx')].conj())
ans0xy = data[(
ai,
aj,
'xy',
)] / (gains[(ai, 'Jxx')] * gains[(aj, 'Jyy')].conj())
ans0yx = data[(
ai,
aj,
'yx',
)] / (gains[(ai, 'Jyy')] * gains[(aj, 'Jxx')].conj())
ans0yy = data[(
ai,
aj,
'yy',
)] / (gains[(ai, 'Jyy')] * gains[(aj, 'Jyy')].conj())
np.testing.assert_almost_equal(ans0xy, ans0yx, decimal=7)
for bl in bls[1:]:
ai, aj, pol = bl
ans_xx = data[(
ai,
aj,
'xx',
)] / (gains[(ai, 'Jxx')] * gains[(aj, 'Jxx')].conj())
ans_xy = data[(
ai,
aj,
'xy',
)] / (gains[(ai, 'Jxx')] * gains[(aj, 'Jyy')].conj())
ans_yx = data[(
ai,
aj,
'yx',
)] / (gains[(ai, 'Jyy')] * gains[(aj, 'Jxx')].conj())
ans_yy = data[(
ai,
aj,
'yy',
)] / (gains[(ai, 'Jyy')] * gains[(aj, 'Jyy')].conj())
# compare calibrated visibilities knowing the input gains
np.testing.assert_almost_equal(ans0xx, ans_xx, decimal=7)
np.testing.assert_almost_equal(ans0xy, ans_xy, decimal=7)
np.testing.assert_almost_equal(ans0yx, ans_yx, decimal=7)
np.testing.assert_almost_equal(ans0yy, ans_yy, decimal=7)
def test_lincal_hex_end_to_end_2pol_with_remove_degen_and_firstcal(self):
antpos = build_hex_array(3)
reds = om.get_reds(antpos, pols=['xx', 'yy'], pol_mode='2pol')
rc = om.RedundantCalibrator(reds)
freqs = np.linspace(.1, .2, 10)
gains, true_vis, d = om.sim_red_data(reds,
gain_scatter=.1,
shape=(1, len(freqs)))
fc_delays = {ant: 100 * np.random.randn()
for ant in gains.keys()} #in ns
fc_gains = {
ant: np.reshape(np.exp(-2.0j * np.pi * freqs * delay),
(1, len(freqs)))
for ant, delay in fc_delays.items()
}
for ant1, ant2, pol in d.keys():
d[(ant1, ant2, pol)] *= fc_gains[(ant1, pol[0])] * np.conj(
fc_gains[(ant2, pol[1])])
for ant in gains.keys():
gains[ant] *= fc_gains[ant]
w = dict([(k, 1.) for k in d.keys()])
sol0 = rc.logcal(d, sol0=fc_gains, wgts=w)
meta, sol = rc.lincal(d, sol0, wgts=w)
np.testing.assert_array_less(meta['iter'],
50 * np.ones_like(meta['iter']))
np.testing.assert_almost_equal(meta['chisq'],
np.zeros_like(meta['chisq']),
decimal=10)
np.testing.assert_almost_equal(meta['chisq'], 0, 10)
for i in xrange(len(antpos)):
self.assertEqual(sol[(i, 'x')].shape, (1, len(freqs)))
self.assertEqual(sol[(i, 'y')].shape, (1, len(freqs)))
for bls in reds:
for bl in bls:
ubl = sol[bls[0]]
self.assertEqual(ubl.shape, (1, len(freqs)))
d_bl = d[bl]
mdl = sol[(bl[0], bl[2][0])] * sol[(bl[1],
bl[2][1])].conj() * ubl
np.testing.assert_almost_equal(np.abs(d_bl), np.abs(mdl), 10)
np.testing.assert_almost_equal(np.angle(d_bl * mdl.conj()), 0,
10)
sol_rd = rc.remove_degen(antpos, sol)
ants = [key for key in sol_rd.keys() if len(key) == 2]
gainPols = np.array([ant[1] for ant in ants])
bl_pairs = [key for key in sol.keys() if len(key) == 3]
visPols = np.array([[bl[2][0], bl[2][1]] for bl in bl_pairs])
bl_vecs = np.array(
[antpos[bl_pair[0]] - antpos[bl_pair[1]] for bl_pair in bl_pairs])
gainSols = np.array([sol_rd[ant] for ant in ants])
g, v = om.get_gains_and_vis_from_sol(sol_rd)
meanSqAmplitude = np.mean([
np.abs(g[key1] * g[key2]) for key1 in g.keys()
for key2 in g.keys()
if key1[1] == 'x' and key2[1] == 'x' and key1[0] != key2[0]
],
axis=0)
np.testing.assert_almost_equal(meanSqAmplitude, 1, 10)
meanSqAmplitude = np.mean([
np.abs(g[key1] * g[key2]) for key1 in g.keys()
for key2 in g.keys()
if key1[1] == 'y' and key2[1] == 'y' and key1[0] != key2[0]
],
axis=0)
np.testing.assert_almost_equal(meanSqAmplitude, 1, 10)
#np.testing.assert_almost_equal(np.mean(np.angle(gainSols[gainPols=='x']), axis=0), 0, 10)
#np.testing.assert_almost_equal(np.mean(np.angle(gainSols[gainPols=='y']), axis=0), 0, 10)
for bls in reds:
for bl in bls:
ubl = sol_rd[bls[0]]
self.assertEqual(ubl.shape, (1, len(freqs)))
d_bl = d[bl]
mdl = sol_rd[(bl[0], bl[2][0])] * sol_rd[
(bl[1], bl[2][1])].conj() * ubl
np.testing.assert_almost_equal(np.abs(d_bl), np.abs(mdl), 10)
np.testing.assert_almost_equal(np.angle(d_bl * mdl.conj()), 0,
10)
sol_rd = rc.remove_degen(antpos, sol, degen_sol=gains)
g, v = om.get_gains_and_vis_from_sol(sol_rd)
gainSols = np.array([sol_rd[ant] for ant in ants])
degenGains = np.array([gains[ant] for ant in ants])
meanSqAmplitude = np.mean([
np.abs(g[key1] * g[key2]) for key1 in g.keys()
for key2 in g.keys()
if key1[1] == 'x' and key2[1] == 'x' and key1[0] != key2[0]
],
axis=0)
degenMeanSqAmplitude = np.mean([
np.abs(gains[key1] * gains[key2]) for key1 in g.keys()
for key2 in g.keys()
if key1[1] == 'x' and key2[1] == 'x' and key1[0] != key2[0]
],
axis=0)
np.testing.assert_almost_equal(meanSqAmplitude, degenMeanSqAmplitude,
10)
meanSqAmplitude = np.mean([
np.abs(g[key1] * g[key2]) for key1 in g.keys()
for key2 in g.keys()
if key1[1] == 'y' and key2[1] == 'y' and key1[0] != key2[0]
],
axis=0)
degenMeanSqAmplitude = np.mean([
np.abs(gains[key1] * gains[key2]) for key1 in g.keys()
for key2 in g.keys()
if key1[1] == 'y' and key2[1] == 'y' and key1[0] != key2[0]
],
axis=0)
np.testing.assert_almost_equal(meanSqAmplitude, degenMeanSqAmplitude,
10)
np.testing.assert_almost_equal(
np.mean(np.angle(gainSols[gainPols == 'x']), axis=0),
np.mean(np.angle(degenGains[gainPols == 'x']), axis=0), 10)
np.testing.assert_almost_equal(
np.mean(np.angle(gainSols[gainPols == 'y']), axis=0),
np.mean(np.angle(degenGains[gainPols == 'y']), axis=0), 10)
for key, val in sol_rd.items():
if len(key) == 2:
np.testing.assert_almost_equal(val, gains[key], 10)
if len(key) == 3:
np.testing.assert_almost_equal(val, true_vis[key], 10)