コード例 #1
0
def plot_components(M=np.eye(n_principal)):
    w_nf_local = M.dot(w_nf)
    x_ni_local = la.inv(M).transpose().dot(x_ni)
    for n in range(n_principal):


        sign_flip = np.sign(np.nanmedian(x_ni_local[n]))
        # sign_flip = np.sign(w_nf_local[n, np.argmax(np.abs(w_nf_local[n]))])

        plot_data_lin = x_ni_local[n] * sign_flip
        # if i == 0:
        #     plot_data = np.log10(plot_data)
        # else:
        plot_data = np.arcsinh(plot_data_lin * 1 / (np.median(np.abs(plot_data_lin))))
        try:
            hpv.mollview(plot_data, nest=True, sub=(5, n_principal, n + 1), cmap=cmap, title="%.4f"%la.norm(plot_data_lin), max=np.percentile(plot_data, 98), min=np.percentile(plot_data, 2), )
        except:
            print "NEED HEALPY PACKAGE FOR PLOTTING!"
        plt.subplot(5, n_principal, n_principal + n + 1)
        plt.plot(np.log10(freqs), sign_flip * w_nf_local[n])
        plt.plot(np.log10(freqs), sign_flip * w_nf_local[n], 'r+')
        plt.ylim([-1, 1])
        plt.subplot(5, n_principal, 2 * n_principal + n + 1)
        plt.plot(np.log10(freqs), np.log10(np.abs(w_nf_local[n] * normalization * la.norm(plot_data_lin))))
        plt.plot(np.log10(freqs), np.log10(np.abs(w_nf_local[n] * normalization * la.norm(plot_data_lin))), 'r+')
        plt.subplot(5, n_principal, 3 * n_principal + n + 1)
        plt.plot(np.log10(freqs), sign_flip * get_derivative(w_nf_local[n]))
        plt.plot(np.log10(freqs), sign_flip * get_derivative(w_nf_local[n]), 'r+')
        plt.ylim([-1, 1])
        plt.subplot(5, n_principal, 4 * n_principal + n + 1)
        plt.plot(np.log10(freqs), sign_flip * get_derivative2(w_nf_local[n]))
        plt.plot(np.log10(freqs), sign_flip * get_derivative2(w_nf_local[n]), 'r+')
        plt.ylim([-1, 1])

    plt.show()
def plot_IQU(solution, title, col, shape=(1, 1), coord='C', rescale_order=-1, min=0, max=4, nside_out=None):
    # Es=solution[np.array(final_index).tolist()].reshape((4, len(final_index)/4))
    # I = Es[0] + Es[3]
    # Q = Es[0] - Es[3]
    # U = Es[1] + Es[2]
    I = sol2map(solution, rescale_order=rescale_order)
    if nside_out != None:
        I = hpf.ud_grade(I, nside_out=nside_out, order_in='NESTED', order_out='NESTED')
    plotcoordtmp = coord
    hpv.mollview(np.log10(I), min=min, max=max, coord=plotcoordtmp, title=title, nest=True, sub=(shape[0], shape[1], col))
    if col == shape[0] * shape[1]:
        plt.show()
def plot_IQU(solution, title, col, shape=(2,3), coord='C', min=0, max=4, log=True, resize=True):
    # Es=solution[np.array(final_index).tolist()].reshape((4, len(final_index)/4))
    # I = Es[0] + Es[3]
    # Q = Es[0] - Es[3]
    # U = Es[1] + Es[2]
    I = sol2map(solution, resize=resize)
    plotcoordtmp = coord
    if log:
        hpv.mollview(np.log10(I), min=min, max=max, coord=plotcoordtmp, title=title, nest=True, sub=(shape[0], shape[1], col))
    else:
        hpv.mollview(I, min=min, max=max, coord=plotcoordtmp, title=title, nest=True, sub=(shape[0], shape[1], col))

    if col == shape[0] * shape[1]:
        plt.show()
def plot_IQU(solution, title, col, ncol=6, coord='C'):
    # Es=solution[np.array(final_index).tolist()].reshape((4, len(final_index)/4))
    # I = Es[0] + Es[3]
    # Q = Es[0] - Es[3]
    # U = Es[1] + Es[2]
    IQUV = sol2map(solution)
    IQUV.shape = (4, IQUV.shape[0] / 4)
    I = IQUV[0]
    Q = IQUV[1]
    U = IQUV[2]
    V = IQUV[3]
    pangle = 180 * np.arctan2(Q, U) / 2 / PI
    plotcoordtmp = coord
    hpv.mollview(np.log10(I), min=0, max=4, coord=plotcoordtmp, title=title, nest=True, sub=(4, ncol, col))

    hpv.mollview((Q ** 2 + U ** 2) ** .5 / I, min=0, max=1, coord=plotcoordtmp, title=title, nest=True,
                 sub=(4, ncol, ncol + col))
    from matplotlib import cm
    cool_cmap = cm.hsv
    cool_cmap.set_under("w")  # sets background to white
    hpv.mollview(pangle, min=-90, max=90, coord=plotcoordtmp, title=title, nest=True, sub=(4, ncol, 2 * ncol + col),
                 cmap=cool_cmap)

    hpv.mollview(np.arcsinh(V) / np.log(10), min=-np.arcsinh(10. ** 4) / np.log(10),
                 max=np.arcsinh(10. ** 4) / np.log(10), coord=plotcoordtmp, title=title, nest=True,
                 sub=(4, ncol, 3 * ncol + col))
    if col == ncol:
        plt.show()
コード例 #5
0
def plot_components_publication(M=np.eye(n_principal), x_ni=x_ni):
    # w_nf_local = M.dot(w_nf)
    x_ni_local = la.inv(M).transpose().dot(x_ni)
    for n in range(n_principal):

        sign_flip = np.sign(np.nanmedian(x_ni_local[n]))
        # sign_flip = np.sign(w_nf_local[n, np.argmax(np.abs(w_nf_local[n]))])

        plot_data_lin = x_ni_local[n] * sign_flip
        # if i == 0:
        #     plot_data = np.log10(plot_data)
        # else:
        plot_data = np.arcsinh(plot_data_lin * 1 / (np.median(np.abs(plot_data_lin))))
        try:
            hpv.mollview(plot_data, nest=True, sub=((n_principal + 1) / 2, 2, n + 1), cmap=cmap, title="%.4f"%la.norm(plot_data_lin), max=np.percentile(plot_data, 98), min=np.percentile(plot_data, 2), )
        except:
            print "NEED HEALPY PACKAGE FOR PLOTTING!"
    plt.show()
