コード例 #1
0
ファイル: plotting.py プロジェクト: d80b2t/python
def plotrand(x, y, frac=0.1, plt=None, **keys):
    import biggles
    from biggles import FramedPlot, Points
    if plt is None:
        plt = FramedPlot()

    x=numpy.array(x,ndmin=1,copy=False)
    y=numpy.array(y,ndmin=1,copy=False)
    if x.size != y.size:
        raise ValueError("x,y must be same size")
    nrand = int(x.size*frac)

    ind = numpy_util.random_subset(x.size, nrand)

    if 'type' not in keys:
        keys['type'] = 'dot'

    c = Points(x[ind], y[ind], **keys)
    plt.add(c)

    if 'xlabel' in keys:
        plt.xlabel = keys['xlabel']
    if 'ylabel' in keys:
        plt.ylabel = keys['ylabel']


    show = keys.get('show',True)
    if show:
        plt.show()

    return plt
コード例 #2
0
ファイル: perfect.py プロジェクト: neffmallon/pistol
def plotprimedens(n):
    pd = primedens(n)
    steps = range(len(pd))
    from biggles import FramedPlot, Curve
    g = FramedPlot()
    g.add(Curve(steps,pd))
    g.show()
    return
コード例 #3
0
ファイル: training.py プロジェクト: esheldon/espy
    def plot_radec(self, type):
        """
        ra/dec plot of all points and the matched points
        """
        import biggles
        import converter
        from biggles import FramedPlot,Points

        print()
        dir=self.plotdir()
        if not os.path.exists(dir):
            os.makedirs(dir)

        psfile = self.plotfile(type)

        orig = self.read_original(type)
        mat = self.read_matched(type)

        plt=FramedPlot() 

        symsize = 2
        if type == 'sdss' or type == 'other':
            symsize = 0.25

        plt.add( Points(orig['ra'],orig['dec'],type='dot', size=symsize) )

        plt.add( Points(mat['ra'],mat['dec'],type='dot',
                        color='red', size=symsize) )
        plt.xlabel = 'RA'
        plt.ylabel = 'DEC'
        print("Writing eps file:", psfile)
        plt.write_eps(psfile)
        converter.convert(psfile, dpi=120, verbose=True)
コード例 #4
0
ファイル: invert.py プロジェクト: esheldon/espy
    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))
コード例 #5
0
ファイル: linear.py プロジェクト: esheldon/espy
    def plot_pk(self,k,pk):
        from biggles import FramedPlot, Curve

        plt=FramedPlot()
        plt.add(Curve(k,pk))
        plt.xlog=True
        plt.ylog=True

        plt.xlabel = r'$k [h/Mpc]$'
        plt.ylabel = r'$P_{lin}(k)$'
        plt.aspect_ratio = 1
        plt.show()
コード例 #6
0
ファイル: linear.py プロジェクト: esheldon/espy
    def plot_xi(self, r, xi):
        from biggles import FramedPlot, Curve
        minval = 1.e-4

        xi = where(xi < minval, minval, xi)

        plt=FramedPlot()
        plt.add(Curve(r,xi))
        plt.xlog=True
        plt.ylog=True

        plt.xlabel = r'$r [Mpc/h]$'
        plt.ylabel = r'$\xi_{lin}(r)$'
        plt.aspect_ratio=1
        plt.show()
コード例 #7
0
ファイル: fit-sprior-true.py プロジェクト: esheldon/espy
    def doplot(self, fitres, h, minmag, maxmag):
        tab=biggles.Table(2,1)

        plt=FramedPlot()
        plt.title='%s %.2f %.2f ' % (self.objtype, minmag, maxmag)
        plt.xlabel=r'$\sigma$'

        sprior=fitres.get_model()

        nrand=100000
        binsize=self.binsize

        hplt=Histogram(h['hist'], x0=h['low'][0], binsize=binsize)
        hplt.label='data'

        srand=sprior.sample(nrand)
        hrand=histogram(srand, binsize=binsize, min=h['low'][0], max=h['high'][-1], more=True)
        hrand['hist'] = hrand['hist']*float(h['hist'].sum())/nrand

        hpltrand=Histogram(hrand['hist'], x0=hrand['low'][0], binsize=binsize,
                           color='blue')
        hpltrand.label='rand'


        key=PlotKey(0.9,0.9,[hplt,hpltrand],halign='right')

        plt.add(hplt, hpltrand, key)

        
        tplt=fitres.plot_trials(show=False,fontsize_min=0.88888888)
        
        tab[0,0] = plt
        tab[1,0] = tplt

        if self.show:
            tab.show()

        d=files.get_prior_dir()
        d=os.path.join(d, 'plots')
        epsfile='pofs-%.2f-%.2f-%s.eps' % (minmag,maxmag,self.objtype)
        epsfile=os.path.join(d,epsfile)
        eu.ostools.makedirs_fromfile(epsfile)
        print epsfile
        tab.write_eps(epsfile)
        os.system('converter -d 100 %s' % epsfile)

        return tab
コード例 #8
0
ファイル: fit-prior.py プロジェクト: esheldon/espy
    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
コード例 #9
0
ファイル: pcolors.py プロジェクト: esheldon/espy
def test_rainbow():
    import numpy
    from biggles import FramedPlot, Points, Curve
    num = 20

    plt = FramedPlot()

    x = numpy.linspace(0.0, 1.0, num)
    y = x**2

    colors = rainbow(num, 'hex')

    for i in xrange(num):
        p = Points([x[i]], [y[i]], type='filled circle', 
                   color=colors[i])
        c = Curve([x[i]],[y[i]], color=colors[i])
        plt.add(p,c)
    plt.show()
コード例 #10
0
ファイル: plotting.py プロジェクト: esheldon/espy
def plot_drho(comb=None, r=None, drho=None, drhoerr=None, 
              color='black',type='filled circle',
              nolabel=False, noshow=False, minval=1.e-5,
              aspect_ratio=1):
    """
    This one stands alone. 
    """

    if comb is not None:
        r=comb['rdrho']
        drho=comb['drho']
        drhoerr=comb['drhoerr']
    else:
        if r is None or drho is None or drhoerr is None:
            raise ValueError("Send a combined struct or r,drho,drhoerr")


    plt=FramedPlot()
    plt.aspect_ratio=aspect_ratio
    plt.xlog=True
    plt.ylog=True

    if not nolabel:
        plt.xlabel = r'$r$ [$h^{-1}$ Mpc]'
        plt.ylabel = r'$\delta\rho ~ [M_{\odot} pc^{-3}]$'


    od=add_to_log_plot(plt, r, drho, drhoerr, 
                       color=color, 
                       type=type,
                       minval=minval)

    # for drho we need even broader yrange
    plt.xrange = od['xrange']

    yr=od['yrange']
    plt.yrange = [0.5*yr[0], 3*yr[1]]

    if not noshow:
        plt.show()
    od['plt'] = plt
    return od
