Exemple #1
0
def plot_sub_pixel(ellip,theta, show=False):
    import biggles
    from biggles import PlotLabel,FramedPlot,Table,Curve,PlotKey,Points
    from pcolors import rainbow

    f=subpixel_file(ellip,theta,'fits')
    data = eu.io.read(f)
    colors = rainbow(data.size,'hex')

    pltSigma = FramedPlot()
    pltSigma.ylog=1
    pltSigma.xlog=1

    curves=[]
    for j in xrange(data.size):
        sigest2 = (data['Irr'][j,:] + data['Icc'][j,:])/2

        pdiff = sigest2/data['sigma'][j]**2 -1
        nsub=numpy.array(data['nsub'][j,:])

        #pc = biggles.Curve(nsub, pdiff, color=colors[j])
        pp = Points(data['nsub'][j,:], pdiff, type='filled circle',color=colors[j])

        pp.label = r'$\sigma: %0.2f$' % data['sigma'][j]
        curves.append(pp)
        pltSigma.add(pp)
        #pltSigma.add(pc)
        #pltSigma.yrange=[0.8,1.8]
        #pltSigma.add(pp)


    c5 = Curve(linspace(1,8, 20), .005+zeros(20))
    pltSigma.add(c5)

    key=PlotKey(0.95,0.95,curves,halign='right',fontsize=1.7)
    key.key_vsep=1

    pltSigma.add(key)
    pltSigma.xlabel='N_{sub}'
    pltSigma.ylabel=r'$\sigma_{est}^2  /\sigma_{True}^2 - 1$'

    lab=PlotLabel(0.05,0.07,r'$\epsilon: %0.2f \theta: %0.2f$' % (ellip,theta),halign='left')
    pltSigma.add(lab)

    pltSigma.yrange = [1.e-5,0.1]
    pltSigma.xrange = [0.8,20]
    if show:
        pltSigma.show()

    epsfile=subpixel_file(ellip,theta,'eps')

    print("Writing eps file:",epsfile)
    pltSigma.write_eps(epsfile)
Exemple #2
0
    def make_plot(self):

        bindata=self.bindata
        bin_field=self.bin_field
        plt=FramedPlot()
        
        plt.uniform_limits=1
        plt.xlog=True
        #plt.xrange=[0.5*bindata[bin_field].min(), 1.5*bindata[bin_field].max()]
        plt.xrange=self.s2n_range
        plt.xlabel=bin_field
        plt.ylabel = r'$\gamma$'
        if self.yrange is not None:
            plt.yrange=self.yrange

        xdata=bindata[bin_field]
        xerr=bindata[bin_field+'_err']

        if self.shnum in sh1exp:
            g1exp=zeros(xdata.size)+sh1exp[self.shnum]
            g2exp=zeros(xdata.size)+sh2exp[self.shnum]
            g1exp_plt=Curve(xdata, g1exp)
            g2exp_plt=Curve(xdata, g2exp)
            plt.add(g1exp_plt)
            plt.add(g2exp_plt)


        xerrpts1 = SymmetricErrorBarsX(xdata, bindata['g1'], xerr)
        xerrpts2 = SymmetricErrorBarsX(xdata, bindata['g2'], xerr)

        type='filled circle'
        g1color='blue'
        g2color='red'
        g1pts = Points(xdata, bindata['g1'], type=type, color=g1color)
        g1errpts = SymmetricErrorBarsY(xdata, bindata['g1'], bindata['g1_err'], color=g1color)
        g2pts = Points(xdata, bindata['g2'], type=type, color=g2color)
        g2errpts = SymmetricErrorBarsY(xdata, bindata['g2'], bindata['g2_err'], color=g2color)

        g1pts.label=r'$\gamma_1$'
        g2pts.label=r'$\gamma_2$'

        key=biggles.PlotKey(0.9,0.5,[g1pts,g2pts],halign='right')

        plt.add( xerrpts1, g1pts, g1errpts )
        plt.add( xerrpts2, g2pts, g2errpts )
        plt.add(key)

        labels=self.get_labels()

        plt.add(*labels)
        plt.aspect_ratio=1

        self.plt=plt
Exemple #3
0
    def make_plot_components(self, fdata, e1, e2, weights, nperbin, 
                             ymin,ymax,
                             fmin=None, fmax=None,
                             coeffs=None):
        be1 = eu.stat.Binner(fdata, e1, weights=weights)
        be2 = eu.stat.Binner(fdata, e2, weights=weights)

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

        # regular hist for display
        print("  regular fixed binsize hist")
        xm,xe,xstd=eu.stat.wmom(fdata, weights, sdev=True)
        bsize = xstd/5.
        hist = eu.stat.histogram(fdata, binsize=bsize, 
                                 weights=weights, more=True)

        ph = eu.plotting.make_hist_curve(hist['low'], hist['high'], hist['whist'], 
                                         ymin=ymin, ymax=ymax, color='grey50')

        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')

        if coeffs is not None:
            poly1=numpy.poly1d(coeffs['coeff_e1'])
            poly2=numpy.poly1d(coeffs['coeff_e2'])
            t1 = Curve( be1['wxmean'], poly1(be1['wxmean']), color='blue')
            t2 = Curve( be2['wxmean'], poly2(be2['wxmean']), color='red')
            return p1,p1err,p2,p2err,ph,t1,t2
        else:
            return p1,p1err,p2,p2err,ph