コード例 #6
0
def make_result_plot(all_freqs, w_nf, xbar_ni, w_estimates, normalization, tag, n_principal, show_plots, vis_freqs=None, vis_ws=None, vis_norms=None):
    fig = plt.Figure(figsize=(200, 100))
    fig.set_canvas(plt.gcf().canvas)
    plt.gcf().set_size_inches(w=10, h=5)
    for i in range(n_principal):
        cmap = cm.gist_rainbow_r
        cmap.set_under('w')
        cmap.set_bad('gray')

        sign_flip = np.sign(w_nf[i, np.argmax(np.abs(w_nf[i]))])#np.sign(xbar_ni[i, hpf.vec2pix(mother_nside, 1, 0, 0, nest=True)])

        plot_data_lin = xbar_ni[i] * sign_flip
        # if i == 0:
        #     plot_data = np.log10(plot_data)
        # else:
        plot_data = np.arcsinh(plot_data_lin * 1 / (np.median(np.abs(plot_data_lin)))) #/ np.log(10.)

        hpv.mollview(plot_data, nest=True, sub=(3, n_principal, i + 1), min=np.percentile(plot_data, 2), max=np.percentile(plot_data, 98), cmap=cmap, title='%.3e'%la.norm(plot_data_lin))

        plt.subplot(3, n_principal, i + 1 + n_principal)
        plt.plot(np.log10(all_freqs), w_nf[i] * sign_flip, 'r+')
        interp_x = np.arange(np.log10(all_freqs[0]), np.log10(all_freqs[-1]), .01)
        interp_y = w_estimates[i](interp_x)
        plt.plot(interp_x, interp_y * sign_flip, 'b-')
        if vis_freqs is not None:
            plt.plot(np.log10(vis_freqs), vis_ws[:, i] * sign_flip, 'g+')
        plt.xlim([np.log10(all_freqs[0]) - .5, np.log10(all_freqs[-1]) + .5])
        plt.ylim([-1.5, 1.5])

        plt.subplot(3, n_principal, i + 1 + 2 * n_principal)
        plt.plot(np.log10(all_freqs), np.log10(w_nf[i] * normalization * sign_flip), '+')
        if vis_freqs is not None:
            plt.plot(np.log10(vis_freqs), np.log10(vis_ws[:, i] * vis_norms * sign_flip), 'g+')
        plt.xlim([np.log10(all_freqs[0]) - .5, np.log10(all_freqs[-1]) + .5])
        plt.ylim(-5, 8)
    fig.savefig(plot_filename_base + tag + '.png', dpi=1000)
    if show_plots:
        plt.show()
    fig.clear()
    plt.gcf().clear()
コード例 #7
0
def plot_dataset(data_set):

    if len(data_set) <= 5:
        nrow = len(data_set)
        ncol = 3

    elif len(data_set) <= 10:
        nrow = (len(data_set) + 1) / 2
        ncol = 6

    else:
        nrow = (len(data_set) + 2) / 3
        ncol = 9

    iplot = 0
    for f in sorted(data_set.keys()):
        d = data_set[f]
        if d.ndim == 2:
            iplot += 1
            plot_d = np.log10(d[0])
            plot_mask = ~(np.isnan(plot_d) | np.isinf(plot_d))
            hpv.mollview(plot_d, sub=(nrow, ncol, iplot), nest=True, min=np.percentile(plot_d[plot_mask], 5), max=np.percentile(plot_d[plot_mask], 95), title="%.3fGHz I, n%i"%(f, (len(plot_d)/12)**.5))

            iplot += 1
            plot_d = pol_frac(d[0], d[1], d[2])
            plot_mask = ~(np.isnan(plot_d) | np.isinf(plot_d))
            hpv.mollview(plot_d, sub=(nrow, ncol, iplot), nest=True, min=np.percentile(plot_d[plot_mask], 5), max=np.percentile(plot_d[plot_mask], 95), title="%.3fGHz pol frac, n%i"%(f, (len(plot_d)/12)**.5))

            iplot += 1
            hpv.mollview(pol_angle(d[0], d[1], d[2]), sub=(nrow, ncol, iplot), nest=True, cmap=cm.hsv, title="%.3fGHz angle, n%i"%(f, (len(plot_d)/12)**.5))
        elif d.ndim== 1:
            iplot += 1
            plot_d = np.log10(d)
            plot_mask = ~(np.isnan(plot_d) | np.isinf(plot_d))
            hpv.mollview(plot_d, sub=(nrow, ncol, iplot), nest=True, min=np.percentile(plot_d[plot_mask], 5), max=np.percentile(plot_d[plot_mask], 95), title="%.3fGHz I, n%i"%(f, (len(plot_d)/12)**.5))
            iplot += 2
        else:
            raise ValueError("Shape problem.")
    plt.show()
コード例 #8
0
w_nf = f['w_nf']#n_principal by frequency
x_ni = f['x_ni']#n_principal by pixel
M = f['M_for_w']#np.transpose(x_ni).dot(w_nf) = np.transpose(np.transpose(la.inv(M)).dot(x_ni)).dot(M.dot(w_nf)), see line 39
freqs = f['freqs']#GHz
n_f = len(freqs)
n_principal = len(w_nf)
########################################
#embarassing fact: I have not been able to unify the units between sub-CMB, CMB, and above_CMB frequencies. If you guys know how to put those 3 into the same unit, it'll be super helpful.
normalization = f['normalization']
normalization[freqs < 20] = K_RJ2MJysr(normalization[freqs < 20], freqs[freqs < 20] * 1e9)
normalization[(freqs >= 20) & (freqs < 500)] = K_CMB2MJysr(normalization[(freqs >= 20) & (freqs < 500)], freqs[(freqs >= 20) & (freqs < 500)] * 1e9)
################################################
#plot orthogonal results
for n in range(n_principal):
    try:
        hpv.mollview(x_ni[n], nest=True, sub=(2, n_principal, n + 1))
    except:
        print "NEED HEALPY PACKAGE FOR PLOTTING!"
    plt.subplot(2, n_principal, n_principal + n + 1)
    plt.plot(np.log10(freqs), w_nf[n])
    plt.ylim([-1, 1])
plt.show()

