pCs[s] = ds.p_hat(MC, qC)
ds.set_iC(save_iC)
# XXX deal with diff w for k1,k2
pC = np.array(
[pCs[sums[k1][i]][:, i] for i in xrange(ds.w[k1].shape[1])]).T
else:
qC = ds.q_hat(k1, k2)
FC = ds.get_F(k1, k2)
MC, WC = ds.get_MW(FC, mode='F^-1/2')
pC = ds.p_hat(MC, qC)
return pC * scalar
data_g, wgt_g = {}, {}
for k in data:
lst_g, data_g[k], wgt_g[k] = oqe.lst_grid(lsts[k[0]], data[k])
################################
ds = oqe.DataSet(data_g, wgt_g)
set_C(3e-6)
#pI,pW,pC = get_p(ks[0],ks[1])
for cnt, k in enumerate(ks):
plt.subplot(NK, 1, cnt + 1)
capo.plot.waterfall(ds.x[k], drng=3)
plt.colorbar()
plt.show()
# for cnt,k in enumerate(ks):
# plt.subplot(NK,1,cnt+1)
# pC = get_p(k,k,'C')
FC = ds.get_F(k1,k2)
MC,WC = ds.get_MW(FC, mode='F^-1/2')
pCs[s] = ds.p_hat(MC,qC)
ds.set_iC(save_iC)
# XXX deal with diff w for k1,k2
pC = np.array([pCs[sums[k1][i]][:,i] for i in xrange(ds.w[k1].shape[1])]).T
else:
qC = ds.q_hat(k1,k2)
FC = ds.get_F(k1,k2)
MC,WC = ds.get_MW(FC, mode='F^-1/2')
pC = ds.p_hat(MC,qC)
return pC * scalar
data_g, wgt_g = {},{}
for k in data:
lst_g,data_g[k],wgt_g[k] = oqe.lst_grid(lsts[k[0]],data[k])
################################
ds = oqe.DataSet(data_g, wgt_g)
set_C(3e-6)
#pI,pW,pC = get_p(ks[0],ks[1])
for cnt,k in enumerate(ks):
plt.subplot(NK,1,cnt+1)
capo.plot.waterfall(ds.x[k], drng=3)
plt.colorbar()
plt.show()
for cnt,k in enumerate(ks):
plt.subplot(NK,1,cnt+1)
pC = get_p(k,k,'C')
flg_dict[key] = n.logical_not(flg)
conj_dict[key[1]] = conj[bl]
keys = data_dict.keys()
bls_master = []
for key in keys: #populate list of baselines
if key[0] == keys[0][0]: bls_master.append(key[1])
print 'Baselines:', len(bls_master)
#import IPython; IPython.embed()
#Align and create dataset
ds = oqe.DataSet(lmode=LMODE)
if opts.lbins:
#import IPython; IPython.embed()
lsts_dict = lsts
for k in data_dict.keys():
#print 'gridding lst for', k
data_dict[k],flg_dict[k],lsts = oqe.lst_grid(lsts_dict[k[0]], data_dict[k], wgts=flg_dict[k], lstbins=opts.lbins)
else:
#import IPython; IPython.embed()
if not EQUIV:
lststemp = lsts[lsts.keys()[0]]
dshift = int(DelT/(lststemp[1]-lststemp[0]))
print 'shifting by ', dshift
#import IPython; IPython.embed()
data_dict,flg_dict, lsts = oqe.lst_shift(sep_avail, sepd_avail, data_dict, flg_dict, lsts, dshift)
#import IPython; IPython.embed()
inds = oqe.lst_align(lsts)
data_dict,flg_dict,lsts = oqe.lst_align_data(inds,dsets=data_dict,wgts=flg_dict,lsts=lsts)
#the lsts given is a dictionary with 'even','odd', etc., but the lsts returned is one array
#import IPython; IPython.embed()
#If data is replaced by noise
#<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
#inds = oqe.lst_align(lsts, lstres=lst_res)
#data,wgts = oqe.lst_align_data(inds, dsets=data, wgts=wgts)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# for s in sets: chisqs[s] = chisqs[s][ind[s]].T
########################################################################
ks = [(s, 'xx', bl) for bl in SEPS for s in sets]
NK = len(ks)
data_gt, wgt_gt = {}, {}
nlst = 2400
for k in data:
lst_g, data_gt[k], wgt_gt[k] = oqe.lst_grid(lsts[k[0]],
data[k],
lstbins=nlst)
data_gt[k], wgt_gt[k] = data_gt[k][nlst / 3:nlst * 4 /
5], wgt_gt[k][nlst / 3:nlst * 4 / 5]
#wgt_gt[k] = np.where(wgt_gt[k]>0.5*np.max(wgt_gt[k]),1,0)
lst_g = lst_g[nlst / 3:nlst * 4 / 5]
set1, set2 = 'even', 'odd'
def is_odd(num):
return num & 0x1
data_g, wgt_g = {}, {}
for bl in SEPS:
conj_dict[key[1]] = conj[bl]
keys = data_dict.keys()
bls_master = []
for key in keys: #populate list of baselines
if key[0] == keys[0][0]: bls_master.append(key[1])
print 'Baselines:', len(bls_master)
#import IPython; IPython.embed()
#Align and create dataset
ds = oqe.DataSet(lmode=LMODE)
if opts.lbins:
#import IPython; IPython.embed()
lsts_dict = lsts
for k in data_dict.keys():
#print 'gridding lst for', k
data_dict[k], flg_dict[k], lsts = oqe.lst_grid(lsts_dict[k[0]],
data_dict[k],
wgts=flg_dict[k],
lstbins=opts.lbins)
else:
#import IPython; IPython.embed()
if not EQUIV:
lststemp = lsts[lsts.keys()[0]]
dshift = int(DelT / (lststemp[1] - lststemp[0]))
print 'shifting by ', dshift
#import IPython; IPython.embed()
data_dict, flg_dict, lsts = oqe.lst_shift(sep_avail, sepd_avail,
data_dict, flg_dict, lsts,
dshift)
#import IPython; IPython.embed()
inds = oqe.lst_align(lsts)
data_dict, flg_dict, lsts = oqe.lst_align_data(inds,
dsets=data_dict,
[pCs[sums[k1][i]][:, i] for i in xrange(ds.w[k1].shape[1])]).T
else:
#pr.enable()
qC = ds.q_hat(k1, k2, cov_flagging=True)
FC = ds.get_F(k1, k2, cov_flagging=True)
MC, WC = ds.get_MW(FC, mode='F^-1/2')
pC = ds.p_hat(MC, qC)
#pr.disable()
#pr.print_stats(sort='time')
return pC * scalar
data_g, wgt_g = {}, {}
for k in data:
lst_g, data_g[k], wgt_g[k] = oqe.lst_grid(lsts[k[0]],
data[k],
lstbins=1500)
data_g[k], wgt_g[k] = data_g[k][550:1200], wgt_g[k][550:1200]
# lst_g,data_g[k],wgt_g[k] = oqe.lst_grid(lsts[k[0]],data[k],lstbins=6000)
# data_g[k], wgt_g[k] = data_g[k][2200:5000], wgt_g[k][2200:5000]
wgt_g[k] = np.where(wgt_g[k] > 0.5 * np.max(wgt_g[k]), 1, 0)
k1, k2 = data.keys()
data_g[('mean', 'xx', (0, 103))] = (data_g[k1] + data_g[k2]) / 2
wgt_g[('mean', 'xx', (0, 103))] = (wgt_g[k1] + wgt_g[k2]) / 2
################################
#import IPython; IPython.embed()
#import IPython; IPython.embed()
# def lst_align(lsts1,lsts2,lstres,offset=0):
# i=0
# if lsts1[0]+offset>lsts2[0]:
#inds = oqe.lst_align(lsts, lstres=lst_res)
#data,wgts = oqe.lst_align_data(inds, dsets=data, wgts=wgts)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# for s in sets: chisqs[s] = chisqs[s][ind[s]].T
########################################################################
ks = [(s,'xx',bl) for bl in SEPS for s in sets]
NK = len(ks)
data_gt, wgt_gt = {},{}
nlst = 2400
for k in data:
lst_g,data_gt[k],wgt_gt[k] = oqe.lst_grid(lsts[k[0]],data[k],lstbins=nlst)
data_gt[k], wgt_gt[k] = data_gt[k][nlst/3:nlst*4/5], wgt_gt[k][nlst/3:nlst*4/5]
#wgt_gt[k] = np.where(wgt_gt[k]>0.5*np.max(wgt_gt[k]),1,0)
lst_g = lst_g[nlst/3:nlst*4/5]
set1,set2 = 'even', 'odd'
def is_odd(num):
return num & 0x1
data_g, wgt_g = {},{}
for bl in SEPS:
k1 = ('odd','xx',bl)
k2 = ('even','xx',bl)
for k in data_gt.keys():
if is_odd(int(k[0])) and k[1]==k1[1] and k[2]==k1[2]: #i.e. k satisfies k1
ds.set_iC(save_iC)
# XXX deal with diff w for k1,k2
pC = np.array([pCs[sums[k1][i]][:,i] for i in xrange(ds.w[k1].shape[1])]).T
else:
#pr.enable()
qC = ds.q_hat(k1,k2,cov_flagging=True)
FC = ds.get_F(k1,k2,cov_flagging=True)
MC,WC = ds.get_MW(FC, mode='F^-1/2')
pC = ds.p_hat(MC,qC)
#pr.disable()
#pr.print_stats(sort='time')
return pC * scalar
data_g, wgt_g = {},{}
for k in data:
lst_g,data_g[k],wgt_g[k] = oqe.lst_grid(lsts[k[0]],data[k],lstbins=1500)
data_g[k], wgt_g[k] = data_g[k][550:1200], wgt_g[k][550:1200]
# lst_g,data_g[k],wgt_g[k] = oqe.lst_grid(lsts[k[0]],data[k],lstbins=6000)
# data_g[k], wgt_g[k] = data_g[k][2200:5000], wgt_g[k][2200:5000]
wgt_g[k] = np.where(wgt_g[k]>0.5*np.max(wgt_g[k]),1,0)
k1, k2 = data.keys()
data_g[('mean','xx',(0,103))] = (data_g[k1]+data_g[k2])/2
wgt_g[('mean','xx',(0,103))] = (wgt_g[k1]+wgt_g[k2])/2
################################
#import IPython; IPython.embed()
#import IPython; IPython.embed()
# def lst_align(lsts1,lsts2,lstres,offset=0):
# i=0
# if lsts1[0]+offset>lsts2[0]:
# while lsts1[0]+offset>lsts2[i]: i += 1