Exemple #4
0
    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)
Exemple #5
0
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
Exemple #6
0
def plot2dsig(r1, dsig1, dsig1err, r2, dsig2, dsig2err, **keys):
    """
    Plot delta sigma and a second delta sigma in two plots the second of which
    is linear.

    Parameters
    ----------
    show: bool, optional
        Show plot in a window, default True
    yrange1: [min,max]
        The y range of the delta sigma plot
    yrange2: [min,max]
        The y range of the ortho-delta sigma plot
    range4var: [min,max]
        The x range over which to calculate a osig variance
        and determine a plot range.  This is overridden by
        range2

    plot_label: string, optional
        a label for the top plot

    # label1,label2 go in a key in the bottom plot
    label1: string, optional
        a label for the first dsig
    label2: string, optional
        a label for the second dsig


    """

    color2 = 'red'
    ptype1='filled circle'
    size1=1.5
    ptype2='filled circle'
    size2=1.5

    xmul = keys.get('xmul',1.)

    show = keys.get('show',True)
    yrange1 = keys.get('yrange1',None)
    yrange2 = keys.get('yrange2',None)

    isortho = keys.get('ortho',False)

    # this is a y-log plot, use more powerful range determination
    print dsig1
    print dsig1err
    yrange1 = eu.plotting.get_log_plot_range(dsig1, err=dsig1err, 
                                             input_range=yrange1)

    rr=numpy.concatenate((r1,r2))
    xrng = eu.plotting.get_log_plot_range(rr)

    # this over-rides
    range4var = keys.get('range4var',None)
    if yrange2 is None:
        if range4var is not None:
            w=where1( (r2 >= range4var[0]) & (r2 <= range4var[1]))
            if w.size == 0:
                raise ValueError("no points in range [%d,%d]" % tuple(range4var))
            sdev = dsig2[w].std()
        else:
            sdev = dsig2.std()

        yrange2 = [-3.5*sdev, 3.5*sdev]


    label  = keys.get('plot_label',None)
    label1 = keys.get('label1',None)
    label2 = keys.get('label2',None)

    # The points and zero curve
    dsig1_p = Points(r1, dsig1, color='black', type=ptype1, size=size1)
    dsig1err_p = SymErrY(r1, dsig1, dsig1err, color='black')
    dsig1_p.label=label1

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

    c=Curve([1.e-5,1.e5],[0,0], type='solid')


    arr = FramedArray(2,1)
    arr.cellspacing=1
    arr.aspect_ratio=2
    arr.xlabel = labels['rproj']
    if isortho:
        arr.ylabel = labels['osig']
    else:
        arr.ylabel = labels['dsig']
    arr.xrange = xrng


    arr[0,0].yrange = yrange1
    arr[0,0].xlog=True
    arr[0,0].ylog=True

    # biggles chokes if you give it negative data for a log plot
    arr[0,0].add(dsig1_p, dsig2_p)
    eu.plotting.add_log_error_bars(arr[0,0],'y',r1,dsig1,dsig1err,yrange1)
    eu.plotting.add_log_error_bars(arr[0,0],'y',r2,dsig2,dsig2err,yrange1,color=color2)

    if label is not None:
        arr[0,0].add(PlotLabel(0.9,0.9,label,halign='right'))


    arr[1,0].yrange = yrange2
    arr[1,0].xlog=True
    arr[1,0].add(c)
    arr[1,0].add(dsig1_p, dsig1err_p, dsig2_p, dsig2err_p)

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


    if show:
        arr.show()
    return arr