コード例 #11
0
ファイル: validation.py プロジェクト: esheldon/espy
    def compare_all_other(self, type, show=True):
        
        fdict=self.all_other_fdict(type)

        # this is the original file.  It has the redshifts
        orig = zphot.weighting.read_training(fdict['origfile'])

        # this is the outputs
        num = zphot.weighting.read_num(fdict['numfile1'])

        # this is the weights file
        weights = zphot.weighting.read_training(fdict['wfile2'])

        # recoverable set
        w_recoverable = where1(num['num'] > 0)
        # this is actually the indexes back into the "orig" file
        w_keep = num['photoid'][w_recoverable]

        # get the z values for these validation objects
        zrec = orig['z'][w_keep]

        binsize=0.0314
        valid_dict = histogram(zrec, min=0, max=1.1, binsize=binsize, more=True)
        plt=FramedPlot()

        vhist = valid_dict['hist']/(float(valid_dict['hist'].sum()))
        pvhist=biggles.Histogram(vhist, x0=valid_dict['low'][0], binsize=binsize)
        pvhist.label = 'truth'

        weights_dict = histogram(weights['z'], min=0, max=1.1, binsize=binsize,
                                 weights=weights['weight'], more=True)
        whist = weights_dict['whist']/weights_dict['whist'].sum()
        pwhist=biggles.Histogram(whist, x0=weights_dict['low'][0], 
                                 binsize=binsize, color='red')
        pwhist.label = 'weighted train'

        key = PlotKey(0.6,0.6,[pvhist,pwhist])
        plt.add(pvhist,pwhist,key)

        plt.add( biggles.PlotLabel(.8, .9, type) )

        plt.write_eps(fdict['zhistfile'])
        converter.convert(fdict['zhistfile'],dpi=90,verbose=True)
        if show:
            plt.show()
コード例 #12
0
ファイル: nfw.py プロジェクト: esheldon/espy
    def plot_m(self, r200, c):
        from biggles import FramedPlot, Curve
        n=1000
        r = numpy.linspace(0.01, 20.0,n)
        m = self.m(r, r200, c)

        plt=FramedPlot()
        plt.add( Curve(r,m) )
        plt.xlog=True
        plt.ylog=True

        plt.show()
コード例 #13
0
ファイル: plotting.py プロジェクト: esheldon/espy
def plot_mass(comb=None, r=None, mass=None, masserr=None, 
              color='black',type='filled circle',
              nolabel=False, noshow=False, minval=1.e11,
              aspect_ratio=1):

    if comb is not None:
        r=comb['rmass']
        mass=comb['mass']
        masserr=comb['masserr']
    else:
        if r is None or mass is None or masserr is None:
            raise ValueError("Send a combined struct or r,mass,masserr")


    plt=FramedPlot()
    plt.aspect_ratio=aspect_ratio
    plt.xlog=True
    plt.ylog=True

    if not nolabel:
        plt.xlabel = r'$r$ [$h^{-1}$ Mpc]'
        plt.ylabel = r'$M(<r) ~ [h^{-1} M_{\odot}]$'


    od=add_to_log_plot(plt, r, mass, masserr, 
                       color=color, 
                       type=type,
                       minval=minval)

    plt.xrange = od['xrange']
    plt.yrange = od['yrange']

    if not noshow:
        plt.show()
    od['plt'] = plt
    return od
コード例 #14
0
ファイル: fit-prior-gmix-eta.py プロジェクト: esheldon/espy
    def plot_fits(self, st):
        import biggles

        biggles.configure("default", "fontsize_min", 2)
        parnames = ["A", "a", "g0", "gmax"]

        npars = len(parnames)
        tab = Table(npars, 1)

        magmiddle = (st["minmag"] + st["maxmag"]) / 2
        for i in xrange(npars):

            yval = st["pars"][:, i]
            yerr = st["perr"][:, i]

            ymean = yval.mean()
            ystd = yval.std()
            yrange = [ymean - 3.5 * ystd, ymean + 3.5 * ystd]

            pts = Points(magmiddle, yval, type="filled circle")
            yerrpts = SymmetricErrorBarsY(magmiddle, yval, yerr)
            xerrpts = ErrorBarsX(yval, st["minmag"], st["maxmag"])

            plt = FramedPlot()
            plt.yrange = yrange
            plt.add(pts, xerrpts, yerrpts)
            plt.xlabel = "mag"
            plt.ylabel = parnames[i]

            tab[i, 0] = plt

        if self.show:
            tab.show()

        d = files.get_prior_dir()
        d = os.path.join(d, "plots")
        epsfile = "pofe-pars-%s.eps" % self.otype
        epsfile = os.path.join(d, epsfile)
        eu.ostools.makedirs_fromfile(epsfile)
        print epsfile
        tab.write_eps(epsfile)
        os.system("converter -d 100 %s" % epsfile)
コード例 #15
0
ファイル: admom_test.py プロジェクト: esheldon/admom
def testfit():
    import biggles 
    from biggles import FramedPlot,Points,Curve
    import scipy
    from scipy.optimize import leastsq

    ## Parametric function: 'v' is the parameter vector, 'x' the independent varible
    fp = lambda v, x: v[0]/(x**v[1])*sin(v[2]*x)

    ## Noisy function (used to generate data to fit)
    v_real = [1.5, 0.1, 2.]
    fn = lambda x: fp(v_real, x)

    ## Error function
    e = lambda v, x, y: (fp(v,x)-y)

    ## Generating noisy data to fit
    n = 30
    xmin = 0.1
    xmax = 5
    x = linspace(xmin,xmax,n)
    y = fn(x) + scipy.rand(len(x))*0.2*(fn(x).max()-fn(x).min())

    ## Initial parameter value
    v0 = [3., 1, 4.]

    ## Fitting
    v, success = leastsq(e, v0, args=(x,y), maxfev=10000)

    print('Estimater parameters: ', v)
    print('Real parameters: ', v_real)
    X = linspace(xmin,xmax,n*5)
    plt=FramedPlot()
    plt.add(Points(x,y))
    plt.add(Curve(X,fp(v,X),color='red'))

    plt.show()
