Example #1
0
def plot_haloness(skynum, kernel=exppow(), N=20.):
    
    gal_x,gal_y,gal_e1,gal_e2 = read_sky(skynum).T
    nhalo, halo_coords = read_halos(skynum)

    margin = 100
    xplot = np.linspace(min(gal_x)-margin, max(gal_x)+margin, N)
    yplot = np.linspace(min(gal_y)-margin, max(gal_y)+margin, N)
    
    X,Y = np.meshgrid(xplot,yplot)
    Z = np.zeros(X.shape)
    
    f = optsky.fwrapper(gal_x=gal_x, gal_y=gal_y, gal_e1=gal_e1, gal_e2=gal_e2, 
                        nhalo=nhalo, kernel=kernel, has_width=False)
    
    for idx, x in enumerate(xplot):
        for idy, y in enumerate(yplot):
            coords = np.array([x,y])
            Z[idy, idx] = f(coords)
    
    #plt.contourf(X, Y, Z)
    plt.pcolor(X, Y, Z)
    plt.colorbar()
    plt.hold(True)
    
    
    for ihalo in range(nhalo):
        plt.scatter(halo_coords[ihalo*2], halo_coords[ihalo*2 + 1],\
                        color='white', s=50)
        
    plt.axis((min(gal_x)-margin, max(gal_x)+margin, min(gal_y)-margin, max(gal_y)+margin))
    plt.title("Objective function value for Sky " + str(skynum))
    
    plt.show()
Example #2
0
def plot_etang_train(kernel=gaussian(1000.)):
    
    for skynum in range(1, 101):
        nhalo, halo_coords = read_halos(skynum)
        gal_x,gal_y,gal_e1,gal_e2 = read_sky(skynum).T

        assert(nhalo==1)
        
        phi = np.arctan((gal_y - halo_coords[1])/(gal_x - halo_coords[0]))
        e_tang = -(gal_e1 * np.cos(2. * phi) +
               gal_e2 * np.sin(2. * phi))
        dist = np.sqrt(np.power(gal_x - halo_coords[0], 2) + 
                       np.power(gal_y - halo_coords[1], 2))
        weight = kernel(dist)
        alpha = np.sum(weight*e_tang)/np.sum(weight*weight)
        print alpha
    
        dist_model = np.linspace(0.0, np.max(dist), 100.0)
        weight_model = kernel(dist_model)
        e_tang_model = alpha*weight_model
    
        plt.plot(dist, e_tang*(alpha*kernel(0.)), 'k.')
        plt.hold(True)
        #plt.plot(dist_model, e_tang_model, 'r-', linewidth=1.5)
    
    plt.xlabel(r'$r$', fontsize=20)
    plt.ylabel(r'$e_{\mathrm{tangential}}$', fontsize=20)
    plt.axis([0.0, np.max(dist)+100.0, -1.0, 1.0])
    plt.show()
Example #3
0
def diagnostic(Nrange, kernel=exppow()):
    
    plt.figure()
    plt.hold(True)
    
    for skynum in range(201, 231):
        nhalo, halo_coords = read_halos(skynum)
        gal_x,gal_y,gal_e1,gal_e2 = read_sky(skynum).T
        print skynum
        
        f = optsky.fwrapper(gal_x=gal_x, gal_y=gal_y, 
                            gal_e1=gal_e1, gal_e2=gal_e2,
                            nhalo=nhalo, kernel=kernel)
    
        val_true = f(halo_coords)
        
        
        val_array = np.zeros(len(Nrange))
        for ii in range(len(Nrange)):
            dm_x, dm_y, val = optsky.predict(skynum, Ngrid=Nrange[ii])
            val_array[ii] = val
            
        val_array = (val_array - val_true)/val_true
        
        plt.plot(Nrange, val_array, linewidth=0.5, color='black', linestyle='-')
        
        #plt.title('Training Sky ' + str(skynum) + ': '\
        #          + str(nhalo) + ' halos')
        plt.xlabel(r'$\mathrm{number \ of \ random \ starts}$')
        plt.ylabel(r'$\mathrm{normalized \ objective \ value}$')
      
    plt.plot(Nrange, np.zeros(len(Nrange)), linewidth=2.0, color='blue', linestyle='--')
    plt.axis('tight')
    plt.show()
