def create_map(width_deg = 20., px_res_arcmin = 0.5, Ngals = 10000000): shape,wcs = omaps.rect_geometry(width_deg = width_deg, px_res_arcmin = px_res_arcmin) bounds = enmap.box(shape,wcs)*180./np.pi Ngals = Ngals ras = np.random.uniform(bounds[0,1], bounds[1,1], Ngals) decs = np.random.uniform(bounds[0,0], bounds[1,0], Ngals) cmapper = cats.CatMapper(ras, decs, shape, wcs) delta = cmapper.counts/cmapper.counts.mean()-1. modlmap = cmapper.counts.modlmap() #result = {'shape': shape, 'wcs': wcs, 'delta': delta} #PIPE result = OrderedDict([('shape', shape), ('wcs', wcs), ('delta', delta), ('modlmap', modlmap)]) return result
def __init__(self, lens_beam = 7.0,lens_noiseT = 33.,lens_noiseP = 56., lens_tellmin = 2,lens_tellmax = 3000,lens_pellmin = 2, lens_pellmax = 3000,lens_kmin = 80,lens_kmax = 2000, lens_f_sky=0.65 ): # get lensing noise # Initialize cosmology and Clkk. Later parts need dimensionless spectra. self.l_min = lens_tellmin self.l_max = lens_tellmax self.k_min = lens_kmin self.k_max = lens_kmax self.f_sky = lens_f_sky cc = cosmology.Cosmology(lmax=self.l_max,pickling=True,dimensionless=True) theory = cc.theory ells = np.arange(2,self.l_max,1) clkk = theory.gCl('kk',ells) # Make a map template for calculating the noise curve on shape,wcs = maps.rect_geometry(width_deg = 5.,px_res_arcmin=1.5) # Define bin edges for noise curve bin_edges = np.arange(80,lens_kmax,20) nlgen = lensing.NlGenerator(shape,wcs,theory,bin_edges,lensedEqualsUnlensed=True) # Experiment parameters, here for Planck polCombs = ['TT','TE','EE','EB','TB'] _,_,_,_ = nlgen.updateNoise( beamX=lens_beam,noiseTX=lens_noiseT,noisePX=lens_noiseP, tellminX=lens_tellmin,tellmaxX=lens_tellmax, pellminX=lens_pellmin,pellmaxX=lens_pellmax) ls,nls,bells,nlbb,efficiency = nlgen.getNlIterative(polCombs,lens_kmin,lens_kmax, lens_tellmax,lens_pellmin,lens_pellmax, verbose=True,plot=False) self.orphics_kk = clkk self.orphics_ls = ls self.orphics_nls = nls self.noise_k = np.interp(np.arange(self.l_max+1), ls, nls) self.noise_k[np.arange(self.l_max+1) <= lens_kmin] = 1e100 self.noise_k[np.arange(self.l_max+1) >= lens_kmax] = 1e100
def enmap_from_config_section(Config, section, pol=False): analysis_section = section projection = Config.get(analysis_section, "projection") try: pt_file = Config.get(analysis_section, "patch_template") imap = enmap.read_map(pt_file) shape_dat = imap.shape wcs_dat = imap.wcs if pol and len(shape_dat) < 3: shape_dat = (3, shape_dat[0], shape_dat[1]) res = np.min(imap.extent() / imap.shape[-2:]) * 60. * 180. / np.pi except: pixel_analysis = Config.getfloat(analysis_section, "pixel_arcmin") try: width_analysis_deg = Config.getfloat(analysis_section, "patch_degrees_width") except: width_analysis_deg = Config.getfloat(analysis_section, "patch_arcmin_width") / 60. try: height_analysis_deg = Config.getfloat(analysis_section, "patch_degrees_height") except: height_analysis_deg = Config.getfloat(analysis_section, "patch_arcmin_height") / 60. ra_offset = Config.getfloat(analysis_section, "ra_offset") dec_offset = Config.getfloat(analysis_section, "dec_offset") shape_dat, wcs_dat = maps.rect_geometry( width_analysis_deg * 60., pixel_analysis, proj=projection, pol=pol, height_arcmin=height_analysis_deg * 60., xoffset_degree=ra_offset, yoffset_degree=dec_offset) return shape_dat, wcs_dat
def lensNoise(Config, expName, lensName, beamOverride=None, noiseTOverride=None, lkneeTOverride=None, lkneePOverride=None, alphaTOverride=None, alphaPOverride=None, tellminOverride=None, pellminOverride=None, tellmaxOverride=None, pellmaxOverride=None, deg=5., px=1.0, gradCut=10000, bigell=9000, plot=False, theoryOverride=None, lensedEqualsUnlensed=True, noiseFuncT=None, noiseFuncP=None): from orphics.io import list_from_config beam = list_from_config(Config, expName, 'beams') noise = list_from_config(Config, expName, 'noises') freq = list_from_config(Config, expName, 'freqs') lkneeT, lkneeP = list_from_config(Config, expName, 'lknee') alphaT, alphaP = list_from_config(Config, expName, 'alpha') if (noiseFuncT is None) and (noiseFuncP is None): print 'Not using noise files for generating lensing noise' else: print 'Using noise files for generating lensing noise' tellmin, tellmax = list_from_config(Config, expName, 'tellrange') if tellminOverride is not None: tellmin = tellminOverride if tellmaxOverride is not None: tellmax = tellmaxOverride pellmin, pellmax = list_from_config(Config, expName, 'pellrange') if pellminOverride is not None: pellmin = pellminOverride if pellmaxOverride is not None: pellmax = pellmaxOverride lmax = int(Config.getfloat(expName, 'lmax')) pols = Config.get(lensName, 'polList').split(',') freq_to_use = Config.getfloat(lensName, 'freq') ind = np.where(np.isclose(freq, freq_to_use)) beamFind = np.array(beam)[ind] noiseFind = np.array(noise)[ind] assert beamFind.size == 1 assert noiseFind.size == 1 if beamOverride is not None: beamX = beamY = beamOverride else: beamX = beamY = beamFind[0] if noiseTOverride is not None: noiseTX = noiseTY = noiseTOverride else: noiseTX = noiseTY = noiseFind[0] if lkneeTOverride is not None: lkneeT = lkneeTOverride if lkneePOverride is not None: lkneeP = lkneePOverride if alphaTOverride is not None: alphaT = alphaTOverride if alphaPOverride is not None: alphaP = alphaPOverride from orphics.lensing import NlGenerator, getMax from orphics import maps #deg = 5. #px = 1.0 dell = 10 kellmin = 10 shape, wcs = maps.rect_geometry(width_deg=deg, px_res_arcmin=px) kellmax = max(tellmax, pellmax) if theoryOverride is None: from orphics.cosmology import Cosmology cc = Cosmology(lmax=int(kellmax), pickling=True) theory = cc.theory else: theory = theoryOverride cc = None bin_edges = np.arange(kellmin, kellmax, dell) myNls = NlGenerator(shape, wcs, theory, bin_edges, gradCut=gradCut, bigell=bigell, unlensedEqualsLensed=lensedEqualsUnlensed) myNls.updateNoise(beamX, noiseTX, np.sqrt(2.) * noiseTX, tellmin, tellmax, pellmin, pellmax, beamY=beamY, noiseTY=noiseTY, noisePY=np.sqrt(2.) * noiseTY, lkneesX=(lkneeT, lkneeP), lkneesY=(lkneeT, lkneeP), alphasX=(alphaT, alphaP), alphasY=(alphaT, alphaP), noiseFuncTX=noiseFuncT, noiseFuncTY=noiseFuncT, noiseFuncPX=noiseFuncP, noiseFuncPY=noiseFuncP) lsmv, Nlmv, ells, dclbb, efficiency = myNls.getNlIterative(pols, kellmin, kellmax, tellmax, pellmin, pellmax, dell=dell, halo=True, plot=plot) return lsmv, Nlmv, ells, dclbb, efficiency, cc
from orphics import maps, cosmology, io from enlib import enmap, lensing import numpy as np theory_file_root = "../alhazen/data/Aug6_highAcc_CDM" theory = cosmology.loadTheorySpectraFromCAMB(theory_file_root, unlensedEqualsLensed=False, useTotal=False, TCMB=2.7255e6, lpad=9000, get_dimensionless=False) shape, wcs = maps.rect_geometry(width_deg=10., px_res_arcmin=0.5) lmax = 4000 ells = np.arange(0, lmax, 1) cltt = theory.uCl('TT', ells) pstt = cltt.reshape((1, 1, ells.size)) cgen = maps.MapGen(shape, wcs, pstt) imap = cgen.get_map() clpp = np.nan_to_num(theory.gCl('kk', ells) * 4. / ells**4.) psphi = clpp.reshape((1, 1, ells.size)) phigen = maps.MapGen(shape, wcs, psphi) phi = phigen.get_map() grad_phi = enmap.grad(phi) omap = lensing.lens_map(imap, grad_phi, order=3,
from __future__ import print_function from orphics import maps,io,cosmology,stats from pixell import enmap import numpy as np import os,sys import symlens nsims = 40 deg = 25. px = 2.0 shape,wcs = maps.rect_geometry(width_deg=deg,px_res_arcmin=px,proj='plain') modlmap = enmap.modlmap(shape,wcs) ymap,xmap = enmap.posmap(shape,wcs) omap = np.sin(ymap/np.pi*100) + np.cos(xmap/np.pi*100) mfact = 10 afact = 20 rms = (omap - omap.min())*mfact + afact # io.hplot(rms,colorbar=True) pmap = enmap.pixsizemap(shape,wcs) ivar = maps.ivar(shape,wcs,rms,ipsizemap=pmap) # io.hplot(ivar,colorbar=True) my_tasks = range(nsims)
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) pl.add(cents, covtools.rednoise(cents, rms, lknee=lknee, alpha=alpha), ls="--") pl.done()
from __future__ import print_function from orphics import maps,cosmology from pixell import enmap import numpy as np import os,sys from symlens import qe from enlib import bench # Say we want analytic RDN0 for the TTTE estimator XY='TE' UV='TE' # example geometry, you can use your own map's geometry shape,wcs = maps.rect_geometry(width_deg=25.,px_res_arcmin=2.0) modlmap = enmap.modlmap(shape,wcs) # symlens QEs always need you to specify 2d Fourier space masks # for the CMB, and also for the final lensing k-mask # For the CMB I use our typical ranges ellmin = 500 ; ellmax = 3000 # and create a 2d mask (you can pass lxcut, lycut etc. if you want # or use the 2d masks you already have for your analysis) cmb_kmask = maps.mask_kspace(shape,wcs,lmin=ellmin,lmax=ellmax) # Similarly, I create a final lensing k-mask which can go to lower L Lmin = 100 ; Lmax = 3000 lens_kmask = maps.mask_kspace(shape,wcs,lmin=Lmin,lmax=Lmax) # You always need a feed_dict to specify various 2d power spectra feed_dict = {} # We need some theory spectra. You'll have your own way to get them, # but I'll load them with orphics
import mlflow from orphics import maps data_dir = config.default_data_dir sehgal_dir = os.path.join(data_dir, 'sehgal') cuda = True compts = ["kappa", "ksz", "tsz", "ir_pts", "rad_pts"] compt_idxes = [0, 1, 2, 3, 4] shape = (len(compt_idxes), 128, 128) sample_interval = 200 save_interval = 5 batch_size = 32 nepochs = 100 norm_info_file = "/home/dwhan89/workspace/cosmikyu/data/sehgal/281020_logzshrink_normalization_info_validation.npz" _, wcs = maps.rect_geometry(width_arcmin=64., px_res_arcmin=0.5) # Configure data loader os.makedirs(data_dir, exist_ok=True) os.makedirs(sehgal_dir, exist_ok=True) SDN = transforms.SehgalDataNormalizerScaledLogZShrink(norm_info_file) SC = transforms.SehgalSubcomponets(compt_idxes) RF = transforms.RandomFlips(p_v=0.5, p_h=0.5) SDS_train = datasets.SehgalDataSet(sehgal_dir, data_type="train141020", transforms=[SDN, RF, SC], dummy_label=True) dataloader = torch.utils.data.DataLoader( SDS_train, batch_size=batch_size,
args = parser.parse_args() # Theory theory_file_root = "../alhazen/data/Aug6_highAcc_CDM" cc = counts.ClusterCosmology(skipCls=True) theory = cosmology.loadTheorySpectraFromCAMB(theory_file_root, unlensedEqualsLensed=False, useTotal=False, TCMB=2.7255e6, lpad=9000, get_dimensionless=False) # Geometry shape, wcs = maps.rect_geometry(width_arcmin=args.arc, px_res_arcmin=args.pix, pol=False) modlmap = enmap.modlmap(shape, wcs) modrmap = enmap.modrmap(shape, wcs) bshape, bwcs = maps.rect_geometry(width_arcmin=args.arc * args.buffer_factor, px_res_arcmin=args.pix, pol=False) bmodlmap = enmap.modlmap(bshape, bwcs) bmodrmap = enmap.modrmap(bshape, bwcs) #gshape, gwcs = maps.rect_geometry(width_arcmin=args.arc,px_res_arcmin=0.1953125,pol=False) gshape, gwcs = maps.rect_geometry(width_arcmin=100., px_res_arcmin=args.pix, pol=False) gshape, gwcs = bshape, bwcs gmodlmap = enmap.modlmap(gshape, gwcs)
def get_ksz_special(self,mass_index,snap,tcmb=2.7255e6): shape,wcs = fmaps.rect_geometry(width_arcmin=20.,px_res_arcmin=old_div(20.,128.)) return self.get_map('kszN',mass_index,snap,shape=shape,wcs=wcs)*tcmb
parser.add_argument("--sim-location", type=str, default=None, help="Path to sims.") parser.add_argument("--norm-file", type=str, default="norm.txt", help="Norm file.") parser.add_argument("--dtype", type=int, default=64, help="dtype bits") args = parser.parse_args() dtype = np.complex128 if args.dtype == 64 else np.complex64 # Resolution res = args.res shape, wcs = maps.rect_geometry(width_deg=args.width, px_res_arcmin=res, proj="car") mlmax = max(args.lmaxt, args.lmaxp) + 500 # Sim location try: if args.sim_location is not None: raise from soapack import interfaces as sints sim_location = sints.dconfig['actsims']['signal_path'] except: sim_location = args.sim_location assert sim_location is not None # Beam and noise ells = np.arange(mlmax)
def make_circular_geometry(shape, wcs, context_arcmin, hole_arcmin, power2d, buffer_factor=2, verbose=False): '''Makes the circular geometry matrices that need to be pre-calculated for later inpainting. Arguments --------- input2DPower - ndarray containing 2D power spectrum of a map. It need not already have been downsampled to the shape of the stamp cutout inputLy inputLx - the fourier wavenumbers corresponding to the y and x axes of the stamp cutout stampArc - the width in arcminutes of the stamp cut out stampPxX - the pixel width in arcminutes of the stamp cut out in the x direction stampPxY - the pixel width in arcminutes of the stamp cut out in the y direction holeArc - the radius of the circular hole in arcminutes bufferFactor - the pixel covariance matrix will be calculated on a periodic stamp larger by this factor verbose - True if you want more commentary Returns ------- meanMul - a matrix that has shape (nh,nc) where nh is the number of pixels in the hole and nc is the number of pixels outside (in the "context"). It should be multiplied by a vector (nc) containing pixels outside to get a vector (nh) for the mean value of the pixels inside covRoot - a (nh,nh) sqrt(covariance matrix) that can be used to generate a random realization in the hole. This can be generated by multiplying the sqrt of cov by a vector (nh) of standard normal variables. The generated vector should be added to the mean value obtained using meanMul pcov - the pixel-pixel covariance matrix used in intermediate steps, if you want to re-use it targetTemplate - a liteMap template of the stamp cutout m1 - a boolean array that can be used to select the hole region m2 - a boolean array that can be used to select the context region ''' arc = context_arcmin res = maps.resolution(shape, wcs) * 60. * 180. / np.pi bshape, bwcs = maps.rect_geometry(width_arcmin=arc * buffer_factor, px_res_arcmin=res) tshape, twcs = maps.rect_geometry(width_arcmin=arc, px_res_arcmin=res) sny, snx = tshape bmodlmap = enmap.modlmap(bshape, bwcs) modlmap = enmap.modlmap(shape, wcs) if verbose: print("Downsampling...") Niy, Nix = shape[-2:] Noy, Nox = bshape[-2:] # print(bshape,tshape,power2d.shape) # io.plot_img(np.fft.fftshift(np.log10(power2d))) #out_power = resample.resample_fft(power2d,bshape[-2:],axes=[-2,-1]) #out_power = np.fft.ifftshift(resample.resample_fft(np.fft.fftshift(power2d),bshape[-2:],axes=[-2,-1])) out_power = resample.resample_bin( power2d, factors=[float(Noy) / Niy, float(Nox) / Nix], axes=[-2, -1]) # io.plot_img(np.fft.fftshift(np.log10(out_power))) # print(out_power.shape) if verbose: print("Starting slow part...") d = maps.diagonal_cov(out_power) with bench.show("pixcov"): pcov = maps.pixcov(bshape, bwcs, d)[0, 0, :sny, :snx, :sny, :snx] modrmap = enmap.modrmap(tshape, twcs) m1 = np.where(modrmap.reshape(-1) < hole_arcmin * np.pi / 180. / 60.)[0] m2 = np.where(modrmap.reshape(-1) >= hole_arcmin * np.pi / 180. / 60.)[0] with bench.show("geom"): meanMul, cov = get_geometry(pcov.reshape(sny * snx, sny * snx), m1, m2) covRoot = stats.eig_pow(cov, 0.5) return meanMul, covRoot, pcov, tshape, twcs, m1, m2
def enmaps_from_config(Config, sim_section, analysis_section, pol=False): """ Algorithm for deciding sim and analysis shapes and wcs: Check if user has specified a *data* template * If yes, use its shape and wcs for the data - Determine ratio simpixel/anpixel - Upsample by that ratio to make sim template * If no, """ pixel_sim = Config.getfloat(sim_section, "pixel_arcmin") buffer_sim = Config.getfloat(sim_section, "buffer") projection = Config.get(analysis_section, "projection") try: pt_file = Config.get(analysis_section, "patch_template") imap = enmap.read_map(pt_file) shape_dat = imap.shape wcs_dat = imap.wcs res = np.min(imap.extent() / imap.shape[-2:]) * 60. * 180. / np.pi if np.isclose(pixel_sim, res, 1.e-2): shape_sim = shape_dat wcs_sim = wcs_dat else: bbox = enmap.box(shape_dat, wcs_dat) shape_sim, wcs_sim = enmap.geometry(bbox, res=pixel_sim * np.pi / 180. / 60., proj=projection) except: pixel_analysis = Config.getfloat(analysis_section, "pixel_arcmin") try: width_analysis_deg = Config.getfloat(analysis_section, "patch_degrees_width") except: width_analysis_deg = Config.getfloat(analysis_section, "patch_arcmin_width") / 60. try: height_analysis_deg = Config.getfloat(analysis_section, "patch_degrees_height") except: height_analysis_deg = Config.getfloat(analysis_section, "patch_arcmin_height") / 60. ra_offset = Config.getfloat(analysis_section, "ra_offset") dec_offset = Config.getfloat(analysis_section, "dec_offset") shape_dat, wcs_dat = maps.rect_geometry( width_analysis_deg * 60., pixel_analysis, proj=projection, pol=pol, height_arcmin=height_analysis_deg * 60., xoffset_degree=ra_offset, yoffset_degree=dec_offset) if np.abs(buffer_sim - 1.) < 1.e-3: shape_sim, wcs_sim = maps.rect_geometry( width_analysis_deg * 60., pixel_sim, proj=projection, pol=pol, height_arcmin=height_analysis_deg * 60., xoffset_degree=ra_offset, yoffset_degree=dec_offset) else: raise NotImplementedError("Buffer !=1 not implemented") return shape_sim, wcs_sim, shape_dat, wcs_dat
# Paths PathConfig = io.load_path_config() pout_dir = PathConfig.get("paths","plots")+"qest_hdv_"+str(args.noise)+"_" io.mkdir(pout_dir,comm) # Theory theory_file_root = "../alhazen/data/Aug6_highAcc_CDM" cc = counts.ClusterCosmology(skipCls=True) theory = cosmology.loadTheorySpectraFromCAMB(theory_file_root,unlensedEqualsLensed=False, useTotal=False,TCMB = 2.7255e6,lpad=9000,get_dimensionless=False) # Geometry shape, wcs = maps.rect_geometry(width_arcmin=args.arc,px_res_arcmin=args.pix,pol=False) modlmap = enmap.modlmap(shape,wcs) modrmap = enmap.modrmap(shape,wcs) # Binning bin_edges = np.arange(0.,20.0,args.pix*2) binner = stats.bin2D(modrmap*60.*180./np.pi,bin_edges) # Noise model noise_uK_rad = args.noise*np.pi/180./60. normfact = np.sqrt(np.prod(enmap.pixsize(shape,wcs))) kbeam = maps.gauss_beam(args.beam,modlmap) # Simulate lmax = int(modlmap.max()+1)
theory_file_root = "../alhazen/data/Aug6_highAcc_CDM" theory = cosmology.loadTheorySpectraFromCAMB(theory_file_root, unlensedEqualsLensed=False, useTotal=False, TCMB=2.7255e6, lpad=9000, get_dimensionless=False) ls, nls = np.loadtxt("nlkk.dat", usecols=[0, 1], unpack=True) clkk = theory.gCl('kk', ls) ellrange = np.arange(0, 6000, 1) totcls = interp1d(ls, clkk + nls, bounds_error=False, fill_value="extrapolate")(ellrange) ps = totcls.reshape((1, 1, ellrange.size)) bshape, bwcs = maps.rect_geometry(width_deg=80., px_res_arcmin=2.0, height_deg=15.) tap_per = 1. / 40. * 100. pad_per = 1. / 40. * 100. mg = maps.MapGen(bshape, bwcs, ps) fc = maps.FourierCalc(bshape, bwcs) taper, w2 = maps.get_taper(bshape, taper_percent=tap_per, pad_percent=pad_per, weight=None) bmap = mg.get_map() #io.plot_img(bmap*taper,"map.png",high_res=True)
from enlib import enmap import orphics.analysis.flatMaps as fmaps import orphics.maps as maps import orphics.analysis.pure as pure import orphics.tools.io as io import orphics.tools.stats as stats from orphics.theory.cosmology import Cosmology import numpy as np import os, sys out_dir = os.environ['WWW']+"plots/pureTest_" cc = Cosmology(lmax=6000,pickling=True,dimensionless=False) theory = cc.theory deg = 20. px = 1.0 shape, wcs = maps.rect_geometry(width_deg=deg,px_res_arcmin=px,pol=True) pa = fmaps.PatchArray(shape,wcs,cc=cc,orphics_is_dimensionless=False) ulensed = pa.get_unlensed_cmb() kappa = pa.get_grf_kappa() cmb = pa.get_lensed(ulensed,order=5) # io.highResPlot2d(cmb[0],out_dir+"t.png") # io.highResPlot2d(cmb[1],out_dir+"q.png") # io.highResPlot2d(cmb[2],out_dir+"u.png") modlmap = enmap.modlmap(shape,wcs) fc = maps.FourierCalc(shape,wcs) lbin_edges = np.arange(200,6000,40) lbinner = stats.bin2D(modlmap,lbin_edges) def plot_powers(cmb,suffix,power=None,w2=1.):
TCMB=2.7255e6, lpad=9000, get_dimensionless=False) lens_func = lambda x: lensing.nfw_kappa(mass, x, cc, zL=0.7, concentration=3.2, overdensity=200., critical=True, atClusterZ=True) #sigma = 1.0 * np.pi/180./60. #lens_func = lambda x: 0.2 * np.exp(-x**2./sigma**2./2.) rshape, rwcs = maps.rect_geometry(width_arcmin=5., px_res_arcmin=0.001) 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
from __future__ import print_function from orphics import maps,io,cosmology,stats from enlib import enmap import numpy as np import os,sys from scipy import signal cc = cosmology.Cosmology(lmax=6000,pickling=True) deg = 15. shape,wcs = maps.rect_geometry(width_deg=deg,px_res_arcmin=1.0) modlmap = enmap.modlmap(shape,wcs) modrmap = enmap.modrmap(shape,wcs) lmax = modlmap.max() ells = np.arange(0,lmax,1) ps = cc.theory.lCl('TT',ells).reshape((1,1,ells.size)) mgen = maps.MapGen(shape,wcs,ps) fwhm = 5. kbeam = maps.gauss_beam(modlmap,fwhm) imap = mgen.get_map() bmap2 = maps.convolve_gaussian(imap.copy(),fwhm=fwhm,nsigma=5.0) print(bmap2.shape) bmap = maps.filter_map(imap.copy(),kbeam)
rank = comm.Get_rank() numcores = comm.Get_size() # Paths PathConfig = io.load_path_config() GridName = PathConfig.get("paths","output_data")+args.GridName with open(GridName+"/attribs.json",'r') as f: attribs = json.loads(f.read()) barc = attribs['arc'] ; bpix = attribs['pix'] ; bbeam = attribs['beam'] pout_dir = PathConfig.get("paths","plots")+args.GridName+"/joint_bayesian_hdv_plots_"+io.join_nums((barc,bpix,bbeam,args.noise))+"_" io.mkdir(pout_dir,comm) # Tiny Geometry bshape, bwcs = maps.rect_geometry(width_arcmin=barc,px_res_arcmin=bpix,pol=False) bmodlmap = enmap.modlmap(bshape,bwcs) bmodrmap = enmap.modrmap(bshape,bwcs) # Noise model noise_uK_rad = args.noise*np.pi/180./60. normfact = np.sqrt(np.prod(enmap.pixsize(bshape,bwcs))) noise_uK_pixel = noise_uK_rad/normfact Ncov = np.diag([(noise_uK_pixel)**2.]*np.prod(bshape)) kbeam = maps.gauss_beam(bbeam,bmodlmap)
from __future__ import print_function from orphics import maps, io, cosmology, stats from pixell import enmap import numpy as np import os, sys from symlens import qe from symlens.factorize import e shape, wcs = maps.rect_geometry(width_deg=20., px_res_arcmin=1.5, proj='plain') theory = cosmology.default_theory() modlmap = enmap.modlmap(shape, wcs) hardening = 'src' # Lmax = 2000 # cluster = False Lmax = 6000 cluster = True if cluster: xmask = maps.mask_kspace(shape, wcs, lmin=100, lmax=2000) ymask = maps.mask_kspace(shape, wcs, lmin=100, lmax=6000) lxmask = maps.mask_kspace(shape, wcs, lmin=100, lmax=2000) lymask = maps.mask_kspace(shape, wcs, lmin=100, lmax=6000) estimator = 'hdv' else: xmask = maps.mask_kspace(shape, wcs, lmin=100, lmax=3500) ymask = maps.mask_kspace(shape, wcs, lmin=100, lmax=3500) lxmask = maps.mask_kspace(shape, wcs, lmin=100, lmax=3500) lymask = maps.mask_kspace(shape, wcs, lmin=100, lmax=3500)
# imap = enmap.enmap(fc.ifft(kmap).real,wcs) # io.hplot(imap,tag) pcross2d = f2power(ik1.reshape((Ny, Nx)), ik2.reshape((Ny, Nx))) cents, p1d = binner.bin(pcross2d) s.add_to_stats(tag, p1d.copy()) def ncompute(ik, nk, tag): pauto2d = f2power(ik.reshape((Ny, Nx)), ik.reshape( (Ny, Nx))) - f2power(nk.reshape((Ny, Nx)), nk.reshape((Ny, Nx))) cents, p1d = binner.bin(pauto2d) s.add_to_stats(tag, p1d.copy()) shape, wcs = maps.rect_geometry(width_deg=width, height_deg=height, px_res_arcmin=px) minell = maps.minimum_ell(shape, wcs) lmax1 = lmax - minell ells = np.arange(0, lmax, 1) theory = cosmology.default_theory() nu0 = 150. if dust: cibkcorr = fg.kappa_cib_corrcoeff(ells) ycorr = fg.y_kappa_corrcoeff(ells) cltt = theory.lCl('tt', ells) clkk = theory.gCl('kk', ells) clss = fg.power_tsz(ells, nu0) # pl = io.Plotter(xscale='log',yscale='log',scalefn=lambda x:x**2.)