コード例 #16
0
ファイル: fit-prior-gmix.py プロジェクト: esheldon/espy
    def plot_fits(self,st):
        import biggles
        biggles.configure( 'default', 'fontsize_min', 2)
        parnames=['A','a','g0','gmax']

        npars=len(parnames)
        tab=Table(npars,1)

        magmiddle=(st['minmag'] + st['maxmag'])/2
        for i in xrange(npars):

            yval=st['pars'][:,i]
            yerr=st['perr'][:,i]

            ymean=yval.mean()
            ystd=yval.std()
            yrange=[ymean-3.5*ystd, ymean+3.5*ystd]
            
            pts=Points(magmiddle, yval, type='filled circle')
            yerrpts=SymmetricErrorBarsY(magmiddle,yval,yerr)
            xerrpts=ErrorBarsX(yval, st['minmag'], st['maxmag'])

            
            plt=FramedPlot()
            plt.yrange=yrange
            plt.add(pts,xerrpts, yerrpts)
            plt.xlabel='mag'
            plt.ylabel=parnames[i]

            tab[i,0] = plt

        if self.show:
            tab.show()

        d=files.get_prior_dir()
        d=os.path.join(d, 'plots')
        epsfile='pofe-pars-%s.eps' % self.otype
        epsfile=os.path.join(d,epsfile)
        eu.ostools.makedirs_fromfile(epsfile)
        print epsfile
        tab.write_eps(epsfile)
        os.system('converter -d 100 %s' % epsfile)
コード例 #17
0
ファイル: fit-prior-true-old.py プロジェクト: esheldon/espy
    def plot_fits(self,st):
        import biggles
        biggles.configure( 'default', 'fontsize_min', 2)
        if self.objtype=='gexp':
            parnames=['A','a','g0','gmax']

        else:
            parnames=['A','b','c']

        npars=len(parnames)
        tab=Table(npars,1)

        magmiddle=(st['minmag'] + st['maxmag'])/2
        for i in xrange(npars):

            yval=st['pars'][:,i]
            yerr=st['perr'][:,i]

            ymean=yval.mean()
            ystd=yval.std()
            yrange=[ymean-3.5*ystd, ymean+3.5*ystd]
            
            pts=Points(magmiddle, yval, type='filled circle')
            yerrpts=SymmetricErrorBarsY(magmiddle,yval,yerr)
            xerrpts=ErrorBarsX(yval, st['minmag'], st['maxmag'])

            
            plt=FramedPlot()
            plt.yrange=yrange
            plt.add(pts,xerrpts, yerrpts)
            plt.xlabel='mag'
            plt.ylabel=parnames[i]

            tab[i,0] = plt

        tab.show()
コード例 #18
0
ファイル: plotting.py プロジェクト: esheldon/espy
def plot_dsig_one(r, dsig, dsigerr, **kw):
    """
    plot delta sigma

    useful if adding to an existing plot

    parameters
    ----------
    r: array
        radius
    dsig: array
        delta sigma
    dsigerr: array
        error on delta sigma
    """

    from biggles import FramedPlot

    nbin=1
    _set_biggles_defs(nbin)

    visible=kw.get('visible',True)
    xlog=kw.get('xlog',True)
    ylog=kw.get('ylog',True)
    aspect_ratio=kw.get('aspect_ratio',1)

    is_ortho=kw.get('is_ortho',False)

    plt=kw.get('plt',None)

    if plt is None:
        plt=FramedPlot()
        plt.aspect_ratio=aspect_ratio
        plt.xlog=xlog
        plt.ylog=ylog

        plt.xlabel = LABELS['rproj']
        if is_ortho:
            plt.ylabel = LABELS['osig']
        else:
            plt.ylabel = LABELS['dsig']

    xrng, yrng = _add_dsig_to_plot(plt, r, dsig, dsigerr, **kw)
    plt.xrange=xrng
    plt.yrange=yrng

    if visible:
        plt.show()

    return plt
コード例 #19
0
ファイル: fit-prior-true-old.py プロジェクト: esheldon/espy
    def doplot(self, fitres, h1, h2, h, minmag, maxmag):
        tab=Table(2,1)
        tab.title='%s %.2f %.2f ' % (self.objtype, minmag, maxmag)

        #xfit,yfit,gprior = self.get_prior_vals(fitres, h)
        gprior=self.get_prior(fitres)

        nrand=100000
        binsize=self.binsize


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

        hrand=histogram(grand, binsize=binsize, min=0., max=1., more=True)
        h1rand=histogram(g1rand, binsize=binsize, min=-1., max=1., more=True)

        #fbinsize=xfit[1]-xfit[0]
        #hrand['hist'] = hrand['hist']*float(yfit.sum())/hrand['hist'].sum()*fbinsize/binsize
        hrand['hist'] = hrand['hist']*float(h['hist'].sum())/nrand
        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)
        key=PlotKey(0.9,0.9,[hplt,hpltrand],halign='right')
        plt.add(hplt, hpltrand, key)


        tab[1,0]=plt
        
        if self.show:
            tab.show()

        return tab
コード例 #20
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)
コード例 #21
0
ファイル: plotting.py プロジェクト: esheldon/espy
def plot_dsig(**keys):
    """
    This one stands alone. 
    """

    comb=keys.get('comb',None)
    r=keys.get('r',None)
    dsig=keys.get('dsig',None)
    dsigerr=keys.get('dsigerr',None)
    color=keys.get('color','black')
    type=keys.get('type','filled circle')
    nolabel=keys.get('nolabel',False)
    show=keys.get('show',True)
    minval=keys.get('minval',1.e-3)
    xlog=keys.get('xlog',True)
    ylog=keys.get('ylog',True)
    aspect_ratio=keys.get('aspect_ratio',1)
    plt=keys.get('plt',None)

    label=keys.get('label',None)

    if comb is not None:
        r=comb['r']
        dsig=comb['dsig']
        dsigerr=comb['dsigerr']
    else:
        if r is None or dsig is None or dsigerr is None:
            raise ValueError("Send a combined struct or r,dsig,dsigerr")

    if plt is None:
        plt=FramedPlot()
        plt.aspect_ratio=aspect_ratio
        plt.xlog=xlog
        plt.ylog=ylog

        if not nolabel:
            plt.xlabel = labels['rproj']
            plt.ylabel = labels['dsig']

    if ylog:
        od=add_to_log_plot(plt, r, dsig, dsigerr, 
                           color=color, 
                           type=type,
                           minval=minval)
        plt.xrange = od['xrange']
        plt.yrange = od['yrange']

        if label:
            od['p'].label=label
    else:
        zpts=Curve(r, dsig*0)
        plt.add(zpts)

        pts=Points(r, dsig, type=type, color=color)

        if label:
            pts.label=label

        plt.add(pts)
        if dsigerr is not None:
            epts=SymErrY(r, dsig, dsigerr, color=color)
            plt.add(epts)

        yrng=keys.get('yrange',None)
        xrng=keys.get('xrange',None)
        if yrng:
            plt.yrange=yrng
        if xrng:
            plt.xrange=xrng
        else:
            if xlog:
                plt.xrange=eu.plotting.get_log_plot_range(r)



    if show:
        plt.show()

    if ylog:
        od['plt'] = plt
        return od
    else:
        return plt
コード例 #22
0
ファイル: plotting.py プロジェクト: esheldon/espy
def plot2dsig_over(r1,dsig1,dsig1err,r2,dsig2, dsig2err, **keys):
    ptype1=keys.get('ptype1','filled circle')
    ptype2=keys.get('ptype2','filled circle')
    size1=keys.get('size1',1)
    size2=keys.get('size2',1)
    color1=keys.get('color1','red')
    color2=keys.get('color2','blue')
    label  = keys.get('label',None)
    label1 = keys.get('label1',None)
    label2 = keys.get('label2',None)
    xrng = keys.get('xrange',None)
    yrng = keys.get('yrange',None)
    show = keys.get('show',True)

    ylog = keys.get('ylog',True)
   
    plt=keys.get('plt',None)

    yall=numpy.concatenate((dsig1, dsig2))
    yerrall=numpy.concatenate((dsig1err, dsig2err))

    if yrng is None:
        if ylog:
            yrng = eu.plotting.get_log_plot_range(yall, err=yerrall, 
                                                  input_range=yrng)

    rr=numpy.concatenate((r1,r2))
    if xrng is None:
        xrng = eu.plotting.get_log_plot_range(rr)

    if plt is None:
        plt=FramedPlot()
    plt.xlog=True
    plt.ylog=ylog
    plt.xrange=xrng
    plt.yrange=yrng
    plt.xlabel = labels['rproj']
    plt.ylabel = labels['dsig']

    dsig1_p = Points(r1, dsig1, color=color1, type=ptype1, size=size1)
    dsig1err_p = SymErrY(r1, dsig1, dsig1err, color=color2)
    dsig1_p.label=label1

    dsig2_p = Points(r2, dsig2, color=color2, type=ptype2, size=size2)
    dsig2err_p = SymErrY(r2, dsig2, dsig2err, color=color2)
    dsig2_p.label=label2

    plt.add(dsig1_p, dsig2_p)

    if ylog:
        # biggles chokes if you give it negative data for a log plot
        eu.plotting.add_log_error_bars(plt,'y',r1,dsig1,dsig1err,yrng,
                                       color=color1)
        eu.plotting.add_log_error_bars(plt,'y',r2,dsig2,dsig2err,yrng,
                                       color=color2)
    else:
        err1 = biggles.SymmetricErrorBarsY(r1,dsig1,dsig1err,color=color1)
        err2 = biggles.SymmetricErrorBarsY(r2,dsig2,dsig2err,color=color2)
        plt.add(err1,err2)

        zerop = biggles.Curve(xrng, [0,0])
        plt.add(zerop)

    if label is not None:
        plt.add(PlotLabel(0.9,0.9,label,halign='right'))

    if label1 is not None or label2 is not None:
        key = PlotKey(0.9,0.15, [dsig1_p,dsig2_p], halign='right')
        plt.add(key)

    if show:
        plt.show()
    return plt
コード例 #23
0
ファイル: princeton.py プロジェクト: esheldon/espy
    def plot_ellip_vs_field(self, field, rmag_max=21.8, fmin=None, fmax=None, nbin=20, nperbin=50000,
                            yrange=None, show=True):
        self.load_data()

        w=where1((self['cmodelmag_dered_r'] > 18.0) & (self['cmodelmag_dered_r'] < rmag_max) )

        if w.size == 0:
            print("no good objects")
            return

        weights = 1.0/(0.32**2 + self['uncer_rg'][w]**2)

        if field == 'psf_fwhm':
            field_data = self['psf_fwhm'][w]
            fstr = 'PSF FWHM (arcsec)'
        elif field == 'psf_sigma':
            field_data = self['psf_sigma'][w]
            fstr = r'$\sigma_{PSF}$'
        elif field == 'R_rg':
            field_data = self['r_rg'][w]
            fstr = 'R_rg'
        else:
            field_data = self[field][w]
            fstr=field

        print("Plotting mean e for field:",field)

        fstr = fstr.replace('_','\_')

        be1 = eu.stat.Binner(field_data, self['e1_rg'][w], weights=weights)
        be2 = eu.stat.Binner(field_data, self['e2_rg'][w], weights=weights)

        print("  hist  e1")
        be1.dohist(nperbin=nperbin, min=fmin, max=fmax)
        #be1.dohist(nbin=nbin, min=fmin, max=fmax)
        print("  stats e1")
        be1.calc_stats()
        print("  hist  e2")
        be2.dohist(nperbin=nperbin, min=fmin, max=fmax)
        #be2.dohist(nbin=nbin, min=fmin, max=fmax)
        print("  stats e2")
        be2.calc_stats()

        plt = FramedPlot()
        p1 = Points( be1['wxmean'], be1['wymean'], type='filled circle', color='blue')
        p1err = SymErrY( be1['wxmean'], be1['wymean'], be1['wyerr2'], color='blue')
        p1.label = r'$e_1$'

        p2 = Points( be2['wxmean'], be2['wymean'], type='filled circle', color='red')
        p2.label = r'$e_2$'
        p2err = SymErrY( be2['wxmean'], be2['wymean'], be2['wyerr2'], color='red')

        key = PlotKey(0.8, 0.9, [p1,p2])
        plt.add(p1, p1err, p2, p2err, key)

        if field != 'cmodelmag_dered_r':
            rmag_lab = PlotLabel(0.1,0.05,'rmag < %0.2f' % rmag_max, halign='left')
            plt.add(rmag_lab)

        plab = PlotLabel(0.1,0.1, 'CH+RM', halign='left')
        plt.add(plab)

        plt.xlabel = r'$'+fstr+'$'
        plt.ylabel = r'$<e>$'

        if yrange is not None:
            plt.yrange=yrange

        if show:
            plt.show()
        epsfile = self.plotfile(field, rmag_max)
        print("  Writing eps file:",epsfile)
        plt.write_eps(epsfile)
