def setUp(self): wcs, msk = read_flat_map("test/benchmarks/msk_flat.fits") (ny, nx) = msk.shape lx = np.radians(np.fabs(nx * wcs.wcs.cdelt[0])) ly = np.radians(np.fabs(ny * wcs.wcs.cdelt[1])) mps = np.array([ read_flat_map("test/benchmarks/mps_flat.fits", i_map=i)[1] for i in range(3) ]) d_ell = 20 lmax = 500. ledges = np.arange(int(lmax / d_ell) + 1) * d_ell + 2 self.b = nmt.NmtBinFlat(ledges[:-1], ledges[1:]) ledges_half = ledges[:len(ledges) // 2] self.b_half = nmt.NmtBinFlat(ledges_half[:-1], ledges_half[1:]) self.f0 = nmt.NmtFieldFlat(lx, ly, msk, [mps[0]]) self.f2 = nmt.NmtFieldFlat(lx, ly, msk, [mps[1], mps[2]]) self.f0_half = nmt.NmtFieldFlat(lx, ly, msk[:ny // 2, :nx // 2], [mps[0, :ny // 2, :nx // 2]]) self.w = nmt.NmtWorkspaceFlat() self.w.read_from("test/benchmarks/bm_f_nc_np_w00.fits") self.w02 = nmt.NmtWorkspaceFlat() self.w02.read_from("test/benchmarks/bm_f_nc_np_w02.fits") self.w22 = nmt.NmtWorkspaceFlat() self.w22.read_from("test/benchmarks/bm_f_nc_np_w22.fits") cls = np.loadtxt("test/benchmarks/cls_lss.txt", unpack=True) l, cltt, clee, clbb, clte, nltt, nlee, nlbb, nlte = cls self.ll = l self.cltt = cltt + nltt self.clee = clee + nlee self.clbb = clbb + nlbb self.clte = clte
def __init__(self): # This is to avoid showing an ugly warning # that has nothing to do with pymaster if (sys.version_info > (3, 1)): warnings.simplefilter("ignore", ResourceWarning) self.wcs, self.msk = read_flat_map("test/benchmarks/msk_flat.fits") (self.ny, self.nx) = self.msk.shape self.lx = np.radians(np.fabs(self.nx*self.wcs.wcs.cdelt[0])) self.ly = np.radians(np.fabs(self.ny*self.wcs.wcs.cdelt[1])) self.mps = np.array([read_flat_map("test/benchmarks/mps_flat.fits", i_map=i)[1] for i in range(3)]) self.mps_s1 = np.array([read_flat_map("test/benchmarks/" "mps_sp1_flat.fits", i_map=i)[1] for i in range(3)]) self.tmp = np.array([read_flat_map("test/benchmarks/tmp_flat.fits", i_map=i)[1] for i in range(3)]) self.d_ell = 20 self.lmax = 500. ledges = np.arange(int(self.lmax/self.d_ell)+1)*self.d_ell+2 self.b = nmt.NmtBinFlat(ledges[:-1], ledges[1:]) self.leff = self.b.get_effective_ells() self.f0 = nmt.NmtFieldFlat(self.lx, self.ly, self.msk, [self.mps[0]]) self.f0_half = nmt.NmtFieldFlat(self.lx, self.ly, self.msk[:self.ny//2, :self.nx//2], [self.mps[0, :self.ny//2, :self.nx//2]]) ledges_half = ledges[:len(ledges)//2] self.b_half = nmt.NmtBinFlat(ledges_half[:-1], ledges_half[1:]) dd = np.loadtxt("test/benchmarks/cls_lss.txt", unpack=True) l, cltt, clee, clbb, clte, nltt, nlee, nlbb, nlte = dd self.ll = l[:] self.cltt = cltt[:] self.clee = clee[:] self.clbb = clbb[:] self.clte = clte[:] self.nltt = nltt[:] self.nlee = nlee[:] self.nlbb = nlbb[:] self.nlte = nlte[:] self.n_good = np.zeros([1, len(l)]) self.n_bad = np.zeros([2, len(l)]) self.nb_good = np.zeros([1, self.b.bin.n_bands]) self.nb_bad = np.zeros([2, self.b.bin.n_bands])
def __init__(self, catfolder): """ Holds all of the information relevant to a given HSC field """ self.name = catfolder.split('_')[-3] self.filepath = catfolder self.cat = fits.open(self.filepath + 'clean_catalog.fits')[1].data self.masked_fraction_fp = self.filepath + 'masked_fraction.fits' self.masked_fraction = fits.open( self.masked_fraction_fp)[0].data.ravel() self.mask_binary = np.ones_like(self.masked_fraction) self.mask_binary[self.masked_fraction < 0.5] = 0. self.weight = self.masked_fraction * self.mask_binary self.goodpix = np.where(self.mask_binary > 0.1)[0] self.fsk, _ = read_flat_map(self.masked_fraction_fp) self.nmaps, self.nmaps_s1, self.nmaps_s2 = self.get_nmaps_split() self.fields = [field(self, thisbin) for thisbin in self.nmaps] self.fields_s1 = [field(self, thisbin) for thisbin in self.nmaps_s1] self.fields_s2 = [field(self, thisbin) for thisbin in self.nmaps_s2] self.ell_bins = nmt.NmtBinFlat(ell_bins[:-1], ell_bins[1:]) self.ell_bins_uncpld = self.ell_bins.get_effective_ells() self.wsp = nmt.NmtWorkspaceFlat() self.wsp.compute_coupling_matrix(self.fields[0].field, self.fields[0].field, self.ell_bins)
def run(self): """ Main function. This stage: - Produces measurements of the power spectrum with and without contaminant deprojections. - Estimates the noise bias - Estimates the covariance matrix - Estimates the deprojection bias """ self.parse_input() # Deal with the fact that SLURM only allows job array indices <= 1000 if self.config['gt1000remd'] != 'NONE': logger.info( 'SLURM jobID is larger than 1000. Old jobID = {}.'.format( self.config['tracerCombInd'])) self.config['tracerCombInd'] += int(self.config['gt1000remd']) logger.info('New jobID = {}.'.format(self.config['tracerCombInd'])) logger.info("Reading mask.") self.msk_bi, self.mskfrac, self.mp_depth = self.get_masks() logger.info("Computing area.") self.area_pix = np.radians(self.fsk.dx) * np.radians(self.fsk.dy) self.area_patch = np.sum(self.msk_bi * self.mskfrac) * self.area_pix self.lmax = int(180. * np.sqrt(1. / self.fsk.dx**2 + 1. / self.fsk.dy**2)) logger.info("Reading contaminants.") temps = self.get_contaminants() logger.info("Setting bandpowers.") lini = np.array(self.config['ell_bpws'])[:-1] lend = np.array(self.config['ell_bpws'])[1:] bpws = nmt.NmtBinFlat(lini, lend) ell_eff = bpws.get_effective_ells() self.nbands = ell_eff.shape[0] logger.info('Number of ell bands = {}.'.format(self.nbands)) tracers_nc, tracers_wc = self.get_all_tracers(temps) self.ntracers = len(tracers_nc) self.nmaps = self.ntracers_counts + self.ntracers_comptony + self.ntracers_kappa + 2 * self.ntracers_shear self.ncross = self.nmaps * (self.nmaps + 1) // 2 + self.ntracers_shear # Set up mapping self.mapping(tracers_nc) cwsp_curr = self.get_covar_mcm( tracers_wc, bpws, tracerCombInd=self.config['tracerCombInd']) # Permissions on NERSC os.system( 'find /global/cscratch1/sd/damonge/GSKY/ -type d -exec chmod -f 777 {} \;' ) os.system( 'find /global/cscratch1/sd/damonge/GSKY/ -type f -exec chmod -f 666 {} \;' )
def test_field_masked(self): wcs, msk = read_flat_map("test/benchmarks/msk_flat.fits") ny, nx = msk.shape lx = np.radians(np.fabs(nx * wcs.wcs.cdelt[0])) ly = np.radians(np.fabs(ny * wcs.wcs.cdelt[1])) mps = np.array([ read_flat_map("test/benchmarks/mps_flat.fits", i_map=i)[1] for i in range(3) ]) mps_msk = np.array([m * msk for m in mps]) d_ell = 20 lmax = 500. ledges = np.arange(int(lmax / d_ell) + 1) * d_ell + 2 b = nmt.NmtBinFlat(ledges[:-1], ledges[1:]) f0 = nmt.NmtFieldFlat(lx, ly, msk, [mps[0]]) f0_msk = nmt.NmtFieldFlat(lx, ly, msk, [mps_msk[0]], masked_on_input=True) f2 = nmt.NmtFieldFlat(lx, ly, msk, [mps[1], mps[2]]) f2_msk = nmt.NmtFieldFlat(lx, ly, msk, [mps_msk[1], mps_msk[2]], masked_on_input=True) w00 = nmt.NmtWorkspaceFlat() w00.compute_coupling_matrix(f0, f0, b) w02 = nmt.NmtWorkspaceFlat() w02.compute_coupling_matrix(f0, f2, b) w22 = nmt.NmtWorkspaceFlat() w22.compute_coupling_matrix(f2, f2, b) def mkcl(w, f, g): return w.decouple_cell(nmt.compute_coupled_cell_flat(f, g, b)) c00 = mkcl(w00, f0, f0).flatten() c02 = mkcl(w02, f0, f2).flatten() c22 = mkcl(w22, f2, f2).flatten() c00_msk = mkcl(w00, f0_msk, f0_msk).flatten() c02_msk = mkcl(w02, f0_msk, f2_msk).flatten() c22_msk = mkcl(w22, f2_msk, f2_msk).flatten() self.assertTrue(np.all(np.fabs(c00 - c00_msk) / np.mean(c00) < 1E-10)) self.assertTrue(np.all(np.fabs(c02 - c02_msk) / np.mean(c02) < 1E-10)) self.assertTrue(np.all(np.fabs(c22 - c22_msk) / np.mean(c22) < 1E-10))
(ny, nx) = msk.shape lx = np.fabs(nx * wcs.wcs.cdelt[0]) * np.pi / 180 ly = np.fabs(ny * wcs.wcs.cdelt[1]) * np.pi / 180 dt, dq, du = nmt.synfast_flat( int(nx), int(ny), lx, ly, [cltt + nltt, clte + nlte, 0 * cltt, clee + nlee, 0 * clee, clbb + nlbb], [0, 2]) write_flat_map("mps_flat.fits", np.array([dt, dq, du]), wcs, ["T", "Q", "U"]) d_ell = 20 lmax = 500. ledges = np.arange(int(lmax / d_ell) + 1) * d_ell + 2 _, st = read_flat_map("tmp_flat.fits", 0) _, sq = read_flat_map("tmp_flat.fits", 1) _, su = read_flat_map("tmp_flat.fits", 2) b = nmt.NmtBinFlat(ledges[:-1], ledges[1:]) leff = b.get_effective_ells() #No contaminants prefix = 'bm_f_nc_np' f0 = nmt.NmtFieldFlat(lx, ly, msk, [dt]) f2 = nmt.NmtFieldFlat(lx, ly, msk, [dq, du]) w00 = nmt.NmtWorkspaceFlat() w00.compute_coupling_matrix(f0, f0, b) cw00 = nmt.NmtCovarianceWorkspaceFlat() cw00.compute_coupling_coefficients(w00, w00) cw00.write_to(prefix + '_cw00.dat') cov = nmt.gaussian_covariance_flat(cw00, l, cltt + nltt, cltt + nltt, cltt + nltt, cltt + nltt) np.savetxt(prefix + "_cov.txt", cov) clb00 = w00.couple_cell(l, np.array([nltt]))
# Write out for reuse later np.save('../data/mpt.npy', mpt) np.save('../data/mpt_conv.npy', mpt_conv) np.save('../data/mpt_conv2.npy', mpt_conv2) np.save('../data/mpt_conv3.npy', mpt_conv3) mask = np.ones_like(mpt) f0 = nmt.NmtFieldFlat(Lx, Ly, mask, [mpt]) f0_conv = nmt.NmtFieldFlat(Lx, Ly, mask, [mpt_conv], beam=[l, beam]) f0_conv2 = nmt.NmtFieldFlat(Lx, Ly, mask, [mpt_conv2], beam=[l, beam]) f0_conv3 = nmt.NmtFieldFlat(Lx, Ly, mask, [mpt_conv3], beam=[l, beam]) l0_bins = np.arange(Nx / 8) * 8 * np.pi / Lx lf_bins = (np.arange(Nx / 8) + 1) * 8 * np.pi / Lx b = nmt.NmtBinFlat(l0_bins, lf_bins) ells_uncoupled = b.get_effective_ells() w00 = nmt.NmtWorkspaceFlat() w00.compute_coupling_matrix(f0, f0, b) w00.write_to("../data/w00_flat.fits") w00_conv = nmt.NmtWorkspaceFlat() w00_conv.compute_coupling_matrix(f0_conv, f0_conv, b) w00_conv.write_to("../data/w00_flat_conv.fits") w00_conv2 = nmt.NmtWorkspaceFlat() w00_conv2.compute_coupling_matrix(f0_conv2, f0_conv2, b) w00_conv2.write_to("../data/w00_flat_conv2.fits") w00_conv3 = nmt.NmtWorkspaceFlat()
def compute_power_spectrum(self, map1, mask1, map2=None, mask2=None, l_bpw=None, return_bpw=False, wsp=None, return_wsp=False, temp1=None, temp2=None): """ Computes power spectrum between two maps. map1 : first map to correlate mask1 : mask for the first map map2 : second map to correlate. If None map2==map1. mask2 : mask for the second map. If None mask2==mask1. l_bpw : bandpowers on which to calculate the power spectrum. Should be an [2,N_ell] array, where the first and second columns list the edges of each bandpower. If None, the function will create bandpowers of its own taylored to the properties of your map. return_bpw : if True, the bandpowers will also be returned wsp : NmtWorkspaceFlat object to accelerate the calculation. If None, this will be precomputed. return_wsp : if True, the workspace will also be returned temp1 : if not None, set of contaminants to remove from map1 temp2 : if not None, set of contaminants to remove from map2 """ same_map = False if map2 is None: map2 = map1 same_map = True same_mask = False if mask2 is None: mask2 = mask1 same_mask = False if len(map1) != self.npix: raise ValueError("Input map has the wrong size") if (len(map1) != len(map2)) or (len(map1) != len(mask1)) or ( len(map1) != len(mask2)): raise ValueError("Sizes of all maps and masks don't match") if l_bpw is None: ell_min = max(2 * np.pi / self.lx_rad, 2 * np.pi / self.ly_rad) ell_max = min(self.nx * np.pi / self.lx_rad, self.ny * np.pi / self.ly_rad) d_ell = 2 * ell_min n_ell = int((ell_max - ell_min) / d_ell) - 1 l_bpw = np.zeros([2, n_ell]) l_bpw[0, :] = ell_min + np.arange(n_ell) * d_ell l_bpw[1, :] = l_bpw[0, :] + d_ell return_bpw = True #Generate binning scheme b = nmt.NmtBinFlat(l_bpw[0, :], l_bpw[1, :]) if temp1 is not None: tmp1 = np.array([[t.reshape([self.ny, self.nx])] for t in temp1]) else: tmp1 = None if temp2 is not None: tmp2 = np.array([[t.reshape([self.ny, self.nx])] for t in temp2]) else: tmp2 = None #Generate fields f1 = nmt.NmtFieldFlat(self.lx_rad, self.ly_rad, mask1.reshape([self.ny, self.nx]), [map1.reshape([self.ny, self.nx])], templates=tmp1) if same_map and same_mask: f2 = f1 else: f2 = nmt.NmtFieldFlat(self.lx_rad, self.ly_rad, mask2.reshape([self.ny, self.nx]), [map2.reshape([self.ny, self.nx])], templates=tmp2) #Compute workspace if needed if wsp is None: wsp = nmt.NmtWorkspaceFlat() wsp.compute_coupling_matrix(f1, f2, b) return_wsp = True #Compute power spectrum cl_coupled = nmt.compute_coupled_cell_flat(f1, f2, b) cl_uncoupled = wsp.decouple_cell(cl_coupled)[0] #Return if return_bpw and return_wsp: return cl_uncoupled, l_bpw, wsp else: if return_bpw: return cl_uncoupled, l_bpw elif return_wsp: return cl_uncoupled, wsp else: return cl_uncoupled
def compute_wsps(self): """ Convenience method for calculating the NaMaster workspaces for all the probes in the simulation. :return wsps: wsps list """ self.wsps = [[None for i in range(self.params['nprobes'])] for ii in range(self.params['nprobes'])] if self.params['signal']: signalmaps = self.simmaps.generate_maps() if self.params['noise']: # We need to add noise maps to the signal maps noisemaps = self.noisemaps.generate_maps() if self.params['signal']: maps = copy.deepcopy(signalmaps) elif self.params['noise']: maps = copy.deepcopy(noisemaps) else: raise RuntimeError( 'Either signal or noise must be True. Aborting.') b = nmt.NmtBinFlat(self.params['l0_bins'], self.params['lf_bins']) # Compute workspaces for all the probes for j in range(self.params['nprobes']): for jj in range(j + 1): if j == jj: compute_cls = True else: if self.params['signal']: compute_cls = True else: compute_cls = False if compute_cls: spin1 = self.params['spins'][j] spin2 = self.params['spins'][jj] logger.info('Spins: spin1 = {}, spin2 = {}.'.format( spin1, spin2)) if spin1 == 2 and spin2 == 0: # Define flat sky spin-2 field emaps = [maps[j], maps[j + self.params['nspin2']]] f2_1 = nmt.NmtFieldFlat(np.radians(self.fsk.lx), np.radians(self.fsk.ly), self.masks[j], emaps, purify_b=False) # Define flat sky spin-0 field emaps = [maps[jj]] f0_1 = nmt.NmtFieldFlat(np.radians(self.fsk.lx), np.radians(self.fsk.ly), self.masks[jj], emaps, purify_b=False) logger.info('Computing workspace element.') wsp = nmt.NmtWorkspaceFlat() wsp.compute_coupling_matrix(f2_1, f0_1, b) self.wsps[j][jj] = wsp if j != jj: self.wsps[jj][j] = wsp elif spin1 == 2 and spin2 == 2: # Define flat sky spin-2 field emaps = [maps[j], maps[j + self.params['nspin2']]] f2_1 = nmt.NmtFieldFlat(np.radians(self.fsk.lx), np.radians(self.fsk.ly), self.masks[j], emaps, purify_b=False) # Define flat sky spin-0 field emaps = [maps[jj], maps[jj + self.params['nspin2']]] f2_2 = nmt.NmtFieldFlat(np.radians(self.fsk.lx), np.radians(self.fsk.ly), self.masks[jj], emaps, purify_b=False) logger.info('Computing workspace element.') wsp = nmt.NmtWorkspaceFlat() wsp.compute_coupling_matrix(f2_1, f2_2, b) self.wsps[j][jj] = wsp if j != jj: self.wsps[jj][j] = wsp else: # Define flat sky spin-0 field emaps = [maps[j]] f0_1 = nmt.NmtFieldFlat(np.radians(self.fsk.lx), np.radians(self.fsk.ly), self.masks[j], emaps, purify_b=False) # Define flat sky spin-0 field emaps = [maps[jj]] f0_2 = nmt.NmtFieldFlat(np.radians(self.fsk.lx), np.radians(self.fsk.ly), self.masks[jj], emaps, purify_b=False) logger.info('Computing workspace element.') wsp = nmt.NmtWorkspaceFlat() wsp.compute_coupling_matrix(f0_1, f0_2, b) self.wsps[j][jj] = wsp if j != jj: self.wsps[jj][j] = wsp return self.wsps
from pixell import enmap spin1, spin2 = config['spins'] logger.info('Spins: spin1 = {}, spin2 = {}.'.format(spin1, spin2)) map1 = enmap.read_fits(config['path2map1']) logger.info('Read map1 from {}.'.format(config['path2map1'])) map2 = enmap.read_fits(config['path2map2']) logger.info('Read map2 from {}.'.format(config['path2map2'])) mask1 = enmap.read_fits(config['path2mask1']) logger.info('Read mask1 from {}.'.format(config['path2mask1'])) mask2 = enmap.read_fits(config['path2mask2']) logger.info('Read mask2 from {}.'.format(config['path2mask2'])) b = nmt.NmtBinFlat(config['l0_bins'], config['lf_bins']) # The effective sampling rate for these bandpowers can be obtained calling: ells_uncoupled = b.get_effective_ells() if spin1 == 2 and spin2 == 0: # Define flat sky spin-2 map emaps = [map1[0], map1[1]] # Define flat sky spin-0 map emaps = [map2] elif spin1 == 2 and spin2 == 0: # Define flat sky spin-2 map emaps = [map1[0], map1[1]] # Define flat sky spin-0 map emaps = [map2]
def guess_spectra_cpld(self, params, saccfile_coadd, noise_saccfile_coadd=None): ell_theor = np.arange(self.config['ellmax']) theor = GSKYPrediction(saccfile_coadd, ells=ell_theor) cl_theor = theor.get_prediction(params) masks, fsk = self.get_masks() dl_min = int( min(2 * np.pi / np.radians(fsk.lx), 2 * np.pi / np.radians(fsk.ly))) ells_hi = np.arange(2, 15800, dl_min * 1.5).astype(int) bpws_hi = nmt.NmtBinFlat(ells_hi[:-1], ells_hi[1:]) leff_hi = bpws_hi.get_effective_ells() cl_cpld = [] trc_combs = saccfile_coadd.get_tracer_combinations() for i, (tr_i, tr_j) in enumerate(trc_combs): logger.info('Computing wsp for trc_comb = {}.'.format( (tr_i, tr_j))) tr_i_ind = self.config['tracers'].index(tr_i) tr_j_ind = self.config['tracers'].index(tr_j) mask_i = masks[tr_i_ind] mask_j = masks[tr_j_ind] cl_theor_curr = [cl_theor[i]] if 'wl' in tr_i: field_i = nmt.NmtFieldFlat( np.radians(fsk.lx), np.radians(fsk.ly), mask_i.reshape([fsk.ny, fsk.nx]), [ mask_i.reshape([fsk.ny, fsk.nx]), mask_i.reshape([fsk.ny, fsk.nx]) ], templates=None) cl_theor_curr.append(np.zeros_like(cl_theor[i])) else: field_i = nmt.NmtFieldFlat(np.radians(fsk.lx), np.radians(fsk.ly), mask_i.reshape([fsk.ny, fsk.nx]), [mask_i.reshape([fsk.ny, fsk.nx])], templates=None) if 'wl' in tr_j: field_j = nmt.NmtFieldFlat( np.radians(fsk.lx), np.radians(fsk.ly), mask_j.reshape([fsk.ny, fsk.nx]), [ mask_j.reshape([fsk.ny, fsk.nx]), mask_j.reshape([fsk.ny, fsk.nx]) ], templates=None) cl_theor_curr.append(np.zeros_like(cl_theor[i])) else: field_j = nmt.NmtFieldFlat(np.radians(fsk.lx), np.radians(fsk.ly), mask_j.reshape([fsk.ny, fsk.nx]), [mask_j.reshape([fsk.ny, fsk.nx])], templates=None) wsp_hi_curr = nmt.NmtWorkspaceFlat() wsp_hi_curr.compute_coupling_matrix(field_i, field_j, bpws_hi) msk_prod = mask_i * mask_j cl_cpld_curr = self.get_cl_cpld(cl_theor_curr, ell_theor, leff_hi, wsp_hi_curr, msk_prod) if noise_saccfile_coadd is not None: logger.info('Adding noise.') if tr_i == tr_j: if 'wl' in tr_i: datatype = 'cl_ee' else: datatype = 'cl_00' l_curr, nl_curr = noise_saccfile_coadd.get_ell_cl( datatype, tr_i, tr_j, return_cov=False) nl_curr_int = scipy.interpolate.interp1d( l_curr, nl_curr, bounds_error=False, fill_value=(nl_curr[0], nl_curr[-1])) nl_curr_hi = nl_curr_int(ell_theor) cl_cpld_curr += nl_curr_hi cl_cpld.append(cl_cpld_curr) # Add tracers to sacc saccfile_guess_spec = sacc.Sacc() for trc_name, trc in saccfile_coadd.tracers.items(): saccfile_guess_spec.add_tracer_object(trc) for i, (tr_i, tr_j) in enumerate(trc_combs): if 'wl' not in tr_i and 'wl' not in tr_j: saccfile_guess_spec.add_ell_cl('cl_00', tr_i, tr_j, ell_theor, cl_cpld[i]) elif ('wl' in tr_i and 'wl' not in tr_j) or ('wl' not in tr_i and 'wl' in tr_j): saccfile_guess_spec.add_ell_cl('cl_0e', tr_i, tr_j, ell_theor, cl_cpld[i]) saccfile_guess_spec.add_ell_cl('cl_0b', tr_i, tr_j, ell_theor, np.zeros_like(cl_cpld[i])) else: saccfile_guess_spec.add_ell_cl('cl_ee', tr_i, tr_j, ell_theor, cl_cpld[i]) saccfile_guess_spec.add_ell_cl('cl_eb', tr_i, tr_j, ell_theor, np.zeros_like(cl_cpld[i])) saccfile_guess_spec.add_ell_cl('cl_bb', tr_i, tr_j, ell_theor, np.zeros_like(cl_cpld[i])) return saccfile_coadd, noise_saccfile_coadd, saccfile_guess_spec
def __call__(self, realiz): """ Convenience method for calculating the signal and noise cls for a given mock realization. This is a function that can be pickled and can be thus used when running the mock generation in parallel using multiprocessing pool. :param realis: number of the realisation to run :param noise: boolean flag indicating if noise is added to the mocks noise=True: add noise to the mocks noise=False: do not add noise to the mocks :param probes: list of desired probes to run the mock for :param maskmat: matrix with the relevant masks for the probes :param clparams: list of dictionaries with the parameters for calculating the power spectra for each probe :return cls: 3D array of signal and noise cls for the given realisation, 0. and 1. axis denote the power spectrum, 2. axis gives the cls belonging to this configuration :return noisecls: 3D array of noise cls for the given realisation, 0. and 1. axis denote the power spectrum, 2. axis gives the cls belonging to this configuration :return tempells: array of the ell range of the power spectra """ logger.info('Running realization : {}.'.format(realiz)) cls = np.zeros((self.params['nautocls'], self.params['nautocls'], self.params['nell'])) noisecls = np.zeros_like(cls) if self.params['signal']: signalmaps = self.simmaps.generate_maps() if self.params['noise']: # We need to add noise maps to the signal maps noisemaps = self.noisemaps.generate_maps() if self.params['signal'] and self.params['noise']: # We need to add the two lists elementwise maps = list(map(add, signalmaps, noisemaps)) elif self.params['signal'] and not self.params['noise']: maps = copy.deepcopy(signalmaps) elif not self.params['signal'] and self.params['noise']: maps = copy.deepcopy(noisemaps) else: raise RuntimeError( 'Either signal or noise must be True. Aborting.') b = nmt.NmtBinFlat(self.params['l0_bins'], self.params['lf_bins']) # The effective sampling rate for these bandpowers can be obtained calling: ells_uncoupled = b.get_effective_ells() # First compute the cls of map realization for all the probes for j in range(self.params['nprobes']): for jj in range(j + 1): if j == jj: compute_cls = True else: if self.params['signal']: compute_cls = True else: compute_cls = False if compute_cls: probe1 = self.params['probes'][j] probe2 = self.params['probes'][jj] spin1 = self.params['spins'][j] spin2 = self.params['spins'][jj] logger.info( 'Computing the power spectrum between probe1 = {} and probe2 = {}.' .format(probe1, probe2)) logger.info('Spins: spin1 = {}, spin2 = {}.'.format( spin1, spin2)) if spin1 == 2 and spin2 == 0: # Define flat sky spin-2 field emaps = [maps[j], maps[j + self.params['nspin2']]] f2_1 = nmt.NmtFieldFlat(np.radians(self.fsk.lx), np.radians(self.fsk.ly), self.masks[j], emaps, purify_b=False) # Define flat sky spin-0 field emaps = [maps[jj]] f0_1 = nmt.NmtFieldFlat(np.radians(self.fsk.lx), np.radians(self.fsk.ly), self.masks[jj], emaps, purify_b=False) if self.wsps[j][jj] is None: logger.info( 'Workspace element for j, jj = {}, {} not set.' .format(j, jj)) logger.info('Computing workspace element.') wsp = nmt.NmtWorkspaceFlat() wsp.compute_coupling_matrix(f2_1, f0_1, b) self.wsps[j][jj] = wsp if j != jj: self.wsps[jj][j] = wsp else: logger.info( 'Workspace element already set for j, jj = {}, {}.' .format(j, jj)) # Compute pseudo-Cls cl_coupled = nmt.compute_coupled_cell_flat( f2_1, f0_1, b) # Uncoupling pseudo-Cls cl_uncoupled = self.wsps[j][jj].decouple_cell( cl_coupled) # For one spin-0 field and one spin-2 field, NaMaster gives: n_cls=2, [C_TE,C_TB] tempclse = cl_uncoupled[0] tempclsb = cl_uncoupled[1] cls[j, jj, :] = tempclse cls[j + self.params['nspin2'], jj, :] = tempclsb elif spin1 == 2 and spin2 == 2: # Define flat sky spin-2 field emaps = [maps[j], maps[j + self.params['nspin2']]] f2_1 = nmt.NmtFieldFlat(np.radians(self.fsk.lx), np.radians(self.fsk.ly), self.masks[j], emaps, purify_b=False) # Define flat sky spin-0 field emaps = [maps[jj], maps[jj + self.params['nspin2']]] f2_2 = nmt.NmtFieldFlat(np.radians(self.fsk.lx), np.radians(self.fsk.ly), self.masks[jj], emaps, purify_b=False) if self.wsps[j][jj] is None: logger.info( 'Workspace element for j, jj = {}, {} not set.' .format(j, jj)) logger.info('Computing workspace element.') wsp = nmt.NmtWorkspaceFlat() wsp.compute_coupling_matrix(f2_1, f2_2, b) self.wsps[j][jj] = wsp if j != jj: self.wsps[jj][j] = wsp else: logger.info( 'Workspace element already set for j, jj = {}, {}.' .format(j, jj)) # Compute pseudo-Cls cl_coupled = nmt.compute_coupled_cell_flat( f2_1, f2_2, b) # Uncoupling pseudo-Cls cl_uncoupled = self.wsps[j][jj].decouple_cell( cl_coupled) # For two spin-2 fields, NaMaster gives: n_cls=4, [C_E1E2,C_E1B2,C_E2B1,C_B1B2] tempclse = cl_uncoupled[0] tempclseb = cl_uncoupled[1] tempclsb = cl_uncoupled[3] cls[j, jj, :] = tempclse cls[j + self.params['nspin2'], jj, :] = tempclseb cls[j + self.params['nspin2'], jj + self.params['nspin2'], :] = tempclsb else: # Define flat sky spin-0 field emaps = [maps[j]] f0_1 = nmt.NmtFieldFlat(np.radians(self.fsk.lx), np.radians(self.fsk.ly), self.masks[j], emaps, purify_b=False) # Define flat sky spin-0 field emaps = [maps[jj]] f0_2 = nmt.NmtFieldFlat(np.radians(self.fsk.lx), np.radians(self.fsk.ly), self.masks[jj], emaps, purify_b=False) if self.wsps[j][jj] is None: logger.info( 'Workspace element for j, jj = {}, {} not set.' .format(j, jj)) logger.info('Computing workspace element.') wsp = nmt.NmtWorkspaceFlat() wsp.compute_coupling_matrix(f0_1, f0_2, b) self.wsps[j][jj] = wsp if j != jj: self.wsps[jj][j] = wsp else: logger.info( 'Workspace element already set for j, jj = {}, {}.' .format(j, jj)) # Compute pseudo-Cls cl_coupled = nmt.compute_coupled_cell_flat( f0_1, f0_2, b) # Uncoupling pseudo-Cls cl_uncoupled = self.wsps[j][jj].decouple_cell( cl_coupled) cls[j, jj, :] = cl_uncoupled # If noise is True, then we need to compute the noise from simulations # We therefore generate different noise maps for each realisation so that # we can then compute the noise power spectrum from these noise realisations if self.params['signal'] and self.params['noise']: # Determine the noise bias on the auto power spectrum for each realisation # For the cosmic shear, we now add the shear from the noisefree signal maps to the # data i.e. we simulate how we would do it in real life noisemaps = self.noisemaps.generate_maps(signalmaps) for j, probe in enumerate(self.params['probes']): logger.info( 'Computing the noise power spectrum for {}.'.format(probe)) if self.params['spins'][j] == 2: # Define flat sky spin-2 field emaps = [ noisemaps[j], noisemaps[j + self.params['nspin2']] ] f2 = nmt.NmtFieldFlat(np.radians(self.fsk.lx), np.radians(self.fsk.ly), self.masks[j], emaps, purify_b=False) if self.wsps[j][j] is None: logger.info( 'Workspace element for j, j = {}, {} not set.'. format(j, j)) logger.info('Computing workspace element.') wsp = nmt.NmtWorkspaceFlat() wsp.compute_coupling_matrix(f2, f2, b) self.wsps[j][j] = wsp else: logger.info( 'Workspace element already set for j, j = {}, {}.'. format(j, j)) # Compute pseudo-Cls cl_coupled = nmt.compute_coupled_cell_flat(f2, f2, b) # Uncoupling pseudo-Cls cl_uncoupled = self.wsps[j][j].decouple_cell(cl_coupled) # For two spin-2 fields, NaMaster gives: n_cls=4, [C_E1E2,C_E1B2,C_E2B1,C_B1B2] tempclse = cl_uncoupled[0] tempclsb = cl_uncoupled[3] noisecls[j, j, :] = tempclse noisecls[j + self.params['nspin2'], j + self.params['nspin2'], :] = tempclsb else: # Define flat sky spin-0 field emaps = [noisemaps[j]] f0 = nmt.NmtFieldFlat(np.radians(self.fsk.lx), np.radians(self.fsk.ly), self.masks[j], emaps, purify_b=False) if self.wsps[j][j] is None: logger.info( 'Workspace element for j, j = {}, {} not set.'. format(j, j)) logger.info('Computing workspace element.') wsp = nmt.NmtWorkspaceFlat() wsp.compute_coupling_matrix(f0, f0, b) self.wsps[j][j] = wsp else: logger.info( 'Workspace element already set for j, j = {}, {}.'. format(j, j)) # Compute pseudo-Cls cl_coupled = nmt.compute_coupled_cell_flat(f0, f0, b) # Uncoupling pseudo-Cls cl_uncoupled = self.wsps[j][j].decouple_cell(cl_coupled) noisecls[j, j, :] = cl_uncoupled if not self.params['signal'] and self.params['noise']: noisecls = copy.deepcopy(cls) cls = np.zeros_like(noisecls) return cls, noisecls, ells_uncoupled
dum, [fgp[0, 0, :], fgp[0, 1, :]] = fm.read_flat_map("data/cont_wl_psf_flat.fits", i_map=-1) #PSF dum, [fgp[1, 0, :], fgp[1, 1, :]] = fm.read_flat_map("data/cont_wl_ss_flat.fits", i_map=-1) #Small-scales #Binning scheme ell_min = max(2 * np.pi / fmi.lx_rad, 2 * np.pi / fmi.ly_rad) ell_max = min(fmi.nx * np.pi / fmi.lx_rad, fmi.ny * np.pi / fmi.ly_rad) d_ell = 2 * ell_min n_ell = int((ell_max - ell_min) / d_ell) - 1 l_bpw = np.zeros([2, n_ell]) l_bpw[0, :] = ell_min + np.arange(n_ell) * d_ell l_bpw[1, :] = l_bpw[0, :] + d_ell b = nmt.NmtBinFlat(l_bpw[0, :], l_bpw[1, :]) #Generate some initial fields print(" - Res(x): %.3lf arcmin. Res(y): %.3lf arcmin." % (fmi.lx * 60 / fmi.nx, fmi.ly * 60 / fmi.ny)) print(" - lmax = %d, lmin = %d" % (int(ell_max), int(ell_min))) def get_fields(): st, sq, su = nmt.synfast_flat(int(fmi.nx), int(fmi.ny), fmi.lx_rad, fmi.ly_rad, [ cltt + nltt, clte + nlte, 0 * cltt, clee + nlee, 0 * clee, clbb + nlbb ], [0, 2]) st = st.flatten() sq = sq.flatten()
def run(self): """ Main function. This stage: - Produces measurements of the power spectrum with and without contaminant deprojections. - Estimates the noise bias - Estimates the covariance matrix - Estimates the deprojection bias """ self.parse_input() print("Reading mask") self.msk_bi, self.mskfrac, self.mp_depth = self.get_masks() print("Computing area") self.area_pix = np.radians(self.fsk.dx) * np.radians(self.fsk.dy) self.area_patch = np.sum(self.msk_bi * self.mskfrac) * self.area_pix self.lmax = int(180. * np.sqrt(1. / self.fsk.dx**2 + 1. / self.fsk.dy**2)) print("Reading contaminants") temps = self.get_contaminants() print("Setting bandpowers") lini = np.array(self.config['ell_bpws'])[:-1] lend = np.array(self.config['ell_bpws'])[1:] bpws = nmt.NmtBinFlat(lini, lend) ell_eff = bpws.get_effective_ells() print("Generating tracers") tracers_nc, tracers_wc = self.get_tracers(temps) self.nbins = len(tracers_nc) print("Translating into SACC tracers") tracers_sacc = self.get_sacc_tracers(tracers_nc) self.ordering = np.zeros([self.nbins, self.nbins], dtype=int) ix = 0 for i in range(self.nbins): for j in range(i, self.nbins): self.ordering[i, j] = ix if j != i: self.ordering[j, i] = ix ix += 1 print("Getting MCM") wsp = self.get_mcm(tracers_nc, bpws) print("Computing window function") windows = self.get_sacc_windows(wsp) print("Computing SACC binning") #No windows binning_nw = self.get_sacc_binning(ell_eff, lini, lend, windows=None) #With windows binning_ww = self.get_sacc_binning(ell_eff, lini, lend, windows=windows) print("Computing power spectra") print(" No deprojections") cls_wodpj, _ = self.get_power_spectra(tracers_nc, wsp, bpws) print(" W. deprojections") cls_wdpj, cls_wdpj_coupled = self.get_power_spectra( tracers_wc, wsp, bpws) self.ncross, self.nell = cls_wodpj.shape print("Getting guess power spectra") lth, clth = self.get_cl_guess(ell_eff, cls_wdpj) print("Computing deprojection bias") cls_wdpj, cls_deproj = self.get_dpj_bias(tracers_wc, lth, clth, cls_wdpj_coupled, wsp, bpws) print("Computing covariance") cov_wodpj = self.get_covar(lth, clth, bpws, tracers_wc, wsp, None, None) if self.config['gaus_covar_type'] == 'analytic': cov_wdpj = cov_wodpj.copy() else: cov_wdpj = self.get_covar(lth, clth, bpws, tracers_wc, wsp, temps, cls_deproj) print("Computing noise bias") nls = self.get_noise(tracers_nc, wsp, bpws) print("Writing output") print(self.get_output_fname('noi_bias', ext='sacc')) self.write_vector_to_sacc(self.get_output_fname('noi_bias', ext='sacc'), tracers_sacc, binning_nw, nls, verbose=False) self.write_vector_to_sacc(self.get_output_fname('dpj_bias', ext='sacc'), tracers_sacc, binning_nw, cls_deproj, verbose=False) self.write_vector_to_sacc(self.get_output_fname('power_spectra_wodpj', ext='sacc'), tracers_sacc, binning_ww, cls_wodpj, covar=cov_wodpj, verbose=False) self.write_vector_to_sacc(self.get_output_fname('power_spectra_wdpj', ext='sacc'), tracers_sacc, binning_ww, cls_wdpj, covar=cov_wdpj, verbose=True)
def xcorr_flatsky(modedecomp=False, simkey="512_alfven3_0002_a_z", Imapkey="", deglen=10, apotype="C2", aposcale=0.5, Epure=True, Bpure=True): TQU = SimsTQU(fn=simkey, modedecomp=modedecomp, ikey=Imapkey) # Define flat-sky field # - Lx and Ly: the size of the patch in the x and y dimensions (in radians) Lx = deglen * np.pi / 180. # arbitrarily set this to a deglen x deglen deg box Ly = deglen * np.pi / 180. # - Nx and Ny: the number of pixels in the x and y dimensions Nx = 512 Ny = 512 # Define mask mask = np.ones_like(TQU.T).flatten() xarr = np.ones(Ny)[:, None] * np.arange(Nx)[None, :] * Lx / Nx yarr = np.ones(Nx)[None, :] * np.arange(Ny)[:, None] * Ly / Ny #Let's also trim the edges mask[np.where(xarr.flatten() < Lx / 16.)] = 0 mask[np.where(xarr.flatten() > 15 * Lx / 16.)] = 0 mask[np.where(yarr.flatten() < Ly / 16.)] = 0 mask[np.where(yarr.flatten() > 15 * Ly / 16.)] = 0 mask = mask.reshape([Ny, Nx]) mask = nmt.mask_apodization_flat(mask, Lx, Ly, aposize=aposcale, apotype=apotype) # Fields: # Once you have maps it's time to create pymaster fields. # Note that, as in the full-sky case, you can also pass # contaminant templates and flags for E and B purification # (see the documentation for more details) f0 = nmt.NmtFieldFlat(Lx, Ly, mask, [TQU.T]) f2 = nmt.NmtFieldFlat(Lx, Ly, mask, [TQU.Q, TQU.U], purify_b=Bpure, purify_e=Epure) # Bins: # For flat-sky fields, bandpowers are simply defined as intervals in ell, and # pymaster doesn't currently support any weighting scheme within each interval. l0_bins = np.arange(Nx / 8) * 8 * np.pi / Lx lf_bins = (np.arange(Nx / 8) + 1) * 8 * np.pi / Lx b = nmt.NmtBinFlat(l0_bins, lf_bins) # The effective sampling rate for these bandpowers can be obtained calling: ells_uncoupled = b.get_effective_ells() # Workspaces: # As in the full-sky case, the computation of the coupling matrix and of # the pseudo-CL estimator is mediated by a WorkspaceFlat case, initialized # by calling its compute_coupling_matrix method: w00 = nmt.NmtWorkspaceFlat() w00.compute_coupling_matrix(f0, f0, b) w02 = nmt.NmtWorkspaceFlat() w02.compute_coupling_matrix(f0, f2, b) w22 = nmt.NmtWorkspaceFlat() w22.compute_coupling_matrix(f2, f2, b) # Computing power spectra: # As in the full-sky case, you compute the pseudo-CL estimator by # computing the coupled power spectra and then decoupling them by # inverting the mode-coupling matrix. This is done in two steps below, # but pymaster provides convenience routines to do this # through a single function call cl00_coupled = nmt.compute_coupled_cell_flat(f0, f0, b) cl00_uncoupled = w00.decouple_cell(cl00_coupled) cl02_coupled = nmt.compute_coupled_cell_flat(f0, f2, b) cl02_uncoupled = w02.decouple_cell(cl02_coupled) cl22_coupled = nmt.compute_coupled_cell_flat(f2, f2, b) cl22_uncoupled = w22.decouple_cell(cl22_coupled) TT = cl00_uncoupled[0] TE = cl02_uncoupled[0] TB = cl02_uncoupled[1] EE = cl22_uncoupled[0] EB = cl22_uncoupled[1] BE = cl22_uncoupled[2] BB = cl22_uncoupled[3] if modedecomp: outroot = "/data/seclark/BlakesleySims/simdata/ModeDecomp/xcorrdata/" else: outroot = "/data/seclark/BlakesleySims/xcorrdata/" outfn = simkey + "_deglen{}_{}apod{}_EBpure{}{}.h5".format( deglen, apotype, aposcale, Epure, Bpure) with h5py.File(outroot + outfn, 'w') as f: TTdset = f.create_dataset(name='TT', data=TT) TEdset = f.create_dataset(name='TE', data=TE) TBdset = f.create_dataset(name='TB', data=TB) EEdset = f.create_dataset(name='EE', data=EE) EBdset = f.create_dataset(name='EB', data=EB) BEdset = f.create_dataset(name='BE', data=BE) BBdset = f.create_dataset(name='BB', data=BB) TTdset.attrs['deglen'] = deglen TTdset.attrs['Epure'] = Epure TTdset.attrs['Bpure'] = Bpure TTdset.attrs['ell_binned'] = ells_uncoupled
temp = read_map_bands(o.prefix_in + '_oc_' + c + '.fits', o.cont_oc_bands) for t in temp: temps.append(t) if temps == []: temps = None else: print(" - Will marginalize over a total of %d contaminant templates" % (len(temps))) #Remove mean for i_t, t in enumerate(temps): temps[i_t] -= np.sum(msk_t * mskfrac * t) / np.sum(msk_t * mskfrac) #Set binning scheme lini, lend = np.loadtxt(o.fname_ellbins, unpack=True) bpws = nmt.NmtBinFlat(lini, lend) ell_eff = bpws.get_effective_ells() #Generate tracers print("Generating tracers") class Tracer(object): def __init__(self, hdu_list, i_bin, fsk, mask_binary, masked_fraction, contaminants=None):
def run(self): """ Main function. This stage: - Produces measurements of the power spectrum with and without contaminant deprojections. - Estimates the noise bias - Estimates the covariance matrix - Estimates the deprojection bias """ self.parse_input() logger.info("Reading mask.") self.msk_bi, self.mskfrac, self.mp_depth = self.get_masks() logger.info("Computing area.") self.area_pix = np.radians(self.fsk.dx) * np.radians(self.fsk.dy) self.area_patch = np.sum(self.msk_bi * self.mskfrac) * self.area_pix self.lmax = int(180. * np.sqrt(1. / self.fsk.dx**2 + 1. / self.fsk.dy**2)) logger.info("Reading contaminants.") temps = self.get_contaminants() logger.info("Setting bandpowers.") lini = np.array(self.config['ell_bpws'])[:-1] lend = np.array(self.config['ell_bpws'])[1:] bpws = nmt.NmtBinFlat(lini, lend) ell_eff = bpws.get_effective_ells() self.nbands = ell_eff.shape[0] logger.info('Number of ell bands = {}.'.format(self.nbands)) tracers_nc, tracers_wc = self.get_all_tracers(temps) self.ntracers = len(tracers_nc) self.nmaps = self.ntracers_counts + self.ntracers_comptony + self.ntracers_kappa + 2 * self.ntracers_shear logger.info("Translating into SACC tracers.") tracers_sacc = self.get_sacc_tracers(tracers_wc) # Set up mapping self.mapping(tracers_nc) logger.info("Getting MCM.") wsp = self.get_mcm(tracers_nc, bpws) logger.info("Computing window functions.") windows = self.get_windows(tracers_nc, wsp) self.ncross = self.nmaps * (self.nmaps + 1) // 2 + self.ntracers_shear if self.config['gaus_covar_type'] == 'analytic': logger.info("Computing analytic covariance.") if not os.path.isfile( self.get_output_fname('power_spectra_wdpj', ext='sacc')): logger.info("Computing deprojected power spectra.") logger.info(" W. deprojections.") cls_wdpj, _ = self.get_power_spectra(tracers_wc, wsp, bpws) else: logger.info("Reading deprojected power spectra.") sacc_cls_wdpj = sacc.Sacc.load_fits( self.get_output_fname('power_spectra_wdpj', ext='sacc')) cls_wdpj = self.convert_sacc_to_clarr(sacc_cls_wdpj, tracers_sacc) if not os.path.isfile( self.get_output_fname('power_spectra_wodpj', ext='sacc')): logger.info("Computing non-deprojected power spectra.") logger.info(" No deprojections.") cls_wodpj, _ = self.get_power_spectra(tracers_nc, wsp, bpws) else: logger.info("Reading non-deprojected power spectra.") sacc_cls_wodpj = sacc.Sacc.load_fits( self.get_output_fname('power_spectra_wodpj', ext='sacc')) cls_wodpj = self.convert_sacc_to_clarr(sacc_cls_wodpj, tracers_sacc) logger.info("Getting guess power spectra.") lth, clth = self.get_cl_guess(ell_eff, cls_wdpj, tracers_sacc) cov_wodpj = self.get_covar(lth, clth, bpws, tracers_wc, wsp, None, None) cov_wdpj = cov_wodpj.copy() else: logger.info("Computing simulated covariance.") if not os.path.isfile( self.get_output_fname('power_spectra_wdpj', ext='sacc')): logger.info("Computing deprojected power spectra.") logger.info(" W. deprojections.") cls_wdpj, cls_wdpj_coupled = self.get_power_spectra( tracers_wc, wsp, bpws) else: logger.info("Reading deprojected power spectra.") sacc_cls_wdpj = sacc.Sacc.load_fits( self.get_output_fname('power_spectra_wdpj', ext='sacc')) cls_wdpj = self.convert_sacc_to_clarr(sacc_cls_wdpj, tracers_sacc) logger.info("Reading deprojected coupled power spectra.") sacc_cls_wdpj_coupled = sacc.Sacc.load_fits( self.get_output_fname('power_spectra_wdpj_coupled', ext='sacc')) cls_wdpj_coupled = self.convert_sacc_to_clarr( sacc_cls_wdpj_coupled, tracers_sacc) logger.info("Getting guess power spectra.") lth, clth = self.get_cl_guess(ell_eff, cls_wdpj, tracers_sacc) if os.path.isfile(self.get_output_fname('dpj_bias', ext='sacc')): sacc_cl_deproj_bias = sacc.Sacc.load_fits( self.get_output_fname('dpj_bias', ext='sacc')) cl_deproj_bias = self.convert_sacc_to_clarr( sacc_cl_deproj_bias, tracers_sacc) else: logger.info("Computing deprojection bias.") _, cl_deproj_bias = self.get_dpj_bias(tracers_wc, lth, clth, cls_wdpj_coupled, wsp, bpws) cov_wodpj = self.get_covar(lth, clth, bpws, tracers_wc, wsp, None, None) cov_wdpj = self.get_covar(lth, clth, bpws, tracers_wc, wsp, temps, cl_deproj_bias) # Write covariances into existing sacc if os.path.isfile( self.get_output_fname('power_spectra_wodpj', ext='sacc')): logger.info('{} provided.'.format( self.get_output_fname('power_spectra_wodpj', ext='sacc'))) logger.info('Adding deprojected covariance matrix to {}.'.format( self.get_output_fname('power_spectra_wodpj', ext='sacc'))) self.write_vector_to_sacc(self.get_output_fname( 'power_spectra_wodpj', ext='sacc'), tracers_sacc, cls_wodpj, ell_eff, windows, covar=cov_wodpj) logger.info('Written deprojected covariance matrix.') else: logger.info('{} not provided.'.format( self.get_output_fname('power_spectra_wodpj', ext='sacc'))) logger.info('Writing deprojected covariance matrix to {}.'.format( self.get_output_fname('cov_wodpj', ext='sacc'))) s_wodpj = sacc.Sacc() s_wodpj.add_covariance(cov_wodpj) s_wodpj.save_fits(self.get_output_fname('cov_wodpj', ext='sacc'), overwrite=True) logger.info('Written deprojected covariance matrix.') if os.path.isfile( self.get_output_fname('power_spectra_wdpj', ext='sacc')): logger.info('{} provided.'.format( self.get_output_fname('power_spectra_wdpj', ext='sacc'))) logger.info('Adding deprojected covariance matrix to {}.'.format( self.get_output_fname('power_spectra_wdpj', ext='sacc'))) self.write_vector_to_sacc(self.get_output_fname( 'power_spectra_wdpj', ext='sacc'), tracers_sacc, cls_wdpj, ell_eff, windows, covar=cov_wdpj) logger.info('Written deprojected covariance matrix.') else: logger.info('{} not provided.'.format( self.get_output_fname('power_spectra_wdpj', ext='sacc'))) logger.info( 'Writing non deprojected covariance matrix to {}.'.format( self.get_output_fname('cov_wdpj', ext='sacc'))) s_wdpj = sacc.Sacc() s_wdpj.add_covariance(cov_wdpj) s_wdpj.save_fits(self.get_output_fname('cov_wdpj', ext='sacc'), overwrite=True) logger.info('Written deprojected covariance matrix.') # Permissions on NERSC os.system( 'find /global/cscratch1/sd/damonge/GSKY/ -type d -exec chmod -f 777 {} \;' ) os.system( 'find /global/cscratch1/sd/damonge/GSKY/ -type f -exec chmod -f 666 {} \;' )
def setUp(self): self.nlb = 5 self.nbands = 399 larr = np.arange(self.nbands + 1) * self.nlb + 2 self.b = nmt.NmtBinFlat(larr[:-1], larr[1:])
def compute_wsps(self): """ Convenience method for calculating the NaMaster workspaces for all the probes in the simulation. :return wsps: wsps list """ wsps = [[None for i in range(self.params['nprobes'])] for ii in range(self.params['nprobes'])] maps = self.simmaps.generate_maps() b = nmt.NmtBinFlat(self.params['l0_bins'], self.params['lf_bins']) # Compute workspaces for all the probes for j in range(self.params['nprobes']): for jj in range(j + 1): spin1 = self.params['spins'][j] spin2 = self.params['spins'][jj] logger.info('Spins: spin1 = {}, spin2 = {}.'.format( spin1, spin2)) if spin1 == 2 and spin2 == 0: # Define flat sky spin-2 field emaps = [maps[j], maps[j + self.params['nspin2']]] f2_1 = nmt.NmtFieldFlat(self.params['Lx'], self.params['Ly'], self.maskmat[j, jj], emaps, purify_b=False) # Define flat sky spin-0 field emaps = [maps[jj]] f0_1 = nmt.NmtFieldFlat(self.params['Lx'], self.params['Ly'], self.maskmat[j, jj], emaps, purify_b=False) logger.info('Computing workspace element.') wsp = nmt.NmtWorkspaceFlat() wsp.compute_coupling_matrix(f2_1, f0_1, b) wsps[j][jj] = wsp if j != jj: wsps[jj][j] = wsp elif spin1 == 2 and spin2 == 2: # Define flat sky spin-2 field emaps = [maps[j], maps[j + self.params['nspin2']]] f2_1 = nmt.NmtFieldFlat(self.params['Lx'], self.params['Ly'], self.maskmat[j, jj], emaps, purify_b=False) # Define flat sky spin-0 field emaps = [maps[jj], maps[jj + self.params['nspin2']]] f2_2 = nmt.NmtFieldFlat(self.params['Lx'], self.params['Ly'], self.maskmat[j, jj], emaps, purify_b=False) logger.info('Computing workspace element.') wsp = nmt.NmtWorkspaceFlat() wsp.compute_coupling_matrix(f2_1, f2_2, b) wsps[j][jj] = wsp if j != jj: wsps[jj][j] = wsp else: # Define flat sky spin-0 field emaps = [maps[j]] f0_1 = nmt.NmtFieldFlat(self.params['Lx'], self.params['Ly'], self.maskmat[j, jj], emaps, purify_b=False) # Define flat sky spin-0 field emaps = [maps[jj]] f0_2 = nmt.NmtFieldFlat(self.params['Lx'], self.params['Ly'], self.maskmat[j, jj], emaps, purify_b=False) logger.info('Computing workspace element.') wsp = nmt.NmtWorkspaceFlat() wsp.compute_coupling_matrix(f0_1, f0_2, b) wsps[j][jj] = wsp if j != jj: wsps[jj][j] = wsp return wsps