Exemplo n.º 1
0
    def plot_masserr(self, filename):
        import pcolors
        data=eu.io.read(filename)
        nr200 = data.size
        nb = data['B'][0].size

        plt = FramedPlot()
        colors = pcolors.rainbow(nr200, 'hex')
        clist = []
        for ri in xrange(nr200):
            r200 = data['r200'][ri]
            m200 = data['m200'][ri]

            p = Points(data['B'][ri], (m200-data['m200meas'][ri])/m200, 
                       type='filled circle', color=colors[ri])
            crv = Curve(data['B'][ri], (m200-data['m200meas'][ri])/m200, 
                        color=colors[ri])
            crv.label = 'r200: %0.2f' % r200
            clist.append(crv)
            plt.add(p,crv)

        key = PlotKey(0.1,0.4,clist)
        plt.add(key)
        plt.xlabel=r'$\Omega_m \sigma_8^2 D(z)^2 b(M,z)$'
        plt.ylabel = r'$(M_{200}^{true}-M)/M_{200}^{true}$'

        epsfile = filename.replace('.rec','.eps')
        print 'writing eps:',epsfile
        plt.write_eps(eu.ostools.expand_path(epsfile))
Exemplo n.º 2
0
    def doplot(self):
        tab = Table(2, 1)
        tab.title = self.title

        xfit, yfit, gprior = self.get_prior_vals()

        nrand = 100000
        binsize = self.binsize
        h = self.h
        h1 = self.h1
        h2 = self.h2

        g1rand, g2rand = gprior.sample2d(nrand)
        grand = gprior.sample1d(nrand)

        hrand = histogram(grand, binsize=binsize, min=0.0, max=1.0, more=True)
        h1rand = histogram(g1rand, binsize=binsize, min=-1.0, max=1.0, more=True)

        fbinsize = xfit[1] - xfit[0]
        hrand["hist"] = hrand["hist"] * float(yfit.sum()) / hrand["hist"].sum() * fbinsize / binsize
        h1rand["hist"] = h1rand["hist"] * float(h1["hist"].sum()) / h1rand["hist"].sum()

        pltboth = FramedPlot()
        pltboth.xlabel = r"$g$"

        hplt1 = Histogram(h1["hist"], x0=h1["low"][0], binsize=binsize, color="red")
        hplt2 = Histogram(h2["hist"], x0=h2["low"][0], binsize=binsize, color="blue")
        hpltrand = Histogram(hrand["hist"], x0=hrand["low"][0], binsize=binsize, color="magenta")
        hplt1rand = Histogram(h1rand["hist"], x0=h1rand["low"][0], binsize=binsize, color="magenta")

        hplt1.label = r"$g_1$"
        hplt2.label = r"$g_2$"
        hplt1rand.label = "rand"
        hpltrand.label = "rand"
        keyboth = PlotKey(0.9, 0.9, [hplt1, hplt2, hplt1rand], halign="right")

        pltboth.add(hplt1, hplt2, hplt1rand, keyboth)
        tab[0, 0] = pltboth

        plt = FramedPlot()
        plt.xlabel = r"$|g|$"

        hplt = Histogram(h["hist"], x0=h["low"][0], binsize=binsize)
        hplt.label = "|g|"

        line = Curve(xfit, yfit, color="blue")
        line.label = "model"

        key = PlotKey(0.9, 0.9, [hplt, line, hpltrand], halign="right")
        plt.add(line, hplt, hpltrand, key)

        tab[1, 0] = plt

        if self.show:
            tab.show()

        return tab
Exemplo n.º 3
0
    def plot_ellip_vs_input(self, show=False):
        '''
        Plot the measured ellip as a function of the input for sigma_index=0
        which is a reasonably large object
        '''
        import biggles
        from biggles import PlotLabel,FramedPlot,Table,Curve,PlotKey,Points
        from pcolors import rainbow
        import pprint

        data = self.read()
        w=where1(data['sigma_index'] == 10)
        data = data[w]
        
        e1_input, e2_input, Tinput = util.mom2ellip(data['Irr_input'],
                                                    data['Irc_input'],
                                                    data['Icc_input'])
        e1_meas, e2_meas, Tinput = util.mom2ellip(data['Irr_meas'],
                                                  data['Irc_meas'],
                                                  data['Icc_meas'])

        einput = sqrt(e1_input**2 + e2_input**2)
        emeas = sqrt(e1_meas**2 + e2_meas**2)

        plt=FramedPlot()

        p = Points(einput,emeas, type='filled circle')
        plt.add(p)
        plt.xlabel=r'$\epsilon_{in}$'
        plt.ylabel=r'$\epsilon_{meas}$'

        sig=sqrt((data['Irr_meas'][0]+data['Icc_meas'][0])/2)
        lab1=PlotLabel(0.1,0.9,self.model, halign='left')
        lab2=PlotLabel(0.1,0.8,r'$\sigma: %0.2f$' % sig, halign='left')
        plt.add(lab1,lab2)


        einput.sort()
        c = Curve(einput, einput, color='red')
        c.label = r'$\epsilon_{input} = \epsilon_{meas}$'
        key=PlotKey(0.95,0.07,[c], halign='right')
        plt.add(c)
        plt.add(key)
        if show:
            plt.show()

        epsfile=self.epsfile('ellip-vs-input')
        print("Writing eps file:",epsfile)
        plt.write_eps(epsfile)
Exemplo n.º 4
0
def test_xi_converge_nplk(epsfile=None):
    """
    Test how xi converges with the number of k points per log10(k)
    Note we should test other convergence factors too!
    """

    tab=Table(2,1) 
    pltbig = FramedPlot()
    pltzoom = FramedPlot()

    pltbig.xlabel='r'
    pltbig.ylabel='xi(r)'
    pltbig.xlog=True
    pltbig.ylog=True
    pltzoom.xlabel='r'
    pltzoom.ylabel='xi(r)'

    l=Linear()
    r=10.0**linspace(0.0,2.3,1000) 
    nplk_vals  = [20,60,100,140,160]
    color_vals = ['blue','skyblue','green','orange','magenta','red']

    plist=[]
    lw=2.4
    for nplk,color in zip(nplk_vals,color_vals):
        print 'nplk:',nplk
        xi =  l.xi(r, nplk=nplk)

        limxi = where(xi < 1.e-5, 1.e-5, xi)
        climxi = Curve(r,limxi,color=color,linewidth=lw)
        climxi.label = 'nplk: %i' % nplk
        pltbig.add(climxi)

        plist.append(climxi)

        w=where1(r > 50.0)
        cxi = Curve(r[w], xi[w], color=color, linewidth=lw)
        pltzoom.add(cxi)

    key = PlotKey(0.7,0.8, plist)
    pltzoom.add(key)
    tab[0,0] = pltbig
    tab[1,0] = pltzoom
    if epsfile is not None:
        tab.write_eps(epsfile)
    else:
        tab.show()
