def test_concatenate_data(): s1 = sacc.Sacc() # Tracer z = np.arange(0., 1.0, 0.01) nz = (z - 0.5)**2 / 0.1**2 s1.add_tracer('NZ', 'source_0', z, nz) for i in range(20): ee = 0.1 * i tracers = ('source_0', 'source_0') s1.add_data_point(sacc.standard_types.galaxy_shear_cl_ee, tracers, ee, ell=10.0 * i) s2 = sacc.Sacc() # Tracer z = np.arange(0., 1.0, 0.01) nz = (z - 0.5)**2 / 0.1**2 s2.add_tracer('NZ', 'source_0', z, nz, quantity='galaxy_shear', spin=2) for i in range(20): ee = 0.1 * i tracers = ('source_0', 'source_0') s2.add_data_point(sacc.standard_types.galaxy_shear_cl_ee, tracers, ee, ell=10.0 * i, label='xxx') # name clash with pytest.raises(ValueError): sacc.concatenate_data_sets(s1, s2) s3 = sacc.concatenate_data_sets(s1, s2, labels=['1', '2']) assert 'source_0_1' in s3.tracers assert 'source_0_2' in s3.tracers assert len(s3) == len(s1) + len(s2) # check data points in right order for i in range(20): assert s3.data[i].get_tag('ell') == 10.0 * i assert s3.data[i + 20].get_tag('ell') == 10.0 * i assert s3.data[i].get_tag('label') == '1' assert s3.data[i + 20].get_tag('label') == 'xxx_2' t1 = s3.data[i].tracers[0] t2 = s3.data[i + 20].tracers[0] assert t1 == 'source_0_1' assert t2 == 'source_0_2' s3.get_tracer(t1) s3.get_tracer(t2)
def test_io(): s = sacc.Sacc() # Tracer z = np.arange(0., 1.0, 0.01) nz = (z - 0.5)**2 / 0.1**2 s.add_tracer('NZ', 'source_0', z, nz) for i in range(20): ee = 0.1 * i tracers = ('source_0', 'source_0') s.add_data_point(sacc.standard_types.galaxy_shear_cl_ee, tracers, ee, ell=10.0 * i) with tempfile.TemporaryDirectory() as tmpdir: filename = os.path.join(tmpdir, 'test.sacc') s.save_fits(filename) s2 = sacc.Sacc.load_fits(filename) assert len(s2) == 20 mu = s2.get_mean(sacc.standard_types.galaxy_shear_cl_ee) for i in range(20): assert mu[i] == 0.1 * i
def test_tracers_later(): s = sacc.Sacc() with pytest.raises(ValueError): tracers = ('source_0', 'source_0') s.add_data_point(sacc.standard_types.galaxy_shear_cl_ee, tracers, 0.0, ell=1) s = sacc.Sacc() tracers = ('source_0', 'source_0') s.add_data_point(sacc.standard_types.galaxy_shear_cl_ee, tracers, 0.0, tracers_later=True, ell=1)
def write_output(self, data, meta, results): import sacc XIP = sacc.standard_types.galaxy_shear_xi_plus XIM = sacc.standard_types.galaxy_shear_xi_minus GAMMAT = sacc.standard_types.galaxy_shearDensity_xi_t S = sacc.Sacc() # We include the n(z) data in the output. # So here we load it in and add it to the data f = self.open_input('photoz_stack') # Load the tracer data N(z) from an input file and # copy it to the output, for convenience for i in data['source_list']: z = f['n_of_z/source/z'][:] Nz = f[f'n_of_z/source/bin_{i}'][:] S.add_tracer('NZ', f'source_{i}', z, Nz) # For both source and lens for i in data['lens_list']: z = f['n_of_z/lens/z'][:] Nz = f[f'n_of_z/lens/bin_{i}'][:] S.add_tracer('NZ', f'lens_{i}', z, Nz) # Closing n(z) file f.close() # Add the data points that we have one by one, recording which # tracer they each require for d in results: tracer1 = f'source_{d.i}' if d.corr_type in [XIP, XIM, GAMMAT ] else f'lens_{d.i}' tracer2 = f'source_{d.j}' if d.corr_type in [XIP, XIM ] else f'lens_{d.j}' # Each of our Measurement objects contains various theta values, # and we loop through and add them all n = len(d.value) for i in range(n): S.add_data_point(d.corr_type, (tracer1, tracer2), d.value[i], theta=d.theta[i], error=d.error[i], npair=d.npair[i], weight=d.weight[i]) #self.write_metadata(S, meta) # Our data points may currently be in any order depending on which processes # ran which calculations. Re-order them. S.to_canonical_order() # Finally, save the output to Sacc file S.save_fits(self.get_output('twopoint_data'), overwrite=True)
def test_construct(): s = sacc.Sacc() # Tracer z = np.arange(0., 1.0, 0.01) nz = (z - 0.5)**2 / 0.1**2 s.add_tracer('NZ', 'source_0', z, nz, quantity='galaxy_density') for i in range(20): ee = 0.1 * i tracers = ('source_0', 'source_0') s.add_data_point(sacc.standard_types.cl_00, tracers, ee, ell=10.0 * i)
def make_sacc(tomo_bin, z, what, mu, C): import sacc # Basic numbers nbin = int(tomo_bin.max()) + 1 tracer_type = get_tracer_type(nbin, what) ntot = nbin * 2 if what == '3x2' else nbin z_mid, n_of_z = get_n_of_z(tomo_bin, z) npair = (ntot * (ntot + 1)) // 2 # Must be the same as above ell, _ = ell_binning() n_ell = len(ell) # Just EE for now EE = sacc.data_types.standard_types.galaxy_shear_cl_ee GG = sacc.data_types.standard_types.galaxy_density_cl GE = sacc.data_types.standard_types.galaxy_shearDensity_cl_e # Start with empty sacc. S = sacc.Sacc() # Add all the tracers for ci in range(ntot): i = ci % nbin if tracer_type[ci] == 'g': S.add_tracer("NZ", f'lens_{i}', z_mid, n_of_z[i]) elif tracer_type[ci] == 'w': S.add_tracer("NZ", f'source_{i}', z_mid, n_of_z[i]) else: raise NotImplemented # Now put in all the data points n = 0 for ic in range(ntot): i = ic % nbin name_i = f'lens_{i}' if tracer_type[ic] == 'g' else f'source_{i}' for jc in range(ic, ntot): j = jc % nbin name_j = f'lens_{j}' if tracer_type[jc] == 'g' else f'source_{j}' if tracer_type[ic] + tracer_type[jc] == 'gg': S.add_ell_cl(GG, name_i, name_j, ell, mu[n:n + n_ell]) elif tracer_type[ic] + tracer_type[jc] == 'ww': S.add_ell_cl(EE, name_i, name_j, ell, mu[n:n + n_ell]) else: S.add_ell_cl(GE, name_i, name_j, ell, mu[n:n + n_ell]) n += n_ell # And finally add the covmat S.add_covariance(C) return S
def save_cell_to_file(self, cell, tracers, fname, with_windows=False): # Create sacc file s = sacc.Sacc() # Add tracers for t in tracers: s.add_tracer_object(t) # Add each power spectrum l_eff = self.bins.get_effective_ells() for b1, b2, s1, s2, l1, l2 in self.get_cell_iterator(): add_BE = not ((b1 == b2) and (s1 == s2)) if with_windows: wname = self.get_workspace_label(b1, b2) s.add_ell_cl('cl_ee', l1, l2, l_eff, cell[l1][l2][0], window=self.win[wname]['EE']) # EE s.add_ell_cl('cl_eb', l1, l2, l_eff, cell[l1][l2][1], window=self.win[wname]['EB']) # EB if add_BE: # Only add B1E2 if 1!=2 s.add_ell_cl('cl_be', l1, l2, l_eff, cell[l1][l2][2], window=self.win[wname]['BE']) # BE s.add_ell_cl('cl_bb', l1, l2, l_eff, cell[l1][l2][3], window=self.win[wname]['BB']) # EE else: s.add_ell_cl('cl_ee', l1, l2, l_eff, cell[l1][l2][0]) # EE s.add_ell_cl('cl_eb', l1, l2, l_eff, cell[l1][l2][1]) # EB if add_BE: # Only add B1E2 if 1!=2 s.add_ell_cl('cl_be', l1, l2, l_eff, cell[l1][l2][2]) # BE s.add_ell_cl('cl_bb', l1, l2, l_eff, cell[l1][l2][3]) # EE print("Saving to " + fname) s = s.save_fits(fname, overwrite=True)
def sacc_and_tracers(): # Initializes a sacc file and fills it up with the shear tracers s = sacc.Sacc() for b in range(nbins): z0, zm, zf, nz = np.loadtxt(predir + f'dndz_metacal_bin{b}.txt', unpack=True) s.add_tracer('NZ', f'bin{b}', quantity='galaxy_shear', spin=2, z=zm, nz=nz, extra_columns={ 'z_i': z0, 'z_f': zf }) return s
def write_output_sacc(self, data, meta, results): # We write out the results slightly differently here # beause they go to a different file and have different # tracers and tags. import sacc dt = "galaxyStarCenters_shearDensity_xi_t" S = sacc.Sacc() f = self.open_input('photoz_stack') z = f['n_of_z/source2d/z'][:] Nz = f[f'n_of_z/source2d/bin_0'][:] f.close() # Add the data points that we have one by one, recording which # tracer they each require S.add_tracer('misc', 'starcenter') S.add_tracer('NZ', 'source2d', z, Nz) d = results[0] assert len(results) == 1 # Each of our Measurement objects contains various theta values, # and we loop through and add them all n = len(d.value) for i in range(n): S.add_data_point(dt, ('source2d', 'starcenter'), d.value[i], theta=d.theta[i], error=d.error[i], npair=d.npair[i], weight=d.weight[i]) self.write_metadata(S, meta) print(S) # Our data points may currently be in any order depending on which processes # ran which calculations. Re-order them. S.to_canonical_order() # Finally, save the output to Sacc file S.save_fits(self.get_output('gammat_dim_stars'), overwrite=True)
def __init__(self, datafile, output, use='cls'): self.datafile = datafile self.data = co.read_data(datafile) self.outdir = self.data['output'] self.use_nl = False self.use_fiducial = False if use == 'cls': pass elif use == 'nl': self.use_nl = True elif use == 'fiducial': self.use_fiducial = True else: raise ValueError('Use must be one of cls, nl or fiducial') self.s = sacc.Sacc() self.add_tracers() self.add_ell_cls() self.add_covariance() fname = os.path.join(self.outdir, output) self.s.save_fits(fname, overwrite=True)
def save_power_spectra(self, tracers, nbin_source, nbin_lens): import sacc from sacc.windows import TopHatWindow CEE = sacc.standard_types.galaxy_shear_cl_ee CBB = sacc.standard_types.galaxy_shear_cl_bb CdE = sacc.standard_types.galaxy_shearDensity_cl_e CdB = sacc.standard_types.galaxy_shearDensity_cl_b Cdd = sacc.standard_types.galaxy_density_cl S = sacc.Sacc() for tracer in tracers.values(): S.add_tracer_object(tracer) for d in self.results: tracer1 = f'source_{d.i}' if d.corr_type in [CEE, CBB, CdE, CdB ] else f'lens_{d.i}' tracer2 = f'source_{d.j}' if d.corr_type in [CEE, CBB ] else f'lens_{d.j}' n = len(d.l) for i in range(n): win = TopHatWindow(d.win[i][0], d.win[i][1]) S.add_data_point(d.corr_type, (tracer1, tracer2), d.value[i], ell=d.l[i], window=win, i=d.i, j=d.j) # Save provenance information for key, value in self.gather_provenance().items(): if isinstance(value, str) and '\n' in value: values = value.split("\n") for i, v in enumerate(values): S.metadata[f'provenance/{key}_{i}'] = v else: S.metadata[f'provenance/{key}'] = value output_filename = self.get_output("twopoint_data_fourier") S.save_fits(output_filename, overwrite=True)
def test_io_maps_bpws(): s = sacc.Sacc() n_ell = 10 d_ell = 100 n_ell_large = n_ell * d_ell ell = np.linspace(2, 1000, n_ell) c_ell = 1. / (ell + 1)**3 beam = np.exp(-0.1 * ell * (ell + 1)) nu = np.linspace(30., 60., 100) bandpass = np.ones(100) z = np.arange(0., 1.0, 0.01) nz = (z - 0.5)**2 / 0.1**2 # Tracer s.add_tracer('NZ', 'gc', z, nz) s.add_tracer('NuMap', 'cmbp', 2, nu, bandpass, ell, beam) s.add_tracer('Map', 'sz', 0, ell, beam) # Window ells_large = np.arange(n_ell_large) window_single = np.zeros([n_ell, n_ell_large]) for i in range(n_ell): window_single[i, i * d_ell:(i + 1) * d_ell] = 1. wins = sacc.BandpowerWindow(ells_large, window_single.T) s.add_ell_cl('cl_00', 'gc', 'gc', ell, c_ell, window=wins) s.add_ell_cl('cl_0e', 'gc', 'cmbp', ell, c_ell, window=wins) s.add_ell_cl('cl_00', 'gc', 'sz', ell, c_ell, window=wins) with tempfile.TemporaryDirectory() as tmpdir: filename = os.path.join(tmpdir, 'test.sacc') s.save_fits(filename) s2 = sacc.Sacc.load_fits(filename) assert len(s2) == 30 l, cl, ind = s2.get_ell_cl('cl_00', 'gc', 'sz', return_ind=True) w = s2.get_bandpower_windows(ind) assert np.all(cl == c_ell) assert w.weight.shape == (n_ell_large, n_ell)
id_j = 0 for j1 in range(n_bins): for j2 in range(j1, n_bins): cl_i1j1 = c_ells_binned[i1, j1, :]+n_ells_binned[i1, j1, :] cl_i1j2 = c_ells_binned[i1, j2, :]+n_ells_binned[i1, j2, :] cl_i2j1 = c_ells_binned[i2, j1, :]+n_ells_binned[i2, j1, :] cl_i2j2 = c_ells_binned[i2, j2, :]+n_ells_binned[i2, j2, :] # Knox formula cov = (cl_i1j1 * cl_i2j2 + cl_i1j2 * cl_i2j1) / (d_ell * fsky * (2 * l_eff + 1)) covar[id_i, :, id_j, :] = np.diag(cov) id_j += 1 id_i += 1 covar = covar.reshape([n_cross * n_bpw, n_cross * n_bpw]) # Open sacc s = sacc.Sacc() # Add tracers for i, n in enumerate(nzs): s.add_tracer('NZ', 'wl_%d' % i, # Name quantity='galaxy_shear', # Quantity spin=2, # Spin z=z, # z nz=n, # nz sigma_g=0.28) # You can add any extra information as **kwargs # Add C_ells wins = sacc.BandpowerWindow(ells, window_single.T) for i1 in range(n_bins): for i2 in range(i1, n_bins): s.add_ell_cl('cl_ee', 'wl_%d' % i1, 'wl_%d' % i2, l_eff, c_ells_binned[i1, i2, :], window=wins) # Add covariance
n_x = (nmaps * (nmaps + 1)) // 2 n_cls = n_ells * n_x cov_full = np.zeros([n_x, n_x, n_ells, n_ells]) for ix1, (e1a, f1a, e1b, f1b, p1a, p1b) in enumerate(get_x_iterator()): for ix2, (e2a, f2a, e2b, f2b, p2a, p2b) in enumerate(get_x_iterator()): cv = get_ell_covar(e1a, f1a, p1a, e1b, f1b, p1b, e2a, f2a, p2a, e2b, f2b, p2b, covar_in, n_ells, id_cov_order) cov_full[ix1, ix2, :, :] = cv cov_full = np.transpose(cov_full, axes=[0, 2, 1, 3]).reshape([n_cls, n_cls]) for isim in range(iStart, iStop): print(isim) spec_sacc = sacc.Sacc() if isim == 0: cov_sacc = sacc.Sacc() sim_suffix = "%05d" % isim for exp in experiments: freqs = d["freqs_%s" % exp] for f in freqs: # dummies file: not in used data_bandpasses = {"nu": [149, 150], "b_nu": [0.5, 0.5]} data_beams = {"l": np.arange(10000), "bl": np.ones(10000)} spec_sacc.add_tracer("NuMap", "%s_%s_s0" % (exp, f), "temperature",
bin_lo, bin_hi, lb, bin_size = pspy_utils.read_binning_file(binning_file, lmax) n_bins = len(bin_hi) # let's get a list of all frequencies we plan to study surveys = d["surveys"] frequencies = [] for sv in surveys: arrays = d["arrays_%s" % sv] for ar in arrays: frequencies += [int(d["nu_eff_%s_%s" % (sv, ar)])] frequencies = np.sort(list(dict.fromkeys(frequencies))) for iii in range(iStart, iStop): # Saving into sacc format act_sacc = sacc.Sacc() for freq in frequencies: for spin, quantity in zip([0, 2], ["temperature", "polarization"]): # dummies file: not in used data_beams = {"l": np.arange(10000), "bl": np.ones(10000)} act_sacc.add_tracer( "NuMap", f"ACT_{freq}_s{spin}", quantity=f"cmb_{quantity}", spin=spin, nu=[freq], bandpass=[1.0], ell=data_beams.get("l"), beam=data_beams.get("bl"), )
def test_data_type_warning(): s = sacc.Sacc() s.add_tracer('Misc', 'source_0') with pytest.warns(UserWarning): s.add_data_point('cl_wrong', ('source_0', 'source_0'), 0.1, ell=10.)
def test_quantity_warning(): s = sacc.Sacc() with pytest.warns(UserWarning): s.add_tracer('Misc', 'source_0', quantity='dummy')
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 get_everything(self): if self.sacc is None: fname = os.path.join(self.config['output_dir'], f'cls_all.fits') fname_n = os.path.join(self.config['output_dir'], f'cls_noise.fits') if not os.path.isfile(fname): self.get_cls() self.get_covariances() s = sacc.Sacc() sn = sacc.Sacc() # Add tracers s.add_tracer('NZ', 'LoTSS', quantity='galaxy_density', spin=0, z=np.linspace(0, 5, 512), nz=np.ones(512)) # We will need a better N(z) s.add_tracer('Map', 'Planck18', quantity='cmb_convergence', spin=0, ell=np.arange(3 * self.nside), beam=np.ones(3 * self.nside)) sn.add_tracer('NZ', 'LoTSS', quantity='galaxy_density', spin=0, z=np.linspace(0, 5, 512), nz=np.ones(512)) # We will need a better N(z) sn.add_tracer('Map', 'Planck18', quantity='cmb_convergence', spin=0, ell=np.arange(3 * self.nside), beam=np.ones(3 * self.nside)) order = [] nls = [] ells = np.arange(3 * self.nside) if 'gg' in self.cls_compute: d = self.cls['gg'] wins = sacc.BandpowerWindow(ells, d['win'][0, :, 0, :].T) s.add_ell_cl('cl_00', 'LoTSS', 'LoTSS', d['ls'], d['cl'][0] - d['nl'][0], window=wins) sn.add_ell_cl('cl_00', 'LoTSS', 'LoTSS', d['ls'], d['nl'][0]) order.append('gg') nls.append(len(d['ls'])) if 'gk' in self.cls_compute: d = self.cls['gk'] wins = sacc.BandpowerWindow(ells, d['win'][0, :, 0, :].T) s.add_ell_cl('cl_00', 'LoTSS', 'Planck18', d['ls'], d['cl'][0] - d['nl'][0], window=wins) sn.add_ell_cl('cl_00', 'LoTSS', 'Planck18', d['ls'], d['nl'][0]) order.append('gk') nls.append(len(d['ls'])) if 'kk' in self.cls_compute: d = self.cls['kk'] wins = sacc.BandpowerWindow(ells, d['win'][0, :, 0, :].T) s.add_ell_cl('cl_00', 'Planck18', 'Planck18', d['ls'], d['cl'][0] - d['nl'][0], window=wins) sn.add_ell_cl('cl_00', 'Planck18', 'Planck18', d['ls'], d['nl'][0]) order.append('kk') nls.append(len(d['ls'])) ncls = len(nls) cov = np.zeros([ncls, nls[0], ncls, nls[0]]) for i1, t1 in enumerate(order): for i2, t2 in enumerate(order): if t1 + t2 in self.cov: cv = self.cov[t1 + t2] else: cv = self.cov[t2 + t1].T cov[i1, :, i2, :] = cv cov = cov.reshape([ncls * nls[0], ncls * nls[0]]) s.add_covariance(cov) s.save_fits(fname) sn.save_fits(fname_n) self.sacc = s self.sacc_noise = sn else: self.sacc = sacc.Sacc.load_fits(fname) self.sacc_noise = sacc.Sacc.load_fits(fname_n) return self.sacc, self.sacc_noise
_, nell[:, 2:], _ = nc.Simons_Observatory_V3_SA_noise(sens, knee, ylf, fsky, lmax + 1, 1) n_bpw = np.sum(nell[:, None, :] * windows[None, :, :], axis=2) bpw_freq_noi = np.zeros_like(bpw_freq_sig) for ib, n in enumerate(n_bpw): bpw_freq_noi[ib, 0, ib, 0, :] = n_bpw[ib, :] bpw_freq_noi[ib, 1, ib, 1, :] = n_bpw[ib, :] # Add to signal bpw_freq_tot = bpw_freq_sig + bpw_freq_noi bpw_freq_tot = bpw_freq_tot.reshape([nfreqs * 2, nfreqs * 2, nbands]) bpw_freq_sig = bpw_freq_sig.reshape([nfreqs * 2, nfreqs * 2, nbands]) bpw_freq_noi = bpw_freq_noi.reshape([nfreqs * 2, nfreqs * 2, nbands]) # Creating Sacc files s_d = sacc.Sacc() s_f = sacc.Sacc() s_n = sacc.Sacc() # Adding tracers print("Adding tracers") for ib, n in enumerate(band_names): bandpass = bpss[n] beam = beams[n] for s in [s_d, s_f, s_n]: s.add_tracer('NuMap', 'band%d' % (ib + 1), quantity='cmb_polarization', spin=2, nu=bandpass.nu, bandpass=bandpass.bnu,
def test_keep_remove(): s = sacc.Sacc() # Tracer z = np.arange(0., 1.0, 0.01) nz = (z - 0.5)**2 / 0.1**2 s.add_tracer('NZ', 'source_0', z, nz) s.add_tracer('NZ', 'source_1', z, nz, quantity='galaxy_shear', spin=2) s.add_tracer('NZ', 'source_2', z, nz, quantity='cluster_density') for i in range(20): ee = 0.1 * i tracers = ('source_0', 'source_0') s.add_data_point(sacc.standard_types.galaxy_shear_cl_ee, tracers, ee, ell=10.0 * i) for i in range(20): bb = 0.1 * i tracers = ('source_1', 'source_1') s.add_data_point(sacc.standard_types.galaxy_shear_cl_bb, tracers, bb, ell=10.0 * i) for i in range(20): ee = 0.1 * i tracers = ('source_2', 'source_2') s.add_data_point(sacc.standard_types.galaxy_shear_cl_ee, tracers, ee, ell=10.0 * i) # Select by data type s2 = s.copy() s2.keep_selection(data_type=sacc.standard_types.galaxy_shear_cl_bb) assert all(d.data_type == sacc.standard_types.galaxy_shear_cl_bb for d in s2.data) assert len(s2) == 20 # From multiple tracers s2 = s.copy() s2.keep_selection(data_type=sacc.standard_types.galaxy_shear_cl_ee) assert all(d.data_type == sacc.standard_types.galaxy_shear_cl_ee for d in s2.data) assert len(s2) == 40 # Test removing a single tracer s2 = s.copy() s2.remove_selection(tracers=('source_1', 'source_1')) for i, d in enumerate(s2.data): if i < 20: assert d.tracers == ('source_0', 'source_0') else: assert d.tracers == ('source_2', 'source_2') assert all(d.data_type == sacc.standard_types.galaxy_shear_cl_ee for d in s2.data) assert len(s2) == 40 # Test selecting by tag s2 = s.copy() s2.remove_selection(ell__lt=55) ell = s2.get_tag('ell') for e in ell: assert e > 55 s2 = s.copy() s2.keep_selection(ell__lt=55) ell = s2.get_tag('ell') for e in ell: assert e < 55 # Cutting just by index s2 = s.copy() ind = s2.indices(tracers=('source_1', 'source_1')) assert (ind == np.arange(20, 40)).all() # multiple selections s2 = s.copy() ind = s2.indices(tracers=('source_2', 'source_2'), ell__lt=45) assert len(ind) == 5
def two_point_template(config): """Creates a template SACC object with tracers and statistics Parameters: ---------- config : dict The dictinary containt the relevant two_point section of the config Returns: ------- sacc : sacc object Sacc objects with appropriate tracers and measurement slots (i.e. data vectors with associated correlation functions, angles, etc), but with zeros for measurement values """ S = sacc.Sacc() verbose = config["verbose"] cosmo = firecrown.get_ccl_cosmology(config["parameters"]) # I assume that kmax will be passed in the default CCL units, i.e., Mpc^-1 kmax = config["kmax"] if "kmax" in config.keys() else None zmean = {} if verbose: print("Generating tracers: ", end="") for src, tcfg in config["sources"].items(): if verbose: print(src, " ", end="") if "Nz_type" not in tcfg: print("Missing Nz_type in %s. Quitting." % src) raise RuntimeError if tcfg["Nz_type"] == "LensSRD2018": mu, wi = tcfg["Nz_center"], tcfg["Nz_width"] alpha, z0 = tcfg["Nz_alpha"], tcfg["Nz_z0"] sig_z = tcfg["Nz_sigmaz"] zall = np.linspace(0, 4, 1500) mask = (zall > mu - wi / 2) & (zall < mu + wi / 2) dndz_bin = np.zeros_like(zall) dndz_bin[mask] = srd_dndz(zall[mask], z0, alpha) dz = zall[1] - zall[0] # Convolve the SRD N(z) with a Gaussian with the required smearing Nz = gaussian_filter(dndz_bin, 0.05 * (1 + mu) / dz) S.add_tracer("NZ", src, zall, Nz) zmean[src] = np.average(zall, weights=Nz / np.sum(Nz)) elif tcfg["Nz_type"] == "Gaussian": mu, wi = tcfg["Nz_center"], tcfg["Nz_width"] zall = np.linspace(0, 4, 1500) mask = (zall > mu - wi / 2) & (zall < mu + wi / 2) Nz = np.exp(-0.5 * (zall - mu)**2 / wi**2) S.add_tracer("NZ", src, zall, Nz) zmean[src] = np.average(zall, weights=Nz / np.sum(Nz)) elif tcfg["Nz_type"] == "TopHat": mu, wi = tcfg["Nz_center"], tcfg["Nz_width"] alpha, z0 = tcfg["Nz_alpha"], tcfg["Nz_z0"] zar = np.linspace(max(0, mu - wi / 2), mu + wi / 2, 5) Nz = np.ones(5) S.add_tracer("NZ", src, zar, Nz) zmean[src] = np.average(zar, weights=Nz / np.sum(Nz)) elif tcfg["Nz_type"] == 'SourceSRD2018': ibin, nbins = tcfg["Nz_bin"], tcfg['Nz_nbins'] alpha, z0 = tcfg["Nz_alpha"], tcfg["Nz_z0"] sig_z = tcfg["Nz_sigmaz"] zall = np.linspace(0, 4, 1500) tile_hi = 1.0 / nbins * (ibin + 1) tile_low = 1.0 / nbins * ibin nz_sum = np.cumsum(srd_dndz(zall, z0, alpha)) / np.sum( srd_dndz(zall, z0, alpha)) zlow = zall[np.argmin(np.fabs(nz_sum - tile_low))] zhi = zall[np.argmin(np.fabs(nz_sum - tile_hi))] zcent = 0.5 * (zlow + zhi) dz = zall[1] - zall[0] mask = (zall > zlow) & (zall < zhi) dndz_bin = np.zeros_like(zall) dndz_bin[mask] = srd_dndz(zall[mask], z0, alpha) # Convolve the SRD N(z) with a Gaussian with the required smearing Nz = gaussian_filter(dndz_bin, sig_z * (1 + zcent) / dz) # sigma should be in units of step S.add_tracer("NZ", src, zall, Nz) zmean[src] = np.average(zall, weights=Nz / np.sum(Nz)) else: print("Bad Nz_type %s in %s. Quitting." % (tcfg["Nz_type"], src)) raise RuntimeError if verbose: print("\nGenerating data slots: ", end="") for name, scfg in config["statistics"].items(): if verbose: print(name, " ", end="") dt = scfg["sacc_data_type"] src1, src2 = scfg["sources"] zmean1 = zmean[src1] zmean2 = zmean[src2] a12 = np.array([1. / (1 + zmean1), 1. / (1 + zmean2)]) if kmax is not None: ell_max = (kmax * ccl.comoving_radial_distance(cosmo, a12) - 0.5).astype(np.int) ell_max = np.min(ell_max) # we get the minimum ell_max else: ell_max = None if "cl" in dt: ell_edges = scfg["ell_edges"] if isinstance(ell_edges, str): ell_edges = eval(ell_edges) else: ell_edges = np.array(ell_edges) ell_edges = np.sort(ell_edges) # Here I choose to cut the last bin to ell_max (we could drop it) if (ell_max is not None) & ("shear_cl_ee" not in dt): ell_edges = ell_edges[ell_edges <= ell_max] scfg["ell_edges"] = ell_edges ells = 0.5 * (ell_edges[:-1] + ell_edges[1:]) for ell in ells: S.add_data_point(dt, (src1, src2), 0.0, ell=ell, error=1e30) elif "xi" in dt: theta_edges = np.array(scfg["theta_edges"]) thetas = 0.5 * (theta_edges[:-1] + theta_edges[1:]) for theta in thetas: S.add_data_point(dt, (src1, src2), 0.0, theta=theta, error=1e30) else: print("Cannot process %s. Quitting." % dt) raise NotImplementedError if verbose: print() config["sacc_data"] = S
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 parse_splits_sacc_file(self, s, get_saccs=False, with_windows=False): """ Transform a SACC file containing splits into 4 SACC vectors: 1 that contains the coadded power spectra. 1 that contains coadded power spectra for cross-split only. 1 that contains an estimate of the noise power spectrum. 1 that contains all null tests """ # Check we have the right number of bands, splits, # cross-correlations and power spectra self.check_sacc_consistency(s) # Now read power spectra into an array of form # [nsplits,nsplits,nbands,nbands,2,2,n_ell] # This duplicates the number of elements, but # simplifies bookkeeping significantly. # Put it in shape [nsplits,nsplits,nbands,2,nbands,2,nl] spectra = np.transpose(s.mean[self.inds].reshape([self.nsplits, self.nbands, 2, self.nsplits, self.nbands, 2, self.n_bpws]), axes=[0, 3, 1, 2, 4, 5, 6]) # Coadding (assuming flat coadding) # Total coadding (including diagonal) weights_total = np.ones(self.nsplits, dtype=float)/self.nsplits spectra_total = np.einsum('i,ijklmno,j', weights_total, spectra, weights_total) # Off-diagonal coadding triu_mean = np.mean(spectra[np.triu_indices(self.nsplits, 1)], axis=0) tril_mean = np.mean(spectra[np.tril_indices(self.nsplits, -1)], axis=0) spectra_xcorr = 0.5*(tril_mean+triu_mean) # Noise power spectra spectra_noise = spectra_total - spectra_xcorr # Nulls spectra_nulls = np.zeros([self.n_nulls, self.nbands, 2, self.nbands, 2, self.n_bpws]) for i_null, (i, j, k, l) in enumerate(self.pairings): spectra_nulls[i_null] = (spectra[i, k]-spectra[i, l] - spectra[j, k]+spectra[j, l]) ret = {} if get_saccs: s_total = sacc.Sacc() s_xcorr = sacc.Sacc() s_noise = sacc.Sacc() s_nulls = sacc.Sacc() for t in self.t_coadd: s_total.add_tracer_object(t) s_xcorr.add_tracer_object(t) s_noise.add_tracer_object(t) for t in self.t_nulls: s_nulls.add_tracer_object(t) itr = self.bands_pol_iterator(half=True, with_windows=with_windows) for b1, ip1, b2, ip2, l1, l2, x, win in itr: s_total.add_ell_cl('cl_' + x, l1, l2, self.ells, spectra_total[b1, ip1, b2, ip2], window=win) s_xcorr.add_ell_cl('cl_' + x, l1, l2, self.ells, spectra_xcorr[b1, ip1, b2, ip2], window=win) s_noise.add_ell_cl('cl_' + x, l1, l2, self.ells, spectra_noise[b1, ip1, b2, ip2], window=win) for i_null, (i, j, k, l) in enumerate(self.pairings): itrb = self.bands_pol_iterator(half=False, with_windows=with_windows) for b1, ip1, b2, ip2, l1, l2, x, win in itrb: l1s = l1 + '_null%dm%d' % (i+1, j+1) l2s = l2 + '_null%dm%d' % (k+1, l+1) s_nulls.add_ell_cl('cl_' + x, l1s, l2s, self.ells, spectra_nulls[i_null, b1, ip1, b2, ip2], window=win) ret['saccs'] = [s_total, s_xcorr, s_noise, s_nulls] spectra_total = spectra_total.reshape([2*self.nbands, 2*self.nbands, self.n_bpws])[np.triu_indices(2*self.nbands)].flatten() spectra_xcorr = spectra_xcorr.reshape([2*self.nbands, 2*self.nbands, self.n_bpws])[np.triu_indices(2*self.nbands)].flatten() spectra_noise = spectra_noise.reshape([2*self.nbands, 2*self.nbands, self.n_bpws])[np.triu_indices(2*self.nbands)].flatten() spectra_nulls = spectra_nulls.reshape([-1, self.n_bpws]).flatten() ret['spectra'] = [spectra_total, spectra_xcorr, spectra_noise, spectra_nulls] return ret
def saveps(sk): prefix_out = f'data/sim0{sk}/' if residuals: sname = 'residual' if masked: fnames = glob.glob(f'{prefix_out}masked_residualmaps*.fits') else: fnames = glob.glob(f'{prefix_out}full_residualmaps*.fits') else: sname = 'baseline' fdir = f'/mnt/zfsusers/mabitbol/simdata/sims_gauss_fullsky_ns256_csd_std0.{sk}_gm3/' fnames = glob.glob(f'{fdir}s*/maps_sky_signal.fits') fnames.sort() if masked: sname += '_masked' sat_mask = hp.ud_grade(hp.read_map('mask_apodized.fits'), nside) else: sat_mask = np.ones(npix) # Precompute coupling matrix for namaster b = nmt.NmtBin.from_nside_linear(nside, dell, is_Dell=True) purify_b = False if masked: purify_b = True empty_field = nmt.NmtField(sat_mask, maps=None, spin=2, purify_b=purify_b) w_yp = nmt.NmtWorkspace() w_yp.compute_coupling_matrix(empty_field, empty_field, b) for kn in range(nsims): x = hp.read_map(fnames[kn], field=np.arange(nfreqs * npol), verbose=False).reshape((nfreqs, npol, -1)) x[:, :, sat_mask == 0] = 0. f2_x = [] for i in range(nfreqs): f2_x.append(nmt.NmtField(sat_mask, x[i], purify_b=purify_b)) bpw_freq_sig = np.zeros((nfreqs, npol, nfreqs, npol, nbands)) for i in range(nfreqs): for j in range(nfreqs): cl_coupled = nmt.compute_coupled_cell(f2_x[i], f2_x[j]) cl_decoupled = w_yp.decouple_cell(cl_coupled) bpw_freq_sig[i, 0, j, 0] = cl_decoupled[0] bpw_freq_sig[i, 0, j, 1] = cl_decoupled[1] bpw_freq_sig[i, 1, j, 0] = cl_decoupled[2] bpw_freq_sig[i, 1, j, 1] = cl_decoupled[3] # Add to signal bpw_freq_tot = bpw_freq_sig + bpw_freq_noi bpw_freq_tot = bpw_freq_tot.reshape( [nfreqs * npol, nfreqs * npol, nbands]) bpw_freq_sig = bpw_freq_sig.reshape( [nfreqs * npol, nfreqs * npol, nbands]) # Creating Sacc files s_d = sacc.Sacc() s_f = sacc.Sacc() s_n = sacc.Sacc() # Adding tracers for ib, n in enumerate(band_names): bandpass = bpss[n] beam = beams[n] for s in [s_d, s_f, s_n]: s.add_tracer('NuMap', 'band%d' % (ib + 1), quantity='cmb_polarization', spin=2, nu=bandpass.nu, bandpass=bandpass.bnu, ell=larr_all, beam=beam, nu_unit='GHz', map_unit='uK_CMB') # Adding power spectra nmaps = npol * nfreqs ncross = (nmaps * (nmaps + 1)) // 2 indices_tr = np.triu_indices(nmaps) map_names = [] for ib, n in enumerate(band_names): map_names.append('band%d' % (ib + 1) + '_E') map_names.append('band%d' % (ib + 1) + '_B') for ii, (i1, i2) in enumerate(zip(indices_tr[0], indices_tr[1])): n1 = map_names[i1][:-2] n2 = map_names[i2][:-2] p1 = map_names[i1][-1].lower() p2 = map_names[i2][-1].lower() cl_type = f'cl_{p1}{p2}' s_d.add_ell_cl(cl_type, n1, n2, leff, bpw_freq_sig[i1, i2, :], window=s_wins) s_f.add_ell_cl(cl_type, n1, n2, leff, bpw_freq_sig[i1, i2, :], window=s_wins) s_n.add_ell_cl(cl_type, n1, n2, leff, bpw_freq_noi_re[i1, i2, :], window=s_wins) # Add covariance cov_bpw = np.zeros([ncross, nbands, ncross, nbands]) factor_modecount = 1. / ((2 * leff + 1) * dell * fsky) for ii, (i1, i2) in enumerate(zip(indices_tr[0], indices_tr[1])): for jj, (j1, j2) in enumerate(zip(indices_tr[0], indices_tr[1])): covar = (bpw_freq_tot[i1, j1, :] * bpw_freq_tot[i2, j2, :] + bpw_freq_tot[i1, j2, :] * bpw_freq_tot[i2, j1, :]) * factor_modecount cov_bpw[ii, :, jj, :] = np.diag(covar) cov_bpw = cov_bpw.reshape([ncross * nbands, ncross * nbands]) s_d.add_covariance(cov_bpw) # Write output skn = str(kn).zfill(4) s_d.save_fits(f'{prefix_out}cls_coadd_{sname}_{skn}.fits', overwrite=True) s_f.save_fits(f'{prefix_out}cls_fid_{sname}_{skn}.fits', overwrite=True) s_n.save_fits(f'{prefix_out}cls_noise_{sname}_{skn}.fits', overwrite=True) return
def coadd_saccs(saccfiles, tracers, ell_max_dict=None, trim_sacc=True): logger.info('Coadding all saccfiles weighted by inverse variance.') for saccfile in saccfiles: logger.info('Initial size of saccfile = {}.'.format( saccfile.mean.size)) logger.info('Removing B-modes.') saccfile.remove_selection(data_type='cl_eb') saccfile.remove_selection(data_type='cl_be') saccfile.remove_selection(data_type='cl_bb') saccfile.remove_selection(data_type='cl_0b') logger.info('Removing yxy.') saccfile.remove_selection(data_type='cl_00', tracers=('y_0', 'y_0')) logger.info('Removing kappaxkappa.') saccfile.remove_selection(data_type='cl_00', tracers=('kappa_0', 'kappa_0')) logger.info('Removing kappaxy.') saccfile.remove_selection(data_type='cl_00', tracers=('kappa_0', 'y_0')) saccfile.remove_selection(data_type='cl_00', tracers=('y_0', 'kappa_0')) logger.info('Size of saccfile after cuts = {}.'.format( saccfile.mean.size)) if ell_max_dict is not None: logger.info('Size of saccfile before ell cuts {}.'.format( saccfile.mean.size)) for tr_i, tr_j in saccfile.get_tracer_combinations(): if tr_i in tracers and tr_j in tracers: ell_max_curr = min(ell_max_dict[tr_i], ell_max_dict[tr_j]) logger.info('Removing ells > {} for {}, {}.'.format( ell_max_curr, tr_i, tr_j)) saccfile.remove_selection(tracers=(tr_i, tr_j), ell__gt=ell_max_curr) else: saccfile.remove_selection(tracers=(tr_i, tr_j)) logger.info('Size of saccfile after ell cuts {}.'.format( saccfile.mean.size)) ntracers_arr = np.array([len(saccfile.tracers) for saccfile in saccfiles]) ntracers_unique = np.unique(ntracers_arr)[::-1] saccs_list = [[] for i in range(ntracers_unique.shape[0])] for i in range(ntracers_unique.shape[0]): for saccfile in saccfiles: if len(saccfile.tracers) == ntracers_unique[i]: saccs_list[i].append(saccfile) sacc_coadds = [0 for i in range(ntracers_unique.shape[0])] for i in range(ntracers_unique.shape[0]): len_curr = ntracers_unique[i] nsacc_curr = len(saccs_list[i]) logger.info('Found {} saccfiles of length {}.'.format( nsacc_curr, len_curr)) for j, saccfile in enumerate(saccs_list[i]): if j == 0: coadd_mean = saccfile.mean coadd_cov = saccfile.covariance.covmat else: coadd_mean += saccfile.mean coadd_cov += saccfile.covariance.covmat coadd_mean /= nsacc_curr coadd_cov /= nsacc_curr**2 # Copy sacc saccfile_coadd = saccfile.copy() # Set mean of new saccfile to coadded mean saccfile_coadd.mean = coadd_mean saccfile_coadd.add_covariance(coadd_cov) sacc_coadds[i] = saccfile_coadd tempsacc = sacc_coadds[0] tempsacc_tracers = tempsacc.tracers.keys() datatypes = tempsacc.get_data_types() invcov_coadd = np.linalg.inv(tempsacc.covariance.covmat) mean_coadd = np.dot(invcov_coadd, tempsacc.mean) assert set(tracers) <= set(tempsacc_tracers), 'Larger tracer set requested than present in largest ' \ 'saccfile. Aborting.' for i, saccfile in enumerate(sacc_coadds[1:]): sacc_tracers = saccfile.tracers.keys() missing_tracers = list(set(tracers) - set(sacc_tracers)) logger.info('Found missing tracers {} in saccfile {}.'.format( missing_tracers, i)) invcov_small_curr = np.linalg.inv(saccfile.covariance.covmat) mean_big_curr = np.zeros_like(tempsacc.mean) invcov_big_curr = np.zeros_like(tempsacc.covariance.covmat) for datatype in datatypes: tracer_combs = tempsacc.get_tracer_combinations(data_type=datatype) for tr_i1, tr_j1 in tracer_combs: _, cl = saccfile.get_ell_cl(datatype, tr_i1, tr_j1, return_cov=False) ind_here = saccfile.indices(data_type=datatype, tracers=(tr_i1, tr_j1)) ind_tempsacc = tempsacc.indices(data_type=datatype, tracers=(tr_i1, tr_j1)) if not ind_here.size == 0: mean_big_curr[ind_tempsacc] = cl for tr_i2, tr_j2 in tracer_combs: ind_i1j1_curr = saccfile.indices(data_type=datatype, tracers=(tr_i1, tr_j1)) ind_i2j2_curr = saccfile.indices(data_type=datatype, tracers=(tr_i2, tr_j2)) subinvcov_curr = invcov_small_curr[np.ix_( ind_i1j1_curr, ind_i2j2_curr)] ind_i1j1_tempsacc = tempsacc.indices(data_type=datatype, tracers=(tr_i1, tr_j1)) ind_i2j2_tempsacc = tempsacc.indices(data_type=datatype, tracers=(tr_i2, tr_j2)) if ind_i1j1_curr.size != 0 and ind_i2j2_curr.size != 0: invcov_big_curr[np.ix_( ind_i1j1_tempsacc, ind_i2j2_tempsacc)] = subinvcov_curr mean_coadd += np.dot(invcov_big_curr, mean_big_curr) invcov_coadd += invcov_big_curr # Copy sacc saccfile_coadd = tempsacc.copy() # Set mean of new saccfile to coadded mean cov_coadd = np.linalg.inv(invcov_coadd) saccfile_coadd.mean = np.dot(cov_coadd, mean_coadd) saccfile_coadd.add_covariance(cov_coadd) if trim_sacc: logger.info('Trimming sacc - removing windows and covariance.') saccfile_coadd_trimmed = sacc.Sacc() for trc_name in saccfile_coadd.tracers.keys(): saccfile_coadd_trimmed.add_tracer_object( saccfile_coadd.tracers[trc_name]) datatypes = saccfile_coadd.get_data_types() for datatype in datatypes: tracer_combs = saccfile_coadd.get_tracer_combinations( data_type=datatype) for tr_i1, tr_j1 in tracer_combs: ell, cl = saccfile_coadd.get_ell_cl(datatype, tr_i1, tr_j1, return_cov=False) saccfile_coadd_trimmed.add_ell_cl(datatype, tr_i1, tr_j1, ell, cl) assert np.all( saccfile_coadd.mean == saccfile_coadd_trimmed.mean ), 'Error while trimming sacc, means not equal. Aborting.' saccfile_coadd_trimmed.add_covariance(cov_coadd) saccfile_coadd = saccfile_coadd_trimmed return saccfile_coadd