Exemple #7
0
def plot2dsig_old(r, dsig1, dsig1err, dsig2, dsig2err, **keys):
    """
    Plot delta sigma and a second delta sigma in two plots the second of which
    is linear.

    Parameters
    ----------
    show: bool, optional
        Show plot in a window, default True
    range1: [min,max]
        The y range of the delta sigma plot
    range2: [min,max]
        The y range of the ortho-delta sigma plot
    range2var: [min,max]
        The x range over which to calculate a osig variance
        and determine a plot range.  This is overridden by
        range2

    plot_label: string, optional
        a label for the top plot

    # label1,label2 go in a key in the bottom plot
    label1: string, optional
        a label for the first dsig
    label2: string, optional
        a label for the second dsig


    """

    show = keys.get('show',True)
    range1 = keys.get('range1',None)
    range2 = keys.get('range2',None)

    # this over-rides
    range4var = keys.get('range4var',None)
    if range2 is None:
        if range4var is not None:
            w=where1( (r >= range4var[0]) & (r <= range4var[1]))
            if w.size == 0:
                raise ValueError("no points in range [%d,%d]" % tuple(range4var))
            sdev = dsig2[w].std()
        else:
            sdev = dsig2.std()

        range2 = [-3.5*sdev, 3.5*sdev]
        print 'range2:',range2


    label  = keys.get('plot_label',None)
    label1 = keys.get('label1',None)
    label2 = keys.get('label2',None)

    # for overplotting
    dsig1_p = Points(r, dsig1, color='red')
    dsig1err_p = SymErrY(r, dsig1, dsig1err, color='red')
    dsig1_p.label=label1

    dsig2_p = Points(r, dsig1, color='red')
    dsig2err_p = SymErrY(r, dsig1, dsig1err, color='black')
    dsig2_p.label=label1

    arr = FramedArray(2,1)
    arr.aspect_ratio=2
    arr.xlabel = labels['rproj']
    arr.ylabel = labels['dsig']

    eu.plotting.bscatter(r, dsig1, yerr=dsig1err,
                         xlog=True, ylog=True, 
                         yrange=range1,
                         show=False, 
                         plt=arr[0,0],
                         **keys)

    if label is not None:
        arr[0,0].add(PlotLabel(0.9,0.9,label,halign='right'))


    pdict=eu.plotting.bscatter(r, dsig2, yerr=dsig2err,
                               xlog=True, 
                               yrange=range2,
                               label=label2,
                               show=False,
                               dict=True,
                               plt=arr[1,0],
                               **keys)
    c=Curve([1.e-5,1.e5],[0,0], type='solid')
    arr[1,0].add(c)
    arr[1,0].add(dsig1_p,dsig1err_p)

    if label1 is not None or label2 is not None:
        key = PlotKey(0.9,0.9, [dsig1_p,pdict['p']], halign='right')
        arr[1,0].add(key)


    if show:
        arr.show()
    return arr
Exemple #8
0
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
Exemple #9
0
    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
Exemple #10
0
    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)
Exemple #11
0
def doplot(run, st, s2n_field, setname, s2n_range, sratio_range, psfnums, nobj):
    tab=Table(2,1)

    color1='blue'
    color2='red'

    m1pts=Points(st['s2n'],st['m1'],type='filled circle',color=color1)
    m1errpts=SymmetricErrorBarsY(st['s2n'],st['m1'],st['m1_err'],color=color1)
    m2pts=Points(st['s2n'],st['m2'],type='filled circle',color=color2)
    m2errpts=SymmetricErrorBarsY(st['s2n'],st['m2'],st['m2_err'],color=color2)

    c1pts=Points(st['s2n'],st['c1'],type='filled circle',color=color1)
    c1errpts=SymmetricErrorBarsY(st['s2n'],st['c1'],st['c1_err'],color=color1)
    c2pts=Points(st['s2n'],st['c2'],type='filled circle',color=color2)
    c2errpts=SymmetricErrorBarsY(st['s2n'],st['c2'],st['c2_err'],color=color2)

    m1pts.label=r'$\gamma_1$'
    m2pts.label=r'$\gamma_2$'

    key=PlotKey(0.9,0.2,[m1pts,m2pts], halign='right')

    xrng=array( [0.5*s2n_range[0], 1.5*s2n_range[1]])
    cyrng=get_symmetric_range(st['c1'],st['c1_err'],st['c2'],st['c2_err'])
    myrng=get_symmetric_range(st['m1'],st['m1_err'],st['m2'],st['m2_err'])

    mplt=FramedPlot()
    cplt=FramedPlot()
    mplt.xlog=True
    cplt.xlog=True

    mplt.xrange=xrng
    cplt.xrange=xrng
    #mplt.yrange=myrng
    #cplt.yrange=cyrng
    mplt.yrange=[-0.15,0.15]
    cplt.yrange=[-0.01,0.01]

    mplt.xlabel=s2n_field
    mplt.ylabel='m'
    cplt.xlabel=s2n_field
    cplt.ylabel='c'

    zplt=Curve(xrng, [0,0])
    mallow=Curve(xrng, [-0.004, 0.004])
    callow=Curve(xrng, [-0.0004, 0.0004])

    mallow=FillBetween(xrng, [0.004,0.004], 
                       xrng, [-0.004,-0.004],
                       color='grey80')
    callow=FillBetween(xrng, [0.0004,0.0004], 
                       xrng, [-0.0004,-0.0004],
                       color='grey80')



    labels=get_labels(run,
                      psfnums,
                      setname,
                      nobj,
                      sratio_range)

    mplt.add( mallow, zplt, m1pts, m1errpts, m2pts, m2errpts, key )
    mplt.add(*labels)

    cplt.add( callow, zplt, c1pts, c1errpts, c2pts, c2errpts )

    tab[0,0] = mplt
    tab[1,0] = cplt

    tab.show()