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()
def plot_nfwfits_byrun(run, name, prompt=False):
conf = lensing.files.read_config(run)
d = lensing.sample_read(type='fit', sample=run, name=name)
omega_m = conf['omega_m']
rvals = numpy.linspace(d['r'].min(), d['r'].max(),1000)
for i in xrange(d.size):
plt = FramedPlot()
lensing.plotting.add_to_log_plot(plt,
d['r'][i],
d['dsig'][i],
d['dsigerr'][i])
z = d['z_mean'][i]
n = lensing.nfw.NFW(omega_m, z)
yfit = n.dsig(rvals, d['r200_fit'][i],d['c_fit'][i])
plt.add(Curve(rvals,yfit,color='blue'))
plt.xlog=True
plt.ylog=True
plt.xlabel = r'$r$ [$h^{-1}$ Mpc]'
plt.ylabel = r'$\Delta\Sigma ~ [M_{sun} pc^{-2}]$'
if prompt:
plt.show()
raw_input('hit a key: ')
else:
epsfile='/home/esheldon/tmp/plots/desmocks-nfwfit-%02i.eps' % i
print 'Writing epsfile:',epsfile
plt.write_eps(epsfile)
def test_fit_nfw_dsig(rmin=0.01):
from biggles import FramedPlot,Points,SymmetricErrorBarsY,Curve
omega_m=0.25
z=0.25
n = lensing.nfw.NFW(omega_m, z)
r200 = 1.0
c = 5.0
rmax = 5.0
log_rmin = log10(rmin)
log_rmax = log10(rmax)
npts = 25
logr = numpy.linspace(log_rmin,log_rmax,npts)
r = 10.0**logr
ds = n.dsig(r, r200, c)
# 10% errors
dserr = 0.1*ds
ds += dserr*numpy.random.standard_normal(ds.size)
guess = numpy.array([r200,c],dtype='f8')
# add 10% error to the guess
guess += 0.1*guess*numpy.random.standard_normal(guess.size)
res = fit_nfw_dsig(omega_m, z, r, ds, dserr, guess)
r200_fit = res['r200']
r200_err = res['r200_err']
c_fit = res['c']
c_err = res['c_err']
print 'Truth:'
print ' r200: %f' % r200
print ' c: %f' % c
print 'r200_fit: %f +/- %f' % (r200_fit,r200_err)
print ' c_fit: %f +/- %f' % (c_fit,c_err)
print 'Cov:'
print res['cov']
logr = numpy.linspace(log_rmin,log_rmax,1000)
rlots = 10.0**logr
yfit = n.dsig(rlots,r200_fit,c_fit)
plt=FramedPlot()
plt.add(Points(r,ds,type='filled circle'))
plt.add(SymmetricErrorBarsY(r,ds,dserr))
plt.add(Curve(rlots,yfit,color='blue'))
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()
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()
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
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()
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()
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)
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
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()
def make_frac_plot(self):
if self.shnum not in sh1exp:
raise ValueError("you must know the expected value")
if sh1exp[self.shnum] != 0:
gfield='g1'
gtrue=sh1exp[self.shnum]
elif sh2exp[self.shnum] != 0:
gfield='g2'
gtrue=sh2exp[self.shnum]
else:
raise ValueError("all expected are listed as zero")
bindata=self.bindata
bin_field=self.bin_field
plt=FramedPlot()
plt.title=self.get_title()
plt.xlog=True
plt.xrange=[0.5*bindata[bin_field].min(), 1.5*bindata[bin_field].max()]
plt.xlabel=bin_field
ylabel=r'$\Delta \gamma/\gamma$'
plt.ylabel = ylabel
xdata=bindata[bin_field]
zero=zeros(xdata.size)
zero_plt=Curve(xdata, zero)
plt.add(zero_plt)
xfill=[xdata.min(), xdata.max()]
plt.add( biggles.FillBetween(xfill, [0.004,0.004],
xfill, [-0.004,-0.004],
color='grey80'))
gfrac = bindata[gfield]/gtrue-1
gfrac_err = bindata[gfield+'_err']/gtrue
type='filled circle'
color='blue'
gpts = Points(xdata, gfrac, type=type, color=color)
gerrpts = SymmetricErrorBarsY(xdata, gfrac, gfrac_err,color=color)
plt.add( gpts, gerrpts )
self.plt=plt
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()
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
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
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)
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
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
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()
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
def xi_int_pk_slow(self, k, Pk, r, debug=False, doplot=False):
"""
Maybe try a slow but more accurate version here
get xi at position r by integrating P(k). r should be a scalar
the integral is done in two parts
"""
import scipy.integrate
# some of this could be pre-computed, but it might
# not matter
NumPerPer = 30.0
# Number of samples per period, should always be > 5 at least
npd = 100
# depends on cosmology but this is ballpark
L_wiggle=170.0
Pref=1.0 /(2.0 * PI**2 * r)
dk1=2.0 *PI/(NumPerPer*L_wiggle)
dk2=2.0 *PI/(NumPerPer*r)
dktry=min([dk1,dk2])
# first section
kmin=0.0
kmax=2.0
numk=int32((kmax-kmin)/dktry)
dk=(kmax-kmin)/(1.0*numk-1)
kk=arange(numk,dtype='f8')*dk+kmin
# Dave used *local* cubic spline interpolation (the /spline)
# keyword for interpol. This seems to give radically different
# results! Using interpsp2 above gets us within about 6%
# of dave's answer. Which is right? I think the right thing
# to do is use more values for Pk,k and do linear interpolation
Pkk=interplin(Pk,k,kk)
#Pkk=interp(kk,k,Pk)
tab=Pkk*kk*sin(kk*r)
integ = scipy.integrate.simps(tab,x=kk)
xi_1=Pref*integ
if debug:
print 'r=',r
if dk1 < dk2:
print 'Baryon wiggle limited'
else:
print 'Sin(k*r) limited'
print 'Numk=',numk
print 'dk=',dk
integ_trap = scipy.integrate.trapz(tab,x=kk)
integ_qg1000 = self.qg1000.integrate(kk,tab)
print 'integ=',integ
print 'integ_trap=',integ_trap
print 'integ_qg1000=',integ_qg1000
nprint=20
if doplot:
wk=where1(k < kmax)
wkk=where1(kk > 1.e-8)
ptab=Table(2,1)
lplt=FramedPlot()
lplt.add( Points(k[wk],Pk[wk],type='filled circle',size=1) )
lplt.add( Points(kk[wkk],Pkk[wkk], color='red',
type='filled circle', size=0.7))
lplt.add( Curve(kk[wkk],Pkk[wkk], color='blue'))
lplt.xlog=True
ptab[0,0] = lplt
splt = FramedPlot()
splt.add(Points(k[wk],Pk[wk]*k[wk]*sin(k[wk]*r),
type='filled circle',size=1))
splt.add(Points(kk[wkk],tab[wkk],
color='red',type='filled circle',size=0.7))
splt.add(Curve(kk[wkk],tab[wkk], color='blue'))
splt.xlog=True
ptab[1,0] = splt
ptab.show()
# next section/method
# now need integral \int_xmax^infinity x P(x/r) sin(x)
Pref2=Pref/(r**2)
xmax=r*kmax
num_dec=5
num_per_dec=npd
numx=num_dec*num_per_dec
x=xmax*10.0**(arange(numx,dtype='f8')/num_per_dec)
Px=interplin(Pk,k,x/r)
y=x*Px
ly=log(y)
n=numx
al=(roll(ly,-1)-ly)/(roll(x,-1)-x)
al[n-1]=al[n-2]
Amp=y/exp(al*x)
# integral boundaries
a=x
b=roll(x,-1)
norm=y/(1+al**2)
Ta=al*sin(a)-cos(a)
Tb=al*sin(b)-cos(b)
dif=exp(al*(b-a))*Tb-Ta
d=norm*dif
d=d[0:n-2]
integ=d.sum()
xi_2=integ*Pref2
xi=xi_1+xi_2
if debug:
print 'xi_1:',xi_1
print 'xi_2:',xi_2
return xi
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()
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()
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)
def main():
options,args = parser.parse_args(sys.argv[1:])
if len(args) < 3:
parser.print_help()
sys.exit(1)
run1 = args[0]
run2 = args[1]
bintype = args[2]
rrange=options.rrange
if rrange is not None:
rrange=[float(r) for r in rrange.split(',')]
biggles.configure('screen','width', 1400)
biggles.configure('default','fontsize_min',1.0)
b = lensing.binning.instantiate_binner(bintype)
name=b.get_name()
data1 = lensing.files.sample_read(type=options.type, sample=run1, name=name)
data2 = lensing.files.sample_read(type=options.type, sample=run2, name=name)
nbin=data1.size
tab=Table(1,2)
for i in xrange(nbin):
tab[0,0] = plot2dsig_over(
data1['r'][i],data1['dsig'][i],data1['dsigerr'][i],
data2['r'][i],data2['dsig'][i],data2['dsigerr'][i],
label1=run1,label2=run2,label=b.bin_label(i),
show=False)
tab[0,0].aspect_ratio=1
pbot = FramedPlot()
rat=data1['dsig'][i]/data2['dsig'][i]
raterr = rat*numpy.sqrt( (data1['dsigerr'][i]/data1['dsig'][i])**2
+(data2['dsigerr'][i]/data2['dsig'][i])**2 )
rpts=Points(data1['r'][i], rat, type='filled circle',color='blue')
rerr=SymErrY(data1['r'][i], rat, raterr,color='blue')
if rrange is None:
rat_use,raterr_use=rat,raterr
else:
w,=numpy.where( (data1['r'][i] > rrange[0]) & (data1['r'][i] < rrange[1]))
rat_use,raterr_use=rat[w],raterr[w]
mn,err = eu.stat.wmom(rat_use, 1/raterr_use**2, calcerr=True)
plot_rrange=[0.5*data1['r'][i].min(),data1['r'][i].max()*2]
z=Curve(plot_rrange, [1,1])
pbot.add(rpts,rerr,z)
pbot.xlog=True
pbot.xlabel = lensing.plotting.labels['rproj']
pbot.ylabel = '%s/%s' % (run1,run2)
pbot.yrange=[0,2]
pbot.xrange = plot_rrange
pbot.aspect_ratio=1
lab='<ratio>'
if rrange is not None:
lab = r'$%s r \in [%.2f,%.2f]$' % (lab,rrange[0],rrange[1])
lab='%s: %0.2f +/- %0.2f' % (lab,mn,err)
pbot.add(PlotLabel(0.9,0.9,lab,halign='right'))
tab[0,1] = pbot
tab.show()
epsfile=lensing.files.sample_file(type='binned-plots',
sample=run1,
name=name,
extra='compare-%s-%02d' % (run2,i),
ext='eps')
print("writing:",epsfile)
tab.write_eps(epsfile)
if nbin > 1:
key=raw_input('hit a key: ')
if key.lower() == 'q':
return
