def get_pix_ranges(shape, wcs, horbox, daz, nt=4, azdown=1, ndet=1.0): (t1,t2),(az1,az2),el = horbox[:,0], horbox[:,1], np.mean(horbox[:,2]) nphi = np.abs(utils.nint(360/wcs.wcs.cdelt[0])) # Find the pixel coordinates of first az sweep naz = utils.nint(np.abs(az2-az1)/daz)/azdown ahor = np.zeros([3,naz]) ahor[0] = utils.ctime2mjd(t1) ahor[1] = np.linspace(az1,az2,naz) ahor[2] = el acel = coordinates.transform("hor","cel",ahor[1:],time=ahor[0],site=site) y, x1 = upscale(fixx(utils.nint(enmap.sky2pix(shape, wcs, acel[::-1])),nphi),azdown) # Reduce to unique y values _, uinds, hits = np.unique(y, return_index=True, return_counts=True) y, x1 = y[uinds], x1[uinds] # Find the pixel coordinates of time drift thor = np.zeros([3,nt]) thor[0] = utils.ctime2mjd(np.linspace(t1,t2,nt)) thor[1] = az1 thor[2] = el tcel = coordinates.transform("hor","cel",thor[1:],time=thor[0],site=site) _, tx = utils.nint(fixx(enmap.sky2pix(shape, wcs, tcel[::-1]),nphi)) x2 = x1 + tx[-1]-tx[0] x1, x2 = np.minimum(x1,x2), np.maximum(x1,x2) pix_ranges = np.concatenate([y[:,None],x1[:,None],x2[:,None]],1) # Weight per pixel in pix ranges. If ndet=1 this corresponds to # telescope time per output pixel weights = (t2-t1)/(naz*azdown)/(x2-x1)*ndet * hits return pix_ranges, weights
def __init__(self, shape, wcs, pattern, offset, site, pad=2.0 * utils.degree): """This unskew operation assumes that equal spacing in dec corresponds to equal spacing in time, and that shifts in RA can be done in units of whole pixels. This is an approximation relative to UnskewCurved, but it is several times faster, uses less memory, and causes less smoothing.""" ndec, nra = shape[-2:] info = calc_az_sweep(pattern, offset, site, pad=pad) sweep_ra, sweep_dec = info.sweep_cel # For each pixel in dec (that we hit for this scanning pattern), we # want to know how far we have been displaced in ra. # First get the dec of each pixel center. ysweep, xsweep = enmap.sky2pix(shape, wcs, [sweep_dec, sweep_ra]) y1 = max(int(np.min(ysweep)), 0) y2 = min(int(np.max(ysweep)) + 1, shape[-2]) # Make fft-friendly ny = y2 - y1 ny2 = fft.fft_len(ny, "above", [2, 3, 5, 7]) y1 = max(y1 - (ny2 - ny) / 2, 0) y2 = min(y1 + ny2, shape[-2]) y = np.arange(y1, y2) dec, _ = enmap.pix2sky(shape, wcs, [y, y * 0]) # Then interpolate the ra values corresponding to those decs. # InterpolatedUnivariateSpline broken. Returns nan even when # interpolating. So we will use UnivariateSpline spline = scipy.interpolate.UnivariateSpline(sweep_dec, sweep_ra) ra = spline(dec) dra = ra - ra[len(ra) / 2] y, x = np.round(enmap.sky2pix(shape, wcs, [dec, ra])) dx = x - x[len(x) / 2] # It's also useful to be able to go from normal map index to # position in y and dx inv_y = np.zeros(shape[-2], dtype=int) - 1 inv_y[y.astype(int)] = np.arange(len(y)) # Compute the azimuth step size based on the total azimuth sweep. daz = (pattern[2] - pattern[1] + 2 * pad) / len(y) # Build the geometry of the unskewed system ushape, uwcs = enmap.geometry(pos=[0, 0], shape=[len(y), shape[-1]], res=[daz, enmap.pixshape(shape, wcs)[1]], proj="car") # And store the result self.y = y.astype(int) self.dx = np.round(dx).astype(int) self.dx_raw = dx self.inv_y = inv_y self.ushape = ushape self.uwcs = uwcs
def calc_pbox(shape, wcs, box, n=10): nphi = utils.nint(np.abs(360 / wcs.wcs.cdelt[0])) dec = np.linspace(box[0, 0], box[1, 0], n) ra = np.linspace(box[0, 1], box[1, 1], n) y = enmap.sky2pix(shape, wcs, [dec, dec * 0 + box[0, 1]])[0] x = enmap.sky2pix(shape, wcs, [ra * 0 + box[0, 0], ra])[1] x = utils.unwind(x, nphi) pbox = np.array([[np.min(y), np.min(x)], [np.max(y), np.max(x)]]) xm1 = np.mean(pbox[:, 1]) xm2 = utils.rewind(xm1, shape[-1] / 2, nphi) pbox[:, 1] += xm2 - xm1 pbox = utils.nint(pbox) return pbox
def __init__(self, shape, wcs, pattern, offset, site, pad=2.0*utils.degree, order=0, subsample=2.0): """Build an unskew operator that uses spline interpolation along an azimuth sweep to straighten out the scanning motion for one scanning pattern. Relatively slow, and leads to some smoothing due to the interpolation, but does not assume that dec changes with a constant speed during a sweep.""" # Find the unskew transformation for this pattern. # We basically want dec->az and ra->ra0, with az spacing # similar to el spacing. ndec, nra = shape[-2:] info = calc_az_sweep(pattern, offset, site, pad=pad, subsample=subsample) sweep_ra, sweep_dec = info.sweep_cel #(sweep_ra, sweep_dec), naz, daz = calc_az_sweep(pattern, offset, site, pad=pad, subsample=subsample) # We want to be able to go from (y,x) to (ra,dec), with # dec = dec[y] # ra = ra[y]-ra[0]+x # Precompute the pixel mapping. This will have the full witdh in ra, # but will be smaller in dec due to the limited az range. raw_dec, raw_ra = enmap.posmap(shape, wcs) skew_pos = np.zeros((2, info.naz, nra)) skew_pos[0] = sweep_dec[:,None] skew_pos[1] = (sweep_ra-sweep_ra[0])[:,None] + raw_ra[None,ndec/2,:] skew_pix = enmap.sky2pix(shape, wcs, skew_pos).astype(dtype) # Build geometry for the unskewed system ushape, uwcs = enmap.geometry(pos=[0,0], shape=[info.naz, nra], res=[np.abs(info.daz), enmap.pixshape(shape,wcs)[1]], proj="car") # Save self.order = order self.shape = shape self.wcs = wcs self.pattern = pattern self.site = site self.skew_pix = skew_pix # External interface self.ushape = ushape self.uwcs = uwcs
def __init__(self, ras_deg, decs_deg, shape=None, wcs=None, nside=None, verbose=True): self.verbose = verbose if nside is not None: if verbose: print("Calculating pixels...") self.pixs = hp.ang2pix(nside, ras_deg, decs_deg, lonlat=True) if verbose: print("Done with pixels...") self.nside = nside self.shape = hp.nside2npix(nside) self.curved = True else: coords = np.vstack((decs_deg, ras_deg)) * np.pi / 180. self.shape = shape self.wcs = wcs if verbose: print("Calculating pixels...") self.pixs = enmap.sky2pix(shape, wcs, coords, corner=True) # should corner=True?! if verbose: print("Done with pixels...") self.curved = False self.counts = self.get_map() if not self.curved: self.counts = enmap.enmap(self.counts, self.wcs)
def __init__(self, shape, wcs, pattern, offset, site, pad=2.0*utils.degree, order=0, subsample=2.0): """Build an unskew operator that uses spline interpolation along an azimuth sweep to straighten out the scanning motion for one scanning pattern. Relatively slow, and leads to some smoothing due to the interpolation, but does not assume that dec changes with a constant speed during a sweep.""" # Find the unskew transformation for this pattern. # We basically want dec->az and ra->ra0, with az spacing # similar to el spacing. ndec, nra = shape[-2:] info = calc_az_sweep(pattern, offset, site, pad=pad, subsample=subsample) sweep_ra, sweep_dec = info.sweep_cel #(sweep_ra, sweep_dec), naz, daz = calc_az_sweep(pattern, offset, site, pad=pad, subsample=subsample) # We want to be able to go from (y,x) to (ra,dec), with # dec = dec[y] # ra = ra[y]-ra[0]+x # Precompute the pixel mapping. This will have the full witdh in ra, # but will be smaller in dec due to the limited az range. raw_dec, raw_ra = enmap.posmap(shape, wcs) skew_pos = np.zeros((2, info.naz, nra)) skew_pos[0] = sweep_dec[:,None] skew_pos[1] = (sweep_ra-sweep_ra[0])[:,None] + raw_ra[None,ndec/2,:] skew_pix = enmap.sky2pix(shape, wcs, skew_pos).astype(dtype) # Build geometry for the unskewed system ushape, uwcs = enmap.geometry(pos=[0,0], shape=[info.naz, nra], res=[np.abs(info.daz), enmap.pixshape(shape,wcs)[1]], proj="car") # Save self.order = order self.shape = shape self.wcs = wcs self.pattern = pattern self.site = site self.skew_pix = skew_pix # External interface self.ushape = ushape self.uwcs = uwcs
def box2pix(shape, wcs, box): """Convert one or several bounding boxes of shape [2,2] or [n,2,2] into pixel counding boxes in standard python half-open format. The box must be [{from,to},...]. """ nphi = int(np.round(np.abs(360. / wcs.wcs.cdelt[0]))) box = np.asarray(box) fbox = box.reshape(-1, 2, 2) if wcs.wcs.cdelt[0] < 0: fbox[..., 1] = fbox[..., ::-1, 1] # Must rollaxis because sky2pix expects [{dec,ra},...] ibox = enmap.sky2pix(shape, wcs, utils.moveaxis(fbox, 2, 0), corner=True) # FIXME: This is one of many places in the code that will break if a bounding # box goes more than half the way around the sky. Properly fixing # this will require a big overhaul, especially if we want to handle # bounding boxes that are bigger than the full sky. ibox[1] = utils.unwrap_range(ibox[1].T, nphi).T #ibox[1] = utils.unwind(ibox[1], nphi) # We now have [{y,x},:,{from,to} # Truncate to integer, and add one to endpoint to make halfopen interval ibox = np.floor(np.sort(ibox, 2)).astype(int) # Add 1 to endpoint to make halfopen interval ibox[:, :, 1] += 1 #ibox = np.array([np.floor(ibox[0]),np.ceil(ibox[1])]).astype(int) # Shuffle to [:,{from,to},{y,x}] ibox = utils.moveaxis(ibox, 0, 2) return ibox.reshape(box.shape)
def __init__(self, shape, wcs, pattern, offset, site, pad=2.0*utils.degree): """This unskew operation assumes that equal spacing in dec corresponds to equal spacing in time, and that shifts in RA can be done in units of whole pixels. This is an approximation relative to UnskewCurved, but it is several times faster, uses less memory, and causes less smoothing.""" ndec, nra = shape[-2:] info = calc_az_sweep(pattern, offset, site, pad=pad) sweep_ra, sweep_dec = info.sweep_cel # For each pixel in dec (that we hit for this scanning pattern), we # want to know how far we have been displaced in ra. # First get the dec of each pixel center. ysweep, xsweep = enmap.sky2pix(shape, wcs, [sweep_dec,sweep_ra]) y1 = max(int(np.min(ysweep)),0) y2 = min(int(np.max(ysweep))+1,shape[-2]) # Make fft-friendly ny = y2-y1 ny2 = fft.fft_len(ny, "above", [2,3,5,7]) y1 = max(y1-(ny2-ny)/2,0) y2 = min(y1+ny2,shape[-2]) y = np.arange(y1,y2) dec, _ = enmap.pix2sky(shape, wcs, [y,y*0]) # Then interpolate the ra values corresponding to those decs. # InterpolatedUnivariateSpline broken. Returns nan even when # interpolating. So we will use UnivariateSpline spline = scipy.interpolate.UnivariateSpline(sweep_dec, sweep_ra) ra = spline(dec) dra = ra - ra[len(ra)/2] y, x = np.round(enmap.sky2pix(shape, wcs, [dec,ra])) dx = x-x[len(x)/2] # It's also useful to be able to go from normal map index to # position in y and dx inv_y = np.zeros(shape[-2],dtype=int)-1 inv_y[y.astype(int)]= np.arange(len(y)) # Compute the azimuth step size based on the total azimuth sweep. daz = (pattern[2]-pattern[1]+2*pad)/len(y) # Build the geometry of the unskewed system ushape, uwcs = enmap.geometry(pos=[0,0], shape=[len(y),shape[-1]], res=[daz,enmap.pixshape(shape,wcs)[1]], proj="car") # And store the result self.y = y.astype(int) self.dx = np.round(dx).astype(int) self.dx_raw = dx self.inv_y = inv_y self.ushape = ushape self.uwcs = uwcs
def draw(self, shape, wcs, window=False, nsigma=10, pad=False): m = enmap.zeros((3, ) + shape[-2:], wcs) w = np.max(self.widths) * nsigma # Find all sources that enter even partially into our area ipos = np.array([ enmap.sky2pix(shape, wcs, self.pos - w, corner=True, safe=True), enmap.sky2pix(shape, wcs, self.pos + w, corner=True, safe=True) ]).astype(int) ipos = np.sort(ipos, 0) ashape = np.array(shape[-2:]) mask = np.all(ipos[1] >= 0, 0) & np.all( ipos[0] < ashape[:, None], 0) & np.all( ipos[1] - ipos[0] < ashape[:, None], 0) nmask = np.sum(mask) if nmask == 0: return m if pad: # We will include enough pixels on each side that we avoid # truncating any part of the source ipos2 = np.array([ enmap.sky2pix(shape, wcs, self.pos[:, mask] - w * 2, corner=True, safe=True), enmap.sky2pix(shape, wcs, self.pos[:, mask] + w * 2, corner=True, safe=True) ]).astype(int) npad = np.maximum( 0, [-np.min(ipos2, (0, 2)), np.max(ipos2, (0, 2)) - ashape]) m, mslice = enmap.pad(m, npad, return_slice=True) for i, (pos, amp, width, ibeam) in enumerate( zip(self.pos.T[mask], self.amps.T[mask], self.widths.T[mask], self.ibeam.T[mask])): # Find necessary bounding box sub = m.submap([pos - w, pos + w]) if sub.size == 0: continue add_gauss(sub, pos, amp, ibeam) # Optinally apply window function if window: m = enmap.apply_window(m) if pad: m = m[mslice] return m
def __init__(self, shape, wcs, ras_deg, decs_deg): coords = np.vstack((decs_deg, ras_deg)) * np.pi / 180. self.shape = shape self.wcs = wcs print("Calculating pixels...") self.pixs = enmap.sky2pix(shape, wcs, coords, corner=True) # should corner=True?! print("Done with pixels...") self.counts = self.get_map()
def update_kappa(self, kappa): # Converts kappa map to pixel displacements import alhazen.lensTools as lt fphi = lt.kappa_to_fphi(kappa, self.modlmap) grad_phi = enmap.gradf(enmap.ndmap(fphi, self.wcs)) pos = self.posmap + grad_phi self._displace_pix = enmap.sky2pix(self.shape, self.wcs, pos, safe=False)
def get_rotated_pixels(shape_source, wcs_source, shape_target, wcs_target, inverse=False): """ Given a source geometry (shape_source,wcs_source) return the pixel positions in the target geometry (shape_target,wcs_target) if the source geometry were rotated such that its center lies on the center of the target geometry. WARNING: Only currently tested for a rotation along declination from one CAR geometry to another CAR geometry. """ from enlib import coordinates # what are the center coordinates of each geometris center_source = enmap.pix2sky(shape_source, wcs_source, (shape_source[0] / 2., shape_source[1] / 2.)) center_target = enmap.pix2sky(shape_target, wcs_target, (shape_target[0] / 2., shape_target[1] / 2.)) decs, ras = center_source dect, rat = center_target # what are the angle coordinates of each pixel in the target geometry pos_target = enmap.posmap(shape_target, wcs_target) lra = pos_target[1, :, :].ravel() ldec = pos_target[0, :, :].ravel() del pos_target # recenter the angle coordinates of the target from the target center to the source center if inverse: newcoord = coordinates.decenter((lra, ldec), (rat, dect, ras, decs)) else: newcoord = coordinates.recenter((lra, ldec), (rat, dect, ras, decs)) del lra del ldec # reshape these new coordinates into enmap-friendly form new_pos = np.empty((2, shape_target[0], shape_target[1])) new_pos[0, :, :] = newcoord[1, :].reshape(shape_target) new_pos[1, :, :] = newcoord[0, :].reshape(shape_target) del newcoord # translate these new coordinates to pixel positions in the target geometry based on the source's wcs pix_new = enmap.sky2pix(shape_source, wcs_source, new_pos) return pix_new
def __init__(self,ras_deg,decs_deg,shape=None,wcs=None,nside=None,verbose=True,hp_coords="equatorial"): self.verbose = verbose if nside is not None: eq_coords = ['fk5','j2000','equatorial'] gal_coords = ['galactic'] if verbose: print( "Calculating pixels...") if hp_coords in gal_coords: if verbose: print( "Transforming coords...") from astropy.coordinates import SkyCoord import astropy.units as u gc = SkyCoord(ra=ras_deg*u.degree, dec=decs_deg*u.degree, frame='fk5') gc = gc.transform_to('galactic') phOut = gc.l.deg * np.pi/180. thOut = gc.b.deg * np.pi/180. thOut = np.pi/2. - thOut #polar angle is 0 at north pole self.pixs = hp.ang2pix( nside, thOut, phOut ) elif hp_coords in eq_coords: ras_out = ras_deg decs_out = decs_deg lonlat = True self.pixs = hp.ang2pix(nside,ras_out,decs_out,lonlat=lonlat) else: raise ValueError if verbose: print( "Done with pixels...") self.nside = nside self.shape = hp.nside2npix(nside) self.curved = True else: coords = np.vstack((decs_deg,ras_deg))*np.pi/180. self.shape = shape self.wcs = wcs if verbose: print( "Calculating pixels...") self.pixs = enmap.sky2pix(shape,wcs,coords,corner=True) # should corner=True?! if verbose: print( "Done with pixels...") self.curved = False self.counts = self.get_map() if not self.curved: self.counts = enmap.enmap(self.counts,self.wcs) self.mask = np.ones(shape) self._counts()
# Simulate lmax = int(modlmap.max()+1) ells = np.arange(0,lmax,1) ps = theory.uCl('TT',ells).reshape((1,1,lmax)) ~ps_noise = np.array([(noise_uK_rad)**2.]*ells.size).reshape((1,1,ells.size)) mg = maps.MapGen(shape,wcs,ps) ng = maps.MapGen(shape,wcs,ps_noise) kamp_true = args.Amp kappa = lensing.nfw_kappa(kamp_true*1e15,modrmap,cc,overdensity=200.,critical=True,atClusterZ=True) phi,_ = lensing.kappa_to_phi(kappa,modlmap,return_fphi=True) grad_phi = enmap.grad(phi) posmap = enmap.posmap(shape,wcs) pos = posmap + grad_phi alpha_pix = enmap.sky2pix(shape,wcs,pos, safe=False) lens_order = 5 if rank==0: print("Starting sims...") # Stats Nsims = args.Nclusters Njobs = Nsims num_each,each_tasks = mpi.mpi_distribute(Njobs,numcores) if rank==0: print ("At most ", max(num_each) , " tasks...") my_tasks = each_tasks[rank] mstats = stats.Stats(comm) np.random.seed(rank) # QE
# We assume that site and pointing offsets are the same for all tods, # so get them based on the first one entry = filedb.data[ids[0]] site = actdata.read(entry, ["site"]).site # Determine the bounding box of our selected data bounds = db.data["bounds"].reshape(2,-1).copy() bounds[0] = utils.rewind(bounds[0], bounds[0,0], 360) box = utils.widen_box(utils.bounding_box(bounds.T), 4*args.rad, relative=False) waz, wel = box[1]-box[0] # Use fullsky horizontally if we wrap too far if waz <= 180: shape, wcs = enmap.geometry(pos=box[:,::-1]*utils.degree, res=args.res*utils.degree, proj="car", ref=(0,0)) else: shape, wcs = enmap.fullsky_geometry(res=args.res*utils.degree) y1, y2 = np.sort(enmap.sky2pix(shape, wcs, [box[:,1]*utils.degree,[0,0]])[0].astype(int)) shape, wcs = enmap.slice_geometry(shape, wcs, (slice(y1,y2),slice(None))) sys.stderr.write("using %s workspace with resolution %.2f deg" % (str(shape), args.res) + "\n") # Get the hitmap for each block hits = enmap.zeros((nblock,narray)+shape, wcs) ndig = calc_ndig(nblock) sys.stderr.write("estimating hitmap for block %*d/%d" % (ndig,0,nblock)) for bi in range(nblock): for ai in range(narray): block_db = db.select(block_inds[bi,ai]) hits[bi,ai] = fastweight.fastweight(shape, wcs, block_db, array_rad=args.rad*utils.degree, site=site, weight=args.weight) sys.stderr.write("%s%*d/%d" % ("\b"*(1+2*ndig),ndig,bi+1,nblock)) sys.stderr.write("\n")
def get_pix_ranges(shape, wcs, horbox, daz, nt=4, ndet=1.0, site=None): """An appropriate daz for this function is about 1 degree""" # For each row in the map we want to know the hit density for that row, # as well as its start and end. In the original function we got one # sample per row by oversampling and then using unique. This is unreliable, # and also results in quantized steps in the depth. We can instead # do a coarse equispaced az -> ra,dec -> y,x. We can then interpolate # this to get exactly one sample per y. To get the density properly, # we just need dy/dt = dy/daz * daz/dt, where we assume daz/dt is constant. # We get dy/daz from the coarse stuff, and interpolate that too, which gives # the density per row. (t1, t2), (az1, az2), el = horbox[:, 0], horbox[:, 1], np.mean(horbox[:, 2]) nphi = np.abs(utils.nint(360 / wcs.wcs.cdelt[0])) # First produce the coarse single scan naz = utils.nint(np.abs(az2 - az1) / daz) if naz <= 1: return None, None ahor = np.zeros([3, naz]) ahor[0] = utils.ctime2mjd(t1) ahor[1] = np.linspace(az1, az2, naz) ahor[2] = el acel = coordinates.transform("hor", "cel", ahor[1:], time=ahor[0], site=site) ylow, x1low = fixx(enmap.sky2pix(shape, wcs, acel[::-1]), nphi) if ylow[1] < ylow[0]: ylow, x1low = ylow[::-1], x1low[::-1] # Find dy/daz for these points glow = np.gradient(ylow) * (naz - 1) / (az2 - az1) # Now interpolate to full resolution y = np.arange(utils.nint(ylow[0]), utils.nint(ylow[-1]) + 1) if len(y) == 0: print "Why is y empty?", naz, ylow[0], ylow[1] return None, None x1 = np.interp(y, ylow, x1low) grad = np.interp(y, ylow, glow) # Now we just need the width of the rows, x2, which comes # from the time drift thor = np.zeros([3, nt]) thor[0] = utils.ctime2mjd(np.linspace(t1, t2, nt)) thor[1] = az1 thor[2] = el tcel = coordinates.transform("hor", "cel", thor[1:], time=thor[0], site=site) _, tx = utils.nint(fixx(enmap.sky2pix(shape, wcs, tcel[::-1]), nphi)) x2 = x1 + tx[-1] - tx[0] x1, x2 = np.minimum(x1, x2), np.maximum(x1, x2) pix_ranges = utils.nint( np.concatenate([y[:, None], x1[:, None], x2[:, None]], 1)) # Weight per pixel. We want this to be in units of seconds of # observing time per pixel if ndet=1. We know the total number of pixels # hit (ny*nx) and the total time (t2-t1), and we know the relative # weight per row (1/grad), so we can just normalize things ny, nx = len(y), x2[0] - x1[0] npix = ny * nx if npix == 0 or np.any(grad <= 0): return pix_ranges, grad * 0 else: weights = 1 / grad weights *= (t2 - t1) / (np.sum(weights) * nx) * ndet # *nx because weight is per row return pix_ranges, weights
def __call__(self, hor): """Transform from [{tsec,az,el},nsamp] to [{y,x,c,s},nsamp]""" res = hor2cel(hor, self.toff) res[:2] = enmap.sky2pix(self.shape, self.wcs, res[1::-1]) return res
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))) m = enmap.zeros(shape[-2:], wcs) m[tuple(pix)] = vals # Grow by smoothing m = enmap.smooth_gauss(m, rad) / norm omap[iaz] = m # Truncate very low values refval = np.mean(np.abs(omap)) * 0.01 mask = np.any(np.abs(omap) > refval, 0) omap[:, ~mask] = 0 if not args.individual: # output a single file enmap.write_map(args.ofile, omap) else:
shape,wcs = maps.rect_geometry(width_deg=20.,px_res_arcmin=0.5) bigmap = enmap.zeros(shape,wcs) Nobj = 1000 ras,decs = catalogs.random_catalog(shape,wcs,Nobj,edge_avoid_deg=1.) arcmin_width = 30. res = np.min(bigmap.extent()/bigmap.shape[-2:])*180./np.pi*60. Npix = int(arcmin_width/res)*1. if Npix%2==0: Npix += 1 cshape,cwcs = enmap.geometry(pos=(0.,0.),res=res/(180./np.pi*60.),shape=(Npix,Npix)) cmodrmap = enmap.modrmap(cshape,cwcs) sigmas = [] for ra,dec in zip(ras,decs): iy,ix = enmap.sky2pix(shape,wcs,(dec*np.pi/180.,ra*np.pi/180.)) sigma = np.random.normal(3.0,1.0)*np.pi/180./60. paste_in = np.exp(-cmodrmap**2./2./sigma**2.) bigmap[int(iy-Npix/2):int(iy+Npix/2),int(ix-Npix/2):int(ix+Npix/2)] += paste_in sigmas.append(sigma) io.plot_img(bigmap,"cat.png",high_res=True) print("done") st = maps.Stacker(bigmap,arcmin_width=30.) stack = 0. for ra,dec in zip(ras,decs): stack += st.cutout(ra*np.pi/180.,dec*np.pi/180.)
#print 'len PS15', len(PS15mJy) #print 'Pass:'******'Fail:', len([x for x in PS15mJy_cut if x==0]) #print 'len PS100', len(PS100mJy) #print 'Pass:'******'Fail:', len([x for x in PS100mJy_cut if x==0]) ######## Mask Component Separated Map Areas (D56 and BN) # d56mask = enmap.read_fits(pathd56mask, hdu=None, sel=None, sel_threshold=10e6) bnmask = enmap.read_fits(pathbnmask, hdu=None, sel=None, sel_threshold=10e6) subs = 18 #in number of pixels pixarrayd56 = enmap.sky2pix(d56mask.shape, d56mask.wcs, np.vstack((dec, ra)) * np.pi / 180., safe=True) radpixelsd56 = pixarrayd56[1, :] decdpixelsd56 = pixarrayd56[0, :] pixarraybn = enmap.sky2pix(bnmask.shape, bnmask.wcs, np.vstack((dec, ra)) * np.pi / 180., safe=True) radpixelsbn = pixarraybn[1, :] decdpixelsbn = pixarraybn[0, :] d56mask_rep = np.zeros((len(ra), subs, subs)) bnmask_rep = np.zeros((len(ra), subs, subs)) print 'Creating submaps...'
fshape, fwcs = maps.rect_geometry(width_arcmin=20., px_res_arcmin=0.1) cshape, cwcs = maps.rect_geometry(width_arcmin=20., px_res_arcmin=0.5) rmodrmap = enmap.modrmap(rshape, rwcs) fmodrmap = enmap.modrmap(fshape, fwcs) cmodrmap = enmap.modrmap(cshape, cwcs) rmodlmap = enmap.modlmap(rshape, rwcs) fmodlmap = enmap.modlmap(fshape, fwcs) cmodlmap = enmap.modlmap(cshape, cwcs) print(fshape, cshape) mass = 2.e14 fkappa = lens_func(fmodrmap) phi, _ = lensing.kappa_to_phi(fkappa, fmodlmap, return_fphi=True) grad_phi = enmap.grad(phi) pos = enmap.posmap(fshape, fwcs) + grad_phi alpha_pix = enmap.sky2pix(fshape, fwcs, pos, safe=False) lmax = cmodlmap.max() ells = np.arange(0, lmax, 1) cls = theory.uCl('TT', ells) ps = cls.reshape((1, 1, ells.size)) mg = maps.MapGen(cshape, cwcs, ps) unlensed = mg.get_map() hunlensed = enmap.enmap(resample.resample_fft(unlensed.copy(), fshape), fwcs) hlensed = enlensing.displace_map(hunlensed, alpha_pix, order=lens_order, mode=mode) lensed = enmap.enmap(resample.resample_fft(hlensed, cshape), cwcs)
kamps = np.linspace(amin, amax, num_amps) cinvs = [] logdets = [] for k, kamp in enumerate(kamps): kappa_template = lensing.nfw_kappa(kamp * 1e15, bmodrmap, cc, overdensity=200., critical=True, atClusterZ=True) phi, _ = lensing.kappa_to_phi(kappa_template, bmodlmap, return_fphi=True) grad_phi = enmap.grad(phi) pos = posmap + grad_phi alpha_pix = enmap.sky2pix(bshape, bwcs, pos, safe=False) #if k==0: io.plot_img(kappa_template) with bench.show("lensing cov"): Scov = lensing.lens_cov(Ucov, alpha_pix, lens_order=lens_order, kbeam=kbeam, bshape=shape) Tcov = Scov + Ncov + 5000 # !!! with bench.show("covwork"): s, logdet = np.linalg.slogdet(Tcov) assert s > 0 cinv = pinv2(Tcov).astype(np.float64)
# We assume that site and pointing offsets are the same for all tods, # so get them based on the first one entry = filedb.data[ids[0]] site = actdata.read(entry, ["site"]).site # Determine the bounding box of our selected data bounds = db.data["bounds"].reshape(2,-1).copy() bounds[0] = utils.rewind(bounds[0], bounds[0,0], 360) box = utils.widen_box(utils.bounding_box(bounds.T), 4*args.rad, relative=False) waz, wel = box[1]-box[0] # Use fullsky horizontally if we wrap too far if waz <= 180: shape, wcs = enmap.geometry(pos=box[:,::-1]*utils.degree, res=args.res*utils.degree, proj="car", ref=(0,0)) else: shape, wcs = enmap.fullsky_geometry(res=args.res*utils.degree) y1, y2 = np.sort(enmap.sky2pix(shape, wcs, [box[:,1]*utils.degree,[0,0]])[0].astype(int)) shape, wcs = enmap.slice_geometry(shape, wcs, (slice(y1,y2),slice(None))) sys.stderr.write("using %s workspace with resolution %.2f deg" % (str(shape), args.res) + "\n") # Get the hitmap for each block hits = enmap.zeros((nblock,narray)+shape, wcs) ndig = calc_ndig(nblock) sys.stderr.write("estimating hitmap for block %*d/%d" % (ndig,0,nblock)) for bi in range(nblock): for ai in range(narray): block_db = db.select(block_inds[bi,ai]) hits[bi,ai] = fastweight.fastweight(shape, wcs, block_db, array_rad=args.rad*utils.degree, site=site, weight=args.weight) sys.stderr.write("%s%*d/%d" % ("\b"*(1+2*ndig),ndig,bi+1,nblock)) sys.stderr.write("\n")
def __call__(self, hor): """Transform from [{tsec,az,el},nsamp] to [{y,x,c,s},nsamp]""" res = hor2cel(hor, self.toff) res[:2] = enmap.sky2pix(self.shape, self.wcs, res[1::-1]) return res
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))) m = enmap.zeros(shape[-2:],wcs) m[tuple(pix)] = vals # Grow by smoothing m = enmap.smooth_gauss(m, rad)/norm omap[iaz] = m # Truncate very low values refval = np.mean(np.abs(omap))*0.01 mask = np.any(np.abs(omap)>refval,0) omap[:,~mask] = 0 if not args.individual: # output a single file enmap.write_map(args.ofile, omap) else: