def test_workspace_deprojection_bias(self): #Test deprojection_bias c = nmt.deprojection_bias(self.f0, self.f0, self.n_good) self.assertEqual(c.shape, (1, self.f0.fl.lmax + 1)) with self.assertRaises(ValueError): c = nmt.deprojection_bias(self.f0, self.f0, self.n_bad) with self.assertRaises(ValueError): c = nmt.deprojection_bias(self.f0, self.f0, self.n_half) with self.assertRaises(RuntimeError): c = nmt.deprojection_bias(self.f0, self.f0_half, self.n_good)
def test_lite_errors(): f0 = nmt.NmtField(WT.msk, [WT.mps[0]], n_iter=0) fl = nmt.NmtField(WT.msk, [WT.mps[0]], templates=[[WT.tmp[0]]], n_iter=0, lite=True) with pytest.raises(ValueError): # Needs spin fe = nmt.NmtField(WT.msk, None) fe = nmt.NmtField(WT.msk, None, spin=0) for f in [fl, fe]: with pytest.raises(RuntimeError): # No deprojection bias nmt.deprojection_bias(f0, f, np.zeros([1, 3*WT.nside])) with pytest.raises(RuntimeError): # No deprojection bias nmt.uncorr_noise_deprojection_bias(fl, WT.mps[0]) with pytest.raises(RuntimeError): # No C_l without maps nmt.compute_coupled_cell(f0, fe)
def test_lite_cont(self): f0 = nmt.NmtField(self.msk, [self.mps[0]], templates=[[self.tmp[0]]]) f2 = nmt.NmtField(self.msk, [self.mps[1], self.mps[2]], templates=[[self.tmp[1], self.tmp[2]]]) f2l = nmt.NmtField(self.msk, [self.mps[1], self.mps[2]], templates=[[self.tmp[1], self.tmp[2]]]) f2e = nmt.NmtField(self.msk, None, lite=True, spin=2) clth = np.array([self.clte, 0*self.clte]) nlth = np.array([self.nlte, 0*self.nlte]) w = nmt.NmtWorkspace() w.compute_coupling_matrix(f0, f2e, self.b) clb = nlth dlb = nmt.deprojection_bias(f0, f2, clth+nlth) clb += dlb cl = w.decouple_cell(nmt.compute_coupled_cell(f0, f2l), cl_bias=clb) tl = np.loadtxt("test/benchmarks/bm_yc_np_c02.txt", unpack=True)[1:, :] tlb = np.loadtxt("test/benchmarks/bm_yc_np_cb02.txt", unpack=True)[1:, :] self.assertTrue((np.fabs(dlb-tlb) <= np.fmin(np.fabs(dlb), np.fabs(tlb))*1E-5).all()) self.assertTrue((np.fabs(cl-tl) <= np.fmin(np.fabs(cl), np.fabs(tl))*1E-5).all())
def test_workspace_deprojection_bias(): # Test deprojection_bias c = nmt.deprojection_bias(WT.f0, WT.f0, WT.n_good) assert c.shape == (1, WT.f0.fl.lmax+1) with pytest.raises(ValueError): nmt.deprojection_bias(WT.f0, WT.f0, WT.n_bad) with pytest.raises(ValueError): nmt.deprojection_bias(WT.f0, WT.f0, WT.n_half) with pytest.raises(RuntimeError): nmt.deprojection_bias(WT.f0, WT.f0_half, WT.n_good)
def mastest(self,wtemp,wpure) : prefix="test/benchmarks/bm" if wtemp : prefix+="_yc" f0=nmt.NmtField(self.msk,[self.mps[0]],templates=[[self.tmp[0]]]) f2=nmt.NmtField(self.msk,[self.mps[1],self.mps[2]], templates=[[self.tmp[1],self.tmp[2]]], purify_b=wpure) else : prefix+="_nc" f0=nmt.NmtField(self.msk,[self.mps[0]]) f2=nmt.NmtField(self.msk,[self.mps[1],self.mps[2]],purify_b=wpure) f=[f0,f2] if wpure : prefix+="_yp" else : prefix+="_np" for ip1 in range(2) : for ip2 in range(ip1,2) : if ip1==ip2==0 : clth=np.array([self.cltt]); nlth=np.array([self.nltt]); elif ip1==ip2==1 : clth=np.array([self.clee,0*self.clee,0*self.clbb,self.clbb]); nlth=np.array([self.nlee,0*self.nlee,0*self.nlbb,self.nlbb]); else : clth=np.array([self.clte,0*self.clte]); nlth=np.array([self.nlte,0*self.nlte]); w=nmt.NmtWorkspace() w.compute_coupling_matrix(f[ip1],f[ip2],self.b) clb=nlth if wtemp : dlb=nmt.deprojection_bias(f[ip1],f[ip2],clth+nlth) tlb=np.loadtxt(prefix+'_cb%d%d.txt'%(2*ip1,2*ip2),unpack=True)[1:,:] self.assertTrue((np.fabs(dlb-tlb)<=np.fmin(np.fabs(dlb),np.fabs(tlb))*1E-5).all()) clb+=dlb cl=w.decouple_cell(nmt.compute_coupled_cell(f[ip1],f[ip2]),cl_bias=clb) tl=np.loadtxt(prefix+'_c%d%d.txt'%(2*ip1,2*ip2),unpack=True)[1:,:] self.assertTrue((np.fabs(cl-tl)<=np.fmin(np.fabs(cl),np.fabs(tl))*1E-5).all())
def mastest(wtemp, wpure, do_teb=False): prefix = "test/benchmarks/bm" if wtemp: prefix += "_yc" f0 = nmt.NmtField(WT.msk, [WT.mps[0]], templates=[[WT.tmp[0]]]) f2 = nmt.NmtField(WT.msk, [WT.mps[1], WT.mps[2]], templates=[[WT.tmp[1], WT.tmp[2]]], purify_b=wpure) else: prefix += "_nc" f0 = nmt.NmtField(WT.msk, [WT.mps[0]]) f2 = nmt.NmtField(WT.msk, [WT.mps[1], WT.mps[2]], purify_b=wpure) f = [f0, f2] if wpure: prefix += "_yp" else: prefix += "_np" for ip1 in range(2): for ip2 in range(ip1, 2): if ip1 == ip2 == 0: clth = np.array([WT.cltt]) nlth = np.array([WT.nltt]) elif ip1 == ip2 == 1: clth = np.array([WT.clee, 0*WT.clee, 0*WT.clbb, WT.clbb]) nlth = np.array([WT.nlee, 0*WT.nlee, 0*WT.nlbb, WT.nlbb]) else: clth = np.array([WT.clte, 0*WT.clte]) nlth = np.array([WT.nlte, 0*WT.nlte]) w = nmt.NmtWorkspace() w.compute_coupling_matrix(f[ip1], f[ip2], WT.b) clb = nlth if wtemp: dlb = nmt.deprojection_bias(f[ip1], f[ip2], clth+nlth) tlb = np.loadtxt(prefix+'_cb%d%d.txt' % (2*ip1, 2*ip2), unpack=True)[1:, :] assert ((np.fabs(dlb-tlb) <= np.fmin(np.fabs(dlb), np.fabs(tlb))*1E-5).all()) clb += dlb cl = w.decouple_cell(nmt.compute_coupled_cell(f[ip1], f[ip2]), cl_bias=clb) tl = np.loadtxt(prefix+'_c%d%d.txt' % (2*ip1, 2*ip2), unpack=True)[1:, :] assert ((np.fabs(cl-tl) <= np.fmin(np.fabs(cl), np.fabs(tl))*1E-5).all()) # TEB if do_teb: clth = np.array([WT.cltt, WT.clte, 0*WT.clte, WT.clee, 0*WT.clee, 0*WT.clbb, WT.clbb]) nlth = np.array([WT.nltt, WT.nlte, 0*WT.nlte, WT.nlee, 0*WT.nlee, 0*WT.nlbb, WT.nlbb]) w = nmt.NmtWorkspace() w.compute_coupling_matrix(f[0], f[1], WT.b, is_teb=True) c00 = nmt.compute_coupled_cell(f[0], f[0]) c02 = nmt.compute_coupled_cell(f[0], f[1]) c22 = nmt.compute_coupled_cell(f[1], f[1]) cl = np.array([c00[0], c02[0], c02[1], c22[0], c22[1], c22[2], c22[3]]) t00 = np.loadtxt(prefix+'_c00.txt', unpack=True)[1:, :] t02 = np.loadtxt(prefix+'_c02.txt', unpack=True)[1:, :] t22 = np.loadtxt(prefix+'_c22.txt', unpack=True)[1:, :] tl = np.array([t00[0], t02[0], t02[1], t22[0], t22[1], t22[2], t22[3]]) cl = w.decouple_cell(cl, cl_bias=nlth) assert ((np.fabs(cl-tl) <= np.fmin(np.fabs(cl), np.fabs(tl))*1E-5).all())
clb22 = np.array([ nlee[:3 * nside_out], 0 * nlee[:3 * nside_out], 0 * nlbb[:3 * nside_out], nlbb[:3 * nside_out] ]) c22 = w22.decouple_cell(nmt.compute_coupled_cell(f2, f2), cl_bias=clb22) w22.write_to(prefix + '_w22.dat') np.savetxt(prefix + "_c22.txt", np.transpose([leff, c22[0], c22[1], c22[2], c22[3]])) #With contaminants prefix = 'bm_yc_np' f0 = nmt.NmtField(mask, [dl], templates=[[sl]]) f2 = nmt.NmtField(mask, [dw_q, dw_u], templates=[[sw_q, sw_u]]) w00 = nmt.NmtWorkspace() w00.compute_coupling_matrix(f0, f0, b) clb00 = nmt.deprojection_bias(f0, f0, [(cltt + nltt)[:3 * nside_out]]) np.savetxt(prefix + '_cb00.txt', np.transpose([lfull, clb00[0]])) clb00 += np.array([nltt[:3 * nside_out]]) c00 = w00.decouple_cell(nmt.compute_coupled_cell(f0, f0), cl_bias=clb00) w00.write_to(prefix + '_w00.dat') np.savetxt(prefix + "_c00.txt", np.transpose([leff, c00[0]])) w02 = nmt.NmtWorkspace() w02.compute_coupling_matrix(f0, f2, b) clb02 = nmt.deprojection_bias( f0, f2, [(clte + nlte)[:3 * nside_out], 0 * clte[:3 * nside_out]]) np.savetxt(prefix + '_cb02.txt', np.transpose([lfull, clb02[0], clb02[1]])) clb02 += np.array([nlte[:3 * nside_out], 0 * nlte[:3 * nside_out]]) c02 = w02.decouple_cell(nmt.compute_coupled_cell(f0, f2), cl_bias=clb02) w02.write_to(prefix + '_w02.dat') np.savetxt(prefix + "_c02.txt", np.transpose([leff, c02[0], c02[1]])) w22 = nmt.NmtWorkspace()
prefix + "_cl_th.txt", np.transpose([ b.get_effective_ells(), cl22_th[0], cl22_th[1], cl22_th[2], cl22_th[3] ])) #Compute noise and deprojection bias if not os.path.isfile(prefix + "_clb22.npy"): print("Computing deprojection and noise bias 22") #Compute noise bias clb22 = w22.couple_cell( [nlee / beam**2, 0 * nlee, 0 * nlbb, nlbb / beam**2]) #Compute deprojection bias if w_cont and (not o.no_deproject) and (not o.no_debias): #Signal contribution clb22 += nmt.deprojection_bias( f2, f2, [clee * beam**2 + nlee, 0 * clee, 0 * clbb, clbb * beam**2 + nlbb]) np.save(prefix + "_clb22", clb22) else: clb22 = np.load(prefix + "_clb22.npy") #Compute mean and variance over nsims simulations cl22_all = [] for i in np.arange(nsims): #if i%100==0 : print("%d-th sim" % (i + o.isim_ini)) if not os.path.isfile(prefix + "_cl_%04d.txt" % (o.isim_ini + i)): np.random.seed(1000 + o.isim_ini + i) f2 = get_fields() cl22 = w22.decouple_cell(nmt.compute_coupled_cell(f2, f2),
def process_catalog(o) : #Read z-binning print "Bins" z0_bins,zf_bins,lmax_bins=np.loadtxt(o.fname_bins_z,unpack=True) try: nbins=len(z0_bins) except: nbins=1 cat=fc.Catalog(read_from=o.fname_in) #Get weights, compute binary mask based on weights, and apodize it if needed print "Window" mask=Mask(cat,o.nside,o.theta_apo) nside=mask.nside tot_area=4.*np.pi*np.sum(mask.weights)/len(mask.weights) #Get contaminant templates if "none" not in o.templates_fname : templates=[[t] for t in hp.read_map(o.templates_fname,field=None)] ntemp=len(templates) else : templates=None ntemp=0 #Generate bandpowers binning scheme (we're assuming all maps will use the same bandpowers!) print "Bandpowers" bpw=nmt.NmtBin(nside,nlb=o.delta_ell) ell_eff=bpw.get_effective_ells() tracers=[] #Generate tracers print "Maps" #TODO: pass extra sampling parameters zs,nzs,mps=bin_catalog(cat,z0_bins,zf_bins,mask) if mrank!=0 : return #Make sure that we have an iterable try: len(lmax_bins) except: lmax_bins=[lmax_bins] for zar,nzar,mp,lmax in zip(zs,nzs,mps,lmax_bins): zav = np.average(zar,weights=nzar) print "-- z-bin: %3.2f "%zav tracers.append(Tracer(mp,zar,nzar,lmax,mask,templates=templates)) if o.save_map: hp.write_map("map_%3.2f.fits"%zav,mp) cat.rewind() print "Compute power spectra" #Compute coupling matrix #TODO: (only done once, assuming all maps have the same mask!) print " Computing coupling matrix" w=nmt.NmtWorkspace() if not(os.path.isfile(o.nmt_workspace)) : w.compute_coupling_matrix(tracers[0].field,tracers[0].field,bpw) if o.nmt_workspace!="none" : w.write_to(o.nmt_workspace) else : w.read_from(o.nmt_workspace) #Compute all cross-correlations def compute_master(fa,fb,wsp,clb=None,cln=None) : cl_coupled=nmt.compute_coupled_cell(fa,fb) cl_decoupled=wsp.decouple_cell(cl_coupled,cl_bias=clb,cl_noise=cln) return cl_decoupled #If attempting to deproject contaminant templates, we need an estimate of the true power spectra. #This can be done interatively from a first guess using cl_bias=0, but I haven't coded that up yet. #For the moment we will use cl_guess=0. cl_guess=np.zeros(3*nside) t1 = time() print " Computing power spectrum" cls_all={} for b1 in np.arange(nbins) : f1=tracers[b1].field for b2 in np.arange(b1,nbins) : f2=tracers[b2].field if (b1==b2) and o.sub_sn : cl_noise=tracers[b1].shotnoise*np.ones([1,3*nside]) else : cl_noise=None if ntemp>0 : cl_bias=nmt.deprojection_bias(f1,f2,w,cl_guess) else : cl_bias=None cls_all[(b1,b2)]=compute_master(f1,f2,w,clb=cl_bias,cln=cl_noise)[0] print 'Computed bin: ', b1, b2, ' in ', time()-t1, ' s' if debug: plt.figure() plt.plot(ell_eff,cls_all[(b1,b1)]) plt.xscale('log') plt.yscale('log') plt.xlabel(r'$l$') plt.ylabel(r'$C_{l}$') plt.show() print "Translating into SACC" #Transform everything into SACC format #1- Generate SACC tracers stracers=[sacc.Tracer("tr_b%d"%i,"point",t.zarr,t.nzarr,exp_sample="gals") for i,t in enumerate(tracers)] #2- Define SACC binning typ,ell,t1,q1,t2,q2=[],[],[],[],[],[] for i1 in np.arange(nbins) : for i2 in np.arange(i1,nbins) : lmax=min(tracers[i1].lmax,tracers[i2].lmax) for l in ell_eff[ell_eff<lmax] : typ.append('F') ell.append(l) t1.append(i1); t2.append(i2) q1.append('P'); q2.append('P') sbin=sacc.Binning(typ,ell,t1,q1,t2,q2) ssbin=sacc.SACC(stracers,sbin) #3- Arrange power spectra into SACC mean vector vec=np.zeros((ssbin.size(),)) for t1i,t2i,ells,ndx in ssbin.sortTracers() : lmax=min(tracers[t1i].lmax,tracers[t2i].lmax) vec[ndx]=cls_all[(t1i,t2i)][np.where(ell_eff<lmax)[0]] svec=sacc.MeanVec(vec) cw = nmt.covariance.NmtCovarianceWorkspace() cw.compute_coupling_coefficients(w,w) #4- Create SACC file and write to file csacc=sacc.SACC(stracers,sbin,svec) #5- Compute covariance if needed if o.compute_covariance: print "Computing covariance" sacc_th = csacc cov_all={} tcov0 = time() #This doesn't avoid some repetitions but it is the simplest way ngar=np.array([np.sum(t.nzarr)/tot_area for t in tracers]) for i1 in np.arange(nbins): for i2 in np.arange(i1,nbins): for i3 in np.arange(nbins): for i4 in np.arange(i3,nbins): cov_all[(i1,i2,i3,i4)]=compute_covariance(w,sacc_th.mean.vector,sacc_th.binning, i1,i2,i3,i4,ngar[i1],ngar[i2],cw) cov_all[(i2,i1,i4,i3)]=cov_all[(i1,i2,i3,i4)] cov=np.zeros((ssbin.size(),ssbin.size())) for t1i,t2i,ells,ndx in ssbin.sortTracers(): for t3i,t4i,ells2,ndy in ssbin.sortTracers(): lmax=min(tracers[t1i].lmax,tracers[t2i].lmax,tracers[t3i].lmax,tracers[t4i].lmax) cov[ndx,ndy]=cov_all[(t1i,t2i,t3i,t4i)][ell_eff<lmax,ell_eff<lmax] icov=inv(cov) precision=sacc.Precision(icov,"dense",sbin) csacc=sacc.SACC(stracers,sbin,svec,precision) print 'Computed covariance in', time()-tcov0, ' seconds' csacc.saveToHDF(o.fname_out)
# ii) Generate random realizations of our fields to compute the errors l, cltt, clee, clbb, clte = np.loadtxt("cls.txt", unpack=True) cl_02_th = np.array([clte, np.zeros_like(clte)]) #We then generate an NmtWorkspace object that we use to compute and store #the mode coupling matrix. Note that this matrix depends only on the masks #of the two fields to correlate, but not on the maps themselves (in this #case both maps are the same. w = nmt.NmtWorkspace() w.compute_coupling_matrix(f0, f2, b) #Since we suspect that our maps are contaminated (that's why we passed the #contaminant templates as arguments to the NmtField constructor), we also #need to compute the bias to the power spectrum caused by contaminant #cleaning (deprojection bias). cl_bias = nmt.deprojection_bias(f0, f2, cl_02_th) #The function defined below will compute the power spectrum between two #NmtFields f_a and f_b, using the coupling matrix stored in the #NmtWorkspace wsp and subtracting the deprojection bias clb. #Note that the most expensive operations in the MASTER algorithm are #the computation of the coupling matrix and the deprojection bias. Since #these two objects are precomputed, this function should be pretty fast! def compute_master(f_a, f_b, wsp, clb): #Compute the power spectrum (a la anafast) of the masked fields #Note that we only use n_iter=0 here to speed up the computation, #but the default value of 3 is recommended in general. cl_coupled = nmt.compute_coupled_cell(f_a, f_b) #Decouple power spectrum into bandpowers inverting the coupling matrix cl_decoupled = wsp.decouple_cell(cl_coupled, cl_bias=clb)
ff2 = nmt.NmtField(mask, [mppq, mppu], purify_e=ispure_e, purify_b=ispure_b, n_iter_mask_purify=10) return mppq, mppu, ff2 mpq, mpu, f2 = get_fields() if plotres: hp.mollview((mpq * mask).flatten(), title='$Q$') hp.mollview((mpu * mask).flatten(), title='$U$') #Compute deprojection bias if w_cont: #Not ready yet clb22 = nmt.deprojection_bias(f2, f2, [clee, 0 * clee, 0 * clbb, clbb]) else: clb22 = None #Use initial fields to generate coupling matrix w22 = nmt.NmtWorkspace() if not os.path.isfile(prefix + "_w22.dat"): print "Computing 22" w22.compute_coupling_matrix(f2, f2, b) w22.write_to(prefix + "_w22.dat") else: w22.read_from(prefix + "_w22.dat") #Generate theory prediction cl22_th = w22.decouple_cell(w22.couple_cell([clee, 0 * clee, 0 * clbb, clbb])) np.savetxt(
else: ff0 = nmt.NmtField(mask, [mppt]) ff2 = nmt.NmtField(mask, [mppq, mppu]) return mppt, mppq, mppu, ff0, ff2 mpt, mpq, mpu, f0, f2 = get_fields() if plotres: hp.mollview((mpt * mask).flatten(), title='$\\delta_g$') hp.mollview((mpq * mask).flatten(), title='$\\gamma_1$') hp.mollview((mpu * mask).flatten(), title='$\\gamma_2$') #Compute deprojection bias if w_cont: clb00 = nmt.deprojection_bias(f0, f0, [cltt]) clb02 = nmt.deprojection_bias(f0, f2, [clte, 0 * clte]) clb22 = nmt.deprojection_bias(f2, f2, [clee, 0 * clee, 0 * clbb, clbb]) else: clb00 = None clb02 = None clb22 = None #Use initial fields to generate coupling matrix w00 = nmt.NmtWorkspace() if not os.path.isfile(prefix + "_w00.dat"): print "Computing 00" w00.compute_coupling_matrix(f0, f0, b) w00.write_to(prefix + "_w00.dat") else: w00.read_from(prefix + "_w00.dat")
def process_catalog(o): #Read z-binning print "Bins" z0_bins, zf_bins, lmax_bins = np.loadtxt(o.fname_bins_z, unpack=True) nbins = len(z0_bins) cat = fc.Catalog(read_from=o.fname_in) #Get weights, compute binary mask based on weights, and apodize it if needed print "Window" mask = Mask(cat, o.nside, o.theta_apo) nside = mask.nside #Get contaminant templates #TODO: check resolution if o.templates_fname != "none": templates = [[t] for t in hp.read_map(o.templates_fname, field=None)] ntemp = len(templates) else: templates = None ntemp = 0 #Generate bandpowers binning scheme (we're assuming all maps will use the same bandpowers!) print "Bandpowers" bpw = nmt.NmtBin(nside, nlb=o.delta_ell) ell_eff = bpw.get_effective_ells() tracers = [] #Generate tracers #TODO: pass extra sampling parameters zs, nzs, mps = bin_catalog(cat, z0_bins, zf_bins, mask) if mrank != 0: return for zar, nzar, mp, lmax in zip(zs, nzs, mps, lmax_bins): zav = np.average(zar, weights=nzar) print "-- z-bin: %3.2f " % zav tracers.append(Tracer(mp, zar, nzar, lmax, mask, templates=templates)) if o.save_map: hp.write_map("map_%3.2f.fits" % zav, mp) cat.rewind() print "Compute power spectra" #Compute coupling matrix #TODO: (only done once, assuming all maps have the same mask!) print " Computing coupling matrix" w = nmt.NmtWorkspace() if not (os.path.isfile(o.nmt_workspace)): w.compute_coupling_matrix(tracers[0].field, tracers[0].field, bpw) if o.nmt_workspace != "none": w.write_to(o.nmt_workspace) else: w.read_from(o.nmt_workspace) #Compute all cross-correlations def compute_master(fa, fb, wsp, clb): cl_coupled = nmt.compute_coupled_cell(fa, fb) cl_decoupled = wsp.decouple_cell(cl_coupled, cl_bias=clb) return cl_decoupled #If attempting to deproject contaminant templates, we need an estimate of the true power spectra. #This can be done interatively from a first guess using cl_bias=0, but I haven't coded that up yet. #For the moment we will use cl_guess=0. cl_guess = np.zeros(3 * nside) t1 = time() print " Computing power spectrum" cls_all = {} for b1 in np.arange(nbins): f1 = tracers[b1].field for b2 in np.arange(b1, nbins): f2 = tracers[b2].field if ntemp > 0: cl_bias = nmt.deprojection_bias(f1, f2, w, cl_theory) else: cl_bias = None cls_all[(b1, b2)] = compute_master(f1, f2, w, clb=cl_bias)[0] print 'Computed bin: ', b1, b2, ' in ', time() - t1, ' s' if debug: plt.figure() plt.plot(ell_eff, cls_all[(b1, b1)]) plt.xscale('log') plt.yscale('log') plt.xlabel(r'$l$') plt.ylabel(r'$C_{l}$') plt.show() print "Translating into SACC" #Transform everything into SACC format #1- Generate SACC tracers stracers = [ sacc.Tracer("tr_b%d" % i, "point", t.zarr, t.nzarr, exp_sample="gals") for i, t in enumerate(tracers) ] #2- Define SACC binning typ, ell, t1, q1, t2, q2 = [], [], [], [], [], [] for i1 in np.arange(nbins): for i2 in np.arange(i1, nbins): lmax = min(tracers[i1].lmax, tracers[i2].lmax) for l in ell_eff[ell_eff < lmax]: typ.append('F') ell.append(l) t1.append(i1) t2.append(i2) q1.append('P') q2.append('P') sbin = sacc.Binning(typ, ell, t1, q1, t2, q2) ssbin = sacc.SACC(stracers, sbin) #3- Arrange power spectra into SACC mean vector vec = np.zeros((ssbin.size(), )) for t1i, t2i, ells, ndx in ssbin.sortTracers(): lmax = min(tracers[t1i].lmax, tracers[t2i].lmax) vec[ndx] = cls_all[(t1i, t2i)][np.where(ell_eff < lmax)[0]] svec = sacc.MeanVec(vec) #4- Create SACC file and write to file csacc = sacc.SACC(stracers, sbin, svec) csacc.saveToHDF(o.fname_out)