コード例 #24
0
ファイル: lcat.py プロジェクト: esheldon/espy
    def plot_coverage(self, region='both', show=True, dops=True):
        import biggles
        from biggles import FramedPlot, Points, PlotKey


        l = self.read()
        w,=numpy.where( (l['ra'] >= 0.0) & (l['ra'] <= 360.0) )
        if w.size != l.size:
            print("threw out",l.size-w.size,"with bad ra")
            l=l[w]

        llam,leta = eu.coords.eq2sdss(l['ra'],l['dec'])
        maskflags = l['maskflags']

        lammin,lammax = (-70.,70.)

        if region=='ngc':
            # a bit high to make room for the legend
            emin,emax=(-40,60)

            biggles.configure('screen','width', 1800)
            biggles.configure('screen','height', 1140)

        elif region=='sgc':
            emin,emax=(100,165)
            biggles.configure('screen','width', 1800)
            biggles.configure('screen','height', 1140)
        else:
            emin,emax=(-40,165)
            biggles.configure('screen','width', 1140)
            biggles.configure('screen','height', 1140)

        wl=where1((leta > emin) & (leta < emax))
        llam=llam[wl]
        leta=leta[wl]
        maskflags=maskflags[wl]


        plt=FramedPlot()
        plt.xlabel=r'$\lambda$'
        plt.ylabel=r'$\eta$'

        print("adding all lenses")

        type = 'filled circle'
        symsize=0.2

        allp = Points(llam,leta,type=type,size=symsize)
        allp.label='all'
        plt.add(allp)

        wquad = es_sdsspy.stomp_maps.quad_check(maskflags)
        print("adding quad pass")
        quadp = Points(llam[wquad],leta[wquad],type=type,color='red',size=symsize)
        quadp.label = 'quad good'
        plt.add(quadp)

        fakepoints = eu.plotting.fake_filled_circles(['all','quad good'],['black','red'])
        key=PlotKey(0.95,0.95,fakepoints,halign='right')
        plt.add(key)


        es_sdsspy.stomp_maps.plot_boss_geometry(color='blue',plt=plt,show=False)

        xrng = (lammin, lammax)
        yrng = (emin, emax)
        plt.xrange = xrng
        plt.yrange = yrng
        plt.aspect_ratio = (yrng[1]-yrng[0])/float(xrng[1]-xrng[0])


        if show:
            plt.show()

        if dops:
            d = lensing.files.sample_dir(type='lcat',sample=self['sample'])
            d = os.path.join(d,'plots')
            if not os.path.exists(d):
                os.makedirs(d)
            epsfile = os.path.join(d, 'lcat-%s-%s-coverage.eps' % (self['sample'],region) )
            print("Writing to eps file:",epsfile)
            plt.write_eps(epsfile)
        return plt
コード例 #25
0
ファイル: invert.py プロジェクト: esheldon/espy
def test_interp_hybrid():
    """
    Send y0,y1 with one or both less than zero to test the
    hybrid offset scheme
    """
    slope = -2.0
    #xvals = 0.1+linspace(0.0,8.0,9)
    xvals = 10.0**linspace(0.0,1.0,10)
    yvals = xvals**slope
    #yerr = 0.5*yvals
    #yerr = sqrt(yvals)
    yerr = yvals.copy()
    yerr[:] = 0.05

    #xfine = 0.1+linspace(0.0,8.0,1000)
    xfine = 10.0**linspace(0.0,1.0,1000)
    yfine = xfine**slope 

    #yerr = yvals.copy()
    #yerr[:] = 2

    plt=FramedPlot()
    plt.xrange = [0.5*xvals.min(), 1.5*xvals.max()]
    plt.xlog=True
    #plt.ylog=True
    plt.add(Points(xvals,yvals,type='filled circle',size=1))
    plt.add(Curve(xfine,yfine,color='blue'))
    #w=where1( (yvals-yerr) > 1.e-5 )
    #plt.add(SymmetricErrorBarsY(xvals[w],yvals[w],yerr[w]))
    plt.add(SymmetricErrorBarsY(xvals,yvals,yerr))

    # make points in between consecutive xvals,yvals so we
    # can use hybrid 2-point function
    xi = numpy.zeros(xvals.size-1,dtype='f8')
    yi = numpy.zeros(xi.size,dtype='f8')
    for i in xrange(xi.size):

        logx = (log10(xvals[i+1])+log10(xvals[i]))/2.0
        xi[i] = 10.0**logx
        yi[i],amp,slope,off = interp_hybrid(xvals[i], xvals[i+1], 
                                            yvals[i], yvals[i+1],
                                            yerr[i], yerr[i+1], 
                                            xi[i],more=True)
        
        print 'amp:',amp
        print 'slope:',slope
        print 'off:',off

    print xvals
    print xi
    print yi
    plt.add( Points(xi, yi, type='filled circle', size=1, color='red'))

    plt.show()
コード例 #26
0
ファイル: test_moments.py プロジェクト: esheldon/fimage
    def plot(self, yrange=None):
        from biggles import FramedPlot, Points, Curve, PlotKey, Table,PlotLabel

        res=self.res

        etrue = res['etrue']
        e1true = res['e1true']
        e2true = res['e2true']

        facvals = res['facvals']
        sigma = res['sigma']
        e1=res['e1']
        e2=res['e2']
        e=res['e']

        T=res['T']
        Ttrue=res['Ttrue']*facvals**2


        e_pdiff = e/etrue-1
        T_pdiff = T/Ttrue-1
        

        compc= Curve(sigma, sigma*0)

        ce = Curve(sigma, e_pdiff, color='red')
        pe = Points(sigma, e_pdiff, type='filled circle')

        e_plt = FramedPlot()
        e_plt.add(ce,pe,compc)
        e_plt.xlabel = r'$\sigma$'
        e_plt.ylabel = r'$e/e_{true}-1$'

        cT = Curve(sigma, T_pdiff, color='red')
        pT = Points(sigma, T_pdiff, type='filled circle')

        T_plt = FramedPlot()
        T_plt.add(cT,pT,compc)
        T_plt.xlabel = r'$\sigma$'
        T_plt.ylabel = r'$T/T_{true}-1$'

        lab=PlotLabel(0.9,0.9,self.model,halign='right')
        T_plt.add(lab)

        if yrange is not None:
            e_plt.yrange=yrange
            T_plt.yrange=yrange
        
        tab=Table(2,1)

        tab[0,0] = T_plt
        tab[1,0] = e_plt


        tab.show()
