def save_covsqrt(self,covsqrt,season=None,patch=None,array=None,coadd=True,mask_patch=None): pout,cout,sout = get_save_paths(self._model,self._version, coadd=coadd,season=season,patch=patch,array=array, overwrite=False,mask_patch=mask_patch) fpath = "%s_covsqrt.fits" % (cout) enmap.write_map(fpath ,covsqrt) print(fpath,covsqrt.shape)
def s18dStamp(ra, dec, data, name, width=0.5, write=True): #Find tile corresponding to RA, Dec path = '/scratch/r/rbond/jorlo/S18d_202006/filteredMaps/' tileName = tileFinder(ra, dec, data) if tileName == None: return None tile = enmap.read_map(path + tileName + '/Arnaud_M2e14_z0p4#' + tileName + '_filteredMap.fits') stamp = reproject.postage_stamp(tile, ra, dec, width * 60, 0.5) if write: #tempdec, tempra = np.deg2rad([dec, ra]) #tempwid = np.deg2rad(width) #box = [[tempdec-tempwid,tempra-tempwid],[tempdec+tempwid,tempra+tempwid]] #stampgeo = tile.submap(box) box = np.array([[ra - width / 2, dec - width / 2], [ra + width / 2, dec + width / 2]]) * utils.degree shape, wcs = enmap.geometry(pos=box, res=0.5 * utils.arcmin, proj='car') print(shape) #print(stampgeo.wcs) #print(stamp.wcs) stamp.wcs = wcs print(stamp.wcs) print(stamp[0].shape) #plt.imshow(stamp[0]) #plt.show() #Return map plot = enplot.plot(stamp, mask=0) enplot.show(plot) enmap.write_map('./for_tony/{}.fits'.format(name), stamp) return stamp
def genGRF(iMock): print("- generating mock " + str(iMock)) # set the random seed np.random.seed(iMock) # Generate GRF healpix map hpGrfMap = hp.synfast(Cl, nSide, lmax=None, mmax=None, alm=False, pol=False, pixwin=False, fwhm=0.0, sigma=None, new=False, verbose=False) # save healpix map hp.write_map(pathOut + "hp_mock_" + str(iMock) + "_grf_f150_daynight.fits", hpGrfMap, overwrite=True) # Convert to pixell CAR map grfMap = reproject.enmap_from_healpix(hpGrfMap, hitShape, hitWcs, rot=None) # save CAR map enmap.write_map(pathOut + "mock_" + str(iMock) + "_grf_f150_daynight.fits", grfMap)
def freqStamp(ra, dec, fmap, name, width = 0.5, write = True): stamp = reproject.postage_stamp(fmap, ra, dec, width*60, 0.5) if write: stamp.wcs.wcs.crval = [ra,dec] enmap.write_map('./for_tony/{}.fits'.format(name), stamp) return stamp
def process(kouts, name="default", ellmax=None, y=False, y_ellmin=400): ellmax = lmax if ellmax is None else ellmax ksilc = enmap.zeros((Ny, Nx), wcs, dtype=np.complex128).reshape(-1) ksilc[modlmap.reshape(-1) < lmax] = np.nan_to_num(kouts.copy()) ksilc = enmap.enmap(ksilc.reshape((Ny, Nx)), wcs) ksilc[modlmap > ellmax] = 0 if y: ksilc[modlmap < y_ellmin] = 0 msilc = np.nan_to_num( fft.ifft(ksilc, axes=[-2, -1], normalize=True).real * bmask) enmap.write_map(proot + "outmap_%s.fits" % name, enmap.enmap(msilc, wcs)) p2d = fc.f2power(ksilc, ksilc) bin_edges = np.arange(100, 3000, 40) binner = stats.bin2D(modlmap, bin_edges) cents, p1d = binner.bin(p2d) try: # io.plot_img(np.log10(np.fft.fftshift(p2d)),proot+"ksilc_%s.png" % name,aspect='auto') # io.plot_img(msilc,proot+"msilc_%s.png" % name) # io.plot_img(msilc,proot+"lmsilc_%s.png" % name,lim=300) tmask = maps.mask_kspace(shape, wcs, lmin=300, lmax=5000 if not (y) else 1500) fmap = maps.filter_map(msilc, tmask) * bmask io.plot_img(fmap, proot + "hmsilc_%s.png" % name, high_res=True) except: pass return cents, p1d
def get_lensed_cmb(self, seed=None, kappa=None, save_output=True, verbose=True, overwrite=False, dtype=np.float64): try: assert(seed is not None) assert(not overwrite) if verbose: print(f"trying to load saved lensed cmb. sim idx: {seed}") lmaps = enmap.empty((3,)+self.shape, self.wcs, dtype=dtype) for i, polidx in enumerate(['T','Q','U']): fname = self.get_output_file_name("lensed_cmb", seed, polidx=polidx) lmaps[i] = enmap.read_map(fname) except: ualm = self._generate_unlensed_cmb_alm(seed=seed) if kappa is None: kappa = self._get_kappa(seed, dtype=np.float64) lmax = 10000 l = np.arange(lmax+1) l_fact = 1/((l*(l+1))/2) l_fact[0] = 0 kalm = curvedsky.map2alm(kappa, lmax=lmax) kalm = curvedsky.map2alm(kappa, lmax=lmax); del kappa kalm = hp.almxfl(kalm, l_fact) tshape, twcs = enmap.fullsky_geometry(res=1*utils.arcmin) print("start lensing") lmaps = lensing.lens_map_curved((3,)+tshape, twcs, kalm, ualm)[0] lalms = curvedsky.map2alm(lmaps, lmax=lmax, spin=0) lmaps = curvedsky.alm2map(lalms, enmap.zeros((3,)+self.shape, self.wcs), spin=0) print("finish lensing") if save_output: for i, polidx in enumerate(['T','Q','U']): fname = self.get_output_file_name("lensed_cmb", seed, polidx=polidx) os.makedirs(os.path.dirname(fname), exist_ok=True) enmap.write_map(fname, lmaps[i].astype(np.float32)) return lmaps.astype(dtype)
def save_filter_noise(self,n2d,season=None,patch=None,array=None,coadd=True,mask_patch=None): pout,cout,sout = get_save_paths(self._model,self._version, coadd=coadd,season=season,patch=patch,array=array, overwrite=False,mask_patch=mask_patch) fpath = "%s_filter_noise.fits" % (cout) enmap.write_map(fpath ,n2d) print(fpath,n2d.shape,n2d.wcs)
def save_sims(self, seed, sims, season, patch, array, mask_patch, coadd=True): pout, cout, sout = get_save_paths(self._model, self._version, coadd=coadd, season=season, patch=patch, array=array, overwrite=False, mask_patch=mask_patch) insplits = self.dm.get_nsplits(season, patch, array) freqs = self.dm.array_freqs[array] nfreqs, nsplits, npol, Ny, Nx = sims.shape assert nsplits == insplits assert len(freqs) == nfreqs for i in range(nfreqs): iarray = freqs[i] for j in range(nsplits): fname = sout + os.path.basename( self.dm.get_split_fname( season, patch, iarray, j, srcfree=True)).replace( ".fits", "_seed_%d.fits" % seed) enmap.write_map(fname, sims[i, j, :, :, :])
def mask(imap, ra, dec, name, width=0.5, apod_pix=4): ra, dec = np.deg2rad([ra, dec]) width = np.deg2rad(width) box = [[dec - width / 2., ra - width / 2.], [dec + width / 2., ra + width / 2.]] stamp = imap.submap(box) taper = enmap.apod(stamp * 0 + 1, apod_pix) name = name.replace(' ', '-').lower() enmap.write_map('./padded_v1/adv{}.fits'.format(name), taper) #s14_stamp = s14map.submap(box) #enmap.write('./padded_v0/s14_{}__pa1_f150_nohwp_night_3pass_4way_set0_ivar.fits'.format(name), s14_stamp) return taper
def get_extraction_test_results(yaml_file): print("Starting tests from ", yaml_file) with open(yaml_file) as f: config = yaml.safe_load(f) geos = get_geometries(config['geometries']) lmax = config['lmax'] lmax_pad = config['lmax_pad'] spectra = get_spectra(config['spectra'], lmax, lmax_pad) seed = config['seed'] results = {} for g in geos.keys(): results[g] = {} for s in spectra.keys(): results[g][s] = {} imap = generate_map(geos[g][0][-2:], geos[g][1], spectra[s], lmax, seed) # Do write and read test filename = "temporary_map.fits" # NOT THREAD SAFE enmap.write_map(filename, imap) imap_in = enmap.read_map(filename) check_equality(imap, imap_in) for e in config['extracts']: print("Doing test for extract ", e['name'], " with geometry ", g, " and spectrum ", s, "...") if e['type'] == 'slice': box = np.deg2rad(np.array(e['box_deg'])) cutout = enmap.read_map(filename, box=box) cutout_internal = imap.submap(box=box) elif e['type'] == 'postage': dec_deg, ra_deg = e['center_deg'] width_arcmin = e['width_arcmin'] res_arcmin = e['res_arcmin'] cutout = reproject.postage_stamp(filename, ra_deg, dec_deg, width_arcmin, res_arcmin, proj='gnomonic') cutout_internal = reproject.postage_stamp(imap, ra_deg, dec_deg, width_arcmin, res_arcmin, proj='gnomonic') check_equality(cutout, cutout_internal) pixels = get_reference_pixels(cutout.shape) results[g][s]['refpixels'] = get_pixel_values(cutout, pixels) results[g][s]['meansquare'] = get_meansquare(cutout) os.remove(filename) return results, config['result_name']
def s18dStamp(ra, dec, data, name, width = 0.5, write = True): #Find tile corresponding to RA, Dec path = '/scratch/r/rbond/jorlo/S18d_202006/filteredMaps/' tileName = tileFinder(ra, dec, data) if tileName == None: return None tile = enmap.read_map(path+tileName+'/Arnaud_M2e14_z0p4#'+tileName+'_filteredMap.fits') stamp = reproject.postage_stamp(tile, ra, dec, width*60, 0.5) if write: stamp.wcs.wcs.crval = [ra,dec] enmap.write_map('./for_tony/{}.fits'.format(name), stamp) return stamp
def save_maps(hmap, root_name, telescope): for res in resolutions[telescope]: shape, wcs = get_geometry(res, bounds_deg=bounds[telescope]) imap = ivar_hp_to_cyl(hmap, shape, wcs) if comm.rank == 0: oname = cr_remote_data.get_local_output( f"{root_name}_CAR_{res:.2f}_arcmin.fits") enmap.write_map(oname, imap) os.system(f"gzip -f {oname}") plots = enplot.get_plots(enmap.downgrade(imap, 8)) savename = cr_remote_data.get_local_output( f"rmap_{root_name}_{res:.2f}") enplot.write(savename, plots) print(f"Plot saved to {savename}")
def s18dStamp(ra, dec, data, name, width=0.5, write=False): #Find tile corresponding to RA, Dec path = '/project/r/rbond/jorlo/S18d_202006/filteredMaps/' tileName = tileFinder(ra, dec, data) if tileName == None: return None tile = enmap.read_map(path + tileName + '/Arnaud_M2e14_z0p4#' + tileName + '_filteredMap.fits') stamp = reproject.postage_stamp(tile, ra, dec, width * 60, 0.5) #print(stamp) if write: temp = np.ndarray((2, ), buffer=np.array([ra, dec])) stamp.wcs.wcs.crval = temp enmap.write_map( './for_tony/mustang2/for_charles/y0_{}.fits'.format(name), stamp) return stamp
def test_extract(self): # Tests that extraction is sensible shape, wcs = enmap.geometry(pos=(0, 0), shape=(500, 500), res=0.01) imap = enmap.enmap(np.random.random(shape), wcs) smap = imap[200:300, 200:300] sshape, swcs = smap.shape, smap.wcs smap2 = enmap.extract(imap, sshape, swcs) pixbox = enmap.pixbox_of(imap.wcs, sshape, swcs) # Do write and read test filename = "temporary_extract_map.fits" # NOT THREAD SAFE enmap.write_map(filename, imap) smap3 = enmap.read_map(filename, pixbox=pixbox) os.remove(filename) assert np.all(np.isclose(smap, smap2)) assert np.all(np.isclose(smap, smap3)) assert wcsutils.equal(smap.wcs, smap2.wcs) assert wcsutils.equal(smap.wcs, smap3.wcs)
def coadd_maps(imaps, ihits, omap, ohit, cont=False, ncomp=-1): # The first map will be used as a reference. All subsequent maps # must fit in its boundaries. if cont and os.path.exists(omap): return if args.verbose: print("Reading %s" % imaps[0]) if ncomp < 0: shape, wcs = enmap.read_map_geometry(imaps[0]) ncomp = 0 if len(shape) == 2 else shape[0] m = read_map(imaps[0], ncomp=ncomp) if args.verbose: print("Reading %s" % ihits[0]) w = apply_edge(apply_apod(apply_trim(read_div(ihits[0], ncomp=ncomp)))) if args.warn and np.any(w.preflat[0] < 0): print("Negative weight in %s" % ihits[0]) wm = mul(w, m) for i, (mif, wif) in enumerate(zip(imaps[1:], ihits[1:])): if args.verbose: print("Reading %s" % mif) try: mi = read_map(mif, m.shape, m.wcs, ncomp=ncomp) except (IOError, OSError): if args.allow_missing: print("Can't read %s. Skipping" % mif) continue else: raise if args.verbose: print("Reading %s" % wif) wi = apply_edge( apply_apod(apply_trim(read_div(wif, m.shape, m.wcs, ncomp=ncomp)))) if args.warn and np.any(wi.preflat[0] < 0): print("Negative weight in %s" % ihits[i + 1]) ## We may need to reproject maps #if mi.shape != m.shape or str(mi.wcs.to_header()) != str(m.wcs.to_header()): # mi = enmap.extract(mi, m.shape, m.wcs) # wi = enmap.extract(wi, w.shape, w.wcs) w = add(w, wi) wm = add(wm, mul(wi, mi)) if args.verbose: print("Solving") m = solve(w, wm) if args.verbose: print("Writing %s" % omap) enmap.write_map(omap, m) if args.verbose: print("Writing %s" % ohit) enmap.write_map(ohit, w)
def get_foreground(self, seed=None, freq=148, verbose=True, input_kappa=None, post_processes=[], save_output=True, flux_cut=7, polfix=True, dtype=np.float64, fgmaps_148=None, overwrite=False): assert(freq in self.freqs) try: assert(seed is not None) assert(not overwrite) if verbose: print(f"trying to load saved foregrounds. sim idx: {seed}, freq: {freq}GHz") fgmaps = enmap.empty((5,)+self.shape, self.wcs, dtype=dtype) for i, compt_idx in reversed(list(enumerate(self.fg_compts))): fname = self.get_output_file_name(compt_idx, seed, freq=freq) fgmaps[i] = enmap.read_map(fname) except: if verbose: print(f"generating foregrounds. sim idx: {seed}, freq: {freq}GHz") fgmaps = None if fgmaps_148 is not None: fgmaps = fgmaps_148.copy() if freq == 148 and fgmaps is None: fgmaps = self._generate_foreground_148GHz(seed=seed, verbose=verbose, input_kappa=input_kappa, post_processes=post_processes, flux_cut=flux_cut, polfix=polfix) else: if fgmaps_148 is None: fgmaps = self.get_foreground(seed=seed, freq=148, verbose=verbose, input_kappa=input_kappa, post_processes=post_processes, save_output=save_output, flux_cut=flux_cut, polfix=polfix, dtype=np.float32) fgmaps[2] *= fnu(freq)/fnu(148) for i in [3,4]: compt_idx = self.fg_compts[i] spec_index = self._get_spectral_index(seed=seed, compt_idx=self.fg_compts[i], freq=freq) fgmaps[i] *= thermo2jysr(148)*(freq/148)**spec_index*jysr2thermo(freq); del spec_index if save_output: for i, compt_idx in enumerate(self.fg_compts): fname = self.get_output_file_name(compt_idx, seed, freq=freq) if os.path.exists(fname) and not overwrite: continue os.makedirs(os.path.dirname(fname), exist_ok=True) enmap.write_map(fname, fgmaps[i].astype(np.float32)) return fgmaps.astype(dtype)
def get_combined_map(self, seed=None, freq=148, verbose=True, input_kappa=None, post_processes=[], save_output=True, flux_cut=7, polfix=True, dtype=np.float64, fgmaps_148=None, tmap=None, fgmaps=None, overwrite=False): fname = self.get_output_file_name('combined', seed, freq=freq, polidx='T') try: print("Loading combiend map") assert(not overwrite) cmap = enmap.read_map(fname) except: if fgmaps is None: fgmaps = self.get_foreground(seed, freq, verbose, input_kappa, post_processes, save_output,flux_cut, polfix, dtype, fgmaps_148, overwrite) if tmap is None: if input_kappa is None and fgmaps is not None: tmap = self.get_temperature_map(seed, fgmaps[0], save_output, verbose, overwrite=overwrite, dtype=dtype) cmap = tmap+np.sum(fgmaps[1:,...], axis=0) if save_output: os.makedirs(os.path.dirname(fname), exist_ok=True) enmap.write_map(fname, cmap.astype(np.float32)) return cmap.astype(dtype)
def merge_results(wdir, odir, geo, tshape=(1000, 1000), margin=100, verbose=False): if verbose: print("Reducing") shape, wcs = geo shape = np.array(shape[-2:]) ny, nx = (shape + tshape - 1) // tshape # Get the tile catalogs and their area of responsibility cats = [] boxes = [] for ty in range(ny): for tx in range(nx): tyx = np.array([ty, tx]) pixbox = np.array( [tyx * tshape, np.minimum((tyx + 1) * tshape, shape)]) boxes.append(np.sort(enmap.pixbox2skybox(*geo, pixbox), 0)) cats.append( pointsrcs.read_sauron(wdir + "/cat_%03d_%03d.fits" % (ty, tx))) if verbose: print("Merging %d cats" % len(cats)) cat = merge_tiled_cats(cats, boxes) cat.ra = utils.rewind(cat.ra) pointsrcs.write_sauron("%s/cat.fits" % odir, cat) pointsrcs.write_sauron("%s/cat.txt" % odir, cat) for name in ["map", "model", "resid", "map_snr", "resid_snr"]: paths = [[ "%s/%s_%03d_%03d.fits" % (wdir, name, ty, tx) for tx in range(nx) ] for ty in range(ny)] if not os.path.isfile(paths[0][0]): continue if verbose: print("Merging tiles for %s" % name) dtype = enmap.read_map(paths[0][0]).dtype map = merge_tiles(*geo, paths, dtype=dtype, margin=margin) enmap.write_map("%s/%s.fits" % (odir, name), map) del map
def write_results(odir, res, padding=0, tag=None): def unpad(map): if padding == 0: return map else: return map[..., padding:-padding, padding:-padding] def fix(map): return unpad(enmap.apply_window(map)) / res.fconvs[:, None, None, None] utils.mkdir(odir) suffix = "" if tag is None else "_" + tag enmap.write_map("%s/map%s.fits" % (odir, suffix), fix(res.maps)) enmap.write_map("%s/model%s.fits" % (odir, suffix), fix(res.model)) enmap.write_map("%s/resid%s.fits" % (odir, suffix), fix(res.maps - res.model)) if res.snr is not None: enmap.write_map("%s/map_snr%s.fits" % (odir, suffix), unpad(res.snr)) if res.resid_snr is not None: enmap.write_map("%s/resid_snr%s.fits" % (odir, suffix), unpad(res.resid_snr)) # If we have indices of the catalog objects into a predefined catalog, then # append that as a new field, so we can use it in merge_results later cat = recfunctions.append_fields( res.cat, "inds", res.inds) if res.inds is not None else res.cat pointsrcs.write_sauron("%s/cat%s.fits" % (odir, suffix), cat)
entry = filedb.data[scan_id] if args.keep_sidelobe is False: remove_sidelobe_cut(entry) try: data = read_metadata(entry) except errors.DataMissing as e: print('rank {:3d}: {} skipped ({})'.format( comm.Get_rank(), scan_id, e.message)) continue nocommon = None if args.nocommon == -1 else args.nocommon map_cuts(entry, data, hitmap, cutmap, keep_buffer=args.keep_buffer, nocommon_frac=nocommon) comm.Barrier() hitmap = utils.reduce(hitmap, comm) cutmap = utils.reduce(cutmap, comm) if comm.Get_rank() == 0: # Up to now cutmap is hits - cuts. We want cuts only. cutmap = hitmap - cutmap enmap.write_map(opj(outdir_sub, 'hits.fits'), hitmap[0]) enmap.write_map(opj(outdir_sub, 'cuts.fits'), cutmap[0])
# In[ ]: # # Check sky area # fSky = np.sum(footMask) / np.prod(footMask.shape) # print "sky area =", fSky * footMask.area() * (180./np.pi)**2, "deg2" # # look at the footprint # plot=enplot.plot(footMask, downgrade=16) # enplot.show(plot) # In[ ]: enmap.write_map(pathOut+"mask_foot.fits", footMask) # # Planck Galactic mask # In[ ]: # Read the Planck Galactic mask pathPlanckMask = "/global/cscratch1/sd/eschaan/project_ksz_act_planck/data/planck_galactic_mask/HFI_Mask_GalPlane-apo0_2048_R2.00.fits" # field, fsky: #0, 0.20 #1, 0.40 #2, 0.60 #3, 0.70 #4, 0.80
###################################################################################3 # Difference between 150GHz reconv to the 90GHz beam and the 90GHz map # for null test (tSZ and kSZ estimators) pathMap1 = "/global/cscratch1/sd/eschaan/project_ksz_act_planck/data/planck_act_coadd_2020_02_28_r2/" + "act_planck_s08_s18_cmb_f150_daynight_map_reconvto90.fits" pathMap2 = "/global/cscratch1/sd/eschaan/project_ksz_act_planck/data/planck_act_coadd_2020_02_28_r2/" + "act_planck_s08_s18_cmb_f090_daynight_map.fits" pathMask = "./output/cmb_map/pact20200228_r2/" + "mask_full_foot_gal60_ps.fits" pathDirOut = "./output/cmb_map/planck_act_coadd_2020_02_28_r2/" if not os.path.exists(pathDirOut): os.makedirs(pathDirOut) pathOut = pathDirOut + "act_planck_s08_s18_cmb_f150reconvto90_minus_f090_daynight_map.fits" # save the difference map diffMap = enmap.read_map(pathMap1) diffMap -= enmap.read_map(pathMap2) enmap.write_map(pathOut, diffMap) # copy the mask copyfile(pathMask, pathDirOut + "mask_full_foot_gal_ps.fits") ###################################################################################3 # Difference between TileC y and TileC y no CIB # for CIB null test (tSZ estimator) pathMap1 = "./output/cmb_map/tilec_pact_y_v1.2.0/" + "tilec_reconv2.4_map.fits" pathMap2 = "./output/cmb_map/tilec_pact_ynocib_v1.2.0/" + "tilec_map.fits" pathMask = "./output/cmb_map/tilec_pact_y_v1.2.0/" + "mask_full_foot_gal_ps.fits" pathDirOut = "./output/cmb_map/tilec_pact_yminusynocib_v1.2.0/" if not os.path.exists(pathDirOut): os.makedirs(pathDirOut) pathOut = pathDirOut + "diff_map.fits"
fnoise,fivars = ngen[dmname].generate_sim(season=season,patch=patch,array=farray,seed=noise_seed,apply_ivar=False) print(fnoise.shape,fivars.shape) if farray=='pa3': ind150 = dm.array_freqs['pa3'].index('pa3_f150') ind090 = dm.array_freqs['pa3'].index('pa3_f090') pa3_cache['pa3_f150'] = (fnoise[ind150].copy(),fivars[ind150].copy()) pa3_cache['pa3_f090'] = (fnoise[ind090].copy(),fivars[ind090].copy()) ind = dm.array_freqs['pa3'].index(arrayname) else: ind = 0 noise = fnoise[ind] ivars = fivars[ind] splits = actnoise.apply_ivar_window(signal[None,None]+noise[None],ivars[None]) assert splits.shape[0]==1 enmap.write_map(fname,splits[0]) sim_splits.append(fname) """ k-space coadd """ """ SAVE COV """ print("Beginning covariance calculation...") with bench.show("sim cov"):
cval=0.0, force=False, prefilter=True, mask_nan=True, safe=True) # Plot the combined maps to check plot = enplot.plot(tilecMask, grid=True) enplot.write(pathFig + "foot_mask", plot) plot = enplot.plot(tilecMap, grid=True) enplot.write(pathFig + "map", plot) # Save the map now, to clear memory print "saving map to " + pathOut + "tilec_maps.fits" enmap.write_map(pathOut + "tilec_map.fits", tilecMap) ######################################################################### # Mask the Milky Way with a Planck mask # Read the Planck Galactic mask pathPlanckMask = "/global/cscratch1/sd/eschaan/project_ucsc/data/planck_galactic_mask/HFI_Mask_GalPlane-apo0_2048_R2.00.fits" # field, fsky: #0, 0.20 #1, 0.40 #2, 0.60 #3, 0.70 #4, 0.80 #5, 0.90 #6, 0.97 #7, 0.99
pathMap = "/global/cscratch1/sd/eschaan/project_ksz_act_planck/data/planck_act_coadd_2020_02_28_r2/" + "act_planck_s08_s18_cmb_f150_daynight_map.fits" # read maps iMap = enmap.read_map(pathMap) # do the reconvolution in Fourier space mapF = enmap.fft(iMap) lMap = np.sqrt(np.sum(iMap.lmap()**2,0)) ########################################################################## # Reconvolve the map print("Reconvolve 150 to 90") pathOutMap = "/global/cscratch1/sd/eschaan/project_ksz_act_planck/data/planck_act_coadd_2020_02_28_r2/" + "act_planck_s08_s18_cmb_f150_daynight_map_reconvto90.fits" oMap = enmap.ifft(mapF * fBeam90F(lMap) / fBeam150F(lMap)).real enmap.write_map(pathOutMap, oMap) print("check finite sum "+str(np.sum(oMap))) print("Reconvolve 150 to TileC deproj") pathOutMap = "/global/cscratch1/sd/eschaan/project_ksz_act_planck/data/planck_act_coadd_2020_02_28_r2/" + "act_planck_s08_s18_cmb_f150_daynight_map_reconvtotilecdeproj.fits" oMap = enmap.ifft(mapF * fBeamTilecDeprojF(lMap) / fBeam150F(lMap)).real enmap.write_map(pathOutMap, oMap) print("check finite sum "+str(np.sum(oMap))) print("Reconvolve 150 to TileC") pathOutMap = "/global/cscratch1/sd/eschaan/project_ksz_act_planck/data/planck_act_coadd_2020_02_28_r2/" + "act_planck_s08_s18_cmb_f150_daynight_map_reconvtotilec.fits" oMap = enmap.ifft(mapF * fBeamTilecF(lMap) / fBeam150F(lMap)).real enmap.write_map(pathOutMap, oMap) print("check finite sum "+str(np.sum(oMap)))
for sim_id in np.arange(core_start, core_end): print("Looking at set=%d sim_id=%d" % (set_id, sim_id)) # check if simulation already exists postfix = "set%d_id%d.fits" % (set_id, sim_id) if apply_rotation: filename = "fullskyalpha_%s" % postfix filename = os.path.join(alpha_map_dir, filename) if not os.path.isfile(filename): # generate full sky rotation map print("File doesn't exist!") raise Exception else: alpha_map = enmap.read_map(filename) else: # if rotation is not needed, alpha_map will not be useful alpha_map = None # generate rotated lensed cmb + noise + foregrounds + beam sims at act patches sg = SimGen(version=map_version, cmb_type='LensedUnabberatedCMB', apply_rotation=apply_rotation, alpha_map=alpha_map, max_cached=max_cached) for psa in psa_list: print("Generating sim for %s" % psa) map_patch = sg.get_sim(**psa, sim_num=sim_id) filename = "{patch}_{season}_{array}_{postfix}".format(patch=psa["patch"], season=psa["season"], array=psa["array"], postfix=postfix) filename = os.path.join(output_dir, filename) print("Saving data: %s..." % filename) enmap.write_map(filename, map_patch) del map_patch del alpha_map
def generate_map(qids, overwrite=False, verbose=True, dg=2, **kwargs): # Here we compute the real coadd map and simulated maps from the noise covariance and pre-computed fullsky signal # This function uses actsims "simgen" code for qid in qids: if qid in ['boss_d04', 's16_d03', 'boss_04']: # Here, the simulation is performed for each array, not frequency, to take into account their correlation # For pa3, there are two frequency bands if verbose: print('skip ' + qid + ': the map is generated by running f090 case.') continue if '_d0' in qid: version = 'v6.3.0_calibrated_mask_version_masks_20200723' else: version = 'v6.3.0_calibrated_mask_version_padded_v1' # define qid_array to take into account multi-frequency case if qid == 'boss_d03': qid_array = ['boss_d03', 'boss_d04'] elif qid == 's16_d02': qid_array = ['s16_d02', 's16_d03'] elif qid == 'boss_03': qid_array = ['boss_03', 'boss_04'] else: # single frequency case qid_array = [qid] # define filename aobj = { q: local.init_analysis_params(qid=q, **kwargs) for q in qid_array } # load survey mask mask = load_survey_mask(qid, dg=1) # Define an object for sim generation model, season, array, patch, freq = local.qid_info(qid) if model == 'dr5': simobj = simgen.SimGen(version=version, qid=qid_array, model=model) if model == 'act_mr3': simobj = simgen.SimGen(version=version, model=model) # save 1/var map if not misctools.check_path(aobj[qid_array[0]].fivar, overwrite=overwrite, verbose=verbose): ivars = get_ivar(qid_array, mask) civars = np.average(ivars, axis=1) # coadd ivar for qi, q in enumerate(qid_array): enmap.write_map(aobj[q].fivar, civars[qi, :, :, :]) # loop over realizations for i in tqdm.tqdm(aobj[qid].rlz): if misctools.check_path(aobj[qid].fmap['s'][i], overwrite=overwrite, verbose=verbose): continue # maps will have signal ('s') and noise ('n') and each has [Nfreq, NTPol, Coord1, Coord2] maps = {} # real data if i == 0: # take coadd data maps['s'] = coadd_real_data(qid_array, mask) # SZ map subtraction shape, wcs = maps['s'][0, 0, :, :].shape, maps['s'].wcs if q in [ 'boss_d03', 's16_d02', 'boss_03' ]: # need both freqs for combined data array of two freqs sz_map_090 = enmap.project( enmap.read_map( 'data_local/input/S18d_202006_confirmed_model_f090.fits' ), shape, wcs) / local.Tcmb sz_map_150 = enmap.project( enmap.read_map( 'data_local/input/S18d_202006_confirmed_model_f150.fits' ), shape, wcs) / local.Tcmb maps['s'][0, 0, :, :] -= sz_map_090 maps['s'][1, 0, :, :] -= sz_map_150 else: sz_map = enmap.project( enmap.read_map( 'data_local/input/S18d_202006_confirmed_model_f150.fits' ), shape, wcs) / local.Tcmb maps['s'][0, 0, :, :] -= sz_map # simulation else: maps['s'], maps['n'], ivars = simobj.get_sim(season, patch, array, sim_num=i, set_idx=0) # coadd with civars weight implicitly multiplied civars = np.average(ivars, axis=1) civars[civars == 0] = np.inf maps['s'] = mask[None, None, :, :] * np.average( maps['s'] * ivars, axis=1) / civars / local.Tcmb maps['n'] = mask[None, None, :, :] * np.average( maps['n'] * ivars, axis=1) / civars / local.Tcmb # downgrade maps['s'] = enmap.downgrade(maps['s'], dg) maps['n'] = enmap.downgrade(maps['n'], dg) # save signal and noise to files for s in ['s', 'n']: if s == 'n' and i == 0: continue # real data is saved to a signal file for qi, q in enumerate(qid_array): enmap.write_map(aobj[q].fmap[s][i], maps[s][qi, :, :, :])
lmin=300, lmax=8000, wnoise_annulus=500, bin_annulus=20, lknee_guess=3000, alpha_guess=-4, method="fft", radial_fit=True) #io.plot_img(np.fft.fftshift(np.log10(ndown)),"ndown.png",aspect='auto',lim=[-6,3]) #io.hplot(np.fft.fftshift(np.log10(ndown)),"hndown") io.hplot(np.fft.fftshift((ndown)), "hndown") io.plot_img(np.fft.fftshift(ndown / nfitted), "nunred.png", aspect='auto') nmod = ndown / nfitted enmap.write_map("anisotropy_template.fits", enmap.samewcs(nmod, npower)) shape, wcs = maps.rect_geometry(width_deg=50., height_deg=30, px_res_arcmin=0.5) rms = 10.0 lknee = 3000 alpha = -3 n2d = covtools.get_anisotropic_noise(shape, wcs, rms, lknee, alpha) modlmap = enmap.modlmap(shape, wcs) bin_edges = np.arange(100, 8000, 100) binner = stats.bin2D(modlmap, bin_edges) cents, n1d = binner.bin(n2d) pl = io.Plotter(yscale='log', xlabel='l', ylabel='C') pl.add(cents, n1d)
nside = healpy.npix2nside(imap.shape[-1]) lmax = args.lmax or 3*nside progress("%s TQU alm2map" % name) alm = curvedsky.map2alm_healpix(imap, lmax=lmax) del imap # work around healpix bug progress("%s TQU rotate_alm" % name) alm = alm.astype(np.complex128,copy=False) healpy.rotate_alm(alm, euler[0], euler[1], euler[2]) alm = alm.astype(ctype,copy=False) progress("%s TQU map2alm" % name) curvedsky.alm2map_cyl(alm, omap) del alm ofile = ifile[:-5] + "_map.fits" progress("%s TQU write %s" % (name, ofile)) enmap.write_map(ofile, omap) def get_pixsize_rect(shape, wcs): """Return the exact pixel size in steradians for the rectangular cylindrical projection given by shape, wcs. Returns area[ny], where ny = shape[-2] is the number of rows in the image. All pixels on the same row have the same area.""" ymin = enmap.sky2pix(shape, wcs, [-np.pi/2,0])[0] ymax = enmap.sky2pix(shape, wcs, [ np.pi/2,0])[0] y = np.arange(shape[-2]) x = y*0 dec1 = enmap.pix2sky(shape, wcs, [np.maximum(ymin, y-0.5),x])[0] dec2 = enmap.pix2sky(shape, wcs, [np.minimum(ymax, y+0.5),x])[0] area = np.abs((np.sin(dec2)-np.sin(dec1))*wcs.wcs.cdelt[0]*np.pi/180) return area if "ivar" in outputs or "map0" in outputs:
def lens_map(imap): return plensing.displace_map(imap, alpha, order=args.lens_order) # Map of distances from center modrmap = enmap.modrmap(shape, wcs) # The convergence ~ projected mass density kappa = lensing.nfw_kappa(massOverh, modrmap, cc, zL=z, concentration=c, overdensity=180., critical=False, atClusterZ=False) if rank == 0: enmap.write_map(f'{savedir}kappa.fits', kappa) # Deflection field alpha = lensing.alpha_from_kappa(kappa) # Fourier magnitude map modlmap = enmap.modlmap(shape, wcs) # Unlensed CMB theory theory = cosmology.default_theory() cltt2d = theory.uCl('TT', modlmap) clte2d = theory.uCl('TE', modlmap) clee2d = theory.uCl('EE', modlmap) power = np.zeros((3, 3, shape[0], shape[1])) power[0, 0] = cltt2d power[1, 1] = clee2d power[1, 2] = clte2d