Exemplo n.º 5
0
    def plot_size_vs_input(self, show=False):
        '''
        Plot recovered size vs input for ellip=0, which is ellip_index=0
        '''

        import biggles
        from biggles import PlotLabel,FramedPlot,Table,Curve,PlotKey,Points
        from pcolors import rainbow
        import pprint

        data = self.read()
        w=where1(data['ellip_index'] == 0)
        data = data[w]

        siginput = sqrt(data['Irr_input'])
        sigmeas  = sqrt(data['Irr_meas'])


        pars=numpy.polyfit(siginput, sigmeas, 1)
        print("offset:",pars[1])
        print("slope: ",pars[0])
        print("IGNORING OFFSET")

        plt=FramedPlot()

        p = Points(siginput,sigmeas, type='filled circle')
        plt.add(p)
        plt.xlabel=r'$\sigma_{in}$'
        plt.ylabel=r'$\sigma_{meas}$'

        lab=PlotLabel(0.1,0.9,self.model)
        plt.add(lab)

        yfit2=pars[0]*siginput
        cfit2=Curve(siginput, yfit2, color='steel blue')
        cfit2.label = r'$%0.2f \sigma_{in}$' % pars[0]

        plt.add( cfit2 )

        key=PlotKey(0.95,0.07,[cfit2], halign='right')
        plt.add(key)
        if show:
            plt.show()

        epsfile=self.epsfile('size-vs-input')
        print("Writing eps file:",epsfile)
        plt.write_eps(epsfile)
