def simple_max(self): srhs = enmap.smooth_gauss(self.map * self.div, self.beam.sigma) sdiv = enmap.smooth_gauss(self.div, self.beam.sigma) sdiv = np.maximum(sdiv, np.median(np.abs(sdiv)) * 0.1) smap = srhs / sdiv**0.5 pos = enmap.argmax(smap) val = smap.at(pos) return pos[::-1], val
def simple_max(self): srhs = enmap.smooth_gauss(self.map*self.div, self.beam.sigma) sdiv = enmap.smooth_gauss(self.div, self.beam.sigma) sdiv = np.maximum(sdiv, np.median(np.abs(sdiv))*0.1) smap = srhs/sdiv**0.5 pos = enmap.argmax(smap) val = smap.at(pos) return pos[::-1], val
def update_mask(self, rand_sigma_arcmin=2., rand_threshold=1e-3): if rand_sigma_arcmin > 1.e-3: print("Smoothing...") smap = enmap.smooth_gauss(self.rand_map, rand_sigma_arcmin * np.pi / 180. / 60.) print("Done smoothing...") else: smap = self.rand_map self.mask = np.zeros(self.shape) self.mask[smap > rand_threshold] = 1 self._counts()
def update_mask(self,rand_sigma_arcmin=2.,rand_threshold=1e-3): if rand_sigma_arcmin>1.e-3: if self.verbose: print( "Smoothing...") if self.curved: smap = hp.smoothing(self.rand_map,sigma=rand_sigma_arcmin*np.pi/180./60.) else: smap = enmap.smooth_gauss(self.rand_map,rand_sigma_arcmin*np.pi/180./60.) if self.verbose: print( "Done smoothing...") else: if self.verbose: smap = self.rand_map self.mask = np.zeros(self.shape) self.mask[smap>rand_threshold] = 1 if not self.curved: self.mask = enmap.enmap(self.mask,self.wcs) self._counts()
imaps = enmap.samewcs(np.array(imaps), imaps[0]) # Downsample by averaging imaps = enmap.downgrade(imaps, (1, args.step)) naz = imaps.shape[-1] # Ok, build our output geometry shape, wcs = enmap.geometry(pos=box, res=args.res * utils.arcmin, proj="car", pre=(naz, )) omap = enmap.zeros(shape, wcs, dtype=dtype) # Normalization norm = enmap.zeros(shape[-2:], wcs) norm[0, 0] = 1 norm = enmap.smooth_gauss(norm, rad)[0, 0] # Loop through slices and populate bazs = [] for iaz in range(naz): # Get our boresight az bazs.append(imaps.pix2sky([0, iaz])[1]) vals = [] for i in range(nfile): # Go from detectors to y-pixel in input maps ypix = utils.transpose_inds(dets[i], nrow, ncol) vals.append(imaps[i, ypix, iaz]) vals = np.concatenate(vals) pos = np.concatenate(offs) # Write to appropriate position in array pix = np.maximum(
ps_cmb[:, :, lmax_tmp:] = ps_cmb_tmp[:, :, -1] sigma = args.beam * np.pi / 180 / 60 / (8 * np.log(2)) l = np.arange(ps_cmb.shape[-1]) ps_src = np.exp(-l * (l + 1) * sigma**2)[None, None, :] * (args.srcrms * np.pi / 180 / 60)**2 L.info("Setting up signal and noise matrices") S = enmap.spec2flat(map.shape, map.wcs, ps_cmb, 1.0) iP = enmap.spec2flat(map.shape, map.wcs, ps_src, -1.0) N = (inoise + np.max(inoise) * 1e-3)**-1 # apodize map based on a smooth noise map L.info("Apodizing") print inoise.shape, inoise.dtype inoise_smooth = enmap.smooth_gauss(inoise[0, 0], 10 * np.pi / 180 / 60)[None, None] apod = (np.minimum(1, inoise_smooth / (np.max(inoise_smooth) * 0.05))**4)[0, 0] map *= apod[None] enmap.write_map(args.odir + "/inoise.fits", inoise) enmap.write_map(args.odir + "/inoise_smooth.fits", inoise_smooth) enmap.write_map(args.odir + "/apod.fits", apod) enmap.write_map(args.odir + "/map_apod.fits", map) def mul(mat, vec, axes=[0, 1]): return enmap.samewcs( array_ops.matmul(mat.astype(vec.dtype), vec, axes=axes), mat, vec) def pow(mat, exp, axes=[0, 1]):
box = utils.widen_box(box, rad*5, relative=False) # We assume that the two maps have the same pixelization imaps = enmap.samewcs(np.array(imaps), imaps[0]) # Downsample by averaging imaps = enmap.downgrade(imaps, (1,args.step)) naz = imaps.shape[-1] # Ok, build our output geometry shape, wcs = enmap.geometry(pos=box, res=args.res*utils.arcmin, proj="car", pre=(naz,)) omap = enmap.zeros(shape, wcs, dtype=dtype) # Normalization norm = enmap.zeros(shape[-2:],wcs) norm[0,0] = 1 norm = enmap.smooth_gauss(norm, rad)[0,0] # Loop through slices and populate bazs = [] for iaz in range(naz): # Get our boresight az bazs.append(imaps.pix2sky([0,iaz])[1]) vals = [] for i in range(nfile): # Go from detectors to y-pixel in input maps ypix = utils.transpose_inds(dets[i], nrow, ncol) vals.append(imaps[i,ypix,iaz]) vals = np.concatenate(vals) pos = np.concatenate(offs) # Write to appropriate position in array pix = np.maximum(0,np.minimum((np.array(shape[-2:])-1)[:,None],enmap.sky2pix(shape, wcs, pos.T).astype(np.int32)))
def fit_grid(self, verbose=False, grid_res=0.6*utils.arcmin, super=10): self.verbose = verbose t1 = time.time() if verbose: print "Building coarse likelihood grid" ngrid = int(np.round(2*self.lik.rmax/grid_res)) dchisqs, amps = self.likgrid(self.lik.rmax, ngrid, super=super, verbose=verbose) if np.all(dchisqs == 0): raise ValueError("featureless likelihood") if False and verbose: for i,s in enumerate(self.sdata): enmap.write_map("map_%d.fits"%i,s.map) enmap.write_map("div_%d.fits"%i,s.div) enmap.write_map("white_%d.fits"%i,s.map*s.div**0.5) enmap.write_map("pchisq_%d.fits"%i,s.map**2*s.div) enmap.write_map("pchisq_smooth_%d.fits%i",enmap.smooth_gauss(s.map**2*s.div,0.6*utils.arcmin)) enmap.write_map("dchisqs.fits",dchisqs) # Find local dchisq maxima maxmap = ndimage.maximum_filter(dchisqs, super) peaks = np.where((dchisqs==maxmap)*(maxmap>0)) maxvals = dchisqs[peaks] maxpos = dchisqs.pix2sky(peaks) # Why isn't this just amps[:,peaks] or similar? maxamps = amps.reshape(amps.shape[0],-1)[:,np.ravel_multi_index(peaks, amps.shape[-2:])] inds = np.argsort(maxvals)[::-1] maxvals = maxvals[inds] maxpos = maxpos[:,inds] maxamps = maxamps[:,inds] # Perform ML fit for the highest one dpos = optimize.fmin_powell(self.calc_chisq_wrapper, maxpos[:,0]/self.scale, disp=False)*self.scale res = self.calc_full_result(dpos, marginalize=False) if False and verbose: for i, m in enumerate(res.models): enmap.write_map("model_%d.fits"%i,m) resid = self.sdata[i].map-m enmap.write_map("resid_%d.fits"%i,resid) pchisq = resid**2*sdata[i].div pchisq_smooth = enmap.smooth_gauss(pchisq, 0.6*utils.arcmin) enmap.write_map("pchisq_smooth_resid.fits",pchisq_smooth) print np.sum((self.sdata[i].map-m)**2*self.sdata[i].div) - self.lik.chisq0 # Ideally we would integrate over the full likelihood, not # just the peaks. But the peaks have higher weight # and should be distributed representatively. Using just the # peaks makes it easy to compare with our ML-fit, which is also # a single point. So we loop over just the peaks here. maxvals = maxvals[1:] maxpos = maxpos[:,1:] maxamps = maxamps[:,1:] P = np.exp(0.5*(maxvals-res.dchisq)) P0 = 1/(1+np.sum(P)) P *= P0 # Marginalize over peaks res.dpos = P0*res.dpos + np.sum(P*maxpos,-1) off = maxpos-res.dpos[:,None] res.pcov = P0*res.pcov + np.sum(P*off[:,None]*off[None,:],-1) res.ddpos = np.diag(res.pcov)**0.5 res.pcorr = res.pcov[0,1]/res.ddpos[0]/res.ddpos[1] res.amps = P0*res.amps + np.sum(P*maxamps,-1) res.damps = (res.damps**2 + np.sum(P*(maxamps-res.amps[:,None])**2,-1))**0.5 # For the significance, we will use the difference from our peak to our # strongest competitor res.dchisq= res.dchisq - maxvals[0] # Base nsigma on the sources res.nsigma= max(0,res.dchisq)**0.5 res.time = time.time()-t1 return res
parser = argparse.ArgumentParser() parser.add_argument("ifiles", nargs=2) parser.add_argument("ofile") parser.add_argument("-b", "--binsize", type=int, default=3) parser.add_argument("-s", "--smooth", type=float, default=30) parser.add_argument("--div", type=float, default=1.0) args = parser.parse_args() b = args.binsize smooth = args.smooth * np.pi/180/60/(8*np.log(2)) m = [enmap.read_map(f) for f in args.ifiles] dm = (m[1]-m[0])/2 pixarea = dm.area()/np.product(dm.shape[-2:])*(180*60/np.pi)**2 # Compute standard deviation in bins dm = dm[...,:dm.shape[-2]/b*b,:dm.shape[-1]/b*b] dm_blocks = dm.reshape(dm.shape[:-2]+(dm.shape[-2]/b,b,dm.shape[-1]/b,b)) var = np.std(dm_blocks,axis=(-3,-1))**2*pixarea/args.div # This reshaping stuff messes up the wcs, which doesn't notice # that we now have bigger pixels. So correct that. var = enmap.samewcs(var, dm[...,::b,::b]) typ = np.median(var[var!=0]) var[~np.isfinite(var)] = 0 var = np.minimum(var,typ*1e6) svar = enmap.smooth_gauss(var, smooth) sigma = svar**0.5 enmap.write_map(args.ofile, sigma)
decs = np.random.uniform(bbox[0, 0], bbox[1, 0], size=N) ras = np.random.uniform(bbox[0, 1], bbox[1, 1], size=N) print((ras.min() * 180. / np.pi, ras.max() * 180. / np.pi)) print((decs.min() * 180. / np.pi, decs.max() * 180. / np.pi)) # coords = np.vstack((decs,ras)) # print "getting pixels..." # pixs = gal_map.sky2pix(coords) # print "binning..." # dat,xedges,yedges = np.histogram2d(pixs[1,:],pixs[0,:],bins=shape) mapper = CatMapper(shape, wcs, ras * 180. / np.pi, decs * 180. / np.pi) gal_map = mapper.get_map() print((gal_map.sum())) print((gal_map.sum() - N)) gal_map = enmap.smooth_gauss(gal_map, 2.0 * np.pi / 180. / 60.) #gal_map = enmap.smooth_gauss(enmap.ndmap(dat.astype(np.float32),wcs),2.0*np.pi/180./60.) print("plotting...") io.highResPlot2d(gal_map, out_dir + "galmap.png") fc = enmap.FourierCalc(shape, wcs) p2d, d, d = fc.power2d(gal_map) io.quickPlot2d(np.fft.fftshift(np.log10(p2d)), out_dir + "logp2d.png") io.quickPlot2d(np.fft.fftshift((p2d)), out_dir + "p2d.png")
def fit_grid(self, verbose=False, grid_res=0.6 * utils.arcmin, super=10): self.verbose = verbose t1 = time.time() if verbose: print "Building coarse likelihood grid" ngrid = int(np.round(2 * self.lik.rmax / grid_res)) dchisqs, amps = self.likgrid(self.lik.rmax, ngrid, super=super, verbose=verbose) if np.all(dchisqs == 0): raise ValueError("featureless likelihood") if False and verbose: for i, s in enumerate(self.sdata): enmap.write_map("map_%d.fits" % i, s.map) enmap.write_map("div_%d.fits" % i, s.div) enmap.write_map("white_%d.fits" % i, s.map * s.div**0.5) enmap.write_map("pchisq_%d.fits" % i, s.map**2 * s.div) enmap.write_map( "pchisq_smooth_%d.fits%i", enmap.smooth_gauss(s.map**2 * s.div, 0.6 * utils.arcmin)) enmap.write_map("dchisqs.fits", dchisqs) # Find local dchisq maxima maxmap = ndimage.maximum_filter(dchisqs, super) peaks = np.where((dchisqs == maxmap) * (maxmap > 0)) maxvals = dchisqs[peaks] maxpos = dchisqs.pix2sky(peaks) # Why isn't this just amps[:,peaks] or similar? maxamps = amps.reshape( amps.shape[0], -1)[:, np.ravel_multi_index(peaks, amps.shape[-2:])] inds = np.argsort(maxvals)[::-1] maxvals = maxvals[inds] maxpos = maxpos[:, inds] maxamps = maxamps[:, inds] # Perform ML fit for the highest one dpos = optimize.fmin_powell(self.calc_chisq_wrapper, maxpos[:, 0] / self.scale, disp=False) * self.scale res = self.calc_full_result(dpos, marginalize=False) if False and verbose: for i, m in enumerate(res.models): enmap.write_map("model_%d.fits" % i, m) resid = self.sdata[i].map - m enmap.write_map("resid_%d.fits" % i, resid) pchisq = resid**2 * sdata[i].div pchisq_smooth = enmap.smooth_gauss(pchisq, 0.6 * utils.arcmin) enmap.write_map("pchisq_smooth_resid.fits", pchisq_smooth) print np.sum((self.sdata[i].map - m)**2 * self.sdata[i].div) - self.lik.chisq0 # Ideally we would integrate over the full likelihood, not # just the peaks. But the peaks have higher weight # and should be distributed representatively. Using just the # peaks makes it easy to compare with our ML-fit, which is also # a single point. So we loop over just the peaks here. maxvals = maxvals[1:] maxpos = maxpos[:, 1:] maxamps = maxamps[:, 1:] P = np.exp(0.5 * (maxvals - res.dchisq)) P0 = 1 / (1 + np.sum(P)) P *= P0 # Marginalize over peaks res.dpos = P0 * res.dpos + np.sum(P * maxpos, -1) off = maxpos - res.dpos[:, None] res.pcov = P0 * res.pcov + np.sum(P * off[:, None] * off[None, :], -1) res.ddpos = np.diag(res.pcov)**0.5 res.pcorr = res.pcov[0, 1] / res.ddpos[0] / res.ddpos[1] res.amps = P0 * res.amps + np.sum(P * maxamps, -1) res.damps = (res.damps**2 + np.sum(P * (maxamps - res.amps[:, None])**2, -1))**0.5 # For the significance, we will use the difference from our peak to our # strongest competitor res.dchisq = res.dchisq - maxvals[0] # Base nsigma on the sources res.nsigma = max(0, res.dchisq)**0.5 res.time = time.time() - t1 return res
parser = argparse.ArgumentParser() parser.add_argument("ifiles", nargs=2) parser.add_argument("ofile") parser.add_argument("-b", "--binsize", type=int, default=3) parser.add_argument("-s", "--smooth", type=float, default=30) parser.add_argument("--div", type=float, default=1.0) args = parser.parse_args() b = args.binsize smooth = args.smooth * np.pi/180/60/(8*np.log(2)) m = [enmap.read_map(f) for f in args.ifiles] dm = (m[1]-m[0])/2 pixarea = dm.area()/np.product(dm.shape[-2:])*(180*60/np.pi)**2 # Compute standard deviation in bins dm = dm[...,:dm.shape[-2]/b*b,:dm.shape[-1]/b*b] dm_blocks = dm.reshape(dm.shape[:-2]+(dm.shape[-2]/b,b,dm.shape[-1]/b,b)) var = np.std(dm_blocks,axis=(-3,-1))**2*pixarea/args.div # This reshaping stuff messes up the wcs, which doesn't notice # that we now have bigger pixels. So correct that. var = enmap.samewcs(var, dm[...,::b,::b]) typ = np.median(var[var!=0]) var[~np.isfinite(var)] = 0 var = np.minimum(var,typ*1e6) svar = enmap.smooth_gauss(var, smooth) sigma = svar**0.5 enmap.write_map(args.ofile, sigma)