コード例 #27
0
ファイル: regauss_test.py プロジェクト: esheldon/espy
    def plot_vs_field(self, field, plot_type, 
                      rmag_min=None, 
                      rmag_max=None, 
                      fmin=None, fmax=None, 
                      nbin=20, nperbin=50000,
                      xrng=None, yrng=None, show=True):

        
        allowed=['meane','residual']
        if plot_type not in allowed:
            raise ValueError("plot_type should be in [%s]" % ','.join(allowed))
        if plot_type == 'residual' and self.sweeptype != 'star':
            raise ValueError("residuals only supported for stars")

        if rmag_min is None:
            if self.sweeptype == 'gal':
                rmag_min=18.0
            else:
                rmag_min=15.0

        if rmag_max is None:
            if self.sweeptype == 'gal':
                rmag_max=21.8
            else:
                rmag_max=19.0

        # this will only load the main data once.
        self.load_data(field)

        print("Using rmag range: [%0.2f,%0.2f]" % (rmag_min,rmag_max))
        # notes 
        #  - amflags here is really corrflags_rg for gals
        #  - e1 is really e1_rg for gals
        logic = ((self['amflags'] == 0)
                 & (self['e1'] < 4)
                 & (self['e1'] > -4)
                 & (self['rmag'] > rmag_min)
                 & (self['rmag'] < rmag_max) )
        
        if self.sweeptype == 'gal':
            logic = logic & (self['R'] > 1.0/3.0) & (self['R'] < 1.0)

        w=where1(logic)
        print("Number passing cuts:",w.size)
        minnum=31000
        if w.size < minnum:
            print("want %d good objects, found %d" % (minnum,w.size))
            return

        weights = 1.0/(0.32**2 + self['uncer'][w]**2)

        # we can try to get nice labels for some fields
        if field == 'fwhm_psf':
            field_data = self['fwhm_psf'][w]
            fstr = 'PSF FWHM (arcsec)'
        elif field == 'sigma_psf':
            field_data = self['sigma_psf'][w]
            fstr = r'\sigma_{PSF}'
        elif field == 'sigma':
            field_data = self['sigma'][w]
            fstr = r'\sigma_{obj+PSF}'
        else:
            field_data = self[field][w]
            fstr=field
            fstr = fstr.replace('_','\_')

        print("Plotting for field:",field)

        if plot_type == 'residual':
            print('  doing: residual')
            be1 = eu.stat.Binner(field_data, self['e1'][w]-self['e1_psf'][w], 
                                 weights=weights)
            be2 = eu.stat.Binner(field_data, self['e2'][w]-self['e2_psf'][w], 
                                 weights=weights)
            ylabel = r'$<e_{star}-e_{PSF}>$'
        else:
            print('  doing meane')
            be1 = eu.stat.Binner(field_data, self['e1'][w], weights=weights)
            be2 = eu.stat.Binner(field_data, self['e2'][w], weights=weights)
            ylabel = r'$<e>$'


        # regular hist for display
        print("  regular fixed binsize hist")
        xm,xe,xstd=eu.stat.wmom(field_data, weights, sdev=True)
        #hxmin = xm-4.0*xstd
        #hxmax = xm+4.0*xstd
        bsize = xstd/5.
        hist = eu.stat.histogram(field_data, binsize=bsize, 
                                 weights=weights, more=True)


        print("  hist  e1, nperbin: ",nperbin)
        be1.dohist(nperbin=nperbin, min=fmin, max=fmax)
        #be1.dohist(nbin=nbin, min=fmin, max=fmax)
        print("  stats e1")
        be1.calc_stats()
        print("  hist  e2, nperbin: ",nperbin)
        be2.dohist(nperbin=nperbin, min=fmin, max=fmax)
        #be2.dohist(nbin=nbin, min=fmin, max=fmax)
        print("  stats e2")
        be2.calc_stats()



        plt = FramedPlot()

        if xrng is not None:
            plt.xrange=xrng
        else:
            if field == 'R':
                plt.xrange=[0.29,1.01]

        if yrng is not None:
            plt.yrange=yrng
            ymin = yrng[0]
            ymax = 0.8*yrng[1]
        else:
            ymin = min( be1['wymean'].min(),be2['wymean'].min() )
            ymax = 0.8*max( be1['wymean'].max(),be2['wymean'].max() )

        # this is a histogram-like object
        ph = eu.plotting.make_hist_curve(hist['low'], hist['high'], hist['whist'], 
                                         ymin=ymin, ymax=ymax, color='grey50')
        plt.add(ph)

        p1 = Points( be1['wxmean'], be1['wymean'], 
                    type='filled circle', color='blue')
        p1err = SymErrY( be1['wxmean'], be1['wymean'], be1['wyerr2'], color='blue')
        p1.label = r'$e_1$'

        p2 = Points( be2['wxmean'], be2['wymean'], 
                    type='filled circle', color='red')
        p2.label = r'$e_2$'
        p2err = SymErrY( be2['wxmean'], be2['wymean'], be2['wyerr2'], color='red')

        key = PlotKey(0.1,0.9, [p1,p2])
        plt.add(p1, p1err, p2, p2err, key)

        if self.camcol != 'any' and field == 'R' and plot_type=='meane':
            order=3
            print("  getting poly order",order)
            coeff1 = numpy.polyfit(be1['wxmean'], be1['wymean'], order)
            poly1=numpy.poly1d(coeff1)
            coeff2 = numpy.polyfit(be2['wxmean'], be2['wymean'], order)
            poly2=numpy.poly1d(coeff2)

            ps1 = Curve( be1['wxmean'], poly1(be1['wxmean']), color='blue')
            ps2 = Curve( be2['wxmean'], poly2(be2['wxmean']), color='red')
            plt.add(ps1,ps2)

            polyf = self.R_polyfile(self.camcol, rmag_max)
            out={'coeff_e1':list([float(c) for c in coeff1]),
                 'coeff_e2':list([float(c) for c in coeff2])}
            print("    -- Writing poly coeffs to:",polyf)
            eu.io.write(polyf,out)
        if field != 'rmag':
            rmag_lab = \
                PlotLabel(0.1,0.05,'%0.2f < rmag < %0.2f' % (rmag_min,rmag_max), 
                          halign='left')
            plt.add(rmag_lab)

        procrun_lab = PlotLabel(0.1,0.1,
                            'procrun: %s filter: %s' % (self.procrun, self.band), 
                            halign='left')
        plt.add(procrun_lab)
        cy=0.9
        if self.run != 'any':
            run_lab = PlotLabel(0.9,0.9, 'run: %06i' % self.run, halign='right')
            plt.add(run_lab)
            cy=0.8
        if self.camcol != 'any':
            run_lab = PlotLabel(0.9,cy, 'camcol: %i' % self.camcol, halign='right')
            plt.add(run_lab)



        plt.xlabel = r'$'+fstr+'$'
        plt.ylabel = ylabel


        if show:
            plt.show()
        epsfile = self.plotfile(field, rmag_max, plot_type=plot_type)
        eu.ostools.makedirs_fromfile(epsfile, verbose=True)
        print("  Writing eps file:",epsfile)
        plt.write_eps(epsfile)

        converter.convert(epsfile, verbose=True)