Exemplo n.º 6
0
    def _draw_background(self, context):
        pc = _PlotComposite()

        nl = self.ribs_l
        b = _series(-90 // 2, 90 // 2, 2 * math.pi / 180.)
        for l0 in _series(-nl, nl, math.pi / nl):
            c = Curve([l0] * len(b), b, **self.ribs_style)
            #c = apply( Curve, ([l0]*len(b), b), self.ribs_style )
            pc.add(c)

        nb = self.ribs_b
        l = _series(-180 // 2, 180 // 2, 2 * math.pi / 180.)
        for b0 in _series(-nb, nb, 0.5 * math.pi / (nb + 1)):
            c = Curve(l, [b0] * len(l), **self.ribs_style)
            #c = apply( Curve, (l, [b0]*len(l)), self.ribs_style )
            pc.add(c)

        pc.render(context)
Exemplo n.º 7
0
    def plot_T(self, k, T, Tc=None, Tb=None):
        from biggles import FramedPlot, Curve, PlotKey

        plt=FramedPlot()

        c=Curve(k, T**2)
        c.label = '$T^2$'
        plt.add(c)
        plist = [c]

        if Tc is not None:
            cc=Curve(k,Tc**2,color='blue')
            cc.label = '$Tc^2$'
            plt.add(cc)
            plist.append(cc)

        if Tb is not None:
            tmp = where(Tb < 1.e-5, 1.e-5, Tb)
            cb=Curve(k,tmp**2,color='red')
            cb.label = '$Tb^2$'
            plt.add(cb)
            plist.append(cb)

        plt.xlog=True
        plt.ylog=True
        plt.ylabel = '$T^2'
        plt.xlabel = 'k'
        plt.yrange = [1.e-8,1.0]
        plt.aspect_ratio=1

        if Tc is not None or Tb is not None:
            key=PlotKey(0.1,0.9,plist)
            plt.add(key)

        plt.show()
Exemplo n.º 8
0
    def test(self, relerr=0.2,dowrite=False, epsfile=None):
        omega_m=0.25
        z = 0.3
        nfw = lensing.nfw.NFW(omega_m, z)
        lin = lensing.linear.Linear(omega_m=omega_m)

        r200=0.5
        c=5.0
        B=1.0

        print 'generating fake data with %i%% errors' % (relerr*100,)
        nr = 21
        logrmin=-2.0
        logrmax=1.5
        r = logspace(logrmin,logrmax,nr)
        ds = nfw.dsig(r,r200,c) + B*lin.dsig(r)
        dserr = ds*relerr
        ds += dserr*numpy.random.standard_normal(nr)

        if dowrite:
            f='~/tmp/fake-dsig.dat'
            print 'Writing fake data to:',f
            colprint(r,ds,dserr,format='%0.8f', file=f)

        print 'generating fine grid truth values'
        rtrue = logspace(logrmin,logrmax,nr*5)
        dstrue  = nfw.dsig(rtrue,r200,c) + B*lin.dsig(rtrue)
        drhotrue = nfw.rho(rtrue,r200,c)  + B*lin.drho(rtrue)
        # add linear term
        mnfw = nfw.m(rtrue, r200,c)
        mlin = lin.m(rtrue, B)
        mtrue = mnfw + mlin

        print 'Doing inversion'
        odict = self.invert(r,ds,dserr=dserr)

        tab = Table(2,2)

        od = lensing.plotting.plot_dsig(odict, noshow=True)

        # show some log-interpolated points of dsig
        nper = 10
        for i in xrange(nr-1):
            amp = odict['ds_amp'][i]
            slope = odict['ds_slope'][i]
            off = odict['ds_offset'][i]
            x = logspace(log10(r[i]),log10(r[i+1]),nper)
            y = amp*x**(-slope) - off
            od['plt'].add(Curve(x,y,color='blue'))

        od['plt'].add(Curve(rtrue,dstrue,color='red'))
        tab[0,0] = od['plt']

        # plot uncorrected with no error bar
        rod = lensing.plotting.plot_drho(r=odict['rdrho'],
                                         drho=odict['drho_noendc'],
                                         drhoerr=odict['drhoerr']*0,
                                         noshow=True)
        rod2 = lensing.plotting.add_to_log_plot(rod['plt'],
                                                odict['rdrho'],
                                                odict['drho'],
                                                odict['drhoerr'],
                                                color='blue')
        
        pnocorr = rod['p']
        p = rod2['p']
        pnocorr.label = 'no end correction'
        p.label = 'end correction'

        plist = [pnocorr,p]
        drhotrue_curve = Curve(rtrue,drhotrue,color='red')
        drhotrue_curve.label = 'Truth'
        rod['plt'].add(drhotrue_curve)
        plist.append(drhotrue_curve)

        rod['plt'].add(PlotKey(0.1,0.2,plist))


        tab[0,1] = rod['plt']



        # for the mass stuff
        # first show log-interpolated points of drho to see how
        # it looks

        rod_interp = lensing.plotting.plot_drho(odict, noshow=True)
        nper = 10
        for i in xrange(odict['drho'].size-1):
            amp = odict['drho_amp'][i]
            slope = odict['drho_slope'][i]
            off = odict['drho_offset'][i]
            x = logspace(log10(r[i]),log10(r[i+1]),nper)
            y = amp*x**(-slope) - off
            y = where(y < 1.e-5, 1.e-5, y)
            rod_interp['plt'].add(Curve(x,y,color='blue'))

        tab[1,0] = rod_interp['plt']
       
        mod = lensing.plotting.plot_mass(odict, noshow=True)
        
        mp = mod['p']
        mp.label = 'Recovered Mass'

        nfw_curve = Curve(rtrue,mnfw,color='green')
        nfw_curve.label = 'NFW'
        mod['plt'].add(nfw_curve)

        lin_curve = Curve(rtrue,mlin,color='orange')
        lin_curve.label = 'linear'
        mod['plt'].add(lin_curve)

        true_curve = Curve(rtrue,mtrue,color='magenta')
        true_curve.label = 'True'
        mod['plt'].add(true_curve)

        #m200 = nfw.m200(r200)
        #m200p = Points([r200],[m200],type='cross',color='blue')
        #m200p.label = r'$M_{200} true'

        #mod['plt'].add(m200p)

        # now find r200 from the mass profile
        #mvf = MvirFinder(omega_m, z, 200)
        #rvir,rvir_err,mvir,mvir_err = mvf.find_mvir(odict['rmass'],
        #                                            odict['mass'],
        #                                            odict['masserr'])

        #mvp = Points([rvir],[mvir],type='filled square',color='red')
        #mvexp = SymErrX([rvir],[mvir],[rvir_err],color='red')
        #mveyp = SymErrY([rvir],[mvir],[mvir_err],color='red')
        #mvp.label = r'$M_{200}'

        #mod['plt'].add(mvp,mvexp,mveyp)

        #mod['plt'].add(PlotKey(0.1,0.9,[mp,true_curve,nfw_curve,lin_curve,
        #                                m200p,mvp]))
        mod['plt'].add(PlotKey(0.1,0.9,[mp,true_curve,nfw_curve,lin_curve]))


        tab[1,1] = mod['plt']


        if dowrite:
            f='~/tmp/fake-dsig-invert.dat'
            print 'Writing inverted fake data to:',f
            colprint(odict['rdrho'], odict['drho'],odict['mass'],odict['masserr'],
                     format='%20.8e',file=f)

        if epsfile is not None:
            print 'Writing eps file:',epsfile
            tab.write_eps(epsfile)
        else:
            tab.show()
Exemplo n.º 9
0
    def plot(self, odict, epsfile=None, show=True, overdrho=True):
        """
        odict is the output of invert()
        """

        tab = Table(2,2)
        od = lensing.plotting.plot_dsig(odict, noshow=True)
        # show some log-interpolated points of dsig
        nper = 10
        r = odict['r']
        for i in xrange(r.size-1):
            amp = odict['ds_amp'][i]
            slope = odict['ds_slope'][i]
            off = odict['ds_offset'][i]
            x = logspace(log10(r[i]),log10(r[i+1]),nper)
            y = amp*x**(-slope) - off
            od['plt'].add(Curve(x,y,color='blue'))

        tab[0,0] = od['plt']

        # plot uncorrected with no error bar
        rod = lensing.plotting.plot_drho(r=odict['rdrho'],
                                         drho=odict['drho_noendc'],
                                         drhoerr=odict['drhoerr']*0,
                                         noshow=True)
        rod2 = lensing.plotting.add_to_log_plot(rod['plt'],
                                                odict['rdrho'],
                                                odict['drho'],
                                                odict['drhoerr'],
                                                color='blue')
        pnocorr = rod['p']
        p = rod2['p']
        pnocorr.label = 'no end correction'
        p.label = 'end correction'

        rod['plt'].add(PlotKey(0.1,0.2,[pnocorr,p]))
        tab[0,1] = rod['plt']


        # for the mass stuff
        # first show log-interpolated points of drho to see how
        # it looks

        rod_interp = lensing.plotting.plot_drho(odict, noshow=True)
        nper = 10
        for i in xrange(odict['drho'].size-1):
            amp = odict['drho_amp'][i]
            slope = odict['drho_slope'][i]
            off = odict['drho_offset'][i]
            x = logspace(log10(r[i]),log10(r[i+1]),nper)
            y = amp*x**(-slope) - off
            y = where(y < 1.e-5, 1.e-5, y)
            rod_interp['plt'].add(Curve(x,y,color='blue'))

        tab[1,0] = rod_interp['plt']
       

        mod = lensing.plotting.plot_mass(odict, noshow=True)
        mp = mod['p']
        mp.label = 'Mass Avg'

        odin=lensing.plotting.add_to_log_plot(mod['plt'], 
                                              odict['rmass'], 
                                              odict['massin'], 
                                              odict['massinerr'],
                                              color='green', type='filled diamond')
        pin = odin['p']
        pin.label = 'Mass In'
        mod['plt'].add(pin)

        odout=lensing.plotting.add_to_log_plot(mod['plt'], 
                                               odict['rmass'], 
                                               odict['massout'], 
                                               odict['massouterr'],
                                               color='magenta', type='filled diamond')
        
        pout = odout['p']
        pout.label = 'Mass Out'

        rhoc0 = 0.27752
        mdel = (4./3.)*PI*200*rhoc0*1.e12*odict['rmass']**3

        pdel = Curve(odict['rmass'],mdel,color='blue')
        pdel.label = r'$200 \rho_{c} V$'
        mod['plt'].add(pdel)
        mod['plt'].add(PlotKey(0.1,0.9,[mp,pin,pout,pdel]))

        tab[1,1] = mod['plt']


        if epsfile is not None:
            print 'Writing to epsfile:',epsfile
            tab.write_eps(epsfile)
        if show:
            tab.show()
Exemplo n.º 10
0
Arquivo: fit.py Projeto: esheldon/espy
def test_fit_nfw_lin_dsig(rmin=0.01):

    from biggles import FramedPlot,Points,SymmetricErrorBarsY,Curve,PlotKey
    omega_m=0.25
    z=0.25


    r200 = 1.0
    c = 5.0
    B=10.0

    rmax = 50.0
    log_rmin = log10(rmin)
    log_rmax = log10(rmax)
    npts = 30
    r = 10.0**linspace(log_rmin,log_rmax,npts)

    fitter = NFWBiasFitter(omega_m,z,r)
    ds = fitter.dsig(r, r200, c, B)
    # 10% errors
    dserr = 0.1*ds
    ds += dserr*numpy.random.standard_normal(ds.size)

    guess = numpy.array([r200,c,B],dtype='f8')
    # add 10% error to the guess
    guess += 0.1*guess*numpy.random.standard_normal(guess.size)

    res = fitter.fit(ds,dserr,guess, more=True)

    r200_fit=res['r200']
    r200_err = res['r200_err']
    c_fit=res['c']
    c_err = res['c_err']
    B_fit=res['B']
    B_err = res['B_err']


    print 'Truth:'
    print '    r200: %f' % r200
    print '       c: %f' % c
    print '       B: %f' % B
    print 'r200_fit: %f +/- %f' % (r200_fit,r200_err)
    print '   c_fit: %f +/- %f' % (c_fit,c_err)
    print '   B_fit: %f +/- %f' % (B_fit,B_err)
    print 'Cov:'
    print res['cov']

 
    rfine = 10.0**linspace(log_rmin,log_rmax,100)
    fitter2 = NFWBiasFitter(omega_m,z,rfine)

    yfit = fitter2.dsig(rfine, r200_fit, c_fit, B_fit)
    yfit_nfw = fitter2.nfw.dsig(rfine, r200_fit, c_fit)
    yfit_lin = fitter2.lin_dsig(rfine,B_fit)

    plt=FramedPlot()
    plt.add(Points(r,ds,type='filled circle'))
    plt.add(SymmetricErrorBarsY(r,ds,dserr))

    cyfit = Curve(rfine,yfit,color='blue')
    cyfit_nfw = Curve(rfine,yfit_nfw,color='red')
    cyfit_lin = Curve(rfine,yfit_lin,color='orange')

    cyfit.label = 'Best Fit'
    cyfit_nfw.label = 'NFW'
    cyfit_lin.label = 'linear'

    key=PlotKey(0.1,0.3,[cyfit,cyfit_nfw,cyfit_lin])
    plt.add(cyfit,cyfit_nfw,cyfit_lin,key)

    plt.xlabel = r'$r$ [$h^{-1}$ Mpc]'
    plt.ylabel = r'$\Delta\Sigma ~ [M_{sun} pc^{-2}]$'

    plt.xrange = [0.5*rmin, 1.5*rmax]
    plt.yrange = [0.5*(ds-dserr).min(), 1.5*(ds+dserr).max()]

    plt.xlog=True
    plt.ylog=True
    plt.show()
Exemplo n.º 11
0
    def test_scinv_npts(self, nplot, show=False, reload=False, type="png"):
        """

        Test accuracy as a function of the numer of points used in the
        integration.


        """

        dzl = 0.015
        zlmin = 0.02
        zlmax = 0.6

        from biggles import Points, FramedPlot, PlotKey, Table, Histogram, Curve
        from time import time
        import lensing
        import pcolors

        if self.data is None or reload:
            self.load_example_data()

        # this is old ScinvCalculator, need to make work
        # with new one
        scalc1000 = ScinvCalculator(self.zs, dzl, zlmin, zlmax, npts=1000)

        nptsvals = [100, 200, 300, 400, 500, 600, 700, 800, 900]
        numcheck = len(nptsvals)
        # colors=['black','magenta','blue','green','orange','red']
        colors = pcolors.rainbow(len(nptsvals), "hex")
        scalc = []
        for npts in nptsvals:
            scalc.append(ScinvCalculator(self.zs, dzl, zlmin, zlmax, npts=npts))

        times = numpy.zeros(numcheck, dtype="f8")
        time1000 = 0.0

        # we'll fill this in
        scinv_all = numpy.zeros((numcheck, scalc1000.zlvals.size))

        xlim = [0, scalc1000.zsvals.max()]
        for i in xrange(nplot):
            pz = self.data["pofz"][i]

            print("Doing 1000...", end="")

            tm0 = time()
            scinv1000 = scalc1000.calc_mean_scinv(pz)
            time1000 += time() - tm0

            print("done")

            for j in xrange(numcheck):
                npts = nptsvals[j]
                print("%d " % npts, end="")
                tm0 = time()
                scinv_all[j, :] = scalc[j].calc_mean_scinv(pz)
                times[j] += time() - tm0

            print("\nplotting")

            # plot the p(z)
            tab = Table(3, 1)

            binsize = scalc1000.zsvals[1] - scalc1000.zsvals[0]
            pzh = Histogram(pz, x0=scalc1000.zsvals[0], binsize=binsize)
            plt_pzh = FramedPlot()
            plt_pzh.xrange = xlim

            plt_pzh.xtitle = r"$z_s$"
            plt_pzh.ytitle = r"$P(z_s)$"
            plt_pzh.add(pzh)
            tab[0, 0] = plt_pzh

            # plot scinv for each npts value
            plt_scinv = FramedPlot()
            plt_scinv.xrange = xlim

            scinv_plots = []
            for j in xrange(numcheck):
                npts = nptsvals[j]
                p = Curve(scalc[j].zlvals, scinv_all[j, :], type="solid", color=colors[j])
                p.label = "npts: %d" % npts

                plt_scinv.add(p)
                scinv_plots.append(p)

            scinv_key = PlotKey(0.95, 0.9, scinv_plots, halign="right")
            plt_scinv.add(scinv_key)

            plt_scinv.ylabel = r"$\langle \Sigma_{crit}^{-1}(z_{lens}) \rangle$"
            plt_scinv.xlabel = r"$z_{lens}$"
            plt_scinv.yrange = [0, 2.1e-4]

            tab[1, 0] = plt_scinv

            # ratio to 1000 points

            plt_rat = FramedPlot()
            plt_rat.xrange = xlim
            plt_rat.yrange = [1 - 1.0e-2, 1 + 1.0e-2]
            rat_plots = []
            for j in xrange(numcheck):
                npts = nptsvals[j]
                w = where1(scinv1000 > 0)
                ratio = scinv_all[j, w] / scinv1000[w]
                # ratio=scinv_all[j,:]/scinv1000[:]

                p = Curve(scalc[j].zlvals[w], ratio, type="solid", color=colors[j])
                p.label = "npts: %d" % npts

                plt_rat.add(p)
                rat_plots.append(p)

            key = PlotKey(0.95, 0.9, rat_plots, halign="right")
            plt_rat.add(key)

            plt_rat.ylabel = r"$\langle \Sigma_{crit}^{-1} \rangle / \langle \Sigma_{crit}^{-1} \rangle_{1000}$"
            plt_rat.xlabel = r"$z_{lens}$"

            tab[2, 0] = plt_rat

            if show:
                tab.show()

            plotfile = self.npts_plot_file(i, type)
            print("writing to file:", plotfile)
            if type == "png":
                tab.write_img(1000, 1000, plotfile)
            else:
                tab.write_eps(plotfile)

        print("time npts=1000:", time1000)
        for j in xrange(numcheck):
            npts = nptsvals[j]
            print("time npts=%s: %s" % (npts, times[j]))
Exemplo n.º 12
0
def test_sigmacritinv_npts(epsfile=None):
    """
    Test accuracy of sigmacrit inv as a function of number
    of points
    """

    from biggles import FramedPlot, PlotKey, PlotLabel, Curve, FramedArray, Table

    c1000 = Cosmo(npts=1000)
    c5 = Cosmo(npts=5)
    c4 = Cosmo(npts=4)
    c3 = Cosmo(npts=3)
    c2 = Cosmo(npts=2)

    tab = Table(2, 2)
    tab.uniform_limits = 0
    tab.cellspacing = 1

    p5 = FramedPlot()
    p5.xlabel = 'zsource'
    p5.ylabel = '% diff'
    p4 = FramedPlot()
    p4.xlabel = 'zsource'
    p4.ylabel = '% diff'
    p3 = FramedPlot()
    p3.xlabel = 'zsource'
    p3.ylabel = '% diff'
    p2 = FramedPlot()
    p2.xlabel = 'zsource'
    p2.ylabel = '% diff'

    l5 = PlotLabel(0.2, 0.7, 'npts = 5')
    p5.add(l5)
    l4 = PlotLabel(0.2, 0.1, 'npts = 4')
    p4.add(l4)
    l3 = PlotLabel(0.2, 0.9, 'npts = 3')
    p3.add(l3)
    l2 = PlotLabel(0.2, 0.9, 'npts = 2')
    p2.add(l2)

    colors = [
        'black', 'violet', 'blue', 'green', 'orange', 'magenta', 'firebrick',
        'red'
    ]
    zlvals = numpy.arange(0.1, 0.9, 0.1)
    if zlvals.size != len(colors):
        raise ValueError("mismatch colors and zlvals")

    i = 0

    allc5 = []
    for zl in zlvals:

        zs = numpy.arange(zl + 0.01, 2.0, 0.01)

        scinv = c1000.sigmacritinv(zl, zs)
        scinv5 = c5.sigmacritinv(zl, zs)
        scinv4 = c4.sigmacritinv(zl, zs)
        scinv3 = c3.sigmacritinv(zl, zs)
        scinv2 = c2.sigmacritinv(zl, zs)

        curve5 = Curve(zs, 100 * (scinv - scinv5) / scinv, color=colors[i])
        curve5.label = 'zlens: %0.2f' % zl
        allc5.append(curve5)
        p5.add(curve5)

        curve4 = Curve(zs, 100 * (scinv - scinv4) / scinv, color=colors[i])
        p4.add(curve4)

        curve3 = Curve(zs, 100 * (scinv - scinv3) / scinv, color=colors[i])
        p3.add(curve3)

        curve2 = Curve(zs, 100 * (scinv - scinv2) / scinv, color=colors[i])
        p2.add(curve2)

        i += 1

    key = PlotKey(0.15, 0.5, allc5)
    p5.add(key)

    tab[0, 0] = p5
    tab[0, 1] = p4
    tab[1, 0] = p3
    tab[1, 1] = p2

    tab.show()

    if epsfile is not None:
        tab.write_eps(epsfile)
Exemplo n.º 13
0
    def test_scinv_dz(self, beg, end, yrange=[0, 2.1e-4], show=False, reload=False, type="png"):
        """

        Test accuracy of interpolating scinv as a function of dzl, the
        lens redshift spacing.

        """
        import biggles
        from biggles import Points, FramedPlot, PlotKey, Table, Histogram, Curve
        from time import time
        import lensing
        import pcolors

        biggles.configure("default", "fontface", "HersheySans")
        biggles.configure("default", "fontsize_min", 1.3)

        zsmin = self.zs[0]
        zsmax = self.zs[-1]

        zlmin = 0.00
        zlmax = 1.0

        # dzl_vals = numpy.linspace(0.001,0.015,10)
        dzl_vals = numpy.linspace(0.001, 0.015, 4)
        nzl_vals = ((zlmax - zlmin) / dzl_vals).astype("i8")

        numcheck = len(dzl_vals)
        colors = pcolors.rainbow(numcheck, "hex")
        scalc = []
        for nzl in nzl_vals:
            s = ScinvCalculator(zlmin, zlmax, nzl, zsmin, zsmax, npts=100)
            scalc.append(s)

        times = numpy.zeros(numcheck, dtype="f8")

        # we'll fill this in
        # scinv_all = numpy.zeros( (numcheck, scalc[0].zlvals.size) )

        xlim = [0, zsmax]
        for i in xrange(beg, end):
            scinv_all = []
            pz = self.data["pofz"][i]

            # print(pz)

            for j in xrange(numcheck):
                dzl = dzl_vals[j]
                nzl = nzl_vals[j]
                print("    nzl: %s dzl: %g" % (nzl, dzl))
                tm0 = time()
                # scinv_all[j,:] = scalc[j].calc_mean_scinv(pz)
                sc = scalc[j].calc_mean_scinv(self.zs, pz)
                # sc=sc.clip(min=0.0)
                # print("sc",j,sc)
                scinv_all.append(sc)
                times[j] += time() - tm0

            print("\nplotting")

            # plot the p(z)
            tab = Table(3, 1)

            binsize = self.zs[1] - self.zs[0]
            pzh = Histogram(pz, x0=self.zs[0], binsize=binsize)
            plt_pzh = FramedPlot()
            plt_pzh.xrange = xlim

            plt_pzh.xtitle = r"$z_s$"
            plt_pzh.ytitle = r"$P(z_s)$"
            plt_pzh.add(pzh)
            tab[0, 0] = plt_pzh
            # plt_pzh.show()

            # plot scinv for each dzl
            plt_scinv = FramedPlot()
            plt_scinv.xrange = xlim

            scinv_plots = []
            for j in xrange(numcheck):
                dzl = dzl_vals[j]
                nzl = nzl_vals[j]
                p = Curve(scalc[j].zlvals, scinv_all[j], type="solid", color=colors[j])
                p.label = r"$nz_{lens}: %s dz_{lens}: %0.3f$" % (nzl, dzl)

                plt_scinv.add(p)
                scinv_plots.append(p)

            scinv_key = PlotKey(0.95, 0.9, scinv_plots, halign="right")
            plt_scinv.add(scinv_key)

            plt_scinv.ylabel = r"$\Sigma_{crit}^{-1}(z_{lens})$"
            plt_scinv.xlabel = r"$z_{lens}$"
            plt_scinv.yrange = yrange

            # plt_scinv.show()
            tab[1, 0] = plt_scinv

            # %diff to best dz

            plt_pdiff = FramedPlot()
            plt_pdiff.xrange = xlim
            plt_pdiff.yrange = [-0.05, 0.05]
            pdiff_plots = []

            zl_interp = numpy.linspace(zlmin, zlmax, 1000)
            scinv_interp_best = esutil.stat.interplin(scinv_all[0], scalc[0].zlvals, zl_interp)

            w = where1(scinv_interp_best > 0)
            for j in xrange(numcheck):
                dzl = dzl_vals[j]
                nzl = nzl_vals[j]

                scinv_interp = esutil.stat.interplin(scinv_all[j], scalc[j].zlvals, zl_interp)

                if w.size > 0:
                    pdiff = scinv_interp[w] / scinv_interp_best[w] - 1.0
                    p = Curve(zl_interp[w], pdiff, type="solid", color=colors[j])
                else:
                    pdiff = numpy.ones(scinv_interp.size)
                    p = Curve(zl_interp, pdiff, type="solid", color=colors[j])

                p.label = r"$nz_{lens}: %s dz_{lens}: %0.3f$" % (nzl, dzl)

                plt_pdiff.add(p)
                pdiff_plots.append(p)

            key = PlotKey(0.95, 0.9, pdiff_plots, halign="right")
            plt_pdiff.add(key)

            plt_pdiff.ylabel = r"$\Sigma_{crit}^{-1} /  \Sigma_{crit}^{-1}_{best} - 1$"
            plt_pdiff.xlabel = r"$z_{lens}$"

            tab[2, 0] = plt_pdiff

            if show:
                tab.show()

            plotfile = self.dzl_plot_file(i, type)
            print("writing to file:", plotfile)
            if type == "png":
                tab.write_img(1000, 1000, plotfile)
            else:
                tab.write_eps(plotfile)

        for j in xrange(numcheck):
            dzl = dzl_vals[j]
            print("time dzl=%s: %s" % (dzl, times[j]))
Exemplo n.º 14
0
Arquivo: fit.py Projeto: esheldon/espy
def plot_nfw_lin_fits_byrun(run, name, npts=100, prompt=False, 
                            withlin=True,
                            ymin=0.01, ymax=2000.0):
    """

    This should be made not specific for the m-z splits we
    used on the sims

    """
    conf = lensing.files.cascade_config(run)
    if withlin:
        ex='lin'
        nex='lin'
    else:
        nex=''
        ex=''
    d = lensing.sample_read(type='fit',sample=run, name=name, extra=ex)

    omega_m = conf['cosmo_config']['omega_m']

    rravel = d['r'].ravel()
    xrange = [0.5*rravel.min(), 1.5*rravel.max()]

    #for i in xrange(d.size):
    i=0
    for dd in d:

        zrange = dd['z_range']
        mrange = dd['m200_range']

        if dd['rrange'][0] > 0:
            log_rmin = log10(dd['rrange'][0])
            log_rmax = log10(dd['rrange'][1])
        else:
            log_rmin = log10(dd['r'][0])
            log_rmax = log10(dd['r'][-1])
        rvals = 10.0**linspace(log_rmin,log_rmax,npts)

        plt = FramedPlot()  
        lensing.plotting.add_to_log_plot(plt, dd['r'],dd['dsig'],dd['dsigerr'])

        z = dd['z_mean']
        fitter = lensing.fit.NFWBiasFitter(omega_m,z,rvals,withlin=withlin)

        if withlin:
            yfit = fitter.nfw_lin_dsig(rvals, dd['r200_fit'],dd['c_fit'],dd['B_fit'])
            yfit_nfw = fitter.nfw.dsig(rvals,dd['r200_fit'],dd['c_fit'])
            yfit_lin = fitter.lin_dsig(rvals,dd['B_fit'])

            yfit = where(yfit < 1.e-5, 1.e-5, yfit)
            yfit_lin = where(yfit_lin < 1.e-5, 1.e-5, yfit_lin)

            cyfit = Curve(rvals,yfit,color='blue')
            cyfit_nfw = Curve(rvals,yfit_nfw,color='red')
            cyfit_lin = Curve(rvals,yfit_lin,color='orange')

            cyfit.label = 'Best Fit'
            cyfit_nfw.label = 'NFW'
            cyfit_lin.label = 'linear'

            key=PlotKey(0.1,0.3,[cyfit,cyfit_nfw,cyfit_lin])
            plt.add(cyfit,cyfit_nfw,cyfit_lin,key)
        else:
            yfit_nfw = fitter.nfw.dsig(rvals,dd['r200_fit'],dd['c_fit'])
            cyfit_nfw = Curve(rvals,yfit_nfw,color='blue')
            plt.add(cyfit_nfw)

        zlab='%0.2f < z < %0.2f' % (zrange[0],zrange[1])
        plt.add(PlotLabel(0.7,0.8,zlab))
        ll = (log10(mrange[0]),log10(mrange[1]))
        mlab = r'$%0.2f < logM_{200} < %0.2f$' % ll
        plt.add(PlotLabel(0.7,0.9,mlab))

        #yrange = [ymin,(dd['dsig']+dd['dsigerr']).max()*1.5]
        yrange = [ymin,ymax]
        plt.xrange = xrange
        plt.yrange = yrange
        plt.xlog=True
        plt.ylog=True
        plt.xlabel = r'$r$ [$h^{-1}$ Mpc]'
        plt.ylabel = r'$\Delta\Sigma ~ [M_{sun} pc^{-2}]$'
        plt.aspect_ratio=1
        if prompt:
            plt.show()
            rinput = raw_input('hit a key: ')
            if rinput == 'q':
                return
        else:
            d = lensing.files.lensbin_plot_dir(run,name)
            if not os.path.exists(d):
                os.makedirs(d)
            epsfile=path_join(d,'desmocks-nfw%s-fit-%02i.eps' % (nex,i))
            print 'Writing epsfile:',epsfile
            plt.write_eps(epsfile)
        i += 1
Exemplo n.º 15
0
def compare_idl(ratios=False, epsfile=None):
    from biggles import FramedPlot,Points, Table
    omega_m=0.25
    omega_b=0.055
    sigma_8=1.0
    h=1.0
    ns=0.98

    r=eu.recfile.Open('/home/esheldon/tmp/linear-compare/pkidl.dat',
                      delim=' ',dtype=[('k','f8'),('pk','f8')])
    pkidlst = r.read()
    r.close()

    k,pkidl = pkidlst['k'],pkidlst['pk']

    r=eu.recfile.Open('/home/esheldon/tmp/linear-compare/xiidl.dat',
                      delim=' ',dtype=[('r','f8'),('xi','f8')])
    xiidlst = r.read()
    r.close()

    r,xiidl = xiidlst['r'],xiidlst['xi']

    l = Linear(omega_m=omega_m,omega_b=omega_b,sigma_8=sigma_8,h=h,ns=ns)

    pk = l.pk(k)
    xi = l.xi(r, nplk=1000)
    #xi = l.xi(r)

    pkrat = pk/pkidl
    xirat = xi/xiidl

    tab=Table(2,1)

    symsize=1

    if ratios:

        pkplt = FramedPlot()
        pkplt.xlabel='k'
        pkplt.xlog=True
        pkplt.ylabel='P(k)/P(k) dave'
        pkplt.add( Points(k,pkrat,type='filled circle',size=symsize) )
        pkplt.add( Curve(k,pkrat,color='blue') )

        tab[0,0] = pkplt

 
    if ratios:

        xiplt = FramedPlot()
        xiplt.xlabel='r'
        xiplt.xlog=True

        xiplt.ylabel='xi(r)/xi(r) dave'
        xiplt.add( Points(r,xirat,type='filled circle',size=symsize) )
        xiplt.add( Curve(r,xirat,color='blue') )

        tab[1,0] = xiplt
    else:

        # big log-log plot
        limxi = where(xi < 1.e-5, 1.e-5, xi)
        #pxi = Points(r,limxi,type='filled circle',size=symsize)
        cxi = Curve(r,limxi,color='blue')

        limxiidl = where(xiidl < 1.e-5, 1.e-5, xiidl)
        #pxiidl = Points(r,limxiidl,type='filled circle',size=symsize)
        cxiidl = Curve(r,limxiidl,color='red')

        xipltall = FramedPlot()
        xipltall.xlabel='r'
        xipltall.xlog=True
        xipltall.ylog=True
        xipltall.ylabel='xi(r)'

        #xipltall.add(pxi,cxi,pxiidl,cxiidl)
        xipltall.add(cxi,cxiidl)
       
        tab[0,0] = xipltall

        # zoomed in plot
        xiplt = FramedPlot()
        xiplt.xlabel='r'
        xiplt.xlog=True
        xiplt.ylabel='xi(r)'

        pxi = Points(r,xi,type='filled circle',size=symsize) 
        cxi = Curve(r,xi,color='blue')
        cxi.label = 'Mine'

        pxiidl = Points(r,xiidl,type='filled circle',size=symsize)
        cxiidl = Curve(r,xiidl,color='red')
        cxiidl.label = 'Dave'

        key=PlotKey(0.8,0.9, [cxi,cxiidl])

        xiplt.add(pxi,cxi,pxiidl,cxiidl)
        xiplt.xrange = [50.0,r.max()]
        xiplt.yrange=[-2.e-3,1.e-2]
        xiplt.add(key)

        tab[1,0] = xiplt



    if epsfile is not None:
        tab.write_eps(epsfile)
    else:
        tab.show()
Exemplo n.º 16
0
    def plot_sheardiff_bys2n(self, nperbin, nperbin_sub, show=False):
        import biggles
        from biggles import FramedPlot,PlotLabel, Curve, Points, Table, PlotKey

        data=self.get_sheardiff_data()
        
        epsfile=get_shear_compare_plot_url(self['serun'],self['merun'])
        print >>stderr,'Will write summary plot:',epsfile

        print >>stderr,'histogramming shear_s2n',nperbin
        hdict=eu.stat.histogram(data['shear_s2n'],nperbin=nperbin,
                                rev=True,more=True)
        rev=hdict['rev']
        cdlist=[]
        for i in xrange(hdict['hist'].size):
            if rev[i] != rev[i+1]:
                w=rev[ rev[i]:rev[i+1] ]
                label=r'$%0.3g < S/N < %0.3g$' \
                    % (hdict['low'][i],hdict['high'][i])
                print >>stderr,label,'mean:',hdict['mean'][i],'num:',w.size
                cd=self.plot_sheardiff(nperbin_sub,indices=w,label=label,
                                       num=i,
                                       show=show)
                cdlist.append(cd)
        
        slopes1=[cd['coeff1'][0] for cd in cdlist]
        offsets1=[cd['coeff1'][1] for cd in cdlist]
        slopes2=[cd['coeff2'][0] for cd in cdlist]
        offsets2=[cd['coeff2'][1] for cd in cdlist]

        tab=Table(2,1)

        plt_slope=FramedPlot()
        cslope1 = Curve(hdict['mean'],slopes1,color='red')
        cslope2 = Curve(hdict['mean'],slopes2,color='blue')
        pslope1 = Points(hdict['mean'],slopes1,color='red',
                         type='filled circle')
        pslope2 = Points(hdict['mean'],slopes2,color='blue',
                         type='filled circle')

        cslope1.label = r'$\gamma_1$'
        cslope2.label = r'$\gamma_2$'
        key=PlotKey(0.1,0.2,[cslope1,cslope2],halign='left')

        plt_slope.add(cslope1,cslope2,pslope1,pslope2,key)
        plt_slope.xlabel = 'Shear S/N'
        plt_slope.ylabel = 'Slope'
        plt_slope.xlog=True
        plt_slope.xrange = eu.plotting.get_log_plot_range(hdict['mean'])

        plt_offset=FramedPlot()
        coffset1 = Curve(hdict['mean'],offsets1,color='red')
        coffset2 = Curve(hdict['mean'],offsets2,color='blue')
        poffset1 = Points(hdict['mean'],offsets1,color='red',
                          type='filled circle')
        poffset2 = Points(hdict['mean'],offsets2,color='blue',
                          type='filled circle')
        plt_offset.add(coffset1,coffset2,poffset1,poffset2)
        plt_offset.xlabel = 'Shear S/N'
        plt_offset.ylabel = 'Offset'
        plt_offset.xlog=True
        plt_offset.xrange = eu.plotting.get_log_plot_range(hdict['mean'])


        tab[0,0] = plt_slope
        tab[1,0] = plt_offset
        if show:
            tab.show()

        print >>stderr,'Writing summary plot:',epsfile
        tab.write_eps(epsfile)
        converter.convert(epsfile,dpi=90,verbose=True)
Exemplo n.º 17
0
def plot_lens_s2n(zl, zslow, zshigh, pzs, cumulative=True):
    """

    Calculate the cumulative expected usefulness of lenses as a function of
    redshift for the given source N(z).

    """

    import biggles
    from biggles import FramedPlot, Curve, PlotLabel, PlotKey, Table, Histogram

    biggles.configure('screen','width',1140)
    biggles.configure('screen','height',1140)
    nzl=zshigh.size
    zlmin = 0.0
    zlmax = max([zl.max(), zshigh.max()])

    # first get the mean inverse critical density as a function
    # of lens redshift
    zsmid = (zshigh+zslow)/2.
    sc = lensing.sigmacrit.ScinvCalculator(zlmin, zlmax, nzl, zsmid[0], zsmind[-1])

    mean_scinv = sc.calc_mean_scinv(pzs)


    # histogram the lens redshifts in a binning corresponding
    # to the mean_scinv

    hdict = eu.stat.histogram(zl, min=zlmin, max=zlmax, binsize=dz, more=True)

    # get distances to the bin centers
    cosmo=cosmology.Cosmo()
    Dlens = cosmo.Da(0.0, hdict['center'])

    # interpolate the mean_scinv onto the centers
    mean_scinv = eu.stat.interplin(mean_scinv, sc.zlvals, hdict['center'])

    # this is the S/N at a given lens redshift
    s2n = sqrt(hdict['hist']/Dlens**2)*mean_scinv

    hd = hdict['hist']/Dlens**2
    hdcum = hd.cumsum()
    s2ncum = (mean_scinv*hd).cumsum()/sqrt(hdcum.clip(1.,hdcum.max()))


    s2n /= s2n.max()
    s2ncum /= s2ncum.max()

    
    tab = Table(2,2)
    tab.aspect_ratio=1

    # redshift histograms
    tab[0,0] = FramedPlot()
    zl_histp = Histogram(hdict['hist']/float(hdict['hist'].sum()), x0=hdict['low'][0], binsize=dz, color='blue')
    zl_histp.label = 'lenses'
    zs_histp = Histogram(pzs/float(pzs.sum()), x0=zslow[0], binsize=dz, color='red')
    zs_histp.label = 'sources'

    hkey=PlotKey(0.9,0.9,[zl_histp,zs_histp],halign='right')
    tab[0,0].add(zl_histp, zs_histp, hkey)
    tab[0,0].xlabel = 'z'

    # mean inverse critical density
    tab[0,1] = FramedPlot()
    tab[0,1].xlabel = 'lens redshift'
    tab[0,1].ylabel = r'$\langle \Sigma_{crit}^{-1} \rangle$'

    mc = Curve(hdict['center'], mean_scinv)
    tab[0,1].add(mc)


    # cumulative volume
    tab[1,0] = FramedPlot()
    tab[1,0].xlabel = 'z'
    tab[1,0].ylabel = 'cumulative volume'
    v=zeros(hdict['center'].size)
    for i in xrange(v.size):
        v[i] = cosmo.V(0.0, hdict['center'][i])
    v /= v.max()
    cv=Curve(hdict['center'], v)
    tab[1,0].add(cv)


    # S/N
    tab[1,1] = FramedPlot()
    tab[1,1].xlabel = 'lens redshift'
    tab[1,1].ylabel = 'S/N'

    cs2n = Curve(hdict['center'], s2n, color='blue')
    cs2ncum = Curve(hdict['center'], s2ncum, color='red')

    cs2n.label = 'S/N'
    cs2ncum.label = 'Cumulative S/N'
    ckey=PlotKey(0.9,0.9,[cs2n, cs2ncum],halign='right')

    tab[1,1].add(cs2n, cs2ncum, ckey)


    tab.show()

    return tab
Exemplo n.º 18
0
def test_sigmacritinv_npts(epsfile=None):
    """
    Test accuracy of sigmacrit inv as a function of number
    of points
    """

    from biggles import FramedPlot, PlotKey, PlotLabel, Curve, FramedArray, Table

    c1000 = Cosmo(npts=1000)
    c5 = Cosmo(npts=5)
    c4 = Cosmo(npts=4)
    c3 = Cosmo(npts=3)
    c2 = Cosmo(npts=2)


    tab = Table( 2, 2 )
    tab.uniform_limits = 0
    tab.cellspacing = 1

    p5 = FramedPlot()
    p5.xlabel = 'zsource'
    p5.ylabel = '% diff'
    p4 = FramedPlot()
    p4.xlabel = 'zsource'
    p4.ylabel = '% diff'
    p3 = FramedPlot()
    p3.xlabel = 'zsource'
    p3.ylabel = '% diff'
    p2 = FramedPlot()
    p2.xlabel = 'zsource'
    p2.ylabel = '% diff'

    l5 = PlotLabel(0.2,0.7,'npts = 5')
    p5.add(l5)
    l4 = PlotLabel(0.2,0.1,'npts = 4')
    p4.add(l4)
    l3 = PlotLabel(0.2,0.9,'npts = 3')
    p3.add(l3)
    l2 = PlotLabel(0.2,0.9,'npts = 2')
    p2.add(l2)


    colors = ['black','violet','blue','green','orange','magenta','firebrick','red']
    zlvals = numpy.arange(0.1,0.9,0.1)
    if zlvals.size != len(colors):
        raise ValueError("mismatch colors and zlvals")



    i=0

    allc5 = []
    for zl in zlvals:

        zs = numpy.arange(zl+0.01, 2.0, 0.01)

        scinv = c1000.sigmacritinv(zl, zs)
        scinv5 = c5.sigmacritinv(zl, zs)
        scinv4 = c4.sigmacritinv(zl, zs)
        scinv3 = c3.sigmacritinv(zl, zs)
        scinv2 = c2.sigmacritinv(zl, zs)

        curve5 = Curve(zs, 100*(scinv-scinv5)/scinv, color=colors[i])
        curve5.label = 'zlens: %0.2f' % zl
        allc5.append(curve5)
        p5.add(curve5)

        curve4 = Curve(zs, 100*(scinv-scinv4)/scinv, color=colors[i])
        p4.add(curve4)

        curve3 = Curve(zs, 100*(scinv-scinv3)/scinv, color=colors[i])
        p3.add(curve3)

        curve2 = Curve(zs, 100*(scinv-scinv2)/scinv, color=colors[i])
        p2.add(curve2)

        i+=1

    key = PlotKey(0.15,0.5,allc5)
    p5.add(key)


    tab[0,0] = p5
    tab[0,1] = p4
    tab[1,0] = p3
    tab[1,1] = p2

    tab.show()

    if epsfile is not None:
        tab.write_eps(epsfile)
Exemplo n.º 19
0
    def plot_meanshear_vs_trueshear_bys2n(self, nperbin, nperbin_sub, show=False):
        from biggles import FramedPlot, Curve, Points, Table, PlotKey

        type = "vs_shear"

        html_file = get_shear_compare_html_url(self["run"], self["mock_catalog"], type)
        print "html_file:", html_file

        data = self.get_data()

        epsfile = get_shear_compare_plot_url(self["run"], self["mock_catalog"], type)
        print >> stderr, "Will write summary plot:", epsfile

        print >> stderr, "histogramming shear_s2n", nperbin
        hdict = eu.stat.histogram(data["shear_s2n"], nperbin=nperbin, rev=True, more=True)
        rev = hdict["rev"]
        cdlist = []
        pngfiles = []
        for i in xrange(hdict["hist"].size):
            if rev[i] != rev[i + 1]:
                w = rev[rev[i] : rev[i + 1]]
                label = r"$%0.3g < S/N < %0.3g$" % (hdict["low"][i], hdict["high"][i])
                print >> stderr, label, "mean:", hdict["mean"][i], "num:", w.size
                cd, png = self.plot_meanshear_vs_trueshear(nperbin_sub, indices=w, label=label, num=i, show=show)
                cdlist.append(cd)
                pngfiles.append(png)

        slopes1 = [cd["coeff1"][0] for cd in cdlist]
        offsets1 = [cd["coeff1"][1] for cd in cdlist]
        slopes2 = [cd["coeff2"][0] for cd in cdlist]
        offsets2 = [cd["coeff2"][1] for cd in cdlist]

        tab = Table(2, 1)

        plt_slope = FramedPlot()
        cslope1 = Curve(hdict["mean"], slopes1, color="red")
        cslope2 = Curve(hdict["mean"], slopes2, color="blue")
        pslope1 = Points(hdict["mean"], slopes1, color="red", type="filled circle")
        pslope2 = Points(hdict["mean"], slopes2, color="blue", type="filled circle")

        cslope1.label = r"$\gamma_1$"
        cslope2.label = r"$\gamma_2$"
        key = PlotKey(0.1, 0.2, [cslope1, cslope2], halign="left")

        plt_slope.add(cslope1, cslope2, pslope1, pslope2, key)
        plt_slope.xlabel = "Shear S/N"
        plt_slope.ylabel = "Slope"
        plt_slope.xlog = True
        plt_slope.xrange = eu.plotting.get_log_plot_range(hdict["mean"])

        plt_offset = FramedPlot()
        coffset1 = Curve(hdict["mean"], offsets1, color="red")
        coffset2 = Curve(hdict["mean"], offsets2, color="blue")
        poffset1 = Points(hdict["mean"], offsets1, color="red", type="filled circle")
        poffset2 = Points(hdict["mean"], offsets2, color="blue", type="filled circle")
        plt_offset.add(coffset1, coffset2, poffset1, poffset2)
        plt_offset.xlabel = "Shear S/N"
        plt_offset.ylabel = "Offset"
        plt_offset.xlog = True
        plt_offset.xrange = eu.plotting.get_log_plot_range(hdict["mean"])

        tab[0, 0] = plt_slope
        tab[1, 0] = plt_offset
        if show:
            tab.show()

        print >> stderr, "Writing summary plot:", epsfile
        tab.write_eps(epsfile)
        converter.convert(epsfile, dpi=90, verbose=True)
        png = epsfile.replace(".eps", ".png")
        pngfiles = [png] + pngfiles

        self.write_html(pngfiles, html_file)