################################################
#try jeff's preliminary M matrix
x_ni_physical = np.transpose(la.inv(M)).dot(x_ni)
w_nf_physical = M.dot(w_nf)
#check that M does not affect the product
print np.allclose(np.transpose(x_ni).dot(w_nf), np.transpose(x_ni_physical).dot(w_nf_physical))
#plot physical results
for n in range(n_principal):
            ###adding back point source for plotting:
            if ps:
                for i in range(len(point_sources)):
                    ra, dec = point_sources[i]
                    theta = np.pi / 2 - dec
                    phi = ra
                    raw_solution[hpf.ang2pix(
                        nside, theta, phi)] += raw_solution[12 * nside**2 + i]
                    w_solution[hpf.ang2pix(
                        nside, theta, phi)] += w_solution[12 * nside**2 + i]

            #plt.plot(np.abs(ev))
            #plt.show()
            hpv.mollview(equatorial_GSM_standard,
                         min=0,
                         max=5000,
                         title='Original map')
            hpv.mollview(wiener.dot(equatorial_GSM),
                         min=0,
                         max=5000,
                         title='Wienered map')
            #if nside != nside_standard:
            #hpv.mollview(equatorial_GSM, min=0,max=5000,fig=2,title='mean map')
            hpv.mollview(raw_solution[:12 * nside**2],
                         min=0,
                         max=5000,
                         title='Raw solution, rcond = %i, noise = %i' %
                         (np.log10(rcondA), np.log10(noise)))
            hpv.mollview(
                np.log10(
                    np.abs(raw_solution[:12 * nside**2] - equatorial_GSM) /
コード例 #10
0
rm1 = mod(np.angle(qudata[0] / qudata[2]) / 2, np.pi) / lambda2[0]
rm2 = mod(np.angle(qudata[1] / qudata[2]) / 2, np.pi) / lambda2[1]
def colorcode(i):
    return abs(hpf.pix2ang(mother_nside, i, nest=True)[0] - np.pi/2)/(np.pi/2)
plt.scatter(rm2, rm1, marker='+', c=[(1. - colorcode(i), .5-2*(colorcode(i) - .5)**2, colorcode(i)) for i in range(mother_npix)], label='data')

maxrm = 500.
rm_step = .5
plt.scatter(mod(np.arange(-maxrm, maxrm, rm_step), np.pi/lambda2[1]), mod(np.arange(-maxrm, maxrm, rm_step), np.pi/lambda2[0]), c=[(0, .5+.5*abs(rm)/maxrm, 0) for rm in np.arange(-maxrm, maxrm,rm_step)], label='equal RM guideline')
plt.xlim([-120, 120])
plt.legend()
plt.ylabel('Inferred RM from 1.4GHz map')
plt.xlabel('Inferred RM from 2.3GHz map')
plt.show()

hpv.mollview(np.abs(rm1-rm2), nest=True, max=10, sub=(3,1,1), title='RM diff')
hpv.mollview(np.abs(qudata[0]) / idata[0], nest=True, sub=(3,1,2), min=0, max=.2, title='1.4GHz pol fraction')
hpv.mollview(np.abs(qudata[1]) / idata[1], nest=True, sub=(3,1,3), min=0, max=.2, title='2.3GHz pol fraction')
plt.show()
####end of digression


pixel_mask = pixel_mask & ~(np.isnan(qudata).any(axis=0))

matplotlib.rcParams.update({'font.size': 25})
for n, qud in enumerate(qudata):
    hpv.mollview(np.log10(np.abs(qud)), nest=True, sub=(4, (len(qudata)+1) / 2, n + 1), title="%.1fGHz"%freqs[n])
    hpv.mollview(np.angle(qud) / 2, nest=True, sub=(4, (len(qudata)+1) / 2, (len(qudata)+1) / 2 * 2 + n + 1), cmap=cm.hsv, title="%.1fGHz"%freqs[n])
plt.show()
exclude_freqs_mask = np.array([freq in exclude_freqs for freq in freqs])
コード例 #11
0
        ###adding back point source:
        if ps:
            for i in range(len(point_sources)):
                ra, dec = point_sources[i]
                theta = np.pi/2 - dec
                phi = ra
                solution[hpf.ang2pix(nside, theta, phi)] += raw_solution[12*nside**2 + i]
                w_solution[hpf.ang2pix(nside, theta, phi)] += raw_solution[12*nside**2 + i]


        #plt.plot(np.abs(ev))
        #plt.show()
        #hpv.mollview(equatorial_GSM_standard, min=0,max=5000,fig=1,title='Original map')
        #if nside != nside_standard:
            #hpv.mollview(equatorial_GSM, min=0,max=5000,fig=2,title='mean map')
        hpv.mollview(solution, min=0,max=5000,title='Raw solution, rcond = %i, noise = %i'%(np.log10(rcondA), np.log10(noise)))
        hpv.mollview(np.log10(np.abs(solution-equatorial_GSM)/equatorial_GSM), return_projected_map=True, min=-2, max=0,title='log10(relative error), rcond = %i, noise = %i'%(np.log10(rcondA), np.log10(noise)))
        hpv.mollview(w_solution, min=0,max=5000,title='Wiener solution, rcond = %i, noise = %i'%(np.log10(rcondA), np.log10(noise)))
        hpv.mollview(np.log10(np.abs(w_solution-equatorial_GSM)/equatorial_GSM), return_projected_map=True, min=-2, max=0,title='log10(relative error wiener), rcond = %i, noise = %i'%(np.log10(rcondA), np.log10(noise)))
        #hpv.mollview(solution/B.dot(equatorial_GSM_standard), min=0, max=3, fig=4,title='sol/mean')

        print " "
plt.show()

#################################plot actual errors and such, see if adding PAPER PSA128 helps
#nPAPERUBL = 13
#A = np.concatenate((np.fromfile('/home/omniscope/simulate_visibilities/data/Amatrix__nside%i_%iby%i_redundantinfo_X5_q3x.bin'%(nside, nt*nUBL, 12*nside**2),dtype='complex64').reshape((nt*nUBL, 12*nside**2)), np.fromfile('/home/omniscope/simulate_visibilities/data/Amatrix__nside%i_%iby%i_redundantinfo_PSA128_26ba_6bu_08-15-2014.bin'%(nside, nt*nPAPERUBL, 12*nside**2),dtype='complex64').reshape((nt*nPAPERUBL, 12*nside**2))))

#hpv.mollview(equatorial_GSM, return_projected_map=True, min=0,max=5000,fig=1,title='Original map')
#vis = A.dot(equatorial_GSM)
#vis = vis + .01 * (2**-.5) * np.mean(np.abs(vis)) * (np.random.randn(len(vis)) + np.random.randn(len(vis)) * 1.j)
コード例 #12
0
while np.sum(~np.isnan(idata[~removed_mask]).any(axis=0)) < mother_npix / 20:#when no region contains all frequencies
    kick_f = coverage_order[kick_candidate]
    # kick_freq = freqs[kick_f]
    # low_coverage_data[kick_freq] = new_mother.pop(kick_freq)
    removed_mask[kick_f] = True

    kick_candidate += 1


####seperate regions before separating data##
region_indices_list, region_mask_list = find_regions(np.isnan(idata))

region_illustration = np.empty(mother_npix)
for i, mask in enumerate(region_mask_list):
    region_illustration[mask] = len(region_mask_list) - i
hpv.mollview(region_illustration, nest=True, title="Frequency Coverage Map")
plt.show()

###put kicked data into add_on, and awkwardly change idata etc to smaller set, will merge back later. doing this awkward back and forth due to unfortunate coding order...
addon_freqs = freqs[removed_mask]
addon_idata = idata[removed_mask]

freqs = freqs[~removed_mask]
idata = idata[~removed_mask]

####seperate regions##
region_indices_list, region_mask_list = find_regions(np.isnan(idata))

region_illustration = np.empty(mother_npix)
for i, mask in enumerate(region_mask_list):
    region_illustration[mask] = len(region_mask_list) - i
コード例 #13
0
	sys.stdout.flush()
	try:
		import healpy as hp
	except:
		print "Healpy package not found. Cannot convert to HEALPIX RING format."
	equatorial_GSM_standard = hp.reorder(equatorial_GSM_standard, n2r=True)
	print 'done.'
	sys.stdout.flush()

# plot GSM map
print 'Plotting GSM'
sys.stdout.flush()
if mv_format == 'Log':
	if mv_pca:
		for pca_index in range(1, pca_num+1):
			hpv.mollview(np.log10(pca_w[pca_index-1]), min=mv_min, max=mv_max, coord=mv_coord, norm=mv_cnorm, cmap=getattr(cm,mv_cmap), title='%s PCA of %iC-GSM at %.3fMHz (%s View, Unit: %s, Nside: %s, Cmap: %s, Cnorm: %s)'%(pca_index, pca_num, freq, mv_format, unit, nside_standard, mv_cmap, mv_cnorm), nest=True)
			#hpv.mollview(np.log10(globals()['pca'+ str(pca_index) +'_w']), min=mv_min, max=mv_max, coord=mv_coord, norm=mv_cnorm, cmap=getattr(cm,mv_cmap), title='%s PCA of %iC-GSM at %.3fMHz (%s View, Unit: %s, Nside: %s, Cmap: %s, Cnorm: %s)'%(pca_index, pca_num, freq, mv_format, unit, nside_standard, mv_cmap, mv_cnorm), nest=True)
			plt.savefig(script_dir + '/../Output/PCA%s_GSM_Map_%.3eghz_%.2fres_%s_%s_healpy%s_%s_%s.pdf'%(pca_index, freq, resolution, mv_format, unit, ['NEST', 'RING'][int(convert_ring)], mv_cnorm, mv_cmap))
			plt.show(block=False)
			plt.close()
	hpv.mollview(np.log10(equatorial_GSM_standard), min=mv_min, max=mv_max, coord=mv_coord, norm=mv_cnorm, cmap=getattr(cm,mv_cmap), title='%iC-GSM at %.3fMHz (%s View, Unit: %s, Nside: %s, Cmap: %s, Cnorm: %s)'%(pca_num, freq, mv_format, unit, nside_standard, mv_cmap, mv_cnorm), nest=True)
	plt.savefig(script_dir + '/../Output/%iC-GSM_Map-%.3eMHz_%sNside_%s_%s_healpy%s_%s_%s.pdf'%(pca_num, freq, nside_standard, mv_format, unit, ['NEST', 'RING'][int(convert_ring)], mv_cnorm, mv_cmap))
	plt.show()
	plt.close()
elif mv_format == 'Lin':
	if mv_pca:
		for pca_index in range(1, pca_num+1):
			hpv.mollview(pca_w[pca_index-1], min=mv_min, max=mv_max, coord=mv_coord, norm=mv_cnorm, cmap=getattr(cm,mv_cmap), title='%s PCA of %iC-GSM at %.3fMHz (%s View, Unit: %s, Nside: %s, Cmap: %s, Cnorm: %s)'%(pca_index, pca_num, freq, mv_format, unit, nside_standard, mv_cmap, mv_cnorm), nest=True)
			#hpv.mollview(globals()['pca'+ str(pca_index) +'_w'], min=mv_min, max=mv_max, coord=mv_coord, norm=mv_cnorm, cmap=getattr(cm,mv_cmap), title='%s PCA of %iC-GSM at %.3fMHz (%s View, Unit: %s, Nside: %s, Cmap: %s, Cnorm: %s)'%(pca_index, pca_num, freq, mv_format, unit, nside_standard, mv_cmap, mv_cnorm), nest=True)
			plt.savefig(script_dir + '/../Output/PCA%s_GSM_Map_%.3eghz_%.2fres_%s_%s_healpy%s_%s_%s.pdf'%(pca_index, freq, resolution, mv_format, unit, ['NEST', 'RING'][int(convert_ring)], mv_cnorm, mv_cmap))
			plt.show(block=False)
コード例 #14
0
if plot_pixelization:
    ##################################################################
    ####################################sanity check########################
    ###############################################################
    #npix = 0
    #for i in nside_distribution:
        #npix += i**2/nside_standard**2
    #print npix, len(thetas)

    stds = np.std((equatorial_GSM_standard*beam_weight).reshape(12*nside_standard**2/4,4), axis = 1)

    ##################################################################
    ####################################plotting########################
    ###############################################################
    hpv.mollview(beam_weight, min=0,max=10, coord=plotcoord, title='beam', nest=True)
    hpv.mollview(np.log10(equatorial_GSM_standard), min=-3.5,max=1.5, coord=plotcoord, title='GSM', nest=True)
    hpv.mollview(np.log10(fake_solution[np.array(final_index).tolist()]), min=-3.5,max=1.5, coord=plotcoord, title='GSM gridded', nest=True)
    hpv.mollview(np.log10(stds/abs_thresh), min=np.log10(thresh)-3, max = 3, coord=plotcoord, title='std', nest=True)
    hpv.mollview(np.log2(nside_distribution), min=np.log2(nside_start),max=np.log2(nside_standard), coord=plotcoord, title='count %i %.3f'%(len(thetas), float(len(thetas))/(12*nside_standard**2)), nest=True)
    plt.show()


##################################################################
####################compute dynamic A matrix########################
###############################################################

A = {}
for p in pols:
    pol = p+p
    #tf file
コード例 #15
0
    #plt.show()
    vis = A_standard.dot(equatorial_GSM_standard)

    vis = vis + .01 * (2**-.5) * np.mean(np.abs(vis)) * (
        np.random.randn(len(vis)) + np.random.randn(len(vis)) * 1.j)
    print vis.shape, A.shape
    sys.stdout.flush()
    solution = AtAi.dot(
        A.conjugate().transpose().dot(vis))[:12 * nside**2] / average_size**2
    #hpv.mollview(equatorial_GSM_standard, min=0,max=5000,fig=1,title='Original map')
    #hpv.mollview(equatorial_GSM, min=0,max=5000,fig=2,title='mean map')
    #hpv.mollview(solution, min=0,max=5000,fig=3,title='Our solution')
    #hpv.mollview(solution/B.dot(equatorial_GSM_standard), min=0, max=3, fig=4,title='sol/mean')
    hpv.mollview(np.log10(np.abs(solution - equatorial_GSM) / equatorial_GSM),
                 return_projected_map=True,
                 min=-2,
                 max=0,
                 title='log10(relative error)')
plt.show()

#################################plot actual errors and such, see if adding PAPER PSA128 helps
#nPAPERUBL = 13
#A = np.concatenate((np.fromfile('/home/omniscope/simulate_visibilities/data/Amatrix__nside%i_%iby%i_redundantinfo_X5_q3x.bin'%(nside, nt*nUBL, 12*nside**2),dtype='complex64').reshape((nt*nUBL, 12*nside**2)), np.fromfile('/home/omniscope/simulate_visibilities/data/Amatrix__nside%i_%iby%i_redundantinfo_PSA128_26ba_6bu_08-15-2014.bin'%(nside, nt*nPAPERUBL, 12*nside**2),dtype='complex64').reshape((nt*nPAPERUBL, 12*nside**2))))

#hpv.mollview(equatorial_GSM, return_projected_map=True, min=0,max=5000,fig=1,title='Original map')
#vis = A.dot(equatorial_GSM)
#vis = vis + .01 * (2**-.5) * np.mean(np.abs(vis)) * (np.random.randn(len(vis)) + np.random.randn(len(vis)) * 1.j)
#solution = la.pinv(A.conjugate().transpose().dot(A), rcond = 1e-10).dot(A.conjugate().transpose().dot(vis))
#hpv.mollview(solution, return_projected_map=True, min=0,max=5000,fig=2,title='Our solution')
#hpv.mollview(np.log10(np.abs(solution-equatorial_GSM)/equatorial_GSM), return_projected_map=True, min=-3, max=0,title='log10(relative error)')
#plt.show()
parkes_85[parkes_85 > parkes_header['DATAMAX']] = -parkes_header['DATAMAX']
parkes_85[parkes_85 < parkes_header['DATAMIN']] = -parkes_header['DATAMAX']
parkes_85 = sv.equirectangular2heapix(parkes_85, nside, nest=False)
parkes_85[parkes_85 <= 0] = np.nan
equ2013_to_gal_matrix = hp.rotator.Rotator(coord='cg').mat.dot(sv.epoch_transmatrix(2000, stdtime=2013.58))
ang0, ang1 = hp.rotator.rotateDirection(equ2013_to_gal_matrix, hpf.pix2ang(nside, range(12 * nside ** 2), nest=True))
parkes_85 = hpf.get_interp_val(parkes_85, ang0, ang1)

haslam = hp.ud_grade(hp.smoothing(fitsio.read("/home/omniscope/data/polarized foregrounds/haslam408_dsds_Remazeilles2014.fits")['TEMPERATURE'].flatten(), fwhm=(1 - 0.8**2)**.5 * PI/180.), nside_out=nside)
smooth_haslam = hp.ud_grade(hp.smoothing(fitsio.read("/home/omniscope/data/polarized foregrounds/haslam408_dsds_Remazeilles2014.fits")['TEMPERATURE'].flatten(), fwhm=(3.8**2 - 0.8**2)**.5 * PI/180.), nside_out=nside)
haslam = hpf.get_interp_val(haslam, ang0, ang1)
smooth_haslam = hpf.get_interp_val(smooth_haslam, ang0, ang1)

gal_lats = hpf.get_interp_val(PI/2 - hpf.pix2ang(nside, range(hpf.nside2npix(nside)))[0], ang0, ang1)

hpv.mollview(np.log10(parkes_150), nest=True, min=0, max=4, sub=(2, 2, 3), title='parkes150MHz', coord='CG')


def smoothing(m, fwhm, nest=True):
    full_map = np.ones(npix)
    full_map[total_mask] = m
    if fwhm <= 0:
        return m
    if nest:
        smoothed_map = hpf.reorder(hp.smoothing(hpf.reorder(full_map, n2r=True), fwhm=fwhm), r2n=True)
    else:
        smoothed_map = hp.smoothing(full_map, fwhm=fwhm)
    return smoothed_map[total_mask]

####GSM####
plot_IQU(fake_solution_map[total_mask], 'GSM', 4, shape=(2, 2), coord='CG')
AtNiSidata = AtNidata_sum + fake_solution_map / S_diag
combined_result = AtNiASii.dotv(AtNiSidata)

plot_IQU(combined_result, '+'.join(INSTRUMENTS) + '+GSM', 2, shape=(2, 2), coord='CG')



###parkes
parkes_150 = fit.read("/home/omniscope/data/polarized foregrounds/parkes_150mhz.bin")[0]
parkes_150[:, :-1] = np.roll(parkes_150[:, :-1], 180, axis=1)[:, ::-1]
parkes_150[:, -1] = parkes_150[:, 0]
parkes_150[parkes_150 > 7.e3] = -1e-9
parkes_150[parkes_150 <= 0] = -1e-9
parkes_150 = sv.equirectangular2heapix(parkes_150, nside_standard)
parkes_150[parkes_150 <= 0] = np.nan
hpv.mollview(np.log10(parkes_150), nest=True, min=0, max=4, sub=(2, 2, 3), title='parkes150MHz')

####GSM####
plot_IQU(fake_solution_map, 'GSM', 4, shape=(2, 2), coord='CG')






clean = False
if clean:#take abt 10 min, not quite working. ringing seems not caused by wiener filter??

    bright_pt_mask = np.abs(result/sizes) > np.percentile(np.abs(result/sizes), 99)
    bright_pt_indices = np.arange(valid_npix)[bright_pt_mask]
    psf = AtNiAi.dotM(AtNiA_sum.dot(np.eye(valid_npix, dtype='float64')[:, bright_pt_mask]))
コード例 #18
0
def plot_jones(beam_heal_equ):
    import matplotlib.pyplot as plt
    for i, ibeam_heal_equ in enumerate(beam_heal_equ):
        hpv.mollview(np.abs(ibeam_heal_equ), sub=(len(beam_heal_equ), 4, 1 + 4 * i))
        PI = np.pi
        TPI = np.pi * 2
        # hpv.mollview((np.angle(ibeam_heal_equ) - np.angle(beam_heal_equ[0]) + PI) % TPI - PI, sub=(len(beam_heal_equ), 2, 2 + 2 * i), min=-PI, max=PI)
        hpv.mollview((np.angle(ibeam_heal_equ) + PI) % TPI - PI, sub=(len(beam_heal_equ), 4, 2 + 4 * i), min=-PI, max=PI)
        hpv.mollview(np.real(ibeam_heal_equ), sub=(len(beam_heal_equ), 4, 3 + 4 * i))
        hpv.mollview(np.imag(ibeam_heal_equ), sub=(len(beam_heal_equ), 4, 4 + 4 * i))
    plt.show()

    hpv.mollview(np.abs(beam_heal_equ[0])**2 + np.abs(beam_heal_equ[1])**2, sub=(2,1,1))
    hpv.mollview(np.abs(beam_heal_equ[2])**2 + np.abs(beam_heal_equ[3])**2, sub=(2,1,2))
    plt.show()
コード例 #19
0
#low_f
low_f_principals = np.array([0, 2])
low_f_mask = np.array([f in [5, 8] for f in range(len(freqso))])#np.array([(f in low_f_file['freqs']) and (f <= 20) for f in freqso])
low_f_data = low_f_file['idata'][np.array([f in freqso[low_f_mask] for f in low_f_file['freqs']])] / np.load(result_filename)['normalization'][low_f_mask][:, None]

A = np.transpose(final_w_nf)[np.ix_(low_f_mask, low_f_principals)]
b = low_f_data - [hp.reorder(hp.smoothing(hp.reorder(d, n2r=True), fwhm=low_res), r2n=True) for d in high_res_fit[low_f_mask]]
high_res_x_ni[low_f_principals] = la.inv(np.transpose(A).dot(A)).dot(A.transpose().dot(b))

#plot all components
for i in range(n_principal):
    qaz = np.copy(high_res_x_ni[i])
    qaz /= la.norm(qaz)
    if i == cmb_principal:
        hpv.mollview(qaz, sub=(3, 2, i+1), nest=True, min=np.percentile(qaz, 1), max=np.percentile(qaz, 99))
    else:
        if i <= 2:
            dy_range = 1
        else:
            dy_range = 2
        qaz *= np.sign(np.median(high_res_x_ni[i]))

        qaz[qaz < np.percentile(qaz, 98) / 10**dy_range] = np.percentile(qaz, 98) / 10**dy_range
        qaz = np.log10(qaz)
        hpv.mollview(qaz, sub=(3, 2, i+1), nest=True, min=np.ceil(np.percentile(qaz, 98))-dy_range, max=np.ceil(np.percentile(qaz, 98)), cmap=cmap, title=labels[i])
plt.show()

w_estimates = si.interp1d(np.log10(freqso), np.arcsinh(final_w_nf * normalizationo), axis=-1, bounds_error=False)
sys.exit(0)
###########
コード例 #20
0
# Do the plotting
plt.figure(figsize=(6, 6))
if args.projection == 'orthographic':
    visufunc.orthview(dust_map,
                      rot=(0, -55, 180),
                      norm='log',
                      coord='GC',
                      half_sky=True,
                      notext=True,
                      cbar=False,
                      title='')
elif args.projection == 'mollweide':
    visufunc.mollview(dust_map,
                      norm='log',
                      coord='GC',
                      notext=True,
                      cbar=False,
                      title='')

visufunc.graticule(15, 360 / 12)
for survey in args.surveys:
    visufunc.projplot(ra[survey],
                      dec[survey],
                      survey_colors[survey],
                      lonlat=True,
                      label=survey_names[survey])

if args.show_coords:
    visufunc.projtext(0,
                      -45,
                      '$-45^\circ$',
コード例 #21
0
    sys.stdout.flush()
    AtAi.astype('complex64').tofile('/home/omniscope/data/GSM_data/ABtABi_%iubl_nside%i_to_nside%i_%iby%i_redundantinfo_X5_q3x.bin'%(nUBL, nside_standard, nside, nt_standard*nUBL, 12*nside_standard**2))

    #plt.imshow(np.abs(AtAi.dot(A.transpose().conjugate().dot(A))))
    #plt.show()
    vis = A_standard.dot(equatorial_GSM_standard)

    vis = vis + .01 * (2**-.5) * np.mean(np.abs(vis)) * (np.random.randn(len(vis)) + np.random.randn(len(vis)) * 1.j)
    print vis.shape, A.shape
    sys.stdout.flush()
    solution = AtAi.dot(A.conjugate().transpose().dot(vis))[:12*nside**2]/average_size**2
    #hpv.mollview(equatorial_GSM_standard, min=0,max=5000,fig=1,title='Original map')
    #hpv.mollview(equatorial_GSM, min=0,max=5000,fig=2,title='mean map')
    #hpv.mollview(solution, min=0,max=5000,fig=3,title='Our solution')
    #hpv.mollview(solution/B.dot(equatorial_GSM_standard), min=0, max=3, fig=4,title='sol/mean')
    hpv.mollview(np.log10(np.abs(solution-equatorial_GSM)/equatorial_GSM), return_projected_map=True, min=-2, max=0,title='log10(relative error)')
plt.show()

#################################plot actual errors and such, see if adding PAPER PSA128 helps
#nPAPERUBL = 13
#A = np.concatenate((np.fromfile('/home/omniscope/simulate_visibilities/data/Amatrix__nside%i_%iby%i_redundantinfo_X5_q3x.bin'%(nside, nt*nUBL, 12*nside**2),dtype='complex64').reshape((nt*nUBL, 12*nside**2)), np.fromfile('/home/omniscope/simulate_visibilities/data/Amatrix__nside%i_%iby%i_redundantinfo_PSA128_26ba_6bu_08-15-2014.bin'%(nside, nt*nPAPERUBL, 12*nside**2),dtype='complex64').reshape((nt*nPAPERUBL, 12*nside**2))))

#hpv.mollview(equatorial_GSM, return_projected_map=True, min=0,max=5000,fig=1,title='Original map')
#vis = A.dot(equatorial_GSM)
#vis = vis + .01 * (2**-.5) * np.mean(np.abs(vis)) * (np.random.randn(len(vis)) + np.random.randn(len(vis)) * 1.j)
#solution = la.pinv(A.conjugate().transpose().dot(A), rcond = 1e-10).dot(A.conjugate().transpose().dot(vis))
#hpv.mollview(solution, return_projected_map=True, min=0,max=5000,fig=2,title='Our solution')
#hpv.mollview(np.log10(np.abs(solution-equatorial_GSM)/equatorial_GSM), return_projected_map=True, min=-3, max=0,title='log10(relative error)')
#plt.show()

###################################investigate eigen values
コード例 #22
0
##################################################################
####################################sanity check########################
###############################################################
# npix = 0
# for i in nside_distribution:
# npix += i**2/nside_standard**2
# print npix, len(thetas)

stds = np.std((equatorial_GSM_standard).reshape(12 * nside_standard ** 2 / 4, 4), axis=1)

##################################################################
####################################plotting########################
###############################################################
with warnings.catch_warnings():
    warnings.filterwarnings("ignore", category=RuntimeWarning)
    hpv.mollview(np.log10(equatorial_GSM_standard), min=0, max=4, coord=plotcoord, title='GSM', nest=True)
    hpv.mollview(np.log10(sol2map(fake_solution)), min=0, max=4, coord=plotcoord,
                 title='GSM gridded', nest=True)
    hpv.mollview(np.log10(stds / abs_thresh), min=np.log10(thresh) - 3, max=3, coord=plotcoord, title='std',
                 nest=True)
    hpv.mollview(np.log2(nside_distribution), min=np.log2(nside_start), max=np.log2(nside_standard),
                 coord=plotcoord,
                 title='count %i %.3f' % (len(thetas), float(len(thetas)) / (12 * nside_standard ** 2)), nest=True)


for instrument, lat in zip(instruments, lats):
    above_horizon_mask = np.abs(thetas - (PI / 2 - lat * PI / 180.)) < PI / 2
    sub_valid_npix = np.sum(above_horizon_mask)
    sub_valid_pix_mask = np.copy(valid_pix_mask)
    sub_valid_pix_mask[sub_valid_pix_mask] = above_horizon_mask
    np.savez(datadir + 'pixel_scheme_%i.npz'%sub_valid_npix, gsm=fake_solution_map[above_horizon_mask], thetas=thetas[above_horizon_mask], phis=phis[above_horizon_mask], sizes=sizes[above_horizon_mask], nside_distribution=nside_distribution, final_index=final_index, n_fullsky_pix=npix, valid_pix_mask=sub_valid_pix_mask, thresh=thresh, parent_valid_npix = valid_npix, child_mask=above_horizon_mask)#thresh is in there for idiotic reason  due to unneccessary inclusion of thresh in A filename
コード例 #23
0
    ###############################################################
    #npix = 0
    #for i in nside_distribution:
    #npix += i**2/nside_standard**2
    #print npix, len(thetas)

    stds = np.std((equatorial_GSM_standard * beam_weight).reshape(
        12 * nside_standard**2 / 4, 4),
                  axis=1)

    ##################################################################
    ####################################plotting########################
    ###############################################################
    hpv.mollview(beam_weight,
                 min=0,
                 max=10,
                 coord=plotcoord,
                 title='beam',
                 nest=True)
    hpv.mollview(np.log10(equatorial_GSM_standard),
                 min=-3.5,
                 max=1.5,
                 coord=plotcoord,
                 title='GSM',
                 nest=True)
    hpv.mollview(np.log10(fake_solution[np.array(final_index).tolist()]),
                 min=-3.5,
                 max=1.5,
                 coord=plotcoord,
                 title='GSM gridded',
                 nest=True)
    hpv.mollview(np.log10(stds / abs_thresh),
コード例 #24
0
            estimated_removal = get_estimated_idata(w_nf, normalization, xbar_ni_rm1, original_freqs[rm_f])
            for l, lat_mask in enumerate(latitude_masks):
                estimation_error = (np.nansum((removed_idata - estimated_removal)[lat_mask&~point_source_mask]**2) / np.nansum(removed_idata[lat_mask&~point_source_mask]**2))**.5
                pseudo_estimation_errors[l].append(estimation_error)

        import matplotlib
        matplotlib.rcParams.update({'font.size': 25})
        for plot_i, logfreq in enumerate(np.arange(-1.7, 4., .03)):
            if logfreq < 0:
                title = '%.1f MHz'%(1e3 * 10**logfreq)
            elif logfreq < 3:
                title = '%.1f GHz'%(10**logfreq)
            else:
                title = '%.1f THz'%(1e-3 * 10**logfreq)
            pltdata = np.arcsinh(np.transpose(xbar_ni).dot([w_estimates[i](logfreq) for i in range(n_principal)]) / np.percentile(np.abs(np.transpose(xbar_ni).dot([w_estimates[i](logfreq) for i in range(n_principal)])), .2))
            hpv.mollview(pltdata, nest=True, title=title, min=np.percentile(pltdata, 1), max=np.percentile(pltdata, 99), cbar=False)
            plt.savefig('/home/omniscope/gif_dir/%04i.png'%plot_i)
            plt.clf()

def cplot(x, y, fmt, mksize, fillstyle='none'):
    for a, b, msize in zip(x, y, mksize):
        plt.plot(a, b, fmt, markersize=msize, fillstyle=fillstyle)

for i in range(1 + n_latitude_regions):
    plt.subplot(1, 1 + n_latitude_regions, i+1)
    
    mksize = (400. * np.sum(~np.isnan(original_idata), axis=-1) / mother_npix)**.5
    plt.plot(np.log10(original_freqs), systematic_errors[i], 'b-', label='systematic error')
    cplot(np.log10(original_freqs), systematic_errors[i], 'bo', mksize)
    plt.plot(np.log10(original_freqs), pseudo_estimation_errors[i], 'g-', label='pseudo estimation error')
    cplot(np.log10(original_freqs), pseudo_estimation_errors[i], 'go', mksize)
コード例 #25
0
               2) / float(len(data) - np.sum(pix_mask))
print "Memory usage: %.3fMB" % (
    resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1000)
sys.stdout.flush()
chisq_sim = np.sum(Ni * np.abs(A.dot(sim_sol[pix_mask]) - sim_data)**
                   2) / float(len(sim_data) - np.sum(pix_mask))
print "Memory usage: %.3fMB" % (
    resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1000)
sys.stdout.flush()

print "chi^2:", chisq, chisq_sim

if False:
    hpv.mollview(equatorial_GSM_standard,
                 min=0,
                 max=5000,
                 coord='CG',
                 title='GSM')
    hpv.mollview(w_GSM, min=0, max=5000, coord='CG', title='wiener GSM')
    hpv.mollview(x,
                 min=0,
                 max=5000,
                 coord='CG',
                 title='raw solution, chi^2=%.2f' % chisq)
    hpv.mollview(w_solution,
                 min=0,
                 max=5000,
                 coord='CG',
                 title='wiener solution')
    hpv.mollview(sim_sol,
                 min=0,
            #plt.colorbar()
            #plt.show()

            ###adding back point source for plotting:
            if ps:
                for i in range(len(point_sources)):
                    ra, dec = point_sources[i]
                    theta = np.pi/2 - dec
                    phi = ra
                    raw_solution[hpf.ang2pix(nside, theta, phi)] += raw_solution[12*nside**2 + i]
                    w_solution[hpf.ang2pix(nside, theta, phi)] += w_solution[12*nside**2 + i]


            #plt.plot(np.abs(ev))
            #plt.show()
            hpv.mollview(equatorial_GSM_standard, min=0,max=5000,title='Original map')
            hpv.mollview(wiener.dot(equatorial_GSM), min=0,max=5000,title='Wienered map')
            #if nside != nside_standard:
                #hpv.mollview(equatorial_GSM, min=0,max=5000,fig=2,title='mean map')
            hpv.mollview(raw_solution[:12*nside**2], min=0,max=5000,title='Raw solution, rcond = %i, noise = %i'%(np.log10(rcondA), np.log10(noise)))
            hpv.mollview(np.log10(np.abs(raw_solution[:12*nside**2]-equatorial_GSM)/equatorial_GSM), return_projected_map=False, min=-3, max=0,title='log10(relative error), rcond = %i, noise = %i'%(np.log10(rcondA), np.log10(noise)))
            hpv.mollview(w_solution[:12*nside**2], min=0,max=5000, title='Wiener solution, rcond = %i, noise = %i'%(np.log10(rcondA), np.log10(noise)))
            hpv.mollview(np.log10(np.abs(w_solution[:12*nside**2]-equatorial_GSM)/equatorial_GSM), return_projected_map=False, min=-3, max=0,title='log10(relative error wiener to input), rcond = %i, rcondSN = %i, noise = %i'%(np.log10(rcondA), np.log10(rcondSN), np.log10(noise)))

            hpv.mollview(np.log10(np.abs(w_solution[:12*nside**2]-wiener.dot(equatorial_GSM))/wiener.dot(equatorial_GSM)), return_projected_map=False, min=-3, max=0,title='log10(relative error wiener to W_input), rcond = %i, rcondSN = %i, noise = %i'%(np.log10(rcondA), np.log10(rcondSN), np.log10(noise)))
            #hpv.mollview(solution/B.dot(equatorial_GSM_standard), min=0, max=3, fig=4,title='sol/mean')

            print " "
plt.show()

#################################plot actual errors and such, see if adding PAPER PSA128 helps
コード例 #27
0
sys.stdout.flush()
A = np.fromfile(A_filename, dtype='float32').reshape((len(data), npix))
print "Memory usage: %.3fMB"%(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1000)
sys.stdout.flush()

chisq = np.sum(Ni * np.abs(A.dot(x[pix_mask]) - data)**2)/float(len(data) - np.sum(pix_mask))
print "Memory usage: %.3fMB"%(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1000)
sys.stdout.flush()
chisq_sim = np.sum(Ni * np.abs(A.dot(sim_sol[pix_mask]) - sim_data)**2)/float(len(sim_data) - np.sum(pix_mask))
print "Memory usage: %.3fMB"%(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1000)
sys.stdout.flush()

print "chi^2:", chisq, chisq_sim

if False:
    hpv.mollview(equatorial_GSM_standard, min=0,max=5000, coord='CG', title='GSM')
    hpv.mollview(w_GSM, min=0,max=5000, coord='CG', title='wiener GSM')
    hpv.mollview(x, min=0,max=5000, coord='CG', title='raw solution, chi^2=%.2f'%chisq)
    hpv.mollview(w_solution, min=0,max=5000, coord='CG', title='wiener solution')
    hpv.mollview(sim_sol, min=0,max=5000, coord='CG', title='simulated noisy solution, chi^2=%.2f'%chisq_sim)
    hpv.mollview(w_sim_sol, min=0,max=5000, coord='CG', title='simulated wiener noisy solution')
else:
    #hpv.mollview(np.log10(gsm_standard), min=0,max=4, coord='G', title='GSM')
    hpv.mollview(np.log10(equatorial_GSM_standard), min=0,max=4, coord=plotcoord, title='GSM')
    hpv.mollview(np.log10(w_GSM), min=0,max=4, coord=plotcoord, title='wiener GSM')
    hpv.mollview(np.log10(x), min=0,max=4, coord=plotcoord, title='raw solution, chi^2=%.2f'%chisq)
    hpv.mollview(np.log10(w_solution), min=0,max=4, coord=plotcoord, title='wiener solution')
    hpv.mollview(np.log10(np.abs(w_solution)), min=0,max=4, coord=plotcoord, title='abs wiener solution')
    hpv.mollview(np.log10(sim_sol), min=0,max=4, coord=plotcoord, title='simulated noisy solution, chi^2=%.2f'%chisq_sim)
    hpv.mollview(np.log10(w_sim_sol), min=0,max=4, coord=plotcoord, title='simulated wiener noisy solution')
plt.show()
    ##################################################################
    ####################################sanity check########################
    ###############################################################
    # npix = 0
    # for i in nside_distribution:
    # npix += i**2/nside_standard**2
    # print npix, len(thetas)

    stds = np.std((equatorial_GSM_standard * beam_weight).reshape(12 * nside_standard ** 2 / 4, 4), axis=1)

    ##################################################################
    ####################################plotting########################
    ###############################################################
    with warnings.catch_warnings():
        warnings.filterwarnings("ignore", category=RuntimeWarning)
        hpv.mollview(beam_weight, min=0, max=4, coord=plotcoord, title='beam', nest=True)
        hpv.mollview(np.log10(equatorial_GSM_standard), min=0, max=4, coord=plotcoord, title='GSM', nest=True)
        hpv.mollview(np.log10(sol2map(fake_solution)[:len(equatorial_GSM_standard)]), min=0, max=4, coord=plotcoord,
                     title='GSM gridded', nest=True)
        hpv.mollview(np.log10(stds / abs_thresh), min=np.log10(thresh) - 3, max=3, coord=plotcoord, title='std',
                     nest=True)
        hpv.mollview(np.log2(nside_distribution), min=np.log2(nside_start), max=np.log2(nside_standard),
                     coord=plotcoord,
                     title='count %i %.3f' % (len(thetas), float(len(thetas)) / (12 * nside_standard ** 2)), nest=True)
    plt.show()


##################################################################
####################compute dynamic A matrix########################
###############################################################
コード例 #29
0
if plot_pixelization:
    ##################################################################
    ####################################sanity check########################
    ###############################################################
    #npix = 0
    #for i in nside_distribution:
        #npix += i**2/nside_standard**2
    #print npix, len(thetas)

    stds = np.std((equatorial_GSM_standard*beam_weight).reshape(12*nside_standard**2/4,4), axis = 1)

    ##################################################################
    ####################################plotting########################
    ###############################################################
    hpv.mollview(beam_weight, min=0,max=10, coord=plotcoord, title='beam', nest=True)
    hpv.mollview(np.log10(equatorial_GSM_standard), min=-3.5,max=1.5, coord=plotcoord, title='GSM', nest=True)
    hpv.mollview(np.log10(fake_solution[np.array(final_index).tolist()]), min=-3.5,max=1.5, coord=plotcoord, title='GSM gridded', nest=True)
    hpv.mollview(np.log10(stds/abs_thresh), min=np.log10(thresh)-3, max = 3, coord=plotcoord, title='std', nest=True)
    hpv.mollview(np.log2(nside_distribution), min=np.log2(nside_start),max=np.log2(nside_standard), coord=plotcoord, title='count %i %.3f'%(len(thetas), float(len(thetas))/(12*nside_standard**2)), nest=True)
    plt.show()

quit()
##################################################################
####################compute dynamic A matrix########################
###############################################################

A = {}
for p in pols:
    pol = p+p
    #tf file
コード例 #30
0
    ev, _ = la.eigh(A.conjugate().transpose().dot(A))
    maxev = np.max(np.abs(ev))
    AtAi = la.pinv(A.conjugate().transpose().dot(A) + maxev * rcondA * np.identity(len(A[0])))#, rcond=rcondA)
    print "Done."
    sys.stdout.flush()
    AtAi.astype('complex64').tofile('/home/omniscope/data/GSM_data/ABtABi_%iubl_nside%i_to_nside%i_%iby%i_redundantinfo_X5_q3x.bin'%(nUBL, nside_standard, nside, len(AtAi), len(AtAi[0])))

    #plt.imshow(np.abs(AtAi.dot(A.transpose().conjugate().dot(A))))
    #plt.show()
    vis = A_standard.dot(equatorial_GSM_standard)

    vis = vis + .01 * (2**-.5) * np.mean(np.abs(vis)) * (np.random.randn(len(vis)) + np.random.randn(len(vis)) * 1.j)
    print vis.shape, A.shape
    sys.stdout.flush()
    solution = AtAi.dot(A.conjugate().transpose().dot(vis))[:12*nside**2]/average_size**2
    hpv.mollview(equatorial_GSM_standard, min=0,max=5000,fig=1,title='Original map')
    hpv.mollview(equatorial_GSM, min=0,max=5000,fig=2,title='mean map')
    hpv.mollview(solution, min=0,max=5000,fig=3,title='Our solution')
    #hpv.mollview(solution/B.dot(equatorial_GSM_standard), min=0, max=3, fig=4,title='sol/mean')
    hpv.mollview(np.log10(np.abs(solution-equatorial_GSM)/equatorial_GSM), return_projected_map=True, min=-2, max=0,title='log10(relative error)')
plt.show()

#################################plot actual errors and such, see if adding PAPER PSA128 helps
#nPAPERUBL = 13
#A = np.concatenate((np.fromfile('/home/omniscope/simulate_visibilities/data/Amatrix__nside%i_%iby%i_redundantinfo_X5_q3x.bin'%(nside, nt*nUBL, 12*nside**2),dtype='complex64').reshape((nt*nUBL, 12*nside**2)), np.fromfile('/home/omniscope/simulate_visibilities/data/Amatrix__nside%i_%iby%i_redundantinfo_PSA128_26ba_6bu_08-15-2014.bin'%(nside, nt*nPAPERUBL, 12*nside**2),dtype='complex64').reshape((nt*nPAPERUBL, 12*nside**2))))

#hpv.mollview(equatorial_GSM, return_projected_map=True, min=0,max=5000,fig=1,title='Original map')
#vis = A.dot(equatorial_GSM)
#vis = vis + .01 * (2**-.5) * np.mean(np.abs(vis)) * (np.random.randn(len(vis)) + np.random.randn(len(vis)) * 1.j)
#solution = la.pinv(A.conjugate().transpose().dot(A), rcond = 1e-10).dot(A.conjugate().transpose().dot(vis))
#hpv.mollview(solution, return_projected_map=True, min=0,max=5000,fig=2,title='Our solution')