コード例 #28
0
ファイル: fit-prior-gmix-eta.py プロジェクト: esheldon/espy
    def doplot(self, gprior, minmag, maxmag):
        from lensing.util import eta1eta2_to_g1g2

        tab = Table(2, 2)
        tab.title = "%s %.2f %.2f " % (self.otype, minmag, maxmag)

        h1_g, h2_g, h_g = self.do_histograms(minmag, maxmag, "g")
        h1_eta, h2_eta, h_eta = self.do_histograms(minmag, maxmag, "eta")

        nrand = 1000000
        binsize_eta = self.binsize_eta
        binsize_g = self.binsize_g

        rbinsize_eta = binsize_eta * 0.2
        rbinsize_g = binsize_g * 0.2

        gr = gprior.sample(nrand)
        eta1_rand = gr[:, 0]
        eta2_rand = gr[:, 1]
        eta_rand = numpy.sqrt(eta1_rand ** 2 + eta2_rand ** 2)

        g1_rand, g2_rand = eta1eta2_to_g1g2(eta1_rand, eta2_rand)
        g_rand = numpy.sqrt(g1_rand ** 2 + g2_rand ** 2)

        hrand_eta = histogram(eta_rand, binsize=rbinsize_eta, min=0, max=self.max_eta, more=True)
        h1rand_eta = histogram(eta1_rand, binsize=rbinsize_eta, min=self.min_eta_2d, max=self.max_eta_2d, more=True)

        hrand_g = histogram(g_rand, binsize=rbinsize_g, min=0, max=self.max_g, more=True)
        h1rand_g = histogram(g1_rand, binsize=rbinsize_g, min=self.min_g_2d, max=self.max_g_2d, more=True)

        # eta 2d plots
        bratio_eta = self.binsize_eta / rbinsize_eta
        hrand_eta["hist"] = hrand_eta["hist"] * bratio_eta * float(h_eta["hist"].sum()) / nrand
        h1rand_eta["hist"] = h1rand_eta["hist"] * bratio_eta * float(h1_eta["hist"].sum()) / h1rand_eta["hist"].sum()

        pltboth_eta = FramedPlot()
        pltboth_eta.xlabel = r"$\eta$"

        hplt1_eta = Histogram(h1_eta["hist"], x0=h1_eta["low"][0], binsize=binsize_eta, color="darkgreen")
        hplt2_eta = Histogram(h2_eta["hist"], x0=h2_eta["low"][0], binsize=binsize_eta, color="blue")
        hpltrand_eta = Histogram(hrand_eta["hist"], x0=hrand_eta["low"][0], binsize=rbinsize_eta, color="red")
        hplt1rand_eta = Histogram(h1rand_eta["hist"], x0=h1rand_eta["low"][0], binsize=rbinsize_eta, color="red")

        hplt1_eta.label = r"$\eta_1$"
        hplt2_eta.label = r"$\eta_2$"
        hplt1rand_eta.label = "rand"
        hpltrand_eta.label = "rand"
        keyboth_eta = PlotKey(0.9, 0.9, [hplt1_eta, hplt2_eta, hplt1rand_eta], halign="right")

        pltboth_eta.add(hplt1_eta, hplt2_eta, hplt1rand_eta, keyboth_eta)

        tab[0, 0] = pltboth_eta

        plt1d_eta = FramedPlot()
        plt1d_eta.xlabel = r"$|\eta|$"

        hplt_eta = Histogram(h_eta["hist"], x0=h_eta["low"][0], binsize=binsize_eta)
        hplt_eta.label = r"$|\eta|$"

        key_eta = PlotKey(0.9, 0.9, [hplt_eta, hpltrand_eta], halign="right")
        plt1d_eta.add(hplt_eta, hpltrand_eta, key_eta)

        tab[1, 0] = plt1d_eta

        # g plots

        bratio_g = self.binsize_g / rbinsize_g
        hrand_g["hist"] = hrand_g["hist"] * bratio_g * float(h_g["hist"].sum()) / nrand
        h1rand_g["hist"] = h1rand_g["hist"] * bratio_g * float(h1_g["hist"].sum()) / h1rand_g["hist"].sum()

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

        hplt1_g = Histogram(h1_g["hist"], x0=h1_g["low"][0], binsize=binsize_g, color="darkgreen")
        hplt2_g = Histogram(h2_g["hist"], x0=h2_g["low"][0], binsize=binsize_g, color="blue")
        hpltrand_g = Histogram(hrand_g["hist"], x0=hrand_g["low"][0], binsize=rbinsize_g, color="red")
        hplt1rand_g = Histogram(h1rand_g["hist"], x0=h1rand_g["low"][0], binsize=rbinsize_g, color="red")

        hplt1_g.label = r"$g_1$"
        hplt2_g.label = r"$g_2$"
        hplt1rand_g.label = "rand"
        hpltrand_g.label = "rand"
        keyboth_g = PlotKey(0.9, 0.9, [hplt1_g, hplt2_g, hplt1rand_g], halign="right")

        pltboth_g.add(hplt1_g, hplt2_g, hplt1rand_g, keyboth_g)

        tab[0, 1] = pltboth_g

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

        hplt_g = Histogram(h_g["hist"], x0=h_g["low"][0], binsize=binsize_g)
        hplt_g.label = "|g|"

        key_g = PlotKey(0.9, 0.9, [hplt_g, hpltrand_g], halign="right")
        plt1d_g.add(hplt_g, hpltrand_g, key_g)

        tab[1, 1] = plt1d_g

        if self.show:
            tab.show()

        d = files.get_prior_dir()
        d = os.path.join(d, "plots")
        epsfile = "pofe-pofeta-%.2f-%.2f-%s.eps" % (minmag, maxmag, self.otype)
        epsfile = os.path.join(d, epsfile)
        eu.ostools.makedirs_fromfile(epsfile)
        print epsfile
        tab.write_eps(epsfile)
        os.system("converter -d 100 %s" % epsfile)

        return tab
