def test_coellip2(nstep=10000, burnin=1000, s2n=None):
ngauss=2
dims=array([21,21])
cen=(dims-1)/2.
covar1=[2.0,0.0,2.0]
covar2=[2.5,0.0,2.5]
counts1=1.0
counts2=0.3
sky=0.0
skysig=0.001
im1 = model_image('gauss',
dims,
cen,covar1,
counts=counts1,
nsub=1)
im2 = model_image('gauss',
dims,
cen,covar2,
counts=counts2,
nsub=1)
im = im1 + im2 + skysig*randn(dims[0]*dims[1]).reshape(dims)
guess=zeros(2+3+2*ngauss)
guess[0:2] = cen + 0.1*(random(2)-0.5)
guess[2:5] = covar + 0.1*(random(3)-0.5)
guess[5:7] = array([0.5,0.5]) # p vals
guess[7:9] = array([1.0,1.0]) # f vals
print 'guess:',guess
# step widths
#[censig,covsig,psig,fsig]
stepsize=array([0.01,0.01,0.01,0.01])
# prior widths
width=array([0.2,0.2,0.2,0.2])
obj=MCMCCoellip(im, sky, skysig, guess, width, stepsize)
m=mcmc.MCMC(obj)
res = m.run(nstep, guess)
means, errs = mcmc.extract_stats(res, burnin,sigma_clip=False)
print 'means +/- err'
for i in xrange(len(means)):
print ' %.16g +/- %.16g' % (means[i],errs[i])
return res
def dopow():
#A = .7151
#B = .3081
#0.5026 x - 0.5806
#A = 0.5026
#B = 0.5806
A = 0.6982
B = - 0.3023
rat=zeros(n)
for i,sigma2 in enumerate(sigma2vals):
sigma2use = 10.**B * sigma2**A
sz=2*sigma2*sigfac
dims=array([sz,sz])
if (dims[0] % 2) == 0:
dims += 1
cen = (dims-1)/2
im=fimage.model_image('dev',
dims,
cen,
[sigma2use,0.,sigma2use],nsub=16)
stat=fimage.statistics.fmom(im)
rat[i] = stat['cov'][0]/sigma2
print 'rat:',rat[i]
def test1(Irr,Irc,Icc,counts=1, sigsky=None, nsub=4):
import pprint
import fimage
T = Irr+Icc
sigma = numpy.sqrt(T/2)
imsize = int( 2*4.5*sigma )
if (imsize % 2) == 0:
imsize += 1
imdims=[imsize]*2
cen = [(imsize-1)/2., (imsize-1)/2.]
e1 = (Icc-Irr)/(Irr+Icc)
e2 = 2*Irc/(Irr+Icc)
g = fimage.model_image('gauss', imdims, cen, Irr, Irc, Icc, counts=counts, nsub=16)
if sigsky is not None:
g[:,:] += numpy.random.normal(size=g.size, scale=sigsky).reshape(g.shape)
res = admom(g, cen[0], cen[1], sigsky=sigsky, guess=T/2, nsub=nsub)
res['Irr_true'] = Irr
res['Irc_true'] = Irc
res['Icc_true'] = Icc
res['e1_true'] = e1
res['e2_true'] = e2
return res, g
def make_f0(self):
import fimage
if 'imstats' not in self or 'psfstats' not in self:
raise ValueError("run admom on image and psf first")
Irr=self['imstats']['Irr']
Irc=self['imstats']['Irc']
Icc=self['imstats']['Icc']
Irr_psf=self['psfstats']['Irr']
Irc_psf=self['psfstats']['Irc']
Icc_psf=self['psfstats']['Icc']
# construct the f0 parameters
Irr_f0 = Irr - Irr_psf
Irc_f0 = Irc - Irc_psf
Icc_f0 = Icc - Icc_psf
det_f0 = Irr_f0*Icc_f0 - Irc_f0**2
imcounts = self.image.sum()
self.f0 = None
if det_f0 > self.detf0_tol:
wrow = self['imstats']['wrow']
wcol = self['imstats']['wcol']
self.f0 = fimage.model_image('gauss',
self.image.shape,
[wrow,wcol],
[Irr_f0, Irc_f0, Icc_f0],
nsub=1,
counts=imcounts)
else:
if self.verbose:
print("Found det(f0) less than tolerance:",det_f0,"<",self.detf0_tol)
def test_admom(covar, ntrial=1, s2n=35.0):
print 'covar:',covar,'s2n:',s2n
import admom
nsub=1
ngauss=1
dims=array([21,21])
cen=(dims-1)/2.
det = covar[0]*covar[2] - covar[1]**2
counts=1.0
sky=0.0
# weighted admom s2n of about 35
#skysig=0.004
skysig = counts/s2n/sqrt(4*pi*det)
s2n_exp = counts/skysig/sqrt(4*pi*det)
im0 = model_image('gauss',
dims,
cen,covar,
counts=counts,
nsub=nsub)
allmeans = zeros( (ntrial, 3) )
for j in xrange(ntrial):
im = im0 + skysig*randn(dims[0]*dims[1]).reshape(dims)
guess = (covar[1]+covar[2])/2 + 0.1*(random(2)-0.5)
res = admom.admom(im, cen[0], cen[1], sigsky=skysig, nsub=nsub)
#print s2n_exp,res['s2n']
allmeans[j,:] = [res['Irr'],res['Irc'],res['Icc']]
return allmeans
def test_psf1():
"""
Test the code where we input the psf moments
"""
import fimage
psf_irr=1.5
psf_irc=0.3
psf_icc=2.0
irr = 2.0
irc = 0.0
icc = 2.3
dims=[31,31]
cen=[15,15]
image = fimage.model_image('gauss',dims,cen,
[irr+psf_irr,irc+psf_irc,icc+psf_icc],
counts=1)
res_comb = admom(image, cen[0], cen[1])
res = admom_1psf(image, cen[0], cen[1], psf_irr, psf_irc, psf_icc)
print("Irr input:",irr,"Irr meas:",res['Irr'])
print("Irc input:",irc,"Irc meas:",res['Irc'])
print("Icc input:",icc,"Icc meas:",res['Icc'])
print("Irr comb input:",irr+psf_irr,"Irr meas:",res_comb['Irr'])
print("Irc comb input:",irc+psf_irc,"Irc meas:",res_comb['Irc'])
print("Icc comb input:",icc+psf_icc,"Icc meas:",res_comb['Icc'])
def make_model(self, pars):
"""
pars = [row,col,T,eta,theta,pi..,fi..]
the pi are normalizations
the fi are a multiplier for the covariance; there
are only ngauss-1 of those
ellip=(1+tanh(eta))/2
"""
cen, covar = self.get_gauss_pars(pars)
self._model[:] = self._sky
psum=0.0
for i in xrange(self._ngauss):
pi = pars[5+i]
covari = covar
if i > 0:
fi = pars[5+self._ngauss+i-1]
covari *= fi
self._model += model_image('gauss',
self._image.shape,
cen,covari,
counts=pi*self._counts,
nsub=self._nsub)
psum += pi
self._model /= psum
return self._model
def test_sub_pixel(ellip,theta):
"""
Round objects for now
"""
import fimage
import images
sigma_vals = linspace(1.0,3.0,10)
nsub_vals = array([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16],dtype='i4')
data = subpixel_struct(sigma_vals.size, nsub_vals.size)
ct=0
amt=0
for j in xrange(sigma_vals.size):
sigma = sigma_vals[j]
data['sigma'][j] = sigma
Irr,Irc,Icc=util.ellip2mom(2*sigma**2, e=ellip, theta=theta)
print("sigma: %0.2f Irr: %0.2f Irc: %0.2f Icc: %0.2f" % (sigma,Irr,Irc,Icc))
d=int( numpy.ceil( 4.5*sigma*2 ) )
if (d % 2) == 0:
d += 1
cen=[(d-1)/2]*2
dims = [d,d]
# create image with super good subpixel integration
ct0=time.time()
im=fimage.model_image('gauss',dims,cen,[Irr,Irc,Icc],nsub=64)
ct += time.time()-ct0
amt0=time.time()
for i in xrange(nsub_vals.size):
nsub = nsub_vals[i]
res = admom(im, cen[0], cen[1], guess=sigma**2, nsub=nsub)
if res['whyflag'] != 0:
print(" ** Failure:'%s'" % res['whystr'])
images.multiview(im, levels=7)
#key=raw_input('hit a key: ')
#if key == 'q': return
data['Irr'][j,i] = res['Irr']
data['Irc'][j,i] = res['Irc']
data['Icc'][j,i] = res['Icc']
data['a4'][j,i] = res['a4']
data['nsub'][j,i] = nsub
#print(" nsub:",nsub)
amt += time.time()-amt0
#print("time for creation:",ct)
#print("time for admom:",amt)
outf=subpixel_file(ellip,theta,'fits')
eu.io.write(outf,data,verbose=True,clobber=True)
plot_sub_pixel(ellip,theta)
def test_gmix_exp():
from fimage import model_image
numpy.random.seed(35)
ngauss=3
nsig=7.
#dims=[41,41]
#cen=[(dims[0]-1)/2., (dims[1]-1)/2.]
#cov=[10.5,0.0,10.5]
T = 2*3
e = 0.3
theta = randu()*360.
e1 = e*cos(2*theta*numpy.pi/180.0)
e2 = e*sin(2*theta*numpy.pi/180.0)
Irc = e2*T/2.0
#Icc = (1+e1)*T/2.0
#Irr = (1-e1)*T/2.0
Icc = (1+e1)*T/2.0
Irr = (1-e1)*T/2.0
#T = 2.*3.0
sigma = sqrt(T/2.)
dim = int(2*nsig*sigma)
if (dim % 2) == 0:
dim += 1
dims=array([dim,dim])
print 'dims:',dims
cen=(dims-1)/2.
#cov = [T/2.,0.0,T/2.]
cov = [Irr,Irc,Icc]
# need order='c' since we will use in in C code!
im = model_image('exp',dims,cen,cov,order='c')
sky = 0.01*im.max()
im_fakesky = im + sky
ntry=0
max_try = 10
flags=9999
while flags != 0 and ntry < max_try:
stderr.write('.')
guess = get_exp_guess(cen,cov,ngauss)
gm=gmix_image.GMixEM(im_fakesky, guess, sky=sky, maxiter=5000)
flags = gm.flags
ntry += 1
if ntry == max_try:
raise ValueError("too many tries")
gmix_image.gmix_print(gm.pars)
stderr.write('\n')
model = gmix2image_em(gm.pars,im.shape)
images.compare_images(im, model)
def test_convolve():
n=14
facvals = numpy.linspace(1.0,6.0,n)
sqrt_det_fft=numpy.zeros(n)
sqrt_det_fconv=numpy.zeros(n)
rat = numpy.zeros(n)
for i in xrange(n):
fac=facvals[i]
fac2=fac**2
dims=[41*fac,41*fac]
cen=[20*fac,20*fac]
covar = [1.5*fac2,0.0,1.5*fac2]
img=fimage.model_image('gauss',dims,cen,covar)
g1covar = [1.4*fac2,0.0,1.4*fac2]
g2covar = [3.0*fac2,0.0,3.0*fac2]
b = 0.1
dg = fimage.double_gauss(dims,cen,b, g1covar, g2covar)
imc_fft = scipy.signal.fftconvolve(img,dg,mode='same')
# now do it by convolving the image with each gaussian and
# adding appropriately
im1 = fimage.fconv.gaussconv(img, g1covar)
im2 = fimage.fconv.gaussconv(img, g2covar)
det1 = g1covar[0]*g1covar[2] - g1covar[1]**2
det2 = g2covar[0]*g2covar[2] - g2covar[1]**2
s2 = sqrt(det2/det1)
imc_fconv = (im1 + b*s2*im2)/(1+b*s2)
mom_fft=fimage.statistics.moments(imc_fft)
mom_fconv=fimage.statistics.moments(imc_fconv)
print("moments from fft")
pprint.pprint(mom_fft)
print("moments from fconv")
pprint.pprint(mom_fconv)
cov_fft = mom_fft['cov']
cov_fconv = mom_fconv['cov']
sqrt_det_fft[i] = sqrt(cov_fft[0]*cov_fft[2] - cov_fft[1]**2)
sqrt_det_fconv[i] = sqrt(cov_fconv[0]*cov_fconv[2] - cov_fconv[1]**2)
rd = {'sqrt_det_fft':sqrt_det_fft,'sqrt_det_fconv':sqrt_det_fconv,'facvals':facvals}
plotconv(rd)
return rd
def test():
fname='~/tmp/test-devprof.rec'
if not os.path.exists(fname):
dt=[('sigma2','f8'),('sigma2meas','f8')]
data=zeros(n,dtype=dt)
for i,sigma2 in enumerate(sigma2vals):
# sigma2 would be equivalent of a half life radius,
# and we expect <x^2> propto r_e^2
sz=int(2*sigma2*sigfac)
dims=array([sz,sz])
if (dims[0] % 2) == 0:
dims += 1
cen = (dims-1)/2
print sigma2,dims,cen
im=fimage.model_image('dev',
dims,
cen,
[sigma2,0.,sigma2],nsub=16)
stat=fimage.statistics.fmom(im)
data['sigma2'][i] = sigma2
data['sigma2meas'][i] = stat['cov'][0]
print data['sigma2meas'][i]/data['sigma2'][i]
#images.multiview(im,title='%d' % i)
eu.io.write(fname,data,verbose=True)
else:
data=eu.io.read(fname,verbose=True)
s=data['sigma2']
m=data['sigma2meas']
deg=3
plyf=polyfit(m, s, deg)
ply=poly1d(plyf)
print 'poly:'
print ply
plt=eu.plotting.bscatter(m, s, show=False,xlabel=r'$\sigma^2_{meas}$',ylabel=r'$\sigma^2_{req}$')
eu.plotting.bscatter(m, ply(m),plt=plt,color='red',type='solid')
return
#ls = log10(data['sigma2'])
#lm = log10(data['sigma2meas'])
deg=1
plyf=polyfit(lm, ls, deg)
ply=poly1d(plyf)
print 'poly:'
print ply
def measure_cov(self):
"""
Test the measured covariance matrix vs the input
"""
import fimage
f=self.file()
sigma_vals = self.sigma_vals()
ellip_vals = self.ellip_vals()
data = self.struct(sigma_vals.size*ellip_vals.size)
ii=0
for i in xrange(sigma_vals.size):
sigma=sigma_vals[i]
for j in xrange(ellip_vals.size):
ellip = ellip_vals[j]
Irr,Irc,Icc = util.ellip2mom(2*sigma**2, e=ellip, theta=0.0)
dim = int( numpy.ceil(2.*self.sigfac*sigma ) )
if (dim % 2) == 0:
dim += 1
dims=[dim,dim]
cen=[(dim-1)/2]*2
print("sigma:",sigma,"ellip:",ellip,"dims:",dims)
im=fimage.model_image(self.model,dims,cen,[Irr,Irc,Icc],nsub=8)
res = admom(im, cen[0], cen[1], guess=sigma, nsub=4)
data['sigma_index'][ii] = i
data['ellip_index'][ii] = j
data['Irr_input'][ii] = Irr
data['Irc_input'][ii] = Irc
data['Icc_input'][ii] = Icc
data['Irr_meas'][ii] = res['Irr']
data['Irc_meas'][ii] = res['Irc']
data['Icc_meas'][ii] = res['Icc']
ii+=1
hdr={'model':self.model}
eu.io.write(f, data, delim=' ', verbose=True, clobber=True, header=hdr)
def make_epsilon(self):
"""
make a model image for the fit gaussian and subtract it from the
psf.
This becomes a convolution kernel on our simplified model for the galaxy
Note psf and the subtracted gaussian are both normalized to 1, and
epsilon thus integrates to zero
"""
import fimage
if 'psfstats' not in self:
raise ValueError("run admom on psf first")
pstats=self['psfstats']
Irr = pstats['Irr']
Irc = pstats['Irc']
Icc = pstats['Icc']
#row = (self.psf.shape[0]-1)/2
#col = (self.psf.shape[1]-1)/2
row = pstats['wrow']
col = pstats['wcol']
#print('row:',row,'col:',col)
#print('wrow:',pstats['wrow'],'wcol:',pstats['wcol'])
gauss = fimage.model_image('gauss',
self.psf.shape,
[row,col],
[Irr,Irc,Icc],
nsub=1,
counts=1)
# need both our gaussian and the psf to be normalized
tpsf = self.psf/self.psf.sum()
if self.debug:
import images
images.compare_images(tpsf, gauss, label1='psf',label2='gauss')
epsilon = tpsf - gauss
self.epsilon = epsilon
def make_model(self, pars):
"""
pars = [row,col,irr,irc,icc,pi...,fi...]
"""
self._model[:] = self._sky
cen = pars[0:2]
for i in xrange(self._ngauss):
pi = pars[5+i]
if i > 0:
fi = pars[5+self._ngauss+i-1]
covari = fi*pars[2:2+3]
else:
covari = pars[2:2+3]
self._model += model_image('gauss',
self._image.shape,
cen,covari,
counts=pi*self._counts, # counts over sky
nsub=self._nsub)
return self._model
def show(self, min=0, **keys):
import fimage
import biggles
plt=images.view(self.im, show=False, min=min, **keys)
s=self.rg['imstats']
if s['whyflag'] == 0:
levels=7
wrow = s['wrow']
wcol = s['wcol']
model = fimage.model_image('gauss',
self.im.shape,
[wrow,wcol],
[s['Irr'],s['Irc'],s['Icc']],
counts=self.im.sum())
cmod = biggles.Contours(model.transpose(), color='grey')
cmod.levels = levels
plt.add(cmod)
plt.show()
def dopoly():
c=[1.658e-06, -0.0005773, 0.1677, 0.6726]
ply=poly1d(c)
rat=zeros(n)
for i,sigma2 in enumerate(sigma2vals):
sigma2use = ply(sigma2)
sz=2*sigma2*sigfac
dims=array([sz,sz])
if (dims[0] % 2) == 0:
dims += 1
cen = (dims-1)/2
im=fimage.model_image('dev',
dims,
cen,
[sigma2use,0.,sigma2use],nsub=16)
stat=fimage.statistics.fmom(im)
rat[i] = stat['cov'][0]/sigma2
print 'rat:',rat[i]
def test_fit_1gauss_galsim(ellip=0.2, s2n=10000):
import images
import galsim
import admom
numpy.random.seed(35)
#sigma = 1.4
sigma = 1
T=2*sigma**2
e = 0.2
theta=23.7
e1,e2 = etheta2e1e2(e,theta)
fimage_cov = ellip2mom(T, e=e, theta=theta)
print 'e: ',e
print 'e1:',e1
print 'e2:',e2
pixel_scale = 1.
nsig=5
dim = int(nsig*T)
if (dim % 2) == 0:
dim += 1
dims=array([dim,dim])
cen=(dims-1)/2
pix = galsim.Pixel(xw=pixel_scale, yw=pixel_scale)
gobj = galsim.Gaussian(sigma=sigma)
gobj.applyDistortion(galsim.Ellipse(e1=e1,e2=e2))
gcobj = galsim.Convolve([gobj,pix])
im0 = galsim.ImageD(int(dims[1]),int(dims[0]))
gcobj.draw(image=im0, dx=pixel_scale)
images.multiview(im0.array)
galsim_nsub=16
ares = admom.admom(im0.array,cen[0],cen[1],guess=T/2,nsub=galsim_nsub)
print 'galsim sigma:',sqrt( (ares['Irr']+ares['Icc'])/2 )
print 'galsim admom e1:',ares['e1']
print 'galsim admom e2:',ares['e2']
print 'galsim center:',ares['row'],ares['col']
fnsub=16
fim0 = model_image('gauss',dims,cen,fimage_cov,nsub=fnsub)
fares = admom.admom(fim0,cen[0],cen[1],guess=T/2,nsub=fnsub)
print 'fimage sigma:',sqrt( (fares['Irr']+fares['Icc'])/2 )
print 'fimage admom e1:',fares['e1']
print 'fimage admom e2:',fares['e2']
print 'fimage center:',fares['row'],fares['col']
return
theta=23.7*numpy.pi/180.
print >>stderr,'ellip:',ellip
pars=array([cen[0],cen[1],eta,theta,1.,T])
print >>stderr,'pars'
gmix = gmix_fit.pars2gmix_coellip_pick(pars,ptype='eta')
nsub=1
im0=gmix2image_em(gmix,dims,nsub=nsub)
im,skysig = fimage.add_noise(im0, s2n,check=True)
images.multiview(im,title='nsub: %d' % nsub)
p0=pars.copy()
p0[0] += 1*(randu()-0.5) # cen0
p0[1] += 1*(randu()-0.5) # cen1
p0[2] += 0.2*(randu()-0.5) # eta
p0[3] += 0.5*(randu()-0.5) # theta radians
p0[4] += 0.1*(randu()-0.5) # p
p0[5] += 1*(randu()-0.5) # T
print_pars(pars,front='pars: ')
print_pars(p0, front='guess: ')
gf=gmix_fit.GMixFitCoellip(im, p0, ptype='eta',verbose=True)
print 'numiter:',gf.numiter
print_pars(gf.popt, front='popt: ')
print_pars(gf.perr, front='perr: ')
images.imprint(gf.pcov)
def test_mcmc1(sigma, nstep=10000, burnin=1000, ntrial=1, s2n=35.0):
"""
S/N is adaptive weighted S/N
"""
covar=[sigma**2,0.0,sigma**2]
ngauss=1
dim=int(2*4*sigma)
if (dim % 2) == 0:
dim += 1
dims=array([dim,dim])
cen=(dims-1)/2.
det = covar[0]*covar[2] - covar[1]**2
counts=1.0
sky=0.0
#skysig = counts/s2n/sqrt(4*pi*det)
skysig = counts/sqrt(dims[0]*dims[1])/s2n
print 'dims: ',dims
print 'cen: ',cen
print 'skysig:',skysig
im0 = model_image('gauss',
dims,
cen,covar,
counts=counts,
nsub=1)
allmeans = zeros( (ntrial, 2+3+2*ngauss) )
allerrs = zeros( (ntrial, 2+3+2*ngauss) )
for j in xrange(ntrial):
print '-'*70
print '%d/%d' % ((j+1),ntrial)
im = im0 + skysig*randn(dims[0]*dims[1]).reshape(dims)
# guess is prior
guess=zeros(2+3+2*ngauss)
guess[0:2] = cen + 0.1*(random(2)-0.5)
guess[2:5] = covar + 0.1*(random(3)-0.5)
guess[5] = 1.0
guess[6] = 1.0
print 'guess:',guess
# prior widths, generally broad
width=array([0.1, # pixels
1.0, # pixels**2
1.0,
1.0])
# step widths
#[censig,covsig,psig,fsig]
stepsize=array([0.01,0.01,0.01,0.01])
obj=MCMCCoellip(im, sky, skysig, guess, width, stepsize)
m=mcmc.MCMC(obj)
res = m.run(nstep, guess)
means, errs = mcmc.extract_stats(res, burnin,sigma_clip=False)
print 'means +/- err'
for i in xrange(len(means)):
print ' %.16g +/- %.16g' % (means[i],errs[i])
allmeans[j,:] = means
allerrs[j,:] = errs
return allmeans, allerrs
def run_trials(nsub, rg_admom_nsub):
n=100
rg_image_nsub = rg_admom_nsub
psf_order=10
gal_shear_order = 8
gal_theta = numpy.linspace(0.01843243,179.13423,n)
spacing = gal_theta[1]-gal_theta[0]
gal_theta += numpy.random.random(n)*spacing
gal_T = 3.1+2.7
gal_T = gal_T*10
gal_e = 0.3
# reduced shear required to make round
shear = tanh( 0.5*arctanh(gal_e) )
dt=[('gal_theta','f8'),
('shear1','f8'),
('shear2','f8'),
('shear','f8'),
('shear1meas','f8'),
('shear2meas','f8'),
('shearmeas','f8')]
wl_shear=numpy.zeros(n, dtype=dt)
am_shear=numpy.zeros(n, dtype=dt)
wl_shear['gal_theta'] = gal_theta
wl_shear['shear'] = shear
am_shear['gal_theta'] = gal_theta
am_shear['shear'] = shear
for i in xrange(n):
galcov=fimage.conversions.ellip2mom(gal_T,e=gal_e,
theta=gal_theta[i])
psfcov=[2.0,0.0,2.0]
#psfcov=[2.0*5,0.0,2.0*5]
imcov=[galcov[0]+psfcov[0],
galcov[1]+psfcov[1],
galcov[2]+psfcov[2]]
im_sigma = fimage.mom2sigma(imcov[0]+imcov[2])
dims = int(2*6*im_sigma)
if (dims % 2) == 0:
dims+=1
if dims < 31: dims=31
dims = [dims]*2
shear1=0.5*(galcov[2]-galcov[0])/(galcov[2]+galcov[0])
shear2=0.5*2*galcov[1]/(galcov[2]+galcov[0])
wl_shear['shear1'][i] = shear1
wl_shear['shear2'][i] = shear2
am_shear['shear1'][i] = shear1
am_shear['shear2'][i] = shear2
wlq = deswl.cwl.WLQuick(psf_order,gal_shear_order)
sky=0.0
psfcen=[(dims[0]-1.)/2., (dims[0]-1.)/2.]
psf = fimage.model_image('gauss',dims,psfcen,psfcov,
nsub=nsub,counts=1)
imcen=[(dims[0]-1.)/2., (dims[0]-1.)/2.]
im = fimage.model_image('gauss',dims,imcen,imcov,
nsub=nsub,counts=10000)
aperture = 4.0*fimage.mom2sigma(imcov[0]+imcov[2])
skysig=1.0
wlq.set_psf(psf,psfcen[0],psfcen[1],sky)
wlq.set_image(im,imcen[0],imcen[1],sky,skysig,aperture)
guess=2.0
flags = wlq.calculate_psf_sigma(guess)
if flags != 0:
print 'sigma flags:',flags
return
#print 'input psf sigma:',fimage.mom2sigma(psfcov[0]+psfcov[2])
#print 'measured sigma: ',wlq.get_psf_sigma()
flags += wlq.calculate_psf_shapelets()
if flags != 0:
print 'psf shapelets flags:',flags
return
#print
flags += wlq.calculate_shear()
if flags != 0:
print 'shear flags:',flags
return
wl_shear['shear1meas'][i] = - wlq.get_shear1()
wl_shear['shear2meas'][i] = wlq.get_shear2()
wl_shear['shearmeas'][i] = sqrt(wlq.get_shear1()**2 +
wlq.get_shear2()**2)
#wl_shear['shear1meas'][i] = - 0.5*wlq.get_e1()
#wl_shear['shear2meas'][i] = - 0.5*wlq.get_e2()
rgkeys={}
rgkeys['guess'] = (galcov[0] + galcov[2])/2
rgkeys['guess_psf'] = (psfcov[0] + psfcov[2])/2
rgkeys['admom_nsub'] = rg_admom_nsub
rgkeys['image_nsub'] = rg_image_nsub
#rgkeys['verbose'] = True
rg = admom.ReGauss(im, imcen[0], imcen[1], psf, **rgkeys)
rg.do_all()
#am_shear['shear1meas'][i]=0.5*rg['rgcorrstats']['e1']
#am_shear['shear2meas'][i]=0.5*rg['rgcorrstats']['e2']
am_shear['shear1meas'][i]=0.5*rg['corrstats']['e1']
am_shear['shear2meas'][i]=0.5*rg['corrstats']['e2']
ame = sqrt(rg['corrstats']['e1']**2 + rg['corrstats']['e2']**2)
am_shear['shearmeas'][i] = tanh(0.5*arctanh(ame))
s='theta: %g in: %g %g wl: %g %g %g %g am: %g %g %g %g'
s = s % (gal_theta[i],
shear1,shear2,
wl_shear['shear1meas'][i],
wl_shear['shear1meas'][i]/shear1-1,
wl_shear['shear2meas'][i],
wl_shear['shear2meas'][i]/shear2-1,
am_shear['shear1meas'][i],
am_shear['shear1meas'][i]/shear1-1,
am_shear['shear2meas'][i],
am_shear['shear2meas'][i]/shear2-1)
print s
return wl_shear, am_shear
def test_regauss(gal_model='gauss',
gal_T=16.0,
gal_e1=0.0,
gal_e2=0.0,
psf_T=4.0,
psf_e1=0.0,
psf_e2=0.0,
show=True):
from pprint import pprint
import fimage
import scipy.signal
nsigma=5
psf_sigma=numpy.sqrt(psf_T/2.)
psf_imsize = int( round(2*nsigma*psf_sigma) )
if (psf_imsize % 2) == 0:
psf_imsize+=1
psf_dims=[psf_imsize]*2
psf_cen=[(psf_imsize-1)/2.]*2
psf_moms = admom.ellip2mom(psf_T,e1=psf_e1,e2=psf_e2)
psf = fimage.model_image('gauss',
psf_dims,
psf_cen,
psf_moms,
nsub=16)
gal_moms = admom.ellip2mom(gal_T,e1=gal_e1,e2=gal_e2)
# for the image size, make it big enough to easily fit
# the *convolved* galaxy
gal_convolved_sigma = admom.mom2sigma(gal_T+psf_T)
gal_imsize = int( round(2*nsigma*gal_convolved_sigma) )
if gal_imsize < psf_imsize:
gal_imsize = psf_imsize
gal_cen = [ (gal_imsize-1)/2. ]*2
gal_dims = [int(gal_imsize)]*2
gal = fimage.model_image(gal_model,
gal_dims,
gal_cen,
gal_moms,
nsub=16)
levels=7
# now convolve with the PSF
imconv = scipy.signal.fftconvolve(gal, psf, mode='same')
if show:
import images
images.multiview(psf, levels=levels)
images.multiview(gal, levels=levels)
images.multiview(imconv, levels=levels)
rg = ReGauss(imconv, gal_cen[0], gal_cen[1], psf, guess=gal_T/2, guess_psf=psf_T/2)
rg.do_admom()
print("admom stats")
pprint(rg['imstats'])
rg.do_psf_admom()
print("psf admom stats")
pprint(rg['psfstats'])
rg.do_basic_corr()
print("admom corrected stats")
pprint(rg['corrstats'])
rg.do_regauss()
print("rg stats")
pprint(rg['rgstats'])
rg.do_rg_corr()
print("rg corrected stats")
pprint(rg['rgcorrstats'])
def test_fit_exp_e1e2():
import admom
import biggles
numpy.random.seed(35)
ptype='e1e2'
e = 0.2
theta = 23.7
e1,e2 = etheta2e1e2(e,theta)
print >>stderr,"e:",e,"e1:",e1,"e2:",e2
nsig=7
ngauss=3
npars=2*ngauss+4
nsigma=20
data=numpy.zeros(nsigma,dtype=[('sigma','f8'),('pars','f8',npars)])
sigvals = numpy.linspace(1.5,5.0,nsigma)
#sigvals = array([3.0])
for isigma,sigma in enumerate(sigvals):
print '-'*70
T = 2*sigma**2
cov = ellip2mom(T, e=e, theta=theta)
dim = int(2*nsig*sigma)
if (dim % 2) == 0:
dim += 1
dims=array([dim,dim])
cen=(dims-1)/2.
im = model_image('exp',dims,cen,cov,nsub=16)
ares = admom.admom(im,cen[0],cen[1],guess=T/2,nsub=16)
Tadmom=ares['Irr'] + ares['Icc']
ngauss=3
# p values: [ 0.61145202 0.33400601 0.03659767]
# T vals/Tadmom: [ 2.69996659 0.61848985 0.08975346]
p0 = [cen[0],# + 0.1*(randu()-0.5),
cen[1],# + 0.1*(randu()-0.5),
e1,# + .2*(randu()-0.5),
e2,# + .2*pi/180.*(randu()-0.5),
0.62,
0.34,
0.04,
Tadmom*2.7,
Tadmom*0.62,
Tadmom*0.09]
print_pars(p0, front='guess: ')
gf=gmix_fit.GMixFitCoellip(im, p0,
ptype=ptype,
verbose=True)
print_pars(gf.popt, front='popt: ')
if gf.flags != 0:
raise RuntimeError("failed")
print 'numiter:',gf.numiter
data['sigma'][isigma] = sigma
data['pars'][isigma,:] = gf.popt
tvals = gf.popt[4+ngauss:]
tmax=tvals.max()
print 't ratios:',tvals/tmax
print 'p values:',gf.popt[4:4+ngauss]
print 'T vals/Tadmom:',tvals/Tadmom
# plot the last one
gmix = gf.gmix
model = gmix2image_em(gmix,im.shape)
title=None
plt=images.compare_images(im,model,title=title)
epsfile='test-opt-exp.eps'
print >>stderr,'epsfile of image compare:',epsfile
plt.write_eps(epsfile)
biggles.configure('fontsize_min', 1.0)
biggles.configure('linewidth',1.0) # frame only
nrows=3
ncols=4
tab=biggles.Table(nrows,ncols)
for par in xrange(npars):
plt=biggles.FramedPlot()
plt.add(biggles.Curve(data['sigma'],data['pars'][:,par]))
plt.xlabel = r'$\sigma$'
plt.ylabel = 'p%d' % par
tab[par//ncols,par%ncols] = plt
tab.title=title
tab.show()
def test_fit_exp_eta():
import biggles
from fimage import model_image
numpy.random.seed(35)
nsig=7
ngauss=3
npars=2*ngauss+4
nsigma=20
data=numpy.zeros(nsigma,dtype=[('sigma','f8'),('pars','f8',npars)])
sigvals = numpy.linspace(1.5,5.0,nsigma)
for isigma,sigma in enumerate(sigvals):
print '-'*70
T = 2*sigma**2
e = 0.3
eta = ellip2eta(e)
#theta = randu()*360.*pi/180.
theta = 23.7*pi/180.
e1 = e*cos(2*theta)
e2 = e*sin(2*theta)
Irc = e2*T/2.
Icc = (1+e1)*T/2.
Irr = (1-e1)*T/2.
sigma = sqrt( (Irr+Icc)/2. )
dim = int(2*nsig*sigma)
if (dim % 2) == 0:
dim += 1
dims=array([dim,dim])
cen=(dims-1)/2.
cov=[Irr,Irc,Icc]
im = model_image('exp',dims,cen,cov,nsub=16)
ngauss=3
p0 = [cen[0],# + 0.1*(randu()-0.5),
cen[1],# + 0.1*(randu()-0.5),
eta,# + 0.2*(randu()-0.5),
theta,# + 10.*pi/180.*(randu()-0.5),
0.2,
0.5,
0.3,
T,
0.05*T,
3.8*T]
gf=gmix_fit.GMixFitCoellip(im, p0,
ptype='eta',
verbose=True)
if gf.flags != 0:
raise RuntimeError("failed")
print 'numiter:',gf.numiter
if gf.flags != 0:
stop
#pcov = gf.pcov
#err = sqrt(diag(pcov))
for i in xrange(len(gf.popt)):
#print '%.6g %.6g' % (gf.popt[i],err[i])
print '%.6g %.6g' % (gf.popt[i],gf.perr[i])
data['sigma'][isigma] = sigma
data['pars'][isigma,:] = gf.popt
tvals = gf.popt[4+ngauss:]
tmax=tvals.max()
print 't ratios:',tvals/tmax
print 'p values:',gf.popt[4:4+ngauss]
# plot the last one
gmix = gmix_fit.pars2gmix_coellip_eta(gf.popt)
model = gmix2image_em(gmix,im.shape)
plt=images.compare_images(im,model)
epsfile='test-opt-exp.eps'
print >>stderr,'epsfile of image compare:',epsfile
plt.write_eps(epsfile)
biggles.configure('fontsize_min', 1.0)
biggles.configure('linewidth',1.0) # frame only
nrows=3
ncols=4
tab=biggles.Table(nrows,ncols)
for par in xrange(npars):
plt=biggles.FramedPlot()
plt.add(biggles.Curve(data['sigma'],data['pars'][:,par]))
plt.xlabel = r'$\sigma$'
plt.ylabel = 'p%d' % par
tab[par//ncols,par%ncols] = plt
tab.show()
def test_fit_exp_cov(method='lm'):
import biggles
from fimage import model_image
numpy.random.seed(35)
nsig=7
ngauss=3
npars=2*ngauss+4
nsigma=20
data=numpy.zeros(nsigma,dtype=[('sigma','f8'),('pars','f8',npars)])
sigvals = numpy.linspace(1.5,5.0,nsigma)
for isigma,sigma in enumerate(sigvals):
print '-'*70
T = 2*sigma**2
#T = 2*8.
e = 0.3
theta = randu()*360.
e1 = e*cos(2*theta*numpy.pi/180.0)
e2 = e*sin(2*theta*numpy.pi/180.0)
Irc = e2*T/2.0
Icc = (1+e1)*T/2.0
Irr = (1-e1)*T/2.0
sigma = sqrt( (Irr+Icc)/2. )
dim = int(2*nsig*sigma)
if (dim % 2) == 0:
dim += 1
dims=array([dim,dim])
cen=(dims-1)/2.
cov=[Irr,Irc,Icc]
im = model_image('exp',dims,cen,cov,nsub=16)
ngauss=3
p0 = [cen[0],cen[1],Irr,Irc,Icc, 0.4,0.07,0.55,0.2,3.8]
#p0 = [cen[0],cen[1],Irr,Irc,Icc,
# .9,.8,.6,0.25,7.]
gf=gmix_fit.GMixFitCoellip(im, p0, ptype='cov',
method=method,verbose=True)
if gf.flags != 0:
raise RuntimeError("failed")
print 'numiter:',gf.numiter
if gf.flags != 0:
stop
#pcov = gf.pcov
#err = sqrt(diag(pcov))
for i in xrange(len(gf.popt)):
#print '%.6g %.6g' % (gf.popt[i],err[i])
print '%.6g' % gf.popt[i]
data['sigma'][isigma] = sigma
data['pars'][isigma,:] = gf.popt
# plot the last one
gmix = gmix_fit.pars2gmix_coellip_pick(gf.popt,ptype='cov')
model = gmix2image_em(gmix,im.shape)
images.compare_images(im,model)
biggles.configure('fontsize_min', 1.0)
biggles.configure('linewidth',1.0) # frame only
nrows=3
ncols=4
tab=biggles.Table(nrows,ncols)
for par in xrange(npars):
plt=biggles.FramedPlot()
plt.add(biggles.Curve(data['sigma'],data['pars'][:,par]))
plt.xlabel = r'$\sigma$'
plt.ylabel = 'p%d' % par
tab[par//ncols,par%ncols] = plt
tab.show()
def test_admom_residuals(image, cen, guess, sky=0.0, sigsky=1.0):
"""
Fit adaptive moments to the input image and display the residuals
"""
import images
import fimage
import biggles
res = admom(image, cen[0], cen[1], guess=guess, sky=sky, sigsky=sigsky,
nsub=8)
counts = image.sum()
wcen=[res['wrow'],res['wcol']]
fake = fimage.model_image('gauss',image.shape,wcen,res['Irr'],res['Irc'],res['Icc'],
counts=counts)
resid = fake-image
maxval = max( image.max(), fake.max() )
minval = 0.0
levels=7
tab=biggles.Table(2,3)
#tab=biggles.Table(3,2)
implt=images.view(image, levels=levels, show=False, min=minval, max=maxval)
fakeplt=images.view(fake, levels=levels, show=False, min=minval, max=maxval)
residplt=images.view(resid, show=False, min=minval, max=maxval)
sigma = numpy.sqrt((res['Irr']+res['Icc'])/2.0)
lab = biggles.PlotLabel(0.1,0.9,r'$\sigma$: %0.2f' % sigma, fontsize=4, halign='left')
fakeplt.add(lab)
implt.title='original'
fakeplt.title='gaussian model'
residplt.title='residuals'
# cross-sections
imrows = image[:,wcen[1]]
imcols = image[wcen[0],:]
fakerows = fake[:,wcen[1]]
fakecols = fake[wcen[0],:]
resrows = resid[:,wcen[1]]
rescols = resid[wcen[0],:]
himrows = biggles.Histogram(imrows, color='blue')
himcols = biggles.Histogram(imcols, color='blue')
hfakerows = biggles.Histogram(fakerows, color='orange')
hfakecols = biggles.Histogram(fakecols, color='orange')
hresrows = biggles.Histogram(resrows, color='red')
hrescols = biggles.Histogram(rescols, color='red')
himrows.label = 'image'
hfakerows.label = 'model'
hresrows.label = 'resid'
key = biggles.PlotKey(0.1,0.9,[himrows,hfakerows,hresrows])
rplt=biggles.FramedPlot()
rplt.add( himrows, hfakerows, hresrows,key )
cplt=biggles.FramedPlot()
cplt.add( himcols, hfakecols, hrescols )
rplt.aspect_ratio=1
cplt.aspect_ratio=1
tab[0,0] = implt
tab[0,1] = fakeplt
tab[0,2] = residplt
tab[1,0] = rplt
tab[1,1] = cplt
#tab[0,0] = implt
#tab[0,1] = fakeplt
#tab[1,0] = residplt
#tab[1,1] = rplt
#tab[2,0] = cplt
tab.show()
def test_flux_ap():
import biggles
import pcolors
nsub=16
# remember, half light radii are sqrt(10.83) smaller than
# unweighted sigma, approximately 3.3
re = 3.0
sigma=re*sqrt(10.83)
e=0.3
theta=27.
sigma2 = sigma**2
cov=fimage.conversions.ellip2mom(2*sigma2, e=e, theta=theta)
dims = array( [400,400])
print >>stderr,'dims:',dims
cen = (dims-1)/2.
im=fimage.model_image('dev',
dims,
cen,
cov,
nsub=nsub)
row,col=numpy.ogrid[0:im.shape[0], 0:im.shape[1]]
rm = array(row - cen[0], dtype='f8')
cm = array(col - cen[1], dtype='f8')
radm = sqrt(rm**2 + cm**2)
radmax=im.shape[0]/2
#colors=pcolors.rainbow(radmax-1,'hex')
radii = numpy.arange(1,radmax+1)
cnts=numpy.zeros(radii.size)
for ir,radius in enumerate(radii):
w=where(radm <= radius)
if w[0].size > 0:
print w[0].size,w[1].size,im[w].size
#color=colors[ir]
cnts[ir] = im[w].sum()
r50 = eu.stat.interplin(radii/re, cnts/cnts.max(), 0.5)
r85 = eu.stat.interplin(radii/re, cnts/cnts.max(), 0.85)
r90 = eu.stat.interplin(radii/re, cnts/cnts.max(), 0.9)
print >>stderr,"r50:",r50
print >>stderr,"r85:",r85
print >>stderr,"r90:",r90
plt=eu.plotting.bscatter(radii/re, cnts/cnts.max(),
xlabel=r'$r/r_e$',
ylabel='counts/max',
title='dim: %d' % dims[0],
xlog=True,ylog=True,show=False)
#plt.add(biggles.Point(r50,0.5,color='red'))
#plt.add(biggles.Point(r90,0.9,color='blue'))
fname='~/tmp/dev-fluxfrac.rec'
dt=[('r_over_re','f8'),
('fluxfrac','f8')]
data=zeros(radii.size, dtype=dt)
data['r_over_re'] = radii/re
data['fluxfrac'] = cnts/cnts.max()
eu.io.write(fname,data,clobber=True,verbose=True)
plt.show()
def test_fit_dev_e1e2(ngauss=4, s2n=1.e5):
import biggles
import admom
import fimage
numpy.random.seed(35)
ptype='e1e2'
e = 0.2
theta = 23.7
e1,e2 = etheta2e1e2(e,theta)
print >>stderr,"e:",e,"e1:",e1,"e2:",e2
nsig=15
#nsig=7
npars=2*ngauss+4
nsigma_vals=20
f='test-opt-dev-bysigma'
f += '-s2n%d' % s2n
f += '.rec'
pngf=f.replace('.rec','.png')
if not os.path.exists(f):
data=numpy.zeros(nsigma_vals,dtype=[('sigma','f8'),('pars','f8',npars)])
#sigvals = numpy.linspace(1.5,5.0,nsigma_vals)
sigvals = numpy.linspace(3.,5.0,nsigma_vals)
#sigvals=array([3.0])
for isigma,sigma in enumerate(sigvals):
print '-'*70
print 'sigma:',sigma
T = 2*sigma**2
cov = ellip2mom(T, e=e, theta=theta)
dim = int(2*nsig*sigma)
if (dim % 2) == 0:
dim += 1
dims=array([dim,dim])
cen=(dims-1)/2.
im0 = model_image('dev',dims,cen,cov,nsub=16)
im,skysig = fimage.add_noise(im0, s2n, check=True)
dim = int(2*nsig*sigma)
if (dim % 2) == 0:
dim += 1
dims=array([dim,dim])
cen=(dims-1)/2.
ares = admom.admom(im0,cen[0],cen[1],guess=T/2,nsub=16)
Tadmom=ares['Irr'] + ares['Icc']
if ngauss == 4:
Tmax = Tadmom*100
# 0.02620127 0.09348825 0.23987656 0.63958437
p0 = array([cen[0],
cen[1],
e1,
e2,
0.026,
0.093,
0.24,
0.64,
Tmax,
Tmax*0.18,
Tmax*0.04,
Tmax*0.0027])
else:
p0 = array([cen[0],
cen[1],
e1,
e2,
1./ngauss,
1./ngauss,
1./ngauss,
Tadmom*4.9,
Tadmom*0.82,
Tadmom*0.18])
print_pars(p0, front='guess: ')
verbose=False
gf=gmix_fit.GMixFitCoellip(im, p0,
ptype=ptype,
verbose=verbose)
chi2per = gf.get_chi2per(gf.popt,skysig)
print 'numiter:',gf.numiter
print_pars(gf.popt, front='popt: ')
if gf.perr is not None:
print_pars(gf.perr, front='perr: ')
print 'chi2/deg:',chi2per
if gf.flags != 0:
gmix_image.printflags('fit',gf.flags)
raise RuntimeError("failed")
data['sigma'][isigma] = sigma
data['pars'][isigma,:] = gf.popt
tvals = gf.popt[4+ngauss:]
tmax=tvals.max()
print 't ratios:',tvals/tmax
print 'p values:',gf.popt[4:4+ngauss]
print 'T vals/Tadmom:',tvals/Tadmom
# plot the last one
gmix = gmix_fit.pars2gmix_coellip_pick(gf.popt,ptype=ptype)
model = gmix2image_em(gmix,im.shape)
images.compare_images(im,model)
else:
data=eu.io.read(f)
biggles.configure('fontsize_min', 1.0)
biggles.configure('linewidth',1.0) # frame only
nrows=3
ncols=4
tab=biggles.Table(nrows,ncols)
for par in xrange(npars):
plt=biggles.FramedPlot()
plt.add(biggles.Curve(data['sigma'],data['pars'][:,par]))
plt.add(biggles.Points(data['sigma'],data['pars'][:,par],
type='filled circle'))
plt.xlabel = r'$\sigma$'
plt.ylabel = 'p%d' % par
tab[par//ncols,par%ncols] = plt
tab.show()
tab.write_img(1024,1024,pngf)
def test_fit_dev_eta_bysigma():
"""
Round object as a function of sigma
"""
import admom
import biggles
from fimage import model_image, ellip2mom
numpy.random.seed(35)
ngauss=4
nsig=15
npars=2*ngauss+4
nsigma_vals=20
e=0.3
eta = ellip2eta(e)
theta=23.7
print >>stderr,'ellip:',e
print >>stderr,'eta:',eta
print >>stderr,'theta:',theta*pi/180.
f='test-opt-dev-bysigma.rec'
pngf=f.replace('.rec','.png')
if not os.path.exists(f):
data=numpy.zeros(nsigma_vals,dtype=[('sigma','f8'),('pars','f8',npars)])
#sigvals = numpy.linspace(1.5,5.0,nsigma_vals)
#sigvals = numpy.linspace(3.,5.0,nsigma_vals)
sigvals=array([7.0])
for isigma,sigma in enumerate(sigvals):
print '-'*70
print 'sigma:',sigma
T = 2*sigma**2
dim = int(2*nsig*sigma)
if (dim % 2) == 0:
dim += 1
dims=array([dim,dim])
cen=(dims-1)/2.
cov=ellip2mom(T, e=e, theta=theta)
im = model_image('dev',dims,cen,cov,nsub=16)
#images.multiview(im)
ares = admom.admom(im,cen[0],cen[1],guess=T/2,nsub=16)
if ares['whyflag'] != 0:
raise ValueError("admom failed")
Tadmom = ares['Irr']+ares['Icc']
print >>stderr,'admom sigma:',sqrt(Tadmom/2)
print >>stderr,'admom T:',Tadmom
print >>stderr,'admom e:',sqrt(ares['e1']**2 + ares['e2']**2)
print >>stderr,'T input:',T
#Tuse = Tadmom
Tuse = T
p0 = array([cen[0],
cen[1],
eta,
theta*pi/180.,
0.22,
0.35,
0.25,
0.15,
Tuse*0.15,
Tuse*0.5,
Tuse*2.0,
Tuse*5.0])
#0.18450384 2.09205287 10.31125635 67.13233512
print_pars(p0, front='guess: ')
gf=gmix_fit.GMixFitCoellip(im, p0, ptype='eta',verbose=True)
flags = gf.flags
print 'numiter:',gf.numiter
print_pars(gf.popt, front='popt: ')
#for i in xrange(len(gf.popt)):
# print '%.6g' % gf.popt[i]
if gf.flags != 0:
raise RuntimeError("failed")
print >>stderr,'T relative to T uw:',gf.popt[4+ngauss:]/T
print >>stderr,'T relative to T admom:',gf.popt[4+ngauss:]/Tadmom
data['sigma'][isigma] = sigma
data['pars'][isigma,:] = gf.popt
# plot the last one
gmix = gmix_fit.pars2gmix_coellip_eta(gf.popt)
model = gmix2image_em(gmix,im.shape)
images.compare_images(im,model)
else:
data=eu.io.read(f)
biggles.configure('fontsize_min', 1.0)
biggles.configure('linewidth',1.0) # frame only
nrows=3
ncols=4
tab=biggles.Table(nrows,ncols)
for par in xrange(npars):
plt=biggles.FramedPlot()
plt.add(biggles.Curve(data['sigma'],data['pars'][:,par]))
plt.add(biggles.Points(data['sigma'],data['pars'][:,par],
type='filled circle'))
plt.xlabel = r'$\sigma$'
plt.ylabel = 'p%d' % par
tab[par//ncols,par%ncols] = plt
tab.show()
tab.write_img(1024,1024,pngf)
def test_ellip():
re=3.0
T = 2*re**2
re2 = re**2
#theta = random()*360.
theta=37.
nsig=15.
num_e=20
evals=linspace(0.0,0.6,num_e)
dt=[('theta','f8'),
('e1','f8'),
('e2','f8'),
('e','f8'),
('e1meas','f8'),
('e2meas','f8'),
('emeas','f8')]
data=zeros(num_e,dtype=dt)
for i,e in enumerate(evals):
print e
e1 = e*cos(2*theta*numpy.pi/180.0)
e2 = e*sin(2*theta*numpy.pi/180.0)
Irr = (1-e1)*T/2.0
Irc = e2*T/2.0
Icc = (1+e1)*T/2.0
cov = [Irr,Irc,Icc]
dim = int(2*nsig*re)
if (dim % 2) == 0:
dim += 1
dims=array([dim,dim])
cen=(dims-1)/2.
im=fimage.model_image('dev',
dims,
cen,
cov,nsub=16)
if False:
#images.multiview(im)
w1,=where(im[cen[0],:] > 0)
w2,=where(im[:,cen[1]] > 0)
plt=eu.plotting.bscatter(w1,im[cen[0],w1],type='solid',
color='blue',
ylog=True,show=False)
plt=eu.plotting.bscatter(w1,im[cen[0],w1],type='filled circle',
color='blue',
plt=plt,show=False)
plt=eu.plotting.bscatter(w2,im[w2,cen[1]],type='solid',
color='red',plt=plt,show=False)
eu.plotting.bscatter(w2,im[w2,cen[1]],type='filled circle',
color='red',plt=plt)
#stop
stat=fimage.statistics.fmom(im)
data['e'][i] = e
data['e1'][i] = e1
data['e2'][i] = e2
data['e1meas'][i] = stat['e1']
data['e2meas'][i] = stat['e2']
data['emeas'][i] = sqrt(stat['e1']**2 + stat['e2']**2)
plt=eu.plotting.bscatter(data['e'],
data['emeas']-data['e'],
xlabel='e requested',
ylabel=r'$e_{meas}-e_{req}$')
def test_ap(redo=False):
import biggles
import pcolors
nsub=16
# remember, half light radii are sqrt(10.83) smaller than
# unweighted sigma, approximately 3.3
re = 1.0
sigma=re*sqrt(10.83)
e=0.3
theta=27.
sigma2 = sigma**2
cov=fimage.conversions.ellip2mom(2*sigma2, e=e, theta=theta)
#cov = array([sigma2,.0,sigma2])
recf='~/tmp/test-devprof-ap-nsub%02d-e%.2f-theta%.2f.rec' % (nsub,e,theta)
epsfile=recf.replace('.rec','.eps')
if not os.path.exists(recf) or redo:
#dimvals = arange(20,100)
#dimvals = arange(100,200)
#dimvals = arange(200,400,8)
#dimvals = arange(200,400,8)
dimvals = linspace(50.0,400.0,20).astype('i8')
#dimvals=[5000]
#rat = zeros(len(dimvals))
dt=[('image_radius','f8'),
('cov','f8',3),
('cov_meas','f8',3)]
data=zeros(len(dimvals), dtype=dt)
for i,dim in enumerate(dimvals):
dims = array( [dim,dim])
print >>stderr,'dims:',dims
cen = (dims-1)/2.
im=fimage.model_image('dev',
dims,
cen,
cov,
nsub=nsub)
stat=fimage.statistics.fmom(im)
#print stat
print dim/sigma/2,dim,stat['cov'][0], stat['cov'][0]/sigma**2
#rat[i] = stat['cov'][0]/sigma**2
data['image_radius'][i] = dim/2
data['cov'][i,:] = cov # constant
data['cov_meas'][i,:] = stat['cov']
eu.io.write(recf, data, clobber=True)
else:
data=eu.io.read(recf)
sigma2 = (data['cov'][:,0] + data['cov'][:,2])/2
sigma2meas = (data['cov_meas'][:,0] + data['cov_meas'][:,2])/2
sigma2_rat = sigma2meas/sigma2
Ttrue=data['cov'][:,2]+data['cov'][:,0]
e1true = (data['cov'][:,2]-data['cov'][:,0])/Ttrue
e2true = 2*data['cov'][:,1]/Ttrue
etrue=sqrt(e1true**2 + e2true**2)
Tmeas=data['cov'][:,2]+data['cov_meas'][:,0]
e1m = (data['cov_meas'][:,2]-data['cov_meas'][:,0])/Tmeas
e2m = 2*data['cov_meas'][:,1]/Tmeas
em=sqrt(e1m**2 + e2m**2)
radrat = data['image_radius']/sqrt(sigma2)
tab=biggles.Table(2,1)
splt=eu.plotting.bscatter(radrat,
sigma2_rat,
yrange=[0,1.1],
xlabel=r'$image radius/\sigma$',
ylabel=r'$\sigma^2_{meas}/\sigma^2_{true}',
show=False)
splt.add(biggles.Curve(radrat,ones(radrat.size),color='blue'))
eplt=eu.plotting.bscatter(radrat,
em-etrue,
xlabel=r'$image radius/\sigma$',
ylabel=r'$e_{meas}-e_{true}$',
show=False)
eplt.add(biggles.Curve(radrat,zeros(radrat.size),color='blue'))
tab[0,0] = splt
tab[1,0] = eplt
tab.title = r'$N_{sub}: %d \epsilon:%.2f \theta:%.2f' % (nsub,e,theta)
tab.show()
tab.write_eps(epsfile)
def admom_atlas(type, run, camcol, field, id, filter,
objs=None,
show=False, showmin=0, **keys):
"""
Objs must be for this camcol!
"""
import admom
import sdsspy
c = sdsspy.FILTERNUM[filter]
if objs is None:
sc=SweepCache()
obj = sc.readobj(type, run, camcol, field, id)
else:
w=where1( (objs['field'] == field) & (objs['id'] == id) )
if w.size == 0:
raise ValueError("Object not found objs: "
"%06i-%i-%04i" % (run,camcol,id))
obj = objs[w[0]]
atls = sdsspy.read('fpAtlas',run,camcol,field,id, trim=True)
im = numpy.array( atls['images'][c], dtype='f8') - atls['SOFT_BIAS']
psfield = sdsspy.read('psField', run, camcol, field, lower=True)
rowc=obj['rowc'][c]
colc=obj['colc'][c]
row=rowc - atls['row0'][c] - 0.5
col=colc - atls['col0'][c] - 0.5
sigsky = psfield['skysig'][0,c]
Tguess_psf=admom.fwhm2mom( obj['psf_fwhm'][c], pixscale=0.4)
if obj['m_rr_cc'][c] > Tguess_psf:
Tguess=obj['m_rr_cc'][c]
else:
Tguess=Tguess_psf
out = admom.admom(im,
row,
col,
sky=0.0,
sigsky=sigsky,
Tguess=Tguess)
if show:
import fimage
import biggles
plt=images.view(im, min=showmin, show=False, **keys)
if out['whyflag'] == 0:
levels=7
wrow = out['wrow']
wcol = out['wcol']
model = fimage.model_image('gauss',
im.shape,
[wrow,wcol],
[out['Irr'],out['Irc'],out['Icc']],
counts=im.sum())
cmod = biggles.Contours(model.transpose(), color='grey')
cmod.levels = levels
plt.add(cmod)
plt.show()
return out
