def redshiftfunctions(self): D = self.D zbins = self.zbins z2bins = self.z2bins Dabins = zbins * 0.0 Dmodbins = zbins * 0.0 Da2bins = numpy.zeros((z2bins.size, z2bins.size)) volumebins = zbins * 0.0 for i in range(zbins.size): Dabins[i] = D.Da(zbins[i]) Dmodbins[i] = D.distance_modulus(zbins[i]) volumebins[i] = D.volume(zbins[i]) for i in range(z2bins.size): for j in range(z2bins.size): if j > i: Da2bins[i, j] = D.Da(z2bins[i], z2bins[j]) self.Da_spline = interpolate.splrep(zbins, Dabins) self.Dmod_spline = interpolate.splrep(zbins, Dmodbins) self.volume_spline = interpolate.splrep(zbins, volumebins) z2d = iT.coords((z2bins.size, z2bins.size)) * self.dz2 self.Da_bispline = interpolate.RectBivariateSpline( z2bins, z2bins, Da2bins) #pickle the splines splinedump = open("redshiftsplines.pkl", "wb") cPickle.dump([ self.Da_spline, self.Dmod_spline, self.volume_spline, self.Da_bispline ], splinedump, 2)
def newAxes(x, y, srcxsize, srcysize): import numpy import indexTricks as iT xdif = x.max() - x.min() ydif = y.max() - y.min() difmax = numpy.max([xdif, ydif]) scentre = ((x.max() + x.min()) / 2., (y.max() + y.min()) / 2.) sshape = ((srcysize, srcxsize)) pscale = 1.2 * (difmax / ((srcysize - 3))) srcy, srcx = iT.coords(sshape) * pscale srcx -= srcx.mean() srcy -= srcy.mean() srcy += scentre[1] srcx += scentre[0] srcxaxis = srcx[0] srcyaxis = srcy[:, 0] srcx = srcx.flatten() srcy = srcy.flatten() return srcxaxis, srcyaxis, srcx, srcy
def lensASource(self,sourcenumber,bands): src=self.src[sourcenumber] lens=massmodel.PowerLaw('lens',{},{'x':self.xl+self.deltaxl,'y':self.yl+self.deltayl,'q':self.ql,'pa':90+self.deltap,'b':self.bl[sourcenumber],'eta':1}) es=massmodel.ExtShear('lens',{},{'x':self.xl+self.deltaxl,'y':self.yl+self.deltayl,'pa':self.xp,'b':self.xb}) lenses=[lens,es] a=51 ox,oy=iT.coords((a,a)) ps=(self.rs[sourcenumber]*(10./a)) ox=(ox-(a-1)/2.)*ps+(self.xs[sourcenumber]) oy=(oy-(a-1)/2.)*ps+(self.ys[sourcenumber]) unlensedsrcmodel=(src.pixeval(ox,oy,csub=5)*(ps**2)).sum() srcnorm=unlensedsrcmodel.sum() unlensedsrcmodel/=srcnorm srcmodel=pylens.lens_images(lenses,src,[self.x,self.y],getPix=True,csub=5)[0] srcmodel[srcmodel<0]=0 srcmodel/=srcnorm self.magnification[sourcenumber]=(numpy.sum(numpy.ravel(srcmodel))/numpy.sum(numpy.ravel(unlensedsrcmodel))) sm={} for band in bands: unlensedtotalsrcflux=10**(-(self.ms[sourcenumber][band]-self.zeropoints[band])/2.5) sm[band]=srcmodel*unlensedtotalsrcflux if sm[band].max()>0: self.totallensedsrcmag[sourcenumber][band]=-2.5*numpy.log10(sm[band].sum())+self.zeropoints[band] else: self.totallensedsrcmag[sourcenumber][band]=99 return sm
def MomentChecks(self,cmax=2.7,cmin=0.5,vb=False): import moments import indexTricks as iT x,y=iT.coords(self.D.shape) x-=self.xl y-=self.yl x*=self.pixelsize y*=self.pixelsize goodlabels=[] unalignedlabels=[] for label in self.labels: D2=self.D*1 D2[self.regions!=label]=0 com,flux,mean=moments.comflux(D2) # we check this bit first since evaluating the shape is the slowest part ca=(com[1]-self.xl,com[0]-self.yl) com_dist=((ca[0]**2+ca[1]**2)**0.5)*self.pixelsize if com_dist < cmin:#arcseconds if vb:print "too close" continue if com_dist > cmax:#arcseconds if vb:print "too far" continue if self.FluxCheck(flux,mean)==False: if vb:print "too faint" continue com,(a,b,q), eigvals,eigvecs, flux,mean= moments.main(D2) ca_hat=ca/((ca[0]**2+ca[1]**2)**0.5) va=eigvecs[:,1]#normalized dp=ca_hat[0]*va[0]+ca_hat[1]*va[1] theta=(numpy.arccos(dp)*180./3.14159) #degrees #this bit will let you visualize what's going on in each detected residual: if self.visualize: plt.imshow(D2,interpolation="None") plt.scatter(self.xl,self.yl,c="r",s=25) plt.plot([self.xl,self.xl+ca[0]],[self.yl,self.yl+ca[1]],c="r",lw=2) plt.scatter(com[1],com[0],c="k",s=25) plt.plot([com[1]-5*va[0],com[1]+5*va[0]],[com[0]-5*va[1],com[0]+5*va[1]],c="k",lw=3) plt.show(block=True) if b*self.pixelsize<0.2:#arcseconds if vb:print "too thin" continue if numpy.abs(theta) >30 and (theta<60 or theta >120): unalignedlabels.append(label) else: goodlabels.append(label) self.q=q self.goodlabels=goodlabels self.unalignedlabels=unalignedlabels
def showRes(x,y,src,psf,img,sig,mask,iflt,vflt,cmat,reg,niter,npix): oy,ox = iT.coords((npix,npix)) oy -= oy.mean() ox -= ox.mean() span = max(x.max()-x.min(),y.max()-y.min()) oy *= span/npix ox *= span/npix ox += x.mean() oy += y.mean() lmat = psf*src.lmat rmat = src.rmat res,fit,model,rhs,regg = aT.getModelG(iflt,vflt,lmat,cmat,rmat,reg,niter=niter) osrc = src.eval(ox.ravel(),oy.ravel(),fit).reshape(ox.shape) oimg = img*numpy.nan oimg[mask] = (lmat*fit) ext = [0,img.shape[1],0,img.shape[0]] ext2 = [x.mean()-span/2.,x.mean()+span/2.,y.mean()-span/2.,y.mean()+span/2.] pylab.figure() pylab.subplot(221) img[~mask] = numpy.nan pylab.imshow(img,origin='lower',interpolation='nearest',extent=ext) pylab.colorbar() pylab.subplot(222) pylab.imshow(oimg,origin='lower',interpolation='nearest',extent=ext) pylab.colorbar() pylab.subplot(223) pylab.imshow((img-oimg)/sig,origin='lower',interpolation='nearest',extent=ext) pylab.colorbar() pylab.subplot(224) pylab.imshow(osrc,origin='lower',interpolation='nearest',extent=ext2) pylab.colorbar() return osrc
def fullSolution(shape,ysoln,orders,wideorders,wsoln): import indexTricks as iT coords = iT.coords(shape) y = coords[0].copy() x = coords[1].copy() soln = [] if shape[1]>3000: disp = 1.65e-5 else: disp = 2*1.65e-5 owave = numpy.arange(3.585,4.038,disp) for i in range(len(ysoln)): low,high = orders[i] wlow,whigh = wideorders[i] ytrue,ymap = ysoln[i] win,wout = wsoln[i] tmpw = genfunc(x[0],0.,win) ow = owave[(owave>=tmpw[0])&(owave<=tmpw[-1])].copy() if ow.size>x.shape[1]: diff = ow.size-x.shape[1] if diff%2==0: ow = ow[int(diff/2):int(diff/-2)] else: ow = ow[int(diff/2):int((diff+1)/-2)] xc = genfunc(ow,0.,wout) xc = xc.repeat(high-low).reshape((xc.size,high-low)).T yc = genfunc(xc.ravel(),y[low:high,:xc.shape[1]].ravel(),ytrue) yc = yc.reshape((high-low,xc.shape[1]))-wlow corr = numpy.linspace(-0.2,0.2,high-low) xc = (xc.T+corr).T #xc = xc.repeat(high-low).reshape(yc.shape[::-1]).T soln.append([numpy.array([yc,xc]),ow[0],ow[-1],disp]) return soln
def matrixAppend(mat,vec): from scipy.sparse import coo_matrix nr,nc = mat.shape mat = mat.tocoo() r = mat.row.copy() c = mat.col.copy() d = mat.data.copy() if vec.ndim==1: if vec.size!=nr: print 'Array is not aligned with matrix' df r = numpy.concatenate((r,numpy.arange(vec.size))) c = numpy.concatenate((c,numpy.ones(vec.size)*nc)) d = numpy.concatenate((d,vec)) return coo_matrix((d,(r,c)),(nr,nc+1)) if vec.shape[1]!=nr: print 'Array is not aligned with matrix' df import indexTricks as iT vr,vc = iT.coords(vec.shape) vc += nc r = numpy.concatenate((r,vr.ravel())) c = numpy.concatenate((c,vc.ravel())) d = numpy.concatenate((d,vec.ravel())) return coo_matrix((d,(r,c)),(nr,nc+vec.shape[0]))
def __init__(self,B,R,sB,sR,pixelsize,zerofluxB,zerofluxR,xl=None,yl=None): self.pixelsize=pixelsize self.zerofluxB=zerofluxB self.zerofluxR=zerofluxR self.zeroflux=self.zerofluxB if xl==None: xl=B.shape[0]/2. if yl==None: yl=B.shape[1]/2. self.xl=xl self.yl=yl x,y=iT.coords(B.shape) x-=self.xl y-=self.yl r=(x**2+y**2)**0.5 mask=((r<2.7) & (r>0.5)) alpha=B[mask].sum()*1./R[mask].sum() self.D=B-alpha*R self.S=(sB**2+(alpha*sR)**2)**.5 self.SN=self.D/self.S
def redshiftfunctions(self): D=self.D zbins=self.zbins z2bins=self.z2bins Dabins=zbins*0.0 Dmodbins=zbins*0.0 Da2bins=numpy.zeros((z2bins.size,z2bins.size)) volumebins=zbins*0.0 for i in range(zbins.size): Dabins[i]=D.Da(zbins[i]) Dmodbins[i]=D.distance_modulus(zbins[i]) volumebins[i]=D.volume(zbins[i]) for i in range(z2bins.size): for j in range(z2bins.size): if j>i: Da2bins[i,j]=D.Da(z2bins[i],z2bins[j]) self.Da_spline=interpolate.splrep(zbins,Dabins) self.Dmod_spline=interpolate.splrep(zbins,Dmodbins) self.volume_spline=interpolate.splrep(zbins,volumebins) z2d=iT.coords((z2bins.size,z2bins.size))*self.dz2 self.Da_bispline=interpolate.RectBivariateSpline(z2bins,z2bins,Da2bins) #pickle the splines splinedump=open("redshiftsplines.pkl","wb") cPickle.dump([self.Da_spline,self.Dmod_spline,self.volume_spline,self.Da_bispline],splinedump,2)
def GetFits(self): bands = dict([('J0837','F606W'),('J0901','F606W'),('J0913','F555W'),('J1125','F606W'),('J1144','F606W'),('J1218','F606W'),('J1248','F555W'),('J1323','F555W'),('J1347','F606W'),('J1446','F606W'),('J1605','F555W'),('J1606','F606W'),('J1619','F606W'),('J2228','F606W')]) # not working yet - this will need us to have all the images somewhere, and all the xc,yc offsets! # get nnls values! Ideally, these should be already saved print "why didn't you save these before?!?" yc,xc = iT.coords(self.img1.shape) OVRS=1 yo,xo=iT.overSample(self.img1.shape,OVRS) colours = [bands[self.name], 'F814W'] models = [] fits = [] for i in range(len(self.imgs)): if i == 0: dx,dy = 0,0 else: dx = self.Ddic['xoffset'] dy = self.Ddic['yoffset'] xp,yp = xc+dx+self.Dx,yc+dy+self.Dx xop,yop = xo+dy+self.Dy,yo+dy+self.Dy image = self.imgs[i] sigma = self.sigs[i] psf = self.PSFs[i] imin,sigin,xin,yin = image.flatten(), sigma.flatten(),xp.flatten(),yp.flatten() n = 0 model = np.empty(((len(self.gals) + len(self.srcs)+1),imin.size)) for gal in self.gals: gal.setPars() tmp = xc*0. tmp = gal.pixeval(xp,yp,1./OVRS,csub=11) # evaulate on the oversampled grid. OVRS = number of new pixels per old pixel. tmp = iT.resamp(tmp,OVRS,True) # convert it back to original size tmp = convolve.convolve(tmp,psf,False)[0] model[n] = tmp.ravel() n +=1 for lens in self.lenses: lens.setPars() x0,y0 = pylens.lens_images(self.lenses,self.srcs,[xp,yp],1./OVRS,getPix=True) for src in self.srcs: src.setPars() tmp = xc*0. tmp = src.pixeval(x0,y0,1./OVRS,csub=11) tmp = iT.resamp(tmp,OVRS,True) tmp = convolve.convolve(tmp,psf,False)[0] model[n] = tmp.ravel() n +=1 model[n] = np.ones(model[n].shape) n +=1 rhs = (imin/sigin) # data op = (model/sigin).T # model matrix fit, chi = optimize.nnls(op,rhs) components = (model.T*fit).T.reshape((n,image.shape[0],image.shape[1])) model = components.sum(0) models.append(model) #SotPleparately(image,model,sigma,colours[i]) #NotPlicely(image,model,sigma) comps = False if comps == True: CotSomponents(components,colours[i]) fits.append(fit) self.fits = fits
def setupImageCoords(image,sig,psf,mask=None,regularizationmode='curvature'): import indexTricks as iT from imageSim import convolve from scipy.sparse import coo_matrix,diags import pixellatedTools import numpy inshape = image.shape image = image.flatten() sig = sig.flatten() ysize,xsize = inshape # There are two sets of coordinates in the image plane, one for the # centers of pixels and one for the corners. This defines a mapping that # describes which corners are associated with a center. yc,xc = iT.coords((ysize+1,xsize+1)) # Corners yc = yc.flatten()-0.5 xc = xc.flatten()-0.5 y0,x0 = iT.coords((ysize,xsize)) # Centers y0 = y0.flatten() x0 = x0.flatten() i = numpy.arange(x0.size) res = i%xsize p = i/xsize i = p*(xsize+1)+res indx = numpy.array([i,i+1,i+xsize+1,i+xsize+2]).T P = pixellatedTools.getPSFMatrix(psf,inshape) if mask!=None: image=image[mask] indx=None sig=sig[mask] yc=yc[mask] xc=xc[mask] y0=y0[mask] x0=x0[mask] P= P.tocsc()[:,list(mask)[0]] P= P[list(mask)[0],:] C = diags(1./sig**2,0) c= diags(sig**2,0) return image,sig,yc,xc,y0,x0,P,c,C,indx,inshape,mask
def getPSFMatrix(psf, imshape, mask=None): """ Create a PSF matrix given the PSF model and image dimensions """ import numpy from scipy.sparse import coo_matrix import indexTricks as iT imsize = imshape[0] * imshape[1] y, x = iT.coords(psf.shape) x -= int(x.mean()) y -= int(y.mean()) c = psf.ravel() != 0 x = x.ravel().astype(numpy.int32)[c] y = y.ravel().astype(numpy.int32)[c] Y, X = iT.coords(imshape) X = X.ravel().astype(numpy.int32) Y = Y.ravel().astype(numpy.int32) cols = X.repeat(x.size) + numpy.tile(x, X.size) rows = Y.repeat(y.size) + numpy.tile(y, Y.size) C = (cols >= 0) & (cols < imshape[1]) & (rows >= 0) & (rows < imshape[0]) cols = cols[C] rows = rows[C] pvals = numpy.tile(psf.ravel()[c], imsize)[C] col = cols + rows * imshape[1] row = numpy.arange(imsize).repeat(c.sum())[C] cols = cols[pvals != 0] rows = rows[pvals != 0] pvals = pvals[pvals != 0] pmat = coo_matrix((pvals, (col, row)), shape=(imsize, imsize)) if mask is not None: npnts = mask.sum() c = numpy.arange(imsize)[mask.ravel()] r = numpy.arange(npnts) smat = coo_matrix((numpy.ones(npnts), (c, r)), shape=(imsize, npnts)) pmat = smat.T * (pmat * smat) return pmat
def getStraight(img, ysoln, low, resamp=True, mode='constant'): yforw = ysoln[2] tmp = img.repeat(2, 0).repeat(2, 1) x = iT.coords(yforw.shape)[1] c = numpy.array([yforw + low * 2, x]) X = ndimage.map_coordinates(rotcoords2[1], c) Y = ndimage.map_coordinates(rotcoords2[0], c) c = numpy.array([Y, X]) tmp = ndimage.map_coordinates(tmp, c, mode=mode) if resamp == True: return iT.resamp(tmp, 2) return tmp
def getPSFMatrix(psf,imshape,mask=None): """ Create a PSF matrix given the PSF model and image dimensions """ import numpy from scipy.sparse import coo_matrix import indexTricks as iT imsize = imshape[0]*imshape[1] y,x = iT.coords(psf.shape) x -= int(x.mean()) y -= int(y.mean()) c = psf.ravel()!=0 x = x.ravel().astype(numpy.int32)[c] y = y.ravel().astype(numpy.int32)[c] Y,X = iT.coords(imshape) X = X.ravel().astype(numpy.int32) Y = Y.ravel().astype(numpy.int32) cols = X.repeat(x.size)+numpy.tile(x,X.size) rows = Y.repeat(y.size)+numpy.tile(y,Y.size) C = (cols>=0)&(cols<imshape[1])&(rows>=0)&(rows<imshape[0]) cols = cols[C] rows = rows[C] pvals = numpy.tile(psf.ravel()[c],imsize)[C] col = cols+rows*imshape[1] row = numpy.arange(imsize).repeat(c.sum())[C] pmat = coo_matrix((pvals,(col,row)),shape=(imsize,imsize)) if mask is not None: npnts = mask.sum() c = numpy.arange(imsize)[mask.ravel()] r = numpy.arange(npnts) smat = coo_matrix((numpy.ones(npnts),(c,r)),shape=(imsize,npnts)) pmat = smat.T*(pmat*smat) return pmat
def resampleData(data, owgrid, low, high, ysoln, xsoln, rwsoln): dy = (high - low) * 2 ygrid = iT.coords((dy, owgrid.size))[0] xgrid = sf.genfunc(owgrid, 0., rwsoln).repeat(dy) xgrid = xgrid.reshape((owgrid.size, dy)).T xgrid = sf.genfunc(xgrid.flatten(), ygrid.flatten(), xsoln['forw']) xgrid = xgrid.reshape(ygrid.shape) c = numpy.array([ygrid, xgrid]) ygrid = ndimage.map_coordinates(ysoln[2], c) c = numpy.array([ygrid + low * 2, xgrid]) X = ndimage.map_coordinates(rotcoords2[1], c) Y = ndimage.map_coordinates(rotcoords2[0], c) c = numpy.array([Y, X]) d = data.repeat(2, 0).repeat(2, 1) img = ndimage.map_coordinates(d, c, order=5) return iT.resamp(img, 2)
def __init__(self, surveyname, fractionofseeing=1): #----------------------------------------------------- ### Read in survey self.surveyname = surveyname survey = Survey( surveyname) #This stores typical survey in Surveys.Survey self.survey = survey self.pixelsize = survey.pixelsize self.side = survey.side self.readnoise = survey.readnoise self.nexposures = survey.nexposures self.f_sky = survey.f_sky self.bands = survey.bands self.strategy = survey.strategy self.strategyx = survey.strategyx self.exposuretimes = {} self.zeropoints = {} self.stochasticobservingdata = {} self.gains = {} self.seeing = {} self.psfscale = {} self.psf = {} self.psfFFT = {} self.ET = {} self.SB = {} for i in range(len(survey.bands)): self.exposuretimes[survey.bands[i]] = survey.exposuretimes[i] self.zeropoints[survey.bands[i]] = survey.zeropoints[i] self.gains[survey.bands[i]] = survey.gains[i] self.stochasticobservingdata[ survey.bands[i]] = survey.stochasticobservingdata[i] self.zeroexposuretime = survey.zeroexposuretime #----------------------------------------------------- ###do some setup self.xl = (self.side - 1.) / 2. self.yl = (self.side - 1.) / 2. self.x, self.y = iT.coords((self.side, self.side)) self.r2 = (self.x - self.xl)**2 + (self.y - self.yl)**2 self.pixelunits = False #----------------------------------------------------- self.Reset()
def __init__(self, surveyname, fractionofseeing=1): #setting surveyname to be the surveyname and declaring the parameters to be the same ### Read in survey self.surveyName = surveyname survey = Survey( surveyname) #This stores typical survey in Surveys.Survey self.survey = Survey(surveyname) self.pixelsize = self.survey.pixelsize #let self.pixelsixe be equal to the pixelsize of survey self.side = self.survey.side self.readnoise = self.survey.readnoise self.nexposures = self.survey.nexposures self.f_sky = self.survey.f_sky self.bands = self.survey.bands self.strategy = self.survey.strategy self.strategyx = self.survey.strategyx self.exposuretimes = {} self.zeropoints = {} self.stochasticobservingdata = {} self.gains = {} self.seeing = {} self.psfscale = {} self.psf = {} self.psfFFT = {} self.ET = {} self.SB = {} #for i in range of the length of bands in survey, set the parameters to self.parameter for i in range(len(survey.bands)): self.exposuretimes[survey.bands[i]] = survey.exposuretimes[i] self.zeropoints[survey.bands[i]] = survey.zeropoints[i] self.gains[survey.bands[i]] = survey.gains[i] self.stochasticobservingdata[ survey.bands[i]] = survey.stochasticobservingdata[i] self.zeroexposuretime = survey.zeroexposuretime ###do some setup self.xl = (self.side - 1.) / 2. self.yl = (self.side - 1.) / 2. self.x, self.y = iT.coords( (self.side, self.side)) #creating an array of the sides coordinates self.r2 = (self.x - self.xl)**2 + ( self.y - self.yl)**2 # r squared (r2) = distance between (x,y) and (xl, yl) self.pixelunits = False self.Reset() #resets all parameters as seen in definition below
def __init__(self,surveyname,fractionofseeing=1): #----------------------------------------------------- ### Read in survey self.surveyname=surveyname survey=Survey(surveyname)#This stores typical survey in Surveys.Survey self.survey=survey self.pixelsize=survey.pixelsize self.side=survey.side self.readnoise=survey.readnoise self.nexposures=survey.nexposures self.f_sky=survey.f_sky self.bands=survey.bands self.strategy=survey.strategy self.strategyx=survey.strategyx self.exposuretimes={} self.zeropoints={} self.stochasticobservingdata={} self.gains={} self.seeing={} self.psfscale={} self.psf={} self.psfFFT={} self.ET={} self.SB={} for i in range(len(survey.bands)): self.exposuretimes[survey.bands[i]]=survey.exposuretimes[i] self.zeropoints[survey.bands[i]]=survey.zeropoints[i] self.gains[survey.bands[i]]=survey.gains[i] self.stochasticobservingdata[survey.bands[i]]=survey.stochasticobservingdata[i] self.zeroexposuretime=survey.zeroexposuretime #----------------------------------------------------- ###do some setup self.xl=(self.side-1.)/2. self.yl=(self.side-1.)/2. self.x,self.y = iT.coords((self.side,self.side)) self.r2 = (self.x-self.xl)**2+(self.y-self.yl)**2 self.pixelunits=False #----------------------------------------------------- self.Reset()
def setupSourceGrid(sshape,pscale,scentre,mask=None,regularizationmode='curvature',R=None): import pixellatedTools import indexTricks as iT srcy,srcx = iT.coords(sshape)*pscale srcx -= srcx.mean() srcy -= srcy.mean() srcy += scentre[1] srcx += scentre[0] srcxaxis=srcx[0] srcyaxis=srcy[:,0] srcx = srcx.flatten() srcy = srcy.flatten() if R==None: R= pixellatedTools.getRegularizationMatrix(srcxaxis,srcyaxis,mode=regularizationmode) return srcx,srcy,srcxaxis,srcyaxis,R,pscale,sshape
pl.title('model') pl.subplot(223) pl.imshow(image-im,origin='lower',interpolation='nearest',extent=ext,vmin=-0.25,vmax=0.25,cmap='afmhot',aspect='auto') pl.colorbar() pl.title('data-model') pl.subplot(224) pl.imshow((image-im)/sigma,origin='lower',interpolation='nearest',extent=ext,vmin=-5,vmax=5,cmap='afmhot',aspect='auto') pl.title('signal-to-noise residuals') pl.colorbar() pl.show() #pl.suptitle(str(V)) #pl.savefig('/data/ljo31/Lens/TeXstuff/plotrun'+str(X)+'.png') image = pyfits.open('/data/ljo31/Lens/J1347/J1347_med_cutout.fits')[0].data.copy() sigma = pyfits.open('/data/ljo31/Lens/J1347/J137_med_sigma.fits')[0].data.copy() yc,xc = iT.coords(image.shape)*0.8 # wide camera: 0.04 arcsec/pixel # Model the PSF as a Moffat xp,yp = iT.coords((100,100))-50 OVRS = 1 # load up model det = np.load('/data/ljo31/Lens/J1347/emcee_FINAL_uncertainties_TWO')[2] lp = np.load('/data/ljo31/Lens/J1347/emcee_FINAL_uncertainties_TWO')[0] ii = np.where(lp==np.amax(lp)) g1,l1,s1,s2,sh = {},{},{},{},{} srcs = [] gals = [] lenses = []
def lensASource(self, sourcenumber, bands): # src is created as a sourcenumber src = self.src[sourcenumber] # lens is a powerlaw instance of massmodel which includes x, y, q, pa, b, eta lens = massmodel.PowerLaw('lens', {}, { 'x': self.xl + self.deltaxl, 'y': self.yl + self.deltayl, 'q': self.ql, 'pa': 90 + self.deltap, 'b': self.bl[sourcenumber], 'eta': 1 }) # es is a ExtShear instance of massmodel. Not sure what ExtShear is es = massmodel.ExtShear('lens', {}, { 'x': self.xl + self.deltaxl, 'y': self.yl + self.deltayl, 'pa': self.xp, 'b': self.xb }) # list lenses created including lens and es lenses = [lens, es] a = 51 # makes array of ox, and oy which shows the shape of the array as a float ox, oy = iT.coords((a, a)) # ps is a float which is calculated by taking the rs value and multiplying it by (10.0/a) ps = (self.rs[sourcenumber] * (10.0 / a)) ox = (ox - (a - 1) / 2.0) * ps + ( self.xSum[sourcenumber] ) # ox are arrays in which values are calculates as ox-(a-1)/2 + the xSum oy = (oy - (a - 1) / 2.0) * ps + ( self.ySum[sourcenumber] ) # oy are arrays in which values are calculates as oy-(a-1)/2 + the ySum unlensedSourceModel = (src.pixeval(ox, oy, csub=5) * (ps**2)).sum() #sum of pixelvalues of souces sourceNorm = unlensedSourceModel.sum() # sum of unlensedSourceModel unlensedSourceModel /= sourceNorm # unlensedSourceModel = unlensedSourceModel / sourceNorm #creating a model for the lenses sourceModel = pylens.lens_images(lenses, src, [self.x, self.y], getPix=True, csub=5)[0] sourceModel[ sourceModel < 0] = 0 # if the sourceModel is < 0,set it to be 0 sourceModel /= sourceNorm #sourceModel = sourceModel / sourceNorm #creating a magnification for each source self.magnification[sourcenumber] = ( numpy.sum(numpy.ravel(sourceModel)) / numpy.sum(numpy.ravel(unlensedSourceModel))) sm = {} #for each band that is seen in the bands list: # unlensedTotalSourceFlux is calculated as flux of the a band with regards to the sourcenumber, # and that same band at the zeropoint # important to note: flux = 10 ** (0.4 *( m2 - m1)), where m2 is the zeropoints # or fluw = 10 ** (-(m1 - m2) / 2.5) for band in bands: unlensedtotalsrcflux = 10**( -(self.ms[sourcenumber][band] - self.zeropoints[band]) / 2.5) sm[band] = sourceModel * unlensedtotalsrcflux if sm[band].max() > 0: # if the maximum value in sm[band] > 0, then the magnitude calculated # magnitude = m1/m2 ((m1/m2) from calculations of flux in comments above) self.totallensedsrcmag[sourcenumber][ band] = -2.5 * numpy.log10( sm[band].sum()) + self.zeropoints[band] else: # else magnitude = 99 self.totallensedsrcmag[sourcenumber][band] = 99 return sm
pl.imshow(image-im,origin='lower',interpolation='nearest',extent=ext,vmin=-0.25,vmax=0.25,cmap='afmhot',aspect='auto') pl.colorbar() #pl.title('data-model') pl.subplot(224) pl.imshow((image-im)/sigma,origin='lower',interpolation='nearest',extent=ext,vmin=-5,vmax=5,cmap='afmhot',aspect='auto') #pl.title('signal-to-noise residuals') pl.colorbar() #pl.subplots_adjust(left=0.05,bottom=0.05,top=0.95,right=0.95) #pl.subplots_adjust(wspace=-0.1,hspace=0.05) #pl.suptitle(str(V)) #pl.savefig('/data/ljo31/Lens/TeXstuff/plotrun'+str(X)+'.png') image = pyfits.open('/data/ljo31/Lens/J1605/J1605_Kp_narrow_med_cutout.fits')[0].data.copy() sigma = pyfits.open('/data/ljo31/Lens/J1605/J1605_Kp_narrow_med_sigma.fits')[0].data.copy() #sigma = np.ones(sigma.shape)*sigma[0,0] yc,xc = iT.coords(image.shape)*0.2 # Model the PSF as a Gaussian to start with. We'll do this over a grid of sigmas, and then maybe also ellitpicity and position anlge (will get kompliziert!!) xp,yp = iT.coords((170,170))-85 OVRS = 1 guiFile = '/data/ljo31/Lens/J1605/terminal_iterated_4' G,L,S,offsets,_ = numpy.load(guiFile) pars = [] cov = [] srcs = [] for name in 'Source 1', 'Source 2': s = S[name] p = {} if name == 'Source 1':
# psf6 pars.append(pymc.Uniform('sigma 6',0.1,400,value= 8 )) pars.append(pymc.Uniform('q 6',0,1,value=0.9)) pars.append(pymc.Uniform('pa 6',-180,180,value= 90 )) pars.append(pymc.Uniform('amp 6',0,1,value=0.15)) cov += [1,0.5,50,0.2] psfObj1 = SBObjects.Gauss('psf 1',{'x':0,'y':0,'sigma':pars[2],'q':pars[3],'pa':pars[4],'amp':pars[5]}) psfObj2 = SBObjects.Gauss('psf 2',{'x':0,'y':0,'sigma':pars[6],'q':pars[7],'pa':pars[8],'amp':pars[9]}) psfObj3 = SBObjects.Gauss('psf 3',{'x':0,'y':0,'sigma':pars[10],'q':pars[11],'pa':pars[12],'amp':pars[13]}) psfObj4 = SBObjects.Gauss('psf 4',{'x':0,'y':0,'sigma':pars[14],'q':pars[15],'pa':pars[16],'amp':pars[17]}) psfObj5 = SBObjects.Gauss('psf 4',{'x':0,'y':0,'sigma':pars[18],'q':pars[19],'pa':pars[20],'amp':pars[21]}) psfObj6 = SBObjects.Gauss('psf 4',{'x':0,'y':0,'sigma':pars[22],'q':pars[23],'pa':pars[24],'amp':pars[25]}) psfObjs = [psfObj1,psfObj2,psfObj3,psfObj4,psfObj5,psfObj6] xpsf,ypsf = iT.coords((200,200))-100 gals = [] for name in ['Galaxy 1', 'Galaxy 2']: p = {} if name == 'Galaxy 1': for key in 'x','y','q','pa','re','n': p[key] = dic[name+' '+key][a1,a2,a3] elif name == 'Galaxy 2': for key in 'q','pa','re','n': p[key] = dic[name+' '+key][a1,a2,a3] for key in 'x','y': p[key] = gals[0].pars[key] gals.append(SBModels.Sersic(name,p)) lenses = []
def MomentChecks(self,cmax=2.7,cmin=0.5,vb=False): import moments import indexTricks as iT x,y=iT.coords(self.D.shape) x-=self.xl y-=self.yl x*=self.pixelsize y*=self.pixelsize goodlabels=[] unalignedlabels=[] for label in self.labels: D2=self.D*1 D2[self.regions!=label]=0 #plt.imshow(D2,interpolation="None") #plt.show(block=True) com,(a,b,q), eigvecs, flux,mean= moments.main(D2) va=eigvecs[:,1] ca=(com[0]-self.xl,com[1]-self.yl) com_dist=((ca[0]**2+ca[1]**2)**0.5)*self.pixelsize ca=ca/((ca[0]**2+ca[1]**2)**0.5) dp=ca[0]*va[0]+ca[1]*va[1] theta=(numpy.arccos(dp)*180/3.14159)#-90 #print theta,self.thetain #plt.imshow(D2,interpolation="none") #plt.show(block=True) if com_dist < cmin:#arcseconds if vb:print 21 continue if com_dist > cmax:#arcseconds if vb:print 22 continue if b*self.pixelsize<0.2:#arcseconds if vb:print 23 continue if self.FluxCheck(flux,mean)==False: if vb:print 24 continue if numpy.abs(theta) >30 and (theta<150 or theta >210):#degrees unalignedlabels.append(label) else: goodlabels.append(label) self.q=q self.goodlabels=goodlabels self.unalignedlabels=unalignedlabels
pylab.subplot(222) pylab.imshow(oimg,origin='lower',interpolation='nearest',extent=ext,cmap='jet') pylab.colorbar() pylab.subplot(223) pylab.imshow((img-oimg)/sig,origin='lower',interpolation='nearest',extent=ext,cmap='jet') pylab.colorbar() pylab.subplot(224) pylab.imshow(osrc,origin='lower',interpolation='nearest',extent=ext2,cmap='jet') pylab.colorbar() return osrc # Setup data for adaptive source modelling img,sig,psf = galsub, sig2,psf2 #pl.figure() #pl.imshow(img) y,x = iT.coords(img.shape) y,x=y+10,x+15 cpsf = convolve.convolve(img,psf)[1] ifltm = img[mask] sfltm = sig[mask] vfltm = sfltm**2 cmatm = diags(1./sfltm,0) xm = x[mask] ym = y[mask] coords = [xm,ym] PSF = pT.getPSFMatrix(psf,img.shape) PSFm = pT.maskPSFMatrix(PSF,mask) iflt = img.flatten() sflt = sig.flatten()
flnprob = np.load('/data/ljo31/Lens/J1605/flnprob_PixFit_2src.npy') fit = np.load('/data/ljo31/Lens/J1605/fit_PixFit_2src.npy') ii = np.argmax(flnprob) XX = fchain[ii] x,y,pa,q,re,n,pa2,q2,re2,n2 = fchain[ii] srcs = [] src1 = SBModels.Sersic('Source 1', {'x':0.1196461*x+10.91,'y':0.11966*y + 5.877,'pa':pa,'q':q,'re':re*0.1196461,'n':n,'amp':fit[0]}) src2 = SBModels.Sersic('Source 2', {'x':0.1196461*x+10.91,'y':0.11966*y + 5.877,'pa':pa2,'q':q2,'re':re2*0.1196461,'n':n2,'amp':fit[1]}) srcs = [src1,src2] guiFile = '/data/ljo31/Lens/J1605/terminal_iterated_4' G,L,S,offsets,shear = numpy.load(guiFile) x0 = offsets[0][3] y0 = offsets[1][3] yc,xc = iT.coords(img2.shape)-15 yc,xc = yc+y0,xc+x0 cov = [] pars = [] gals = [] for name in 'Galaxy 1', 'Galaxy 2': s = G[name] p = {} if name == 'Galaxy 1': for key in 'x','y','q','pa','re','n': if s[key]['type']=='constant': p[key] = s[key]['value'] else: lo,hi,val = s[key]['lower'],s[key]['upper'],s[key]['value'] pars.append(pymc.Uniform('%s %s'%(name,key),lo,hi,value=val))
def GetPDFs(self,kpc=False): self.muPDF = [] self.murestPDF = [] self.RePDF = [] self.magrestPDF = [] self.LumPDF = [] self.magPDF = [] self.fitPDF = [] self.bbandPDF = [] OVRS=self.OVRS yo,xo = iT.coords(self.img1.shape) yc,xc=iT.overSample(self.img1.shape,OVRS) colours = [bands[self.name], 'F814W'] for b1 in range(0,len(self.dictionaries),100): srcs,gals,lenses = [],[],[] for number in range(1,1+self.srcno): name = 'Source '+str(number) p = {} for key in 'q','re','n','pa': p[key] = self.dictionaries[b1][name+' '+key] for key in 'x','y': # subtract lens potition - to be added back on later in each likelihood iteration! p[key] = self.dictionaries[b1][name+' '+key]+self.dictionaries[b1]['Lens 1 '+key] srcs.append(SBBModels.Sersic(name,p)) for number in range(1,1+self.galno): name = 'Galaxy '+str(number) p = {} for key in 'x','y','q','re','n','pa': p[key] = self.dictionaries[b1][name+' '+key] gals.append(SBBModels.Sersic(name,p)) p = {} for key in 'x','y','q','pa','b','eta': p[key] = self.dictionaries[b1]['Lens 1 '+key] lenses.append(MassModels.PowerLaw('Lens 1',p)) p = {} p['x'] = lenses[0].pars['x'] p['y'] = lenses[0].pars['y'] p['b'] = self.dictionaries[b1]['extShear'] p['pa'] = self.dictionaries[b1]['extShear PA'] lenses.append(MassModels.ExtShear('shear',p)) # fits fits = [] for i in range(len(self.imgs)): if i == 0: dx,dy = 0,0 else: dx = self.dictionaries[b1]['xoffset'] dy = self.dictionaries[b1]['yoffset'] xp,yp = xc+dx+self.Dx,yc+dy+self.Dy xop,yop = xo+dy+self.Dx,yo+dy+self.Dy image = self.imgs[i] sigma = self.sigs[i] psf = self.PSFs[i] imin,sigin,xin,yin = image.flatten(), sigma.flatten(),xp.flatten(),yp.flatten() n = 0 model = np.empty(((len(gals) + len(srcs)+1),imin.size)) for gal in gals: gal.setPars() tmp = xc*0. tmp = gal.pixeval(xp,yp,1./OVRS,csub=11) # evaulate on the oversampled grid. OVRS = number of new pixels per old pixel. tmp = iT.resamp(tmp,OVRS,True) # convert it back to original size tmp = convolve.convolve(tmp,psf,False)[0] model[n] = tmp.ravel() n +=1 for lens in lenses: lens.setPars() x0,y0 = pylens.lens_images(lenses,srcs,[xp,yp],1./OVRS,getPix=True) for src in srcs: src.setPars() tmp = xc*0. if 'boxiness' in self.dic.keys(): if src.name == 'Source 2': #print 'this source has a boxy/disky component with c = ', '%.2f'%self.Ddic['boxiness'], '. I hope this is J1606!' tmp = src.boxypixeval(x0,y0,1./OVRS,csub=11,c=self.Ddic['boxiness']) else: tmp = src.pixeval(x0,y0,1./OVRS,csub=11) else: tmp = src.pixeval(x0,y0,1./OVRS,csub=11) tmp = iT.resamp(tmp,OVRS,True) tmp = convolve.convolve(tmp,psf,False)[0] model[n] = tmp.ravel() if self.name == 'J0837': #print "making J0837's dust lane..." if src.name == 'Source 2': model[n] *= -1 n +=1 model[n] = np.ones(model[n].shape) n +=1 rhs = (imin/sigin) # data op = (model/sigin).T # model matrix fit, chi = optimize.nnls(op,rhs) fits.append(fit) # source plane (observed) magnitudes if len(self.srcs)==1 or self.name == 'J0837': mag_v = srcs[0].getMag(fits[0][-2],self.ZPs[0]) mag_i = srcs[0].getMag(fits[1][-2],self.ZPs[1]) elif len(self.srcs)==2 and self.name != 'J0837': mv1,mv2 = srcs[0].getMag(fits[0][-3],self.ZPs[0]), srcs[1].getMag(fits[0][-2],self.ZPs[0]) mi1,mi2 = srcs[0].getMag(fits[1][-3],self.ZPs[1]),srcs[1].getMag(fits[1][-2],self.ZPs[1]) Fv = 10**(0.4*(self.ZPs[0]-mv1)) + 10**(0.4*(self.ZPs[0]-mv2)) Fi = 10**(0.4*(self.ZPs[0]-mi1)) + 10**(0.4*(self.ZPs[0]-mi2)) mag_v, mag_i = -2.5*np.log10(Fv) + self.ZPs[0], -2.5*np.log10(Fi) + self.ZPs[1] else: print 'how many sources do you want from me?' # intrinsic magnitudes if bands[self.name] == 'F555W': vband = MassB2 bband = MassB2toB elif bands[self.name] == 'F606W': vband = MassB1 bband = MassB1toB iband, kband = MassR, MassK Lv,mag_v_rest = vband(mag_v, self.z) Li,mag_i_rest = iband(mag_i, self.z) Lb,mag_b_rest = bband(mag_v,self.z) # sizes if self.srcno == 1 or self.name == 'J0837': Re_v, Re_i = srcs[0].pars['re']*0.05, srcs[0].pars['re']*0.05 elif self.srcno == 2 and self.name != 'J0837': Xgrid = np.logspace(-4,5,1501) Ygrid = np.logspace(-4,5,1501) bandRes = [] for i in range(len(self.imgs)): source = fits[i][-3]*srcs[0].eval(Xgrid) + fits[i][-2]*srcs[1].eval(Xgrid) R = Xgrid.copy() light = source*2.*np.pi*R mod = splrep(R,light,t=np.logspace(-3.8,4.8,1301)) intlight = np.zeros(len(R)) for i in range(len(R)): intlight[i] = splint(0,R[i],mod) model = splrep(intlight[:-300],R[:-300]) if len(model[1][np.where(np.isnan(model[1])==True)]>0): #print 'here' model = splrep(intlight[:-600],R[:-600]) reff = splev(0.5*intlight[-1],model) bandRes.append(reff*0.05) Re_v,Re_i = bandRes # surface brightnesses mu_v_rest = mag_v_rest + 2.5*np.log10(2.*np.pi*Re_v**2.) mu_i_rest = mag_i_rest + 2.5*np.log10(2.*np.pi*Re_i**2.) mu_b_rest = mag_b_rest + 2.5*np.log10(2.*np.pi*Re_v**2.) mu_v = mag_v + 2.5*np.log10(2.*np.pi*Re_v**2.) mu_i = mag_i + 2.5*np.log10(2.*np.pi*Re_i**2.) self.muPDF.append([mu_v,mu_i]) self.murestPDF.append([mu_v_rest,mu_i_rest,mu_b_rest]) if kpc: self.RePDF.append([Re_v*self.scale,Re_i*self.scale]) else: self.RePDF.append([Re_v,Re_i]) self.magrestPDF.append([mag_v_rest,mag_i_rest,mag_b_rest]) self.LumPDF.append([Lv,Li,Lb]) self.magPDF.append([mag_v,mag_i]) self.fitPDF.append(fits)
src = SBModels.Sersic('src',{'x':para[i,7],'y':para[i,8],'re':para[i,9],'q':para[i,10],'pa':para[i,11],'n':para[i,12]}) mag_src = para[i,13] srcMag = src.Mag(zp) src.amp = 10.**(-0.4*(mag_src-srcMag)) # Create mass (or lensing) objects lensMass = MassModels.PowerLaw('lens',{'x':para[i,14],'y':para[i,15],'b':para[i,16],'q':para[i,17],'pa':para[i,18],'eta':para[i,19]}) shear = MassModels.ExtShear('shear',{'x':para[i,20],'y':para[i,21],'b':para[i,22],'pa':para[i,23]}) lenses = [lensMass,shear] #create the coordinate grids that the image will be evaluated on y,x = iT.coords((240,240)) #with higher resolution 60*6 # create a PSF import pyfits psf = pyfits.open('../fits/sub400.fits')[0].data.copy() psf /= psf.sum() # Form the image and convolve (convolution returns the image and FFT'd PSF) img,psf = convolve.convolve(lensGal.pixeval(x,y),psf) xl,yl = pylens.getDeflections(lenses,[x,y]) img +=convolve.convolve(src.pixeval(xl,yl),psf,False)[0] #pylab.imshow(img,origin='lower',interpolation='nearest') #pylab.colorbar() #pylab.show()
OVRS = 1 PVRS=2 yc,xc = iT.overSample(image.shape,OVRS) yo,xo = iT.overSample(image.shape,1) xc,xo,yc,yo=xc*0.2,xo*0.2,yc*0.2,yo*0.2 xc,xo = xc+12 , xo+12 yc,yo = yc+20 , yo+20 mask = np.zeros(image.shape) tck = RectBivariateSpline(yo[:,0],xo[0],mask) mask2 = tck.ev(xc,yc) mask2[mask2<0.5] = 0 mask2[mask2>0.5] = 1 mask2 = mask2==0 mask = mask==0 xpsf,ypsf = iT.coords((340,340))-170 xpsf,ypsf = iT.overSample((340,340),PVRS) # oversampling xpsf,ypsf=xpsf-170.,ypsf-170. dx,dy,sig1,q1,pa1,amp1,sig2,q2,pa2 = trace[a1,a2,a3] amp2=1.-amp1 gals = [] for name in G.keys(): s = G[name] p = {} if name == 'Galaxy 1': for key in 'x','y','q','pa','re','n': p[key] =s[key]['value'] elif name == 'Galaxy 2': for key in 'q','pa','re','n': p[key] =s[key]['value'] for key in 'x','y':
def lnprob(X, xc, yc, rhs): if np.any(X < 0): return -np.inf x, y, pa, q, re, n = X src = SBModels.Sersic("Source 1", {"x": x, "y": y, "pa": pa, "q": q, "re": re, "n": n}) model = src.pixeval(xc, yc) fit = optimize.leastsq(func, 0.1, args=(model, rhs))[0].item() lnL = (-0.5 * (model * fit - rhs) ** 2.0).sum() # print lnL return lnL osrc = np.load("/data/ljo31/Lens/J1605/osrc_F814W.npy") yc, xc = iT.coords(osrc.shape) ii = np.where(np.isnan(osrc) == False) yc, xc = yc[ii], xc[ii] rhs = osrc[ii].flatten() # set up emcee ndim, nwalkers = 6, 40 # for instance p0 = np.zeros((nwalkers, ndim)) p0[:, 0] = 200 + np.random.randn(nwalkers) * 20 # x p0[:, 1] = 200.0 + np.random.randn(nwalkers) * 20 # y p0[:, 2] = 170.0 + np.random.randn(nwalkers) * 20 # pa p0[:, 3] = 0.8 + np.random.randn(nwalkers) * 0.5 # q p0[:, 4] = 25 + np.random.randn(nwalkers) * 3 # Re p0[:, 5] = 4.0 + np.random.randn(nwalkers) * 1 # n
kresult = np.load('/data/ljo31/Lens/J2228/KeckPSF_final') klp= kresult[0] ka2=0 ka1,ka3 = numpy.unravel_index(klp[:,0].argmax(),klp[:,0].shape) ktrace = kresult[1] kdic = kresult[2] imgs = [img] sigs = [sig] PSFs = [] xpsf,ypsf = iT.coords((201,201))-100. xoffset,yoffset,sig1,q1,pa1,amp1,sig2,q2,pa2,amp2,sig3,q3,pa3,amp3,sig4,q4,pa4,amp4,sig5,q5,pa5,amp5 = ktrace[ka1,ka2,ka3] psfObj1 = SBObjects.Gauss('psf 1',{'x':0,'y':0,'sigma':sig1,'q':q1,'pa':pa1,'amp':amp1}) psfObj2 = SBObjects.Gauss('psf 2',{'x':0,'y':0,'sigma':sig2,'q':q2,'pa':pa2,'amp':amp2}) psfObj3 = SBObjects.Gauss('psf 3',{'x':0,'y':0,'sigma':sig3,'q':q3,'pa':pa3,'amp':amp3}) psfObj4 = SBObjects.Gauss('psf 4',{'x':0,'y':0,'sigma':sig4,'q':q4,'pa':pa4,'amp':amp4}) psfObj5 = SBObjects.Gauss('psf 5',{'x':0,'y':0,'sigma':sig5,'q':q5,'pa':pa5,'amp':amp5}) psf1 = psfObj1.pixeval(xpsf,ypsf) / (np.pi*2.*sig1**2.) psf2 = psfObj2.pixeval(xpsf,ypsf) / (np.pi*2.*sig2**2.) psf3 = psfObj3.pixeval(xpsf,ypsf) / (np.pi*2.*sig3**2.) psf4 = psfObj4.pixeval(xpsf,ypsf) / (np.pi*2.*sig4**2.) psf5 = psfObj5.pixeval(xpsf,ypsf) / (np.pi*2.*sig5**2.) psf = psf1 + psf2 + psf3 + psf4 + psf5 #pl.figure()
def lnprob(X,xc,yc,rhs): x,y,pa,q,re,n,pa2,q2,re2,n2 = X if np.any(np.array([x,y,q,q2,n,n2,re,re2])<0) or n<0.1 or n2<0.1 or n>6 or n2>6 or re>300 or re2>300 or q>1 or q2>1 or pa>200 or pa2>200 or pa<-180 or pa2<-180: return -np.inf src = SBModels.Sersic('Source 1',{'x':x,'y':y,'pa':pa,'q':q,'re':re,'n':n}) src2 = SBModels.Sersic('Source 2',{'x':x,'y':y,'pa':pa2,'q':q2,'re':re2,'n':n2}) model1 = src.pixeval(xc,yc) model2 = src2.pixeval(xc,yc) op = np.column_stack((model1,model2)) fit = optimize.nnls(op,rhs)[0] lnL = (-0.5*(model1*fit[0] + model2*fit[1] - rhs)**2.).sum() #lnL = (-0.5*(np.dot(op,fit) -rhs)**2.).sum() return lnL osrc = np.load('/data/ljo31/Lens/J1605/osrc_F814W.npy') yc,xc = iT.coords(osrc.shape) ii = np.where(np.isnan(osrc)==False) yc,xc = yc[ii],xc[ii] rhs = osrc[ii].flatten() # set up emcee ndim,nwalkers = 10,60 # for instance p0 = np.zeros((nwalkers, ndim)) p0[:,0] = 220 +np.random.randn(nwalkers)*20 # x p0[:,1] = 200. +np.random.randn(nwalkers)*20 # y p0[:,2] = 0. + np.random.randn(nwalkers)*20 # pa p0[:,3] = 0.7 + np.random.randn(nwalkers)*0.1 # q p0[:,4] = 220 + np.random.randn(nwalkers)*20 # Re # 120 p0[:,5] = 4. + np.random.randn(nwalkers)*1 # n p0[:,6] = 150. + np.random.randn(nwalkers)*20 # pa
return mod def clip(arr, nsig=3.5): a = arr.flatten() a.sort() a = a[a.size / 20:a.size * 0.95] m, s, l = a.mean(), a.std(), a.size while 1: a = a[abs(a - m) < s * nsig] if a.size == l: return m, s m, s, l = a.mean(), a.std(), a.size y, x = iT.coords((1200, 1200)) c = cos(-84.9 * pi / 180.) s = sin(-84.9 * pi / 180.) X = (x - 599.5) * c + (y - 599.5) * s + 511.5 Y = (599.5 - x) * s + (y - 599.5) * c + 511.5 rotcoords = numpy.array([Y, X]) y, x = iT.coords((1024, 1024)) c = cos(84.9 * pi / 180.) s = sin(84.9 * pi / 180.) X = (x - 511.5) * c + (y - 511.5) * s + 599.5 Y = (511.5 - x) * s + (y - 511.5) * c + 599.5 derotcoords = numpy.array([Y, X]) y, x = iT.coords((2400, 2400)) c = cos(-84.9 * pi / 180.) s = sin(-84.9 * pi / 180.) X = (x - 1199.5) * c + (y - 1199.5) * s + 1023.5
pl.colorbar() pl.title('model') pl.subplot(223) pl.imshow(image-im,origin='lower',interpolation='nearest',extent=ext,vmin=-0.25,vmax=0.25) pl.colorbar() pl.title('data-model') pl.subplot(224) pl.imshow((image-im)/sigma,origin='lower',interpolation='nearest',extent=ext,vmin=-5,vmax=5) pl.title('signal-to-noise residuals') pl.colorbar() #pl.suptitle(str(V)) #pl.savefig('/data/ljo31/Lens/TeXstuff/plotrun'+str(X)+'.png') image = pyfits.open('/data/ljo31/Lens/J1605/J1605_Kp_narrow_med_cutout.fits')[0].data.copy() sigma = pyfits.open('/data/ljo31/Lens/J1605/J1605_Kp_narrow_med_sigma.fits')[0].data.copy() yc,xc = iT.coords(image.shape) # Model the PSF as a Gaussian to start with. We'll do this over a grid of sigmas, and then maybe also ellitpicity and position anlge (will get kompliziert!!) xp,yp = iT.coords((50,50))-25 OVRS = 1 # we should get these from the iterated terminal version. det = np.load('/data/ljo31/Lens/J1605/det8.npy')[()] g1,g2,l1,s1,s2,sh = {},{},{},{},{},{} coeff=[] lenses = [] for name in det.keys(): s = det[name] coeff.append(s[-1]) if name[:8] == 'Source 1':
dic = result[2] OVRS = 1 yc, xc = iT.overSample(image.shape, OVRS) yo, xo = iT.overSample(image.shape, 1) xc, xo, yc, yo = xc * 0.2, xo * 0.2, yc * 0.2, yo * 0.2 xc, xo = xc + 12, xo + 12 yc, yo = yc + 20, yo + 20 mask = np.zeros(image.shape) tck = RectBivariateSpline(yo[:, 0], xo[0], mask) mask2 = tck.ev(xc, yc) mask2[mask2 < 0.5] = 0 mask2[mask2 > 0.5] = 1 mask2 = mask2 == 0 mask = mask == 0 xpsf, ypsf = iT.coords((310, 310)) - 165 dx, dy, sig1, q1, pa1, amp1, sig2 = trace[a1, a2, a3] amp2 = 1.0 - amp1 pa2 = 0 gals = [] for name in G.keys(): s = G[name] p = {} if name == "Galaxy 1": for key in "x", "y", "q", "pa", "re", "n": p[key] = s[key]["value"] elif name == "Galaxy 2": for key in "q", "pa", "re", "n": p[key] = s[key]["value"] for key in "x", "y":
src = SBModels.Sersic('src',{'x':para[i,7],'y':para[i,8],'re':para[i,9],'q':para[i,10],'pa':para[i,11],'n':para[i,12]}) mag_src = para[i,13] srcMag = src.Mag(zp) src.amp = 10.**(-0.4*(mag_src-srcMag)) # Create mass (or lensing) objects lensMass = MassModels.PowerLaw('lens',{'x':para[i,14],'y':para[i,15],'b':para[i,16],'q':para[i,17],'pa':para[i,18],'eta':para[i,19]}) shear = MassModels.ExtShear('shear',{'x':para[i,20],'y':para[i,21],'b':para[i,22],'pa':para[i,23]}) lenses = [lensMass,shear] #create the coordinate grids that the image will be evaluated on y,x = iT.coords((360,360)) #with higher resolution 60*6 # create a PSF import pyfits psf = pyfits.open('sub600.fits')[0].data.copy() psf /= psf.sum() # Form the image and convolve (convolution returns the image and FFT'd PSF) img,psf = convolve.convolve(lensGal.pixeval(x,y),psf) xl,yl = pylens.getDeflections(lenses,[x,y]) img +=convolve.convolve(src.pixeval(xl,yl),psf,False)[0] #pylab.imshow(img,origin='lower',interpolation='nearest') #pylab.colorbar() #pylab.show()
# psf4 pars.append(pymc.Uniform('sigma 4',0.1,400,value= sig4 )) pars.append(pymc.Uniform('q 4',0,1,value=q4)) pars.append(pymc.Uniform('pa 4',-180,180,value= pa4 )) pars.append(pymc.Uniform('amp 4',0,1,value=amp4)) cov += [1,0.5,50,0.5] psfObj1 = SBObjects.Gauss('psf 1',{'x':0,'y':0,'sigma':pars[2],'q':pars[3],'pa':pars[4],'amp':pars[5]}) psfObj2 = SBObjects.Gauss('psf 2',{'x':0,'y':0,'sigma':pars[6],'q':pars[7],'pa':pars[8],'amp':pars[9]}) psfObj3 = SBObjects.Gauss('psf 3',{'x':0,'y':0,'sigma':pars[10],'q':pars[11],'pa':pars[12],'amp':pars[13]}) psfObj4 = SBObjects.Gauss('psf 4',{'x':0,'y':0,'sigma':pars[14],'q':pars[15],'pa':pars[16],'amp':pars[17]}) psfObjs = [psfObj1,psfObj2,psfObj3,psfObj4] xpsf,ypsf = iT.coords((101,101))-50 gals = [] for name in ['Galaxy 1', 'Galaxy 2']: p = {} if name == 'Galaxy 1': for key in 'x','y','q','pa','re','n': p[key] = dic[name+' '+key][a1,a2,a3] elif name == 'Galaxy 2': for key in 'q','pa','re','n': p[key] = dic[name+' '+key][a1,a2,a3] for key in 'x','y': p[key] = gals[0].pars[key] gals.append(SBModels.Sersic(name,p)) lenses = []
pl.colorbar() pl.title('model') pl.subplot(223) pl.imshow(image-im,origin='lower',interpolation='nearest',extent=ext,vmin=-0.25,vmax=0.25) pl.colorbar() pl.title('data-model') pl.subplot(224) pl.imshow((image-im)/sigma,origin='lower',interpolation='nearest',extent=ext,vmin=-5,vmax=5) pl.title('signal-to-noise residuals') pl.colorbar() #pl.suptitle(str(V)) #pl.savefig('/data/ljo31/Lens/TeXstuff/plotrun'+str(X)+'.png') image = pyfits.open('/data/ljo31/Lens/J1605/J1605_Kp_narrow_med_cutout.fits')[0].data.copy() sigma = pyfits.open('/data/ljo31/Lens/J1605/J1605_Kp_narrow_med_sigma.fits')[0].data.copy() yc,xc = iT.coords(image.shape) # Model the PSF as a Gaussian to start with. We'll do this over a grid of sigmas, and then maybe also ellitpicity and position anlge (will get kompliziert!!) xp,yp = iT.coords((150,150))-75 #print yp.shape,xp.shape #sig=1 #4. #psfObj = SBObjects.Gauss('psf',{'x':0,'y':0,'sigma':sig,'q':1,'pa':0,'amp':1}) #psf = psfObj.pixeval(xp,yp) #psf /= psf.sum() #psf = convolve.convolve(image,psf)[1] OVRS = 1 # we should get these from the iterated terminal version. det = np.load('/data/ljo31/Lens/J1605/det8.npy')[()] g1,g2,l1,s1,s2,sh = {},{},{},{},{},{}
# psf4 pars.append(pymc.Uniform('sigma 4',0.1,400,value= 10 )) pars.append(pymc.Uniform('q 4',0,1,value=0.9)) pars.append(pymc.Uniform('pa 4',-180,180,value= 90 )) pars.append(pymc.Uniform('amp 4',0,1,value=0.25)) cov += [1,0.5,50,0.5] psfObj1 = SBObjects.Gauss('psf 1',{'x':0,'y':0,'sigma':pars[2],'q':pars[3],'pa':pars[4],'amp':pars[5]}) psfObj2 = SBObjects.Gauss('psf 2',{'x':0,'y':0,'sigma':pars[6],'q':pars[7],'pa':pars[8],'amp':pars[9]}) psfObj3 = SBObjects.Gauss('psf 3',{'x':0,'y':0,'sigma':pars[10],'q':pars[11],'pa':pars[12],'amp':pars[13]}) psfObj4 = SBObjects.Gauss('psf 4',{'x':0,'y':0,'sigma':pars[14],'q':pars[15],'pa':pars[16],'amp':pars[17]}) psfObjs = [psfObj1,psfObj2,psfObj3,psfObj4] xpsf,ypsf = iT.coords((221,221))-110 gals = [] for name in ['Galaxy 1', 'Galaxy 2']: p = {} if name == 'Galaxy 1': for key in 'q','pa','n': p[key] = dic[name+' '+key][a1,a2,a3] for key in 'x','y','re': p[key] = dic[name+' '+key][a1,a2,a3]*5. elif name == 'Galaxy 2': for key in 'q','pa','re','n': if key == 're': p[key] = dic[name+' '+key][a1,a2,a3]*5. else: p[key] = dic[name+' '+key][a1,a2,a3]
cov += [1,0.5,50,0.2] # psf4 #pars.append(pymc.Uniform('sigma 4',0.1,400,value=kdic['sigma 4'][ka1,ka2,ka3])) #pars.append(pymc.Uniform('q 4',0,1,value=kdic['q 4'][ka1,ka2,ka3])) #pars.append(pymc.Uniform('pa 4',-180,180,value= kdic['pa 4'][ka1,ka2,ka3] )) #pars.append(pymc.Uniform('amp 4',0,1,value=kdic['amp 4'][ka1,ka2,ka3])) #cov += [1,0.5,50,0.2] psfObj1 = SBObjects.Gauss('psf 1',{'x':0,'y':0,'sigma':pars[4],'q':pars[5],'pa':pars[6],'amp':pars[7]}) psfObj2 = SBObjects.Gauss('psf 2',{'x':0,'y':0,'sigma':pars[8],'q':pars[9],'pa':pars[10],'amp':pars[11]}) psfObj3 = SBObjects.Gauss('psf 3',{'x':0,'y':0,'sigma':pars[12],'q':pars[13],'pa':pars[14],'amp':pars[15]}) #psfObj4 = SBObjects.Gauss('psf 4',{'x':0,'y':0,'sigma':pars[16],'q':pars[17],'pa':pars[18],'amp':pars[19]}) psfObjs = [psfObj1,psfObj2,psfObj3]#,psfObj4] xpsf,ypsf = iT.coords((81,81))-40 los = dict([('q',0.05),('pa',-180.),('re',0.1),('n',0.5)]) his = dict([('q',1.00),('pa',180.),('re',100.),('n',10.)]) covs = dict([('x',0.1),('y',0.1),('q',0.05),('pa',10.),('re',3.),('n',0.2)]) covlens = dict([('x',0.1),('y',0.1),('q',0.05),('pa',10.),('b',0.2),('eta',0.1)]) lenslos, lenshis = dict([('q',0.05),('pa',-180.),('b',0.5),('eta',0.5)]), dict([('q',1.00),('pa',180.),('b',100.),('eta',1.5)]) gals = [] for name in ['Galaxy 1', 'Galaxy 2']: p = {} if name == 'Galaxy 1': for key in 'x','y','q','pa','re','n': val = dic[name+' '+key][a1,a2,a3] if key == 'x' or key == 'y': lo,hi=val-10,val+10 else: lo,hi= los[key],his[key]