Example #4
0
def plot_sky(skynum, dm_x=None, dm_y=None, test=False):    
    
    nhalo, halo_coords = read_halos(skynum, test=test)
    
    gal_x,gal_y,gal_e1,gal_e2 = read_sky(skynum, test=test).T
    n_gal = gal_x.size
    ax = plt.figure().add_subplot(1,1,1)
    ax.patch.set_facecolor('black')
    if (test):
        ax.set_title('Test Sky ' + str(skynum) + ': ' +\
                         str(n_gal) + ' galaxies, ' + str(nhalo) +\
                         ' halos')
    else:
        ax.set_title('Training Sky ' + str(skynum) + ': ' +\
                         str(n_gal) + ' galaxies, ' + str(nhalo) +\
                         ' halos')
    
    margin = 100
    ax.axis((min(gal_x)-margin, max(gal_x)+margin, 
             min(gal_y)-margin, max(gal_y)+margin))
        
    # plot galaxy centers
    ax.scatter(gal_x, gal_y, s=5, color='white')
    plt.hold(True);
    
    # plot ellipticity
    scale = 200.0; # scaling factor for ellipticity
    for igal in xrange(n_gal):
        assert(gal_e1[igal] > -1.0 and gal_e1[igal] < 1.0)
        assert(gal_e2[igal] > -1.0 and gal_e2[igal] < 1.0)
        e_mag = np.sqrt(gal_e1[igal]*gal_e1[igal] +
                           gal_e2[igal]*gal_e2[igal]);
        theta = 0.5*np.arctan2(gal_e2[igal],gal_e1[igal]);
        dx = scale*e_mag*np.cos(theta);
        dy = scale*e_mag*np.sin(theta);
        tmp_coords = np.empty((2,2))
        tmp_coords[0][0] = gal_x[igal] - dx
        tmp_coords[0][1] = gal_x[igal] + dx
        tmp_coords[1][0] = gal_y[igal] - dy
        tmp_coords[1][1] = gal_y[igal] + dy
        ax.plot(tmp_coords[0], tmp_coords[1], color='white')
                
    if (test==False):
        # plot halos        
        for ihalo in range(nhalo):
            # try to get the blurred effect...
            for ii in range(1,10):
                ax.scatter(halo_coords[ihalo], halo_coords[ihalo + nhalo],\
                               color='white', alpha=0.5-ii/20.0, s=ii*50)
            
    # plot predicted halo locations, if given
    if ((dm_x != None) | (dm_y != None)):
        assert ((dm_x != None) & (dm_y != None))
        assert ((nhalo == dm_x.size) & (nhalo == dm_y.size)) 
        
        plt.scatter(dm_x, dm_y, color="red", s=50)    

    plt.show();
Example #5
0
def plot_etang(skynum, kernel=gaussian(1000.)):
    nhalo, halo_coords = read_halos(skynum)
    gal_x,gal_y,gal_e1,gal_e2 = read_sky(skynum).T

    assert(nhalo==1)
    print halo_coords
    
    phi = np.arctan((gal_y - halo_coords[1])/(gal_x - halo_coords[0]))
    e_tang = -(gal_e1 * np.cos(2. * phi) +
               gal_e2 * np.sin(2. * phi))
    e_rad = -(gal_e1 * np.sin(2. * phi) -
              gal_e2 * np.cos(2. * phi))
    dist = np.sqrt(np.power(gal_x - halo_coords[0], 2) + 
                   np.power(gal_y - halo_coords[1], 2))
    weight = kernel(dist)
    alpha = np.sum(weight*e_tang)/np.sum(weight*weight)
    print alpha
    
    dist_model = np.linspace(0.0, np.max(dist), 100.0)
    weight_model = kernel(dist_model)
    e_tang_model = alpha*weight_model
    
    plt.figure()
    plt.plot(dist_model, e_tang_model, 'r-', linewidth=2.0)
    plt.hold(True)
    
    weight = gaussian()(dist)
    alpha = np.sum(weight*e_tang)/np.sum(weight*weight)
    
    weight_model = gaussian(1159.)(dist_model)
    e_tang_model = alpha*weight_model
    plt.plot(dist_model, e_tang_model, 'b-', linewidth=2.0)
    plt.plot(dist, e_tang, '.', color='black')
    plt.legend(['learned exponential model', 'gaussian model'])
    plt.xlabel(r'$\mathrm{radius} \ \ r$', fontsize=18)
    plt.ylabel(r'$\mathrm{tangential \ ellipticity} \ \ e_{\mathrm{tan}}$', fontsize=18)
    plt.axis([0.0, np.max(dist)+100.0, -1.0, 1.0])

    plt.figure()
    plt.plot(dist, e_rad, '.', color='black')
    plt.xlabel(r'$\mathrm{radius} \ \ r$', fontsize=18)
    plt.ylabel(r'$\mathrm{radial \ ellipticity} \ \ e_{\mathrm{rad}}$', fontsize=18)
    plt.axis([0.0, np.max(dist)+100.0, -1.0, 1.0])
    
    plt.show()
Example #6
0
def plot_likelihood(skynum, pdf=None, kernel=exppow_lim(), N=20):
    
    if (pdf == None):
        pdf = optsky.build_pdf(kernel)

    nhalo, halo_coords = read_halos(skynum)
    sky = read_sky(skynum)
    gal_x, gal_y, gal_e1, gal_e2 = sky.T

    f = optsky.fwrapper(gal_x=gal_x, gal_y=gal_y, 
                        gal_e1=gal_e1, gal_e2=gal_e2,
                        nhalo=nhalo, kernel=kernel, pdf=pdf)

    margin = 0
    xplot = np.linspace(0.0, 4200.0, N)
    yplot = np.linspace(0.0, 4200.0, N)
    
    X,Y = np.meshgrid(xplot,yplot)
    Z = np.zeros(X.shape)
    
    for idx, x in enumerate(xplot):
        for idy, y in enumerate(yplot):
            Z[idy, idx] = f(np.array([x,y]))
    
    #plt.contourf(X, Y, Z)
    plt.pcolor(X, Y, Z)
    plt.colorbar()
    plt.hold(True)
    
    nhalo, halo_coords = read_halos(skynum)
    for ihalo in range(nhalo):
        plt.scatter(halo_coords[ihalo], halo_coords[ihalo + nhalo],\
                        color='white', s=50)
        
    plt.axis((min(gal_x)-margin, max(gal_x)+margin, min(gal_y)-margin, max(gal_y)+margin))
    
    plt.show()