コード例 #29
0
ファイル: lcat.py プロジェクト: esheldon/espy
    def plot_coverage(self, region='both', show=True, dops=True):
        """

        Plot a random subset of the randoms along with the
        boss survey geometry area as bounding boxes

        """
        import biggles
        from biggles import FramedPlot, Points, PlotKey

        symsize=0.5

        l = self.read()
        llam,leta = eu.coords.eq2sdss(l['ra'],l['dec'])

        lammin,lammax = (-70.,70.)

        if region=='ngc':
            # a bit high to make room for the legend
            emin,emax=(-40,60)

            biggles.configure('screen','width', 1800)
            biggles.configure('screen','height', 1140)
            width=1.5

        elif region=='sgc':
            emin,emax=(125,165)
            biggles.configure('screen','width', 1800)
            biggles.configure('screen','height', 1140)
            width=2
        else:
            emin,emax=(-40,165)
            biggles.configure('screen','width', 1140)
            biggles.configure('screen','height', 1140)
            width=2

        wl=where1((leta > emin) & (leta < emax))
        llam=llam[wl]
        leta=leta[wl]


        plt=FramedPlot()
        plt.xlabel=r'$\lambda$'
        plt.ylabel=r'$\eta$'
        xrng = (lammin, lammax)
        yrng = (emin, emax)
        plt.xrange = xrng
        plt.yrange = yrng


        print("adding random subset of randoms")

        ii = eu.numpy_util.random_subset(llam.size, 500000)
        allp = Points(llam[ii],leta[ii],type='dot',size=symsize)
        plt.add(allp)

        plt.aspect_ratio = (yrng[1]-yrng[0])/float(xrng[1]-xrng[0])

        #es_sdsspy.stomp_maps.plot_boss_geometry(color='blue',plt=plt,show=False)
        es_sdsspy.stomp_maps.plot_boss_geometry(plt=plt,show=False,width=width)

        if show:
            plt.show()

        if dops:
            d = lensing.files.sample_dir(type='lcat',sample=self['sample'])
            d = os.path.join(d,'plots')
            if not os.path.exists(d):
                os.makedirs(d)
            epsfile = os.path.join(d, '%s-%s-coverage.eps' % ('lcat',self['sample']))
            print("Writing to eps file:",epsfile)
            plt.write_eps(epsfile)
        return plt
コード例 #30
0
ファイル: cosmology_purepy.py プロジェクト: esheldon/esutil
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)
コード例 #31
0
ファイル: lcat.py プロジェクト: esheldon/espy
    def plot_coverage_bybin(self, binner, region='both', 
                            show=True, dops=True, rand=None):
        import pcolors
        import biggles
        import converter
        from biggles import FramedPlot, Points, PlotKey


        orig = self.read_original()
        lcat = self.read()

        all_clam,all_ceta = eu.coords.eq2sdss(orig['ra'],orig['dec'])

        l = orig[lcat['zindex']]
        clam,ceta = eu.coords.eq2sdss(lcat['ra'],lcat['dec'])

        clammin,clammax = (-70.,120.)

        if region=='ngc':
            # a bit high to make room for the legend
            emin,emax=(-40,60)

            biggles.configure('screen','width', 1800)
            biggles.configure('screen','height', 1140)

            clammin,clammax = (-70.,120.)

        elif region=='sgc':
            emin,emax=(105,165)
            biggles.configure('screen','width', 1800)
            biggles.configure('screen','height', 1140)
            clammin,clammax = (-50.,90.)
        else:
            emin,emax=(-40,165)
            biggles.configure('screen','width', 1140)
            biggles.configure('screen','height', 1140)
            clammin,clammax = (-70.,120.)

        wl=where1((all_ceta > emin) & (all_ceta < emax))
        all_clam=all_clam[wl]
        all_ceta=all_ceta[wl]

        wl=where1((ceta > emin) & (ceta < emax))
        clam=clam[wl]
        ceta=ceta[wl]
        l=l[wl]


        plt=FramedPlot()
        plt.xlabel=r'$\lambda$'
        plt.ylabel=r'$\eta$'
        xrng = (clammin, clammax)
        yrng = (emin, emax)
        plt.xrange = xrng
        plt.yrange = yrng


        print("adding all lenses")

        type = 'filled circle'
        symsize=0.2
        colors = pcolors.rainbow(binner['nbin'],'hex')


        if rand is not None:
            clam_r,ceta_r = eu.coords.eq2sdss(rand['ra'],rand['dec'])
            wl=where1((ceta_r > emin) & (ceta_r < emax))
            clam_r=clam_r[wl]
            ceta_r=ceta_r[wl]
            rp = Points(clam_r, ceta_r, type='dot', size=0.2)
            plt.add(rp)
        
        size_min=0.2
        size_max=4

        sizes=[]
        minlambda = l['lambda_zred'].min()
        maxlambda = l['lambda_zred'].max()
        for i in xrange(binner['nbin']):
            w=binner.select_bin(l, i)
            mlam=l['lambda_zred'][w].mean()
            # scale 0 to 1
            sz=(mlam-minlambda)/maxlambda
            # now scale size
            sz = size_min + sz*(size_max-size_min)
            sizes.append(sz)

        all_plots=[]
        labels=[]
        #for i in xrange(binner['nbin']):
        for i in reversed(xrange(binner['nbin'])):
            w=binner.select_bin(l, i)

            #points = Points(clam[w], ceta[w],type=type,size=symsize, color=colors[i])
            points = Points(clam[w], ceta[w],type=type,size=sizes[i], color=colors[i])
            labels.append(binner.bin_label(i))

            plt.add(points)


        labels.reverse()
        fakepoints = eu.plotting.fake_filled_circles(labels, colors)
        key=PlotKey(0.95,0.95,fakepoints,halign='right',size=1.5)
        plt.add(key)

        plt.aspect_ratio = (yrng[1]-yrng[0])/float(xrng[1]-xrng[0])

        es_sdsspy.stomp_maps.plot_boss_geometry(color='blue',plt=plt,show=False)

        if show:
            plt.show()

        if dops:
            d = lensing.files.sample_dir(type='lcat',sample=self['sample'])
            d = os.path.join(d,'plots')
            if not os.path.exists(d):
                os.makedirs(d)
            epsfile = os.path.join(d, 'lcat-%s-coverage-bybin.eps' % self['sample'])
            if rand is not None:
                epsfile=epsfile.replace('.eps','-withrand.eps')
            if region in ['sgc','ngc']:
                epsfile=epsfile.replace('.eps','-%s.eps' % region)

            print("Writing to eps file:",epsfile)
            plt.write_eps(epsfile)
            print("converting to png")
            converter.convert(epsfile, dpi=300)
        return plt