def test_workspace_covar_spin0(): # Compute all coefficients cw1 = nmt.NmtCovarianceWorkspace() cw1.compute_coupling_coefficients(CT.f0, CT.f2) # Write to file cw1.write_to("cwsp_test.fits") # Only spin-0 cw2 = nmt.NmtCovarianceWorkspace() cw2.compute_coupling_coefficients(CT.f0, CT.f2, spin0_only=True) # Read only spin-0 from file cw3 = nmt.NmtCovarianceWorkspace() cw3.read_from("cwsp_test.fits", force_spin0_only=True) # Spin-0 matrices c1 = nmt.gaussian_covariance(cw1, 0, 0, 0, 0, [CT.cltt], [CT.cltt], [CT.cltt], [CT.cltt], CT.w) c2 = nmt.gaussian_covariance(cw2, 0, 0, 0, 0, [CT.cltt], [CT.cltt], [CT.cltt], [CT.cltt], CT.w) c3 = nmt.gaussian_covariance(cw3, 0, 0, 0, 0, [CT.cltt], [CT.cltt], [CT.cltt], [CT.cltt], CT.w) assert np.all(c1 == c2) assert np.all(c1 == c3) # Errors thrown otherwise # This should be fine c1 = nmt.gaussian_covariance(cw1, 0, 2, 0, 2, [CT.cltt], [CT.clte, 0 * CT.clte], [CT.clte, 0 * CT.clte], [CT.clee, 0 * CT.clee, 0 * CT.clee, CT.clbb], CT.w02, wb=CT.w02) # These shouldn't with pytest.raises(RuntimeError): nmt.gaussian_covariance(cw2, 0, 2, 0, 2, [CT.cltt], [CT.clte, 0 * CT.clte], [CT.clte, 0 * CT.clte], [CT.clee, 0 * CT.clee, 0 * CT.clee, CT.clbb], CT.w02, wb=CT.w02) with pytest.raises(RuntimeError): nmt.gaussian_covariance(cw3, 0, 2, 0, 2, [CT.cltt], [CT.clte, 0 * CT.clte], [CT.clte, 0 * CT.clte], [CT.clee, 0 * CT.clee, 0 * CT.clee, CT.clbb], CT.w02, wb=CT.w02)
def test_workspace_covar_errors(): cw = nmt.NmtCovarianceWorkspace() with pytest.raises(ValueError): # Write uninitialized cw.write_to("wsp.fits") cw.compute_coupling_coefficients(CT.f0, CT.f0) # All good assert cw.wsp.lmax == CT.w.wsp.lmax assert cw.wsp.lmax == CT.w.wsp.lmax cw.read_from('test/benchmarks/bm_nc_np_cw00.fits') # Correct reading assert cw.wsp.lmax == CT.w.wsp.lmax assert cw.wsp.lmax == CT.w.wsp.lmax # gaussian_covariance with pytest.raises(ValueError): # Wrong input cl size nmt.gaussian_covariance(cw, 0, 0, 0, 0, [CT.cltt], [CT.cltt], [CT.cltt], [CT.cltt[:15]], CT.w) with pytest.raises(ValueError): # Wrong input cl shapes nmt.gaussian_covariance(cw, 0, 0, 0, 0, [CT.cltt], [CT.cltt], [CT.cltt], [CT.cltt, CT.cltt], CT.w) with pytest.raises(ValueError): # Wrong input spins nmt.gaussian_covariance(cw, 0, 2, 0, 0, [CT.cltt], [CT.cltt], [CT.cltt], [CT.cltt, CT.cltt], CT.w) with pytest.raises(RuntimeError): # Incorrect reading cw.read_from('none') with pytest.raises(ValueError): # Incompatible resolutions cw.compute_coupling_coefficients(CT.f0, CT.f0_half)
def get_cw_sn(b_a1, b_a2, b_b1, b_b2, n_a1, n_a2, n_b1, n_b2): name = "%d%d_%d%d" % (b_a1, b_a2, b_b1, b_b2) name += "_%d%d_%d%d" % (n_a1, n_a2, n_b1, n_b2) fields_a = [fields_s, fields_n] if name in cw_sn: pass else: cw_sn[name] = nmt.NmtCovarianceWorkspace() fname_cmcm = prefix_cmcm + name + '_ns%d.fits' % o.nside if os.path.isfile(fname_cmcm): printflush(" - Reading") cw_sn[name].read_from(fname_cmcm) else: printflush(" - Fields") if b_a1 not in fields_a[n_a1]: fields_a[n_a1][b_a1] = get_field(b_a1, mask_sigma=bool(n_a1)) if b_a2 not in fields_a[n_a2]: fields_a[n_a2][b_a2] = get_field(b_a2, mask_sigma=bool(n_a2)) if b_b1 not in fields_a[n_b1]: fields_a[n_b1][b_b1] = get_field(b_b1, mask_sigma=bool(n_b1)) if b_b2 not in fields_a[n_b2]: fields_a[n_b2][b_b2] = get_field(b_b2, mask_sigma=bool(n_b2)) printflush(" - Computing " + name) cw_sn[name].compute_coupling_coefficients(fields_a[n_a1][b_a1], fields_a[n_a2][b_a2], fields_a[n_b1][b_b1], fields_a[n_b2][b_b2]) cw_sn[name].write_to(fname_cmcm)
def test_workspace_covar_errors(self): cw = nmt.NmtCovarianceWorkspace() with self.assertRaises(ValueError): # Write uninitialized cw.write_to("wsp.fits") cw.compute_coupling_coefficients(self.f0, self.f0) # All good self.assertEqual(cw.wsp.lmax, self.w.wsp.lmax) self.assertEqual(cw.wsp.lmax, self.w.wsp.lmax) with self.assertRaises(RuntimeError): # Write uninitialized cw.write_to("tests/wsp.fits") cw.read_from('test/benchmarks/bm_nc_np_cw00.fits') # Correct reading self.assertEqual(cw.wsp.lmax, self.w.wsp.lmax) self.assertEqual(cw.wsp.lmax, self.w.wsp.lmax) # gaussian_covariance with self.assertRaises(ValueError): # Wrong input cl size nmt.gaussian_covariance(cw, 0, 0, 0, 0, [self.cltt], [self.cltt], [self.cltt], [self.cltt[:15]], self.w) with self.assertRaises(ValueError): # Wrong input cl shapes nmt.gaussian_covariance(cw, 0, 0, 0, 0, [self.cltt], [self.cltt], [self.cltt], [self.cltt, self.cltt], self.w) with self.assertRaises(ValueError): # Wrong input spins nmt.gaussian_covariance(cw, 0, 2, 0, 0, [self.cltt], [self.cltt], [self.cltt], [self.cltt, self.cltt], self.w) with self.assertRaises(RuntimeError): # Incorrect reading cw.read_from('none') with self.assertRaises(ValueError): # Incompatible resolutions cw.compute_coupling_coefficients(self.f0, self.f0_half)
def get_covariance_workspace(self): mask1, mask2 = self.clA1A2.get_masks_names() mask3, mask4 = self.clB1B2.get_masks_names() fname = os.path.join(self.outdir, f'cw__{mask1}__{mask2}__{mask3}__{mask4}.fits') cw = nmt.NmtCovarianceWorkspace() recompute = self.data.data['recompute']['cmcm'] if recompute or (not os.path.isfile(fname)): n_iter = self.data.data['sphere']['n_iter_cmcm'] l_toeplitz, l_exact, dl_band = self.data.check_toeplitz('cov') fA1, fB1 = self.clA1B1.get_nmt_fields() fA2, fB2 = self.clA2B2.get_nmt_fields() cw.compute_coupling_coefficients(fA1, fA2, fB1, fB2, n_iter=n_iter, l_toeplitz=l_toeplitz, l_exact=l_exact, dl_band=dl_band) # Recheck again in case other process has started writing it if (not os.path.isfile(fname)): cw.write_to(fname) self.recompute_cmcm = False else: cw.read_from(fname) return cw
def compute_subcovmat(self, spins): cw = nmt.NmtCovarianceWorkspace() cw.compute_coupling_coefficients( self.get_field(self.namap1, spins[0]), self.get_field(self.namap2, spins[1]), self.get_field(self.namap1, spins[2]), self.get_field(self.namap2, spins[3]), lmax=self.lmax, ) a1b1, a1b2, a2b1, a2b2 = self.get_cov_input_spectra(spins) ordering_a = self.ordering[(spins[0], spins[1])] ordering_b = self.ordering[(spins[2], spins[3])] covar = nmt.gaussian_covariance( cw, spins[0], spins[1], spins[2], spins[3], a1b1, a1b2, a2b1, a2b2, self.mc_12.workspace_dict[(spins[0], spins[1])], wb=self.mc_12.workspace_dict[(spins[2], spins[3])], ).reshape( [self.num_ell, len(ordering_a), self.num_ell, len(ordering_b)]) for i, AB in enumerate(ordering_a): for j, CD in enumerate(ordering_b): self.covmat[AB + CD] = covar[:, i, :, j]
def get_covariance_coeff(self): if self.cw is None: cw = nmt.NmtCovarianceWorkspace() cw.compute_coupling_coefficients(self.f0, self.f0, self.f0, self.f0, lmax=self.lmax) self.cw = cw
def get_cmcm(f1, f2, f3, f4): fname = p.get_fname_cmcm(f1, f2, f3, f4) cmcm = nmt.NmtCovarianceWorkspace() try: cmcm.read_from(fname) except: # print(" Computing CMCM") cmcm.compute_coupling_coefficients(f1.field, f2.field, f3.field, f4.field) cmcm.write_to(fname) return cmcm
def test_workspace_covar_benchmark(self): cw = nmt.NmtCovarianceWorkspace() cw.compute_coupling_coefficients(self.w, self.w) covar = nmt.gaussian_covariance(cw, self.cltt, self.cltt, self.cltt, self.cltt) covar_bench = np.loadtxt("test/benchmarks/bm_nc_np_cov.txt", unpack=True) self.assertTrue( (np.fabs(covar - covar_bench) <= np.fmin(np.fabs(covar), np.fabs(covar_bench)) * 1E-5).all())
def get_cmcm(p, f1, f2, f3, f4): fname = p.get_fname_cmcm(f1.mask_id, f2.mask_id, f3.mask_id, f4.mask_id) cmcm = nmt.NmtCovarianceWorkspace() try: cmcm.read_from(fname) except: cmcm.compute_coupling_coefficients(f1.field, f2.field, f3.field, f4.field) try: cmcm.write_to(fname) except RuntimeError: pass return cmcm
def get_workspace(self, fields): fname, found = self._get_workspace_file(self.msks_1, self.msks_2) cw = nmt.NmtCovarianceWorkspace() if found and (not self.recompute): cw.read_from(fname) else: print("Computing " + fname) cw.compute_coupling_coefficients( fields[self.tracers_1[0]].get_field(), fields[self.tracers_1[1]].get_field(), fields[self.tracers_2[0]].get_field(), fields[self.tracers_2[1]].get_field()) cw.write_to(fname) return cw
def get_covariance_workspace(self, typ1, typ2): tttt = typ1 + typ2 fname = self.get_clfile_name(tttt, 'cwsp', 'fits') cwsp = nmt.NmtCovarianceWorkspace() if not os.path.isfile(fname): if 'g' in tttt: self.get_delta_field() if 'k' in tttt: self.get_kappa_field() fl = {'g': self.f_d, 'k': self.f_k} t1, t2, t3, t4 = tttt cwsp.compute_coupling_coefficients(fl[t1], fl[t2], fl[t3], fl[t4], **(self.toe_cov)) cwsp.write_to(fname) else: cwsp.read_from(fname) return cwsp
def get_cw_nn(b_a1, b_a2, b_b1, b_b2): name = "%d%d_%d%d" % (b_a1, b_a2, b_b1, b_b2) if name in cw_nn: pass else: cw_nn[name] = nmt.NmtCovarianceWorkspace() fname_cmcm = prefix_cmcm + name + '_ns%d.fits' % o.nside if os.path.isfile(fname_cmcm): printflush(" - Reading") cw_nn[name].read_from(fname_cmcm) else: printflush(" - Fields") for b in [b_a1, b_a2, b_b1, b_b2]: fields_n[b] = get_field(b, mask_sigma=True) printflush(" - Computing " + name) cw_nn[name].compute_coupling_coefficients(fields_n[b_a1], fields_n[b_a2], fields_n[b_b1], fields_n[b_b2]) cw_nn[name].write_to(fname_cmcm)
def gcov_make(fa1, fa2, fb1, fb2, wa, wb, cla1b1, cla1b2, cla2b1, cla2b2, n_ell): """Returns the Gaussian covariance matrix fa1fa2_fb1fb2 """ cw = nmt.NmtCovarianceWorkspace() cw.compute_coupling_coefficients(fa1, fb1, fa2, fb2) cov = nmt.gaussian_covariance( cw, 2, 2, 2, 2, # Spins of the 4 fields # EE, EB, BE, BB cla1b1, cla1b2, cla2b1, cla2b2, wa, wb=wb).reshape([n_ell, 4, n_ell, 4]) return cov
def test_workspace_covar_errors(self): cw = nmt.NmtCovarianceWorkspace() with self.assertRaises(ValueError): #Write uninitialized cw.write_to("wsp.dat") cw.compute_coupling_coefficients(self.w, self.w) #All good self.assertEqual(cw.wsp.cs.n_eq, self.w.wsp.cs.n_eq) self.assertEqual(cw.wsp.lmax_a, self.w.wsp.lmax) self.assertEqual(cw.wsp.lmax_b, self.w.wsp.lmax) with self.assertRaises(RuntimeError): #Write uninitialized cw.write_to("tests/wsp.dat") cw.read_from('test/benchmarks/bm_nc_np_cw00.dat') #Correct reading self.assertEqual(cw.wsp.cs.n_eq, self.w.wsp.cs.n_eq) self.assertEqual(cw.wsp.lmax_a, self.w.wsp.lmax) self.assertEqual(cw.wsp.lmax_b, self.w.wsp.lmax) #gaussian_covariance with self.assertRaises(ValueError): #Wrong input power spectra nmt.gaussian_covariance(cw, self.cltt, self.cltt, self.cltt, self.cltt[:15]) with self.assertRaises(RuntimeError): #Incorrect reading cw.read_from('none') w2 = nmt.NmtWorkspace() w2.read_from("test/benchmarks/bm_nc_np_w00.dat") w2.wsp.cs.n_eq = self.w.wsp.cs.n_eq // 2 with self.assertRaises(ValueError): #Incompatible resolutions cw.compute_coupling_coefficients(self.w, w2) w2.wsp.cs.n_eq = self.w.wsp.cs.n_eq w2.wsp.lmax = self.w.wsp.lmax // 2 with self.assertRaises(RuntimeError): #Incompatible resolutions cw.compute_coupling_coefficients(self.w, w2) w2.wsp.lmax = self.w.wsp.lmax w2.read_from("test/benchmarks/bm_nc_np_w02.dat") with self.assertRaises(ValueError): #Spin-2 cw.compute_coupling_coefficients(self.w, w2)
def generate_covariance_workspace00(run_path, fa1, fa2, flat=False): if flat: w00 = nmt.NmtWorkspaceFlat() cw00 = nmt.NmtCovarianceWorkspaceFlat() else: w00 = nmt.NmtWorkspace() cw00 = nmt.NmtCovarianceWorkspace() w00.read_from(run_path + "_w00.dat") cw00_file = run_path + "_cw00.dat" if not os.path.isfile(cw00_file): if flat: raise ValueError('flat not implemented yet') # cw00.compute_coupling_coefficients(w00, w00) else: cw00.compute_coupling_coefficients(fa1, fa2) cw00.write_to(cw00_file) else: cw00.read_from(cw00_file) return w00, cw00
def get_covariance_workspace(self): mask1 = os.path.basename(self.data['tracers'][self.trA1]['mask']) mask2 = os.path.basename(self.data['tracers'][self.trA2]['mask']) mask3 = os.path.basename(self.data['tracers'][self.trB1]['mask']) mask4 = os.path.basename(self.data['tracers'][self.trB2]['mask']) # Remove the extension mask1 = os.path.splitext(mask1)[0] mask2 = os.path.splitext(mask2)[0] mask3 = os.path.splitext(mask3)[0] mask4 = os.path.splitext(mask4)[0] fname = os.path.join( self.outdir, 'cw__{}__{}__{}__{}.fits'.format(mask1, mask2, mask3, mask4)) cw = nmt.NmtCovarianceWorkspace() if not os.path.isfile(fname): n_iter = self.data['healpy']['n_iter_cmcm'] if 'toeplizt' in self.data: l_toeplitz = self.data['toeplizt']['l_toeplitz'] l_exact = self.data['toeplizt']['l_exact'] dl_band = self.data['toeplizt']['dl_band'] else: l_toeplitz = l_exact = dl_band = -1 fA1, fB1 = self.clA1B1.get_fields() fA2, fB2 = self.clA2B2.get_fields() cw.compute_coupling_coefficients(fA1.f, fA2.f, fB1.f, fB2.f, n_iter=n_iter, l_toeplitz=l_toeplitz, l_exact=l_exact, dl_band=dl_band) cw.write_to(fname) else: cw.read_from(fname) return cw
def set_covariance_matrices(self): correlation_pairs = get_pairs(self.correlation_symbols, join_with='-') for correlation_pair in tqdm(correlation_pairs, desc='covariance matrices'): a1 = correlation_pair[0] a2 = correlation_pair[1] b1 = correlation_pair[3] b2 = correlation_pair[4] covariance_workspace = nmt.NmtCovarianceWorkspace() covariance_workspace.compute_coupling_coefficients( self.fields[a1], self.fields[a2], self.fields[b1], self.fields[b2]) self.covariance_matrices[ correlation_pair] = nmt.gaussian_covariance( covariance_workspace, 0, 0, 0, 0, [self.theory_correlations[''.join(sorted([a1, b1]))]], [self.theory_correlations[''.join(sorted([a1, b2]))]], [self.theory_correlations[''.join(sorted([a2, b1]))]], [self.theory_correlations[''.join(sorted([a2, b2]))]], wa=self.workspaces[a1 + a2], wb=self.workspaces[b1 + b2], ) transpose_corr_symbol = b1 + b2 + '-' + a1 + a2 self.covariance_matrices[transpose_corr_symbol] = np.transpose( self.covariance_matrices[correlation_pair]) if a1 + a2 == b1 + b2: self.correlation_matrices[ correlation_pair] = get_correlation_matrix( self.covariance_matrices[correlation_pair])
k = '%d%d' % (o.bin_a1, o.bin_b2) if k not in clt: clt[k] = get_cl(tracers, o.bin_a1, o.bin_b2) k = '%d%d' % (o.bin_a2, o.bin_b1) if k not in clt: clt[k] = get_cl(tracers, o.bin_a2, o.bin_b1) k = '%d%d' % (o.bin_a2, o.bin_b2) if k not in clt: clt[k] = get_cl(tracers, o.bin_a2, o.bin_b2) printflush("CMCM") fname_cmcm = predir + 'cls_metacal_cmcm_bins_' fname_cmcm += '%d%d_%d%d_ns%d.fits' % (o.bin_a1, o.bin_a2, o.bin_b1, o.bin_b2, o.nside) cw = nmt.NmtCovarianceWorkspace() fields_s = {} fields_n = {} if os.path.isfile(fname_cmcm) and not o.recompute_mcm: printflush(" - Reading") cw.read_from(fname_cmcm) else: printflush(" - Fields") if o.bin_a1 not in fields_s: fields_s[o.bin_a1] = get_field(o.bin_a1) if o.bin_a2 not in fields_s: fields_s[o.bin_a2] = get_field(o.bin_a2) if o.bin_b1 not in fields_s: fields_s[o.bin_b1] = get_field(o.bin_b1) if o.bin_b2 not in fields_s: fields_s[o.bin_b2] = get_field(o.bin_b2)
w02.read_from(prefix_out + "_w02_02.dat") w22 = nmt.NmtWorkspace() if not os.path.isfile(prefix_out + "_w22_22.dat"): #spin0-spin2 print("Computing w22") w22.compute_coupling_matrix(f2, f2, b, n_iter=o.n_iter) w22.write_to(prefix_out + "_w22_22.dat") else: w22.read_from(prefix_out + "_w22_22.dat") ############################################################################## # Compute covariance (only depends on the masks) ############################################################################## if not os.path.isfile(prefix_out + '_covTh{}.npz'.format('old' if o.oldcov else '')): cw00_00 = nmt.NmtCovarianceWorkspace() if not os.path.isfile(prefix_out + "_cw0000.dat"): # mask0-mask0-mask0-mask0 print("Computing cw0000") cw00_00.compute_coupling_coefficients(f0, f0, f0, f0, n_iter=o.n_iter) cw00_00.write_to(prefix_out + "_cw0000.dat") else: cw00_00.read_from(prefix_out + '_cw0000.dat') cw00_02 = nmt.NmtCovarianceWorkspace() if not os.path.isfile(prefix_out + "_cw0002.dat"): # mask0-mask0-mask0-mask2 print("Computing cw0002") cw00_02.compute_coupling_coefficients(f0, f0, f0, f2, n_iter=o.n_iter) cw00_02.write_to(prefix_out + "_cw0002.dat") else:
def test_workspace_covar_benchmark(self): def compare_covars(c, cb): # Check first and second diagonals for k in [0, 1]: d = np.diag(c, k=k) db = np.diag(cb, k=k) self.assertTrue( (np.fabs(d - db) <= np.fmin(np.fabs(d), np.fabs(db)) * 1E-4).all()) # Check against a benchmark cw = nmt.NmtCovarianceWorkspace() cw.compute_coupling_coefficients(self.f0, self.f0) # [0,0 ; 0,0] covar = nmt.gaussian_covariance(cw, 0, 0, 0, 0, [self.cltt], [self.cltt], [self.cltt], [self.cltt], self.w) covar_bench = np.loadtxt("test/benchmarks/bm_nc_np_cov.txt", unpack=True) compare_covars(covar, covar_bench) # [0,2 ; 0,2] covar = nmt.gaussian_covariance( cw, 0, 2, 0, 2, [self.cltt], [self.clte, 0 * self.clte], [self.clte, 0 * self.clte], [self.clee, 0 * self.clee, 0 * self.clee, self.clbb], self.w02, wb=self.w02) covar_bench = np.loadtxt("test/benchmarks/bm_nc_np_cov0202.txt") compare_covars(covar, covar_bench) # [0,0 ; 0,2] covar = nmt.gaussian_covariance(cw, 0, 0, 0, 2, [self.cltt], [self.clte, 0 * self.clte], [self.cltt], [self.clte, 0 * self.clte], self.w, wb=self.w02) covar_bench = np.loadtxt("test/benchmarks/bm_nc_np_cov0002.txt") compare_covars(covar, covar_bench) # [0,0 ; 2,2] covar = nmt.gaussian_covariance(cw, 0, 0, 2, 2, [self.clte, 0 * self.clte], [self.clte, 0 * self.clte], [self.clte, 0 * self.clte], [self.clte, 0 * self.clte], self.w, wb=self.w22) covar_bench = np.loadtxt("test/benchmarks/bm_nc_np_cov0022.txt") compare_covars(covar, covar_bench) # [2,2 ; 2,2] covar = nmt.gaussian_covariance( cw, 2, 2, 2, 2, [self.clee, 0 * self.clee, 0 * self.clee, self.clbb], [self.clee, 0 * self.clee, 0 * self.clee, self.clbb], [self.clee, 0 * self.clee, 0 * self.clee, self.clbb], [self.clee, 0 * self.clee, 0 * self.clee, self.clbb], self.w22, wb=self.w22) covar_bench = np.loadtxt("test/benchmarks/bm_nc_np_cov2222.txt") compare_covars(covar, covar_bench)
def test_cls_vs_namaster(): # cls # Get cl from randomnly generated map ("data") cl_class = get_cl_class() ell, cl_data = cl_class.get_ell_cl() b = cl_class.get_NmtBin() win = cl_class.get_bandpower_windows() # Read output clfile = np.load(os.path.join(tmpdir1, 'Dummy_Dummy', 'cl_Dummy__0_Dummy__0.npz')) shutil.rmtree(tmpdir1) # Compute covariance cov_class = get_cov_class() cov = cov_class.get_covariance() shutil.rmtree(tmpdir1) # NaMaster config = get_config() conf = config['tracers']['Dummy__0'] conf['nside'] = config['sphere']['nside'] conf['coords'] = config['sphere']['coords'] m = MapperDummy(conf) # True cl cl_m = m.get_cl() spin = m.get_spin() mask = m.get_mask() signal_map = m.get_signal_map() n_iter_sht = config['sphere']['n_iter_sht'] n_iter_mcm = config['sphere']['n_iter_mcm'] n_iter_cmcm = config['sphere']['n_iter_cmcm'] # Compute Cl from map f = nmt.NmtField(mask, signal_map, spin=spin, n_iter=n_iter_sht) wsp = nmt.NmtWorkspace() wsp.compute_coupling_matrix(f, f, bins=b, n_iter=n_iter_mcm) cl_data_nmt_cp = nmt.compute_coupled_cell(f, f) cl_data_nmt = wsp.decouple_cell(cl_data_nmt_cp) # Couple true Cl cl_m_cp = wsp.couple_cell([cl_m]) cl_m = wsp.decouple_cell(cl_m_cp) # Compute cov with NaMaster cwsp = nmt.NmtCovarianceWorkspace() cwsp.compute_coupling_coefficients(f, f, n_iter=n_iter_cmcm) cl_cov = cl_m_cp / np.mean(mask * mask) cov_nmt = nmt.gaussian_covariance(cwsp, spin, spin, spin, spin, cl_cov, cl_cov, cl_cov, cl_cov, wsp) bpwin = wsp.get_bandpower_windows() icov_nmt = np.linalg.inv(cov_nmt) def compare(cl, cv, wn, tol=1E-5): rdev = cl / cl_data_nmt - 1 assert np.max(np.abs(rdev)) < tol # Compare cl and covariance icov = np.linalg.inv(cv) dCl = (cl - cl_m)[0] chi2 = dCl.dot(icov).dot(dCl) chi2_m = dCl.dot(icov_nmt).dot(dCl) assert np.fabs(chi2/chi2_m-1) < tol # Compare bandpower windows assert np.all(win == bpwin) compare(cl_data, cov, win) compare(clfile['cl'], cov, clfile['wins']) assert np.allclose(clfile['cl_cp'], cl_data_nmt_cp, atol=0) assert np.allclose(clfile['cl_cov_cp'], cl_data_nmt_cp, atol=0) assert np.allclose(clfile['cl_cov_11_cp'], cl_data_nmt_cp, atol=0) assert np.allclose(clfile['cl_cov_12_cp'], cl_data_nmt_cp, atol=0) assert np.allclose(clfile['cl_cov_22_cp'], cl_data_nmt_cp, atol=0)
def compute_covariance_full(clTh, nls_all, nbpw, nbins, maps_bins, maps_spins, maps_masks, masks): nmaps = len(maps_bins) fname_cw_old = '' cl_indices = [] cl_spins = [] cl_bins = [] cl_masks = [] for i in range(nmaps): si = maps_spins[i] for j in range(i, nmaps): if (maps_masks[i] == 0) and (maps_masks[j] == 0) and ( i != j): # Don't compute gcX-gcY for X!=Y print('Skipping', i, j) continue sj = maps_spins[j] cl_indices.append([i, j]) cl_spins.append([si, sj]) cl_bins.append([maps_bins[i], maps_bins[j]]) cl_masks.append([maps_masks[i], maps_masks[j]]) cov_indices = [] cov_spins = [] cov_bins = [] cov_masks = [] for i, clij in enumerate(cl_indices): for j, clkl in enumerate(cl_indices[i:], i): cov_indices.append(cl_indices[i] + cl_indices[j]) cov_spins.append(cl_spins[i] + cl_spins[j]) cov_bins.append(cl_bins[i] + cl_bins[j]) cov_masks.append(cl_masks[i] + cl_masks[j]) cov_indices = np.array(cov_indices) cov_spins = np.array(cov_spins) cov_bins = np.array(cov_bins) cov_masks = np.array(cov_masks) old_workspaces = None old_masks = None for i, indices in enumerate(cov_indices): s_a1, s_a2, s_b1, s_b2 = cov_spins[i] m_a1, m_a2, m_b1, m_b2 = cov_masks[i] na1 = get_nelems_spin(s_a1) na2 = get_nelems_spin(s_a2) nb1 = get_nelems_spin(s_b1) nb2 = get_nelems_spin(s_b2) bin_a1, bin_a2, bin_b1, bin_b2 = cov_bins[i] fname = os.path.join( outdir, 'cov_s{}{}{}{}_b{}{}{}{}.npz'.format(*cov_spins[i], *cov_bins[i])) if os.path.isfile(fname): continue ibin_a1 = np.where(maps_bins == bin_a1)[0][0] ibin_a2 = np.where(maps_bins == bin_a2)[0][0] ibin_b1 = np.where(maps_bins == bin_b1)[0][0] ibin_b2 = np.where(maps_bins == bin_b2)[0][0] cla1b1 = np.concatenate(clTh[ibin_a1:ibin_a1 + na1, ibin_b1:ibin_b1 + nb1]) cla1b2 = np.concatenate(clTh[ibin_a1:ibin_a1 + na1, ibin_b2:ibin_b2 + nb2]) cla2b1 = np.concatenate(clTh[ibin_a2:ibin_a2 + na2, ibin_b1:ibin_b1 + nb1]) cla2b2 = np.concatenate(clTh[ibin_a2:ibin_a2 + na2, ibin_b2:ibin_b2 + nb2]) nla1b1 = np.concatenate(nls_all[ibin_a1:ibin_a1 + na1, ibin_b1:ibin_b1 + nb1]) nla1b2 = np.concatenate(nls_all[ibin_a1:ibin_a1 + na1, ibin_b2:ibin_b2 + nb2]) nla2b1 = np.concatenate(nls_all[ibin_a2:ibin_a2 + na2, ibin_b1:ibin_b1 + nb1]) nla2b2 = np.concatenate(nls_all[ibin_a2:ibin_a2 + na2, ibin_b2:ibin_b2 + nb2]) ##### Couple Cl wa1b1, wa1b2, wa2b1, wa2b2, wa, wb = get_workspaces_waXbY( m_a1, m_a2, m_b1, m_b2, old_masks, old_workspaces) # Free space!! old_masks = {} old_workspaces = {} # cla1b1 = wa1b1.couple_cell(cla1b1) cla1b2 = wa1b2.couple_cell(cla1b2) cla2b1 = wa2b1.couple_cell(cla2b1) cla2b2 = wa2b2.couple_cell(cla2b2) ##### #### Weight the Cls cla1b1 = (cla1b1 + nla1b1) / np.mean(masks[m_a1] * masks[m_b1]) cla1b2 = (cla1b2 + nla1b2) / np.mean(masks[m_a1] * masks[m_b2]) cla2b1 = (cla2b1 + nla2b1) / np.mean(masks[m_a2] * masks[m_b1]) cla2b2 = (cla2b2 + nla2b2) / np.mean(masks[m_a2] * masks[m_b2]) #### fname_cw = os.path.join(obsdir, 'cw{}{}{}{}.dat'.format(*cov_masks[i])) if fname_cw != fname_cw_old: cw = nmt.NmtCovarianceWorkspace() cw.read_from(fname_cw) fname_cw_old = fname_cw # cla1b1_label = np.concatenate(Cls[ibin_a1 : ibin_a1 + na1, ibin_b1 : ibin_b1 + nb1]) # cla1b2_label = np.concatenate(Cls[ibin_a1 : ibin_a1 + na1, ibin_b2 : ibin_b2 + nb2]) # cla2b1_label = np.concatenate(Cls[ibin_a2 : ibin_a2 + na2, ibin_b1 : ibin_b1 + nb1]) # cla2b2_label = np.concatenate(Cls[ibin_a2 : ibin_a2 + na2, ibin_b2 : ibin_b2 + nb2]) # print(np.concatenate(cla1b1)) # print(np.concatenate(cla1b2)) # print(np.concatenate(cla2b1)) # print(np.concatenate(cla2b2)) print('Computing {}'.format(fname)) # print('spins: ', s_a1, s_a2, s_b1, s_b2) # print('cla1b1', (s_a1, s_b1), cla1b1.shape, ibin_a1, ibin_a1 + na1, ibin_b1, ibin_b1 + nb1, cla1b1_label) # print('cla1b2', (s_a1, s_b2), cla1b2.shape, ibin_a1, ibin_a1 + na1, ibin_b2, ibin_b2 + nb2, cla1b2_label) # print('cla2b1', (s_a2, s_b1), cla2b1.shape, ibin_a2, ibin_a2 + na2, ibin_b1, ibin_b1 + nb1, cla2b1_label) # print('cla2b2', (s_a2, s_b2), cla2b2.shape, ibin_a2, ibin_a2 + na2, ibin_b2, ibin_b2 + nb2, cla2b2_label) cov = nmt.gaussian_covariance(cw, int(s_a1), int(s_a2), int(s_b1), int(s_b2), cla1b1, cla1b2, cla2b1, cla2b2, wa, wb) np.savez_compressed(fname, cov) tracer_names = [co.get_tracer_name(ibin) for ibin in cov_bins[i]] fname_new = os.path.join(outdir, 'cov_{}_{}_{}_{}.npz'.format(*tracer_names)) # TT -> 0; TE -> 0; EE -> 0 np.savez_compressed( fname_new, cov.reshape((nbpw, na1 * na2, nbpw, nb1 * nb2))[:, 0, :, 0]) print('Computed {}'.format(fname_new)) old_masks = { 'a1': m_a1, 'a_2': m_a2, 'b1': m_b1, 'b2': m_b2, 'a1a2': [m_a1, m_a2], 'b1b2': [m_b1, m_b2], 'a1b1': [m_a1, m_b1], 'a1b2': [m_a1, m_b2], 'a2b1': [m_a2, m_b1], 'a2b2': [m_a2, m_b2] } old_workspaces = { 'a1b1': wa1b1, 'a1b2': wa1b2, 'a2b1': wa2b1, 'a2b2': wa2b2, 'a1a2': wa, 'b1b2': wb, 'wa': wa, 'wb': wb }
def compute_covariance_full(nmaps, nbins, maps_bins, maps_spins): cl_indices = [] cl_spins = [] cl_bins = [] for i in range(nmaps): si = maps_spins[i] for j in range(i, nmaps): sj = maps_spins[j] cl_indices.append([i, j]) cl_spins.append([si, sj]) cl_bins.append([maps_bins[i], maps_bins[j]]) cov_indices = [] cov_spins = [] cov_bins = [] for i, clij in enumerate(cl_indices): for j, clkl in enumerate(cl_indices[i:]): cov_indices.append(cl_indices[i] + cl_indices[i + j]) cov_spins.append(cl_spins[i] + cl_spins[i + j]) cov_bins.append(cl_bins[i] + cl_bins[i + j]) cov_indices = np.array(cov_indices) cov_spins = np.array(cov_spins) cov_bins = np.array(cov_bins) fname_cw_old = '' for i, indices in enumerate(cov_indices): s_a1, s_a2, s_b1, s_b2 = cov_spins[i] na1 = get_nelems_spin(s_a1) na2 = get_nelems_spin(s_a2) nb1 = get_nelems_spin(s_b1) nb2 = get_nelems_spin(s_b2) bin_a1, bin_a2, bin_b1, bin_b2 = cov_bins[i] fname = out_run_path + '_cov_c{}{}{}{}_{}{}{}{}.npz'.format( *cov_spins[i], *cov_bins[i]) if os.path.isfile(fname): continue ibin_a1, ibin_a2, ibin_b1, ibin_b2 = indices cla1b1 = [clTh[ibin_a1, ibin_b1]] cla1b2 = [clTh[ibin_a1, ibin_b2]] cla2b1 = [clTh[ibin_a2, ibin_b1]] cla2b2 = [clTh[ibin_a2, ibin_b2]] wa = get_workspace_from_spins_masks(0, 0, bin_a1, bin_a2) wb = get_workspace_from_spins_masks(0, 0, bin_b1, bin_b2) print('Computing ', fname) print('spins: ', s_a1, s_a2, s_b1, s_b2) print('cla1b1', (s_a1, s_b1), ibin_a1) print('cla1b2', (s_a1, s_b2), ibin_a1) print('cla2b1', (s_a2, s_b1), ibin_a2) print('cla2b2', (s_a2, s_b2), ibin_a2) fname_cw = out_run_path_NKA + '_cw{}{}{}{}.dat'.format(*cov_bins[i]) if fname_cw != fname_cw_old: cw = nmt.NmtCovarianceWorkspace() cw.read_from(fname_cw) fname_cw_old = fname_cw cov = nmt.gaussian_covariance(cw, 0, 0, 0, 0, cla1b1, cla1b2, cla2b1, cla2b2, wa, wb) np.savez_compressed(fname, cov)
def test_workspace_covar_benchmark(): def compare_covars(c, cb): # Check first and second diagonals for k in [0, 1]: d = np.diag(c, k=k) db = np.diag(cb, k=k) assert (np.fabs(d - db) <= np.fmin(np.fabs(d), np.fabs(db)) * 1E-4).all() # Check against a benchmark cw = nmt.NmtCovarianceWorkspace() cw.compute_coupling_coefficients(CT.f0, CT.f0) # [0,0 ; 0,0] covar = nmt.gaussian_covariance(cw, 0, 0, 0, 0, [CT.cltt], [CT.cltt], [CT.cltt], [CT.cltt], CT.w) covar_bench = np.loadtxt("test/benchmarks/bm_nc_np_cov.txt", unpack=True) compare_covars(covar, covar_bench) # Check coupled covar_rc = nmt.gaussian_covariance(cw, 0, 0, 0, 0, [CT.cltt], [CT.cltt], [CT.cltt], [CT.cltt], CT.w, coupled=True) # [nl, nl] covar_c = np.array([CT.w.decouple_cell([row])[0] for row in covar_rc]) # [nl, nbpw] covar = np.array([CT.w.decouple_cell([col])[0] for col in covar_c.T]).T # [nbpw, nbpw] compare_covars(covar, covar_bench) # [0,2 ; 0,2] covar = nmt.gaussian_covariance( cw, 0, 2, 0, 2, [CT.cltt], [CT.clte, 0 * CT.clte], [CT.clte, 0 * CT.clte], [CT.clee, 0 * CT.clee, 0 * CT.clee, CT.clbb], CT.w02, wb=CT.w02) covar_bench = np.loadtxt("test/benchmarks/bm_nc_np_cov0202.txt") compare_covars(covar, covar_bench) # [0,0 ; 0,2] covar = nmt.gaussian_covariance(cw, 0, 0, 0, 2, [CT.cltt], [CT.clte, 0 * CT.clte], [CT.cltt], [CT.clte, 0 * CT.clte], CT.w, wb=CT.w02) covar_bench = np.loadtxt("test/benchmarks/bm_nc_np_cov0002.txt") compare_covars(covar, covar_bench) # [0,0 ; 2,2] covar = nmt.gaussian_covariance(cw, 0, 0, 2, 2, [CT.clte, 0 * CT.clte], [CT.clte, 0 * CT.clte], [CT.clte, 0 * CT.clte], [CT.clte, 0 * CT.clte], CT.w, wb=CT.w22) covar_bench = np.loadtxt("test/benchmarks/bm_nc_np_cov0022.txt") compare_covars(covar, covar_bench) # [2,2 ; 2,2] covar = nmt.gaussian_covariance( cw, 2, 2, 2, 2, [CT.clee, 0 * CT.clee, 0 * CT.clee, CT.clbb], [CT.clee, 0 * CT.clee, 0 * CT.clee, CT.clbb], [CT.clee, 0 * CT.clee, 0 * CT.clee, CT.clbb], [CT.clee, 0 * CT.clee, 0 * CT.clee, CT.clbb], CT.w22, wb=CT.w22) covar_bench = np.loadtxt("test/benchmarks/bm_nc_np_cov2222.txt") compare_covars(covar, covar_bench)
# of l_toeplitz, l_exact and dl_band are arbitrary, and should not # be understood as a rule of thumb. wt = nmt.NmtWorkspace() wt.compute_coupling_matrix(f0, f0, b, l_toeplitz=nside, l_exact=nside // 2, dl_band=40) c_tpltz = wt.get_coupling_matrix() / (2 * ls[None, :] + 1.) cl_tpltz = wt.decouple_cell(nmt.compute_coupled_cell(f0, f0)) # You can also use the Toeplitz approximation to compute the # Gaussian covariance matrix. Let's try that here: # First, the exact calculation cwe = nmt.NmtCovarianceWorkspace() cwe.compute_coupling_coefficients(f0, f0) cov_exact = nmt.gaussian_covariance(cwe, 0, 0, 0, 0, [cl_theory], [cl_theory], [cl_theory], [cl_theory], we) # Now using the Toeplitz approximation: cwt = nmt.NmtCovarianceWorkspace() cwt.compute_coupling_coefficients(f0, f0, l_toeplitz=nside, l_exact=nside // 2, dl_band=40) cov_tpltz = nmt.gaussian_covariance(cwt, 0, 0, 0, 0, [cl_theory], [cl_theory], [cl_theory], [cl_theory], wt) # Let's compare the mode-coupling matrices themselves: fig, (ax1, ax2, ax3) = plt.subplots(ncols=3, figsize=(14, 4))