def main(dic_par): cosmo = ccl.Cosmology( ccl.Parameters( Omega_c=dic_par['omega_c'], Omega_b=dic_par['omega_b'], h=dic_par['h0'], sigma8=dic_par['sigma_8'], n_s=dic_par['n_s'], ), transfer_function=dic_par['transfer_function'], matter_power_spectrum=dic_par['matter_power_spectrum']) tracers, cltracers = getTracers(cosmo, dic_par) binning = getBinning(tracers) binning_sacc = sacc.SACC(tracers, binning) theories = getTheories(cosmo, binning_sacc, cltracers) mean = getTheoryVec(binning_sacc, theories) precision, covmatrix = getPrecisionMatrix(binning_sacc, theories) chol = la.cholesky(covmatrix) csacc = sacc.SACC(tracers, binning, mean, precision) csacc.printInfo() ## generate mean sim generate_sim("sims/sim_mean.sacc", csacc, add_random=False, store_precision=True, cholesky=chol) #Generate file containing only noiseless realization and precision matrix nsim = 10 for i in np.arange(nsim): generate_sim("sims/sim_%03d.sacc" % i, csacc, cholesky=chol)
def get_mean_cov(s_data, Ntr, Nztr, noi_fac, upsample): ## THIS IMPLEMENTS UPSAMPLING + SECTION 2.2.1 # photo-z codes pz_codes = ['nz_demp', 'nz_ephor', 'nz_ephor_ab', 'nz_frankenz'] # store new tracers and noise covariance myNztr = Nztr * upsample cov_all = np.zeros((myNztr * Ntr, myNztr * Ntr)) tr = [] for i in range(Ntr): # get nz for all pz codes zs = s_data.tracers[i].z nzs = s_data.tracers[i].Nz nzs /= np.sum(nzs) if (upsample >= 1): minz, maxz = zs[0], zs[-1] newzs = zs[0] + np.arange(myNztr) * (maxz - minz) / (Nztr - 1) / upsample newnzs = np.zeros(myNztr) w = np.where(newzs <= maxz) newnzs[w] = [interp1d(zs, nzs, kind='cubic')(newzs[w])] nzs = [newnzs] else: newzs = zs nzs = [nzs] for pn in pz_codes: n = s_data.tracers[i].extra_cols[pn] n /= np.sum(n) newn = np.zeros(myNztr) newn[w] = interp1d(zs, n, kind='cubic')(newzs[w]) nzs.append(newn) nzs = np.array(nzs) # get mean and variance #nz_mean = np.mean(nzs, axis=0) # TESTING nz_mean = np.zeros(myNztr) nz_mean[w] = interp1d(zs, s_data.tracers[i].Nz, kind='cubic')(newzs[w]) nz_var = np.var(nzs, axis=0) # TODO: is this necessary? nz_var = gaussian_filter(nz_var, 2.5 * upsample) # TODO: is this correct? # used to be #corr = np.eye(Nztr) #sqrtnz_var = np.sqrt(nz_var) #cov = noi_fac*np.outer(sqrtnz_var,sqrtnz_var)*corr # I think it should be cov = noi_fac * np.diag(nz_var) cov_all[i * myNztr:(i + 1) * myNztr, i * myNztr:(i + 1) * myNztr] = cov # store new tracers T = sacc.Tracer('bin_%d' % i, 'point', newzs, nz_mean, exp_sample='HSC_DESC') tr.append(T) s_m = sacc.SACC(tr, s_data.binning, s_data.mean) return s_m, cov_all
def get_mean_cov(s_data, Ntr, Nztr, noi_fac): # photo-z codes pz_codes = ['nz_demp', 'nz_ephor', 'nz_ephor_ab', 'nz_frankenz'] # store new tracers and noise covariance cov_all = np.zeros((Nztr * Ntr, Nztr * Ntr)) tr = [] for i in range(Ntr): # get nz for all pz codes zs = s_data.tracers[i].z nzs = [s_data.tracers[i].Nz / np.sum(s_data.tracers[i].Nz)] for pn in pz_codes: n = s_data.tracers[i].extra_cols[pn] nzs.append(n / np.sum(n)) nzs = np.array(nzs) # get mean and variance nz_mean = np.mean(nzs, axis=0) nz_var = np.var(nzs, axis=0) nz_var_mean = nz_var[nz_mean > 0].mean() cov = np.diag(noi_fac * nz_var_mean * np.ones(len(zs))) cov_all[i * len(zs):(i + 1) * len(zs), i * len(zs):(i + 1) * len(zs)] = cov # store new tracers T = sacc.Tracer('bin_%d' % i, 'point', zs, nz_mean, exp_sample='HSC_DESC') tr.append(T) s_m = sacc.SACC(tr, s_data.binning, s_data.mean) return s_m, cov_all
def write_vector_to_sacc(self, fname_out, sacc_t, sacc_b, cls, covar=None, verbose=False): """ Write a vector of power spectrum measurements into a SACC file. :param fname_out: path to output file :param sacc_t: list of SACC tracers :param sacc_b: SACC Binning object. :param cls: list of power spectrum measurements. :param covar: covariance matrix: :param verbose: do you want to print out information about the SACC file? """ sacc_mean = sacc.MeanVec(cls.flatten()) if covar is None: sacc_precision = None else: sacc_precision = sacc.Precision(covar, "dense", is_covariance=True, binning=sacc_b) sacc_meta = {'Area_rad': self.area_patch} s = sacc.SACC(sacc_t, sacc_b, sacc_mean, precision=sacc_precision, meta=sacc_meta) if verbose: s.printInfo() s.saveToHDF(fname_out)
def get_smooth_s_and_prior(s_data, cosmo, want_prior, A_smooth=0.25, noi_fac=4.): # number of tracers and bins Nz_per_tracer = len(s_data.tracers[0].z) N_tracers = len(s_data.tracers) Nz_total = N_tracers * Nz_per_tracer zs = s_data.tracers[0].z # obtain the mean of the 4 pz codes with their noise s_mean, cov_noise = get_mean_cov(s_data, N_tracers, Nz_per_tracer, noi_fac) s0 = NzVec(s_data) # compute the CV if os.path.isfile("cov_CV.npy"): print("!!!!! Loading cached CV covariance matrix !!!!!") cov_CV = np.load("cov_CV.npy") else: # compute cv covmat cov_CV = np.zeros((Nz_total, Nz_total)) for i in range(N_tracers): # cosmic variance covmat for each tracer cov_CV_per_tracer = compute_covmat_cv(cosmo, s_mean.tracers[i].z, s_mean.tracers[i].Nz) cov_CV[i * Nz_per_tracer:(i + 1) * Nz_per_tracer, i * Nz_per_tracer:(i + 1) * Nz_per_tracer] = cov_CV_per_tracer np.save("cov_CV.npy", cov_CV) # impose smoothness of first and second derivative D = A_smooth**2 * obtain_smoothing_D(s_mean, first=True, second=True) # compute total covariance of noise cov_total = cov_noise + cov_CV # compute precision with and without the smoothing matrix D P0 = np.linalg.inv(cov_total) P = P0 + D # get the smoothed N(z) for all tracers s_smooth = np.dot(np.dot(np.linalg.inv(P0 + D), P0), s0) print(s0[:10], s_smooth[:10]) tr = [] for i in range(N_tracers): T = sacc.Tracer('bin_%d' % i, 'point', zs, s_smooth[i * Nz_per_tracer:(i + 1) * Nz_per_tracer], exp_sample='HSC_DESC') tr.append(T) s = sacc.SACC(tr, s_data.binning, s_data.mean) # return smooth s (and smooth prior) if want_prior: return s, P else: return s
def save_cell_to_file(self, cell, tracers, binning, fname): # Create data vector vector = [] for b1, b2, s1, s2, l1, l2 in self.get_cell_iterator(): add_BE = not ((b1 == b2) and (s1 == s2)) vector.append(cell[l1][l2][0]) #EE vector.append(cell[l1][l2][1]) #EB if add_BE: #Only add B1E2 if 1!=2 vector.append(cell[l1][l2][2]) #BE vector.append(cell[l1][l2][3]) #BB sacc_mean = sacc.MeanVec(np.array(vector).flatten()) s = sacc.SACC(tracers, binning, sacc_mean) print("Saving to " + fname) s.saveToHDF(fname)
Tmatfn = "Tmat_%s_%i.npy"%(read,upsample) if os.path.isfile(Tmatfn): print ("Loading cached Tmat") Tmat = np.load(Tmatfn) else: Tmat = obtain_Tmat(s_m,s_noi,hod_params,Z_params,HMCorrection) np.save(Tmatfn,Tmat) # Obtain the new covariance matrix cov_CVnoismo = obtain_improved_cov(cov,Tmat,prior_smo) # Weirdly it seems like this object actually expects the covariance rather than the precision cov_n = sacc.Precision(cov_CVnoismo) # Create new sacc file (TODO: ask about "dense") s_n = sacc.SACC(s_d.tracers,s_d.binning,s_d.mean.vector,cov_n,meta=s_d.meta) # Save the new covariance and the power spectrum of the data which shall be run via MCMC if not os.path.exists(dir_write): os.makedirs(dir_write) s_n.saveToHDF(dir_write+"/power_spectra_wdpj.sacc") # Copying noise bias file shutil.copy(dir_read +"/noi_bias.sacc",dir_write) # !!!!! Everything below is just for checking that the code works !!!!!! # Sanity check of implementation prec_CVnoismo = s_n.precision.getPrecisionMatrix()
q2_arr += nbands * [q2] t1_arr += nbands * [t1] t2_arr += nbands * [t2] typ_arr += nbands * [typ] bins = sacc.Binning(typ_arr, ls_arr, t1_arr, q1_arr, t2_arr, q2_arr, windows=w_arr) #Write s_d = sacc.SACC(tracers, bins, mean=v_signal, precision=precis, meta={'data_name': 'SO_V3_Mock_no_noise_data'}) s_f = sacc.SACC(tracers, bins, mean=v_signal, meta={'data_name': 'SO_V3_Mock_no_noise_fiducial'}) s_n = sacc.SACC(tracers, bins, mean=v_noise, meta={'data_name': 'SO_V3_Mock_no_noise_noise'}) s_d.saveToHDF(prefix_out + ".sacc") s_d.printInfo() s_f.saveToHDF(prefix_out + "_fiducial.sacc") s_f.printInfo()
val.append(np.random.uniform(0, 10)) err.append(np.random.uniform(1, 2)) binning = sacc.Binning(type, ell, t1, q1, t2, q2, windows=wins) mean = sacc.MeanVec(val) ## We need to add covariance matrix. We will use ell_block_diagonal ## where everything is coupled across tracers/redshifts at the same ell but not ## across ell with fixed 10% off-diagonal elements Np = binning.size() cov = np.zeros((Np, Np)) for i in range(Np): for j in range(i, Np): if ell[i] == ell[j]: cov[i, j] = err[i] * err[j] if (i != j): cov[i, j] /= 10 cov[j, i] = cov[i, j] precision = sacc.Precision(cov, "ell_block_diagonal", is_covariance=True, binning=binning) ## Add some meta data meta = {"Creator": "McGyver", "Project": "Victory"} ## finally, create SACC object s = sacc.SACC(tracers, binning, mean, precision, meta) s.printInfo() s.saveToHDF("test.sacc")
typ = q1 + q2 for b in range(nells): w = windows[b, ic] lmean = np.sum(ls * w) / np.sum(w) win = sacc.Window(ls, w) ls_arr.append(lmean) w_arr.append(win) q1_arr += nells * [q1] q2_arr += nells * [q2] t1_arr += nells * [t1] t2_arr += nells * [t2] typ_arr += nells * [typ] bins = sacc.Binning(typ_arr, ls_arr, t1_arr, q1_arr, t2_arr, q2_arr, windows=w_arr) #SACC file s = sacc.SACC(tracers, bins, mean=meanvec, precision=precis, meta={'data_name': 'BK15_bmode_analysis'}) #Save SACC file s.saveToHDF("BK15.sacc") s.printInfo()
nz_new += np.sum((np.random.randn(n_svd) * sigs)[None, :] * evs, axis=1) T = sacc.Tracer('bin_%d' % i, 'point', zs, nz_new, exp_sample='HSC_DESC') tr.append(T) return tr tr_mean = get_new_tracers(add_random=False) tr_rand = get_new_tracers(add_random=True, n_svd=4) # SACC object containing the mean N(z) (which we will treat as the truth) s_mean = sacc.SACC(tr_mean, s_d.binning, s_d.mean) # Halo model correction cosmo = ccl.Cosmology(n_s=0.9649, sigma8=0.8111, h=0.6736, Omega_c=0.264, Omega_b=0.0493) HMCorr = HaloModCorrection(cosmo, k_range=[1e-4, 1e2], nlk=256, z_range=[0., 3.], nz=50) # Parameters cosmo_params = {
for i2 in range(i1, 2 * nfreqs): b2 = i2 // 2 p2 = i2 % 2 ty = pol_names[p1] + pol_names[p2] for il, ll in enumerate(ells_bpw): ell.append(ll) typ.append(ty) t1.append(b1) t2.append(b2) q1.append('C') q2.append('C') bins = sacc.Binning(typ, ell, t1, q1, t2, q2) bpw_model = bpw_model.reshape([2 * nfreqs, 2 * nfreqs, n_bpw])[np.triu_indices(2 * nfreqs)].flatten() mean_model = sacc.MeanVec(bpw_model) sacc_model = sacc.SACC(tracers, bins, mean=mean_model) os.system('mkdir -p ' + prefix_out) sacc_model.saveToHDF(prefix_out + "/cells_model.sacc") nhits_binary = np.zeros_like(nhits) inv_sqrtnhits = np.zeros_like(nhits) inv_sqrtnhits[nhits > 1E-3] = 1. / np.sqrt(nhits[nhits > 1E-3]) nhits_binary[nhits > 1E-3] = 1 #Add noise ylf = 1 nell = np.zeros([nfreqs, lmax + 1]) _, nell[:, 2:], _ = Simons_Observatory_V3_SA_noise(sens, knee, ylf, fsky, lmax + 1,
w_arr=[] for ic, c in enumerate(corr_ordering): s1, s2 = c tn1 = s1[:-2] q1 = s1[-1] t1 = np.where(tracer_names==tn1)[0][0] tn2 = s2[:-2] q2 = s2[-1] t2 = np.where(tracer_names==tn2)[0][0] typ = q1 + q2 for b in range(nells) : w = windows[typ][b] lmean = np.sum(ls * w) / np.sum(w) win = sacc.Window(ls, w) ls_arr.append(lmean) w_arr.append(win) q1_arr += nells * [q1] q2_arr += nells * [q2] t1_arr += nells * [t1] t2_arr += nells * [t2] typ_arr += nells * [typ] bins = sacc.Binning(typ_arr, ls_arr, t1_arr, q1_arr, t2_arr, q2_arr, windows=w_arr) #SACC files s = sacc.SACC(tracers, bins, mean=meanvec, precision=precis, meta={'data_name':'ACTPol_TT_TE_EE_analysis'}) #Save SACC file s.saveToHDF("ACTPol_0.sacc") s.printInfo()
def get_smooth_s_and_prior(s_data, cosmo, noi_fac=4., A_smooth=1., dz_thr=0.04, upsample=1, cov_cv=True): # number of tracers and bins Nz_per_tracer = len(s_data.tracers[0].z) N_tracers = len(s_data.tracers) Nz_total = N_tracers * Nz_per_tracer zs_data = s_data.tracers[0].z # obtain the mean of the 4 pz codes with their noise s_mean, cov_noise = get_mean_cov(s_data, N_tracers, Nz_per_tracer, noi_fac, upsample) zs_mean = s_mean.tracers[0].z s0 = NzVec(s_mean) if cov_cv: # compute the CV covfn = "cov_CV_%i.npy" % (upsample) if os.path.isfile(covfn): print("!!!!! Loading cached CV covariance matrix !!!!!") cov_CV = np.load(covfn) else: # compute cv covmat cov_CV = np.zeros((Nz_total * upsample, Nz_total * upsample)) for i in range(N_tracers): print("Tracer = %i out of %i" % (i, N_tracers - 1)) # cosmic variance covmat for each tracer cov_CV_per_tracer = compute_covmat_cv(cosmo, s_data.tracers[i].z, s_data.tracers[i].Nz) if upsample > 1: new_Nz_per_tracer = Nz_per_tracer * upsample assert (new_Nz_per_tracer == len(zs_mean)) cov_CV_up_per_tracer = np.zeros( (new_Nz_per_tracer, new_Nz_per_tracer)) intermediate_cov = np.zeros( (Nz_per_tracer, new_Nz_per_tracer)) bor_cov_CV_up_per_tracer = np.zeros( (new_Nz_per_tracer, new_Nz_per_tracer)) """ ## I think this might or might not be right. ## but in fact it is, just looks wrong. for row in range(Nz_per_tracer): fun = interpolate.interp1d(zs_data,cov_CV_per_tracer[row,:],fill_value="extrapolate") bor_cov_CV_up_per_tracer[row,:] = fun(zs_mean) for col in range(Nz_per_tracer*upsample): fun = interpolate.interp1d(zs_data,bor_cov_CV_up_per_tracer[:len(zs_data),col],fill_value="extrapolate") bor_cov_CV_up_per_tracer[:,col] = fun(zs_mean) """ for row in range(Nz_per_tracer): fun = interpolate.interp1d(zs_data, cov_CV_per_tracer[row, :], fill_value="extrapolate") intermediate_cov[row, :] = fun(zs_mean) for col in range(Nz_per_tracer * upsample): fun = interpolate.interp1d(zs_data, intermediate_cov[:, col], fill_value="extrapolate") cov_CV_up_per_tracer[:, col] = fun(zs_mean) print(bor_cov_CV_up_per_tracer - cov_CV_up_per_tracer) cov_CV[i * len(zs_mean):(i + 1) * len(zs_mean), i * len(zs_mean):(i + 1) * len(zs_mean)] = cov_CV_up_per_tracer else: cov_CV[i * len(zs_mean):(i + 1) * len(zs_mean), i * len(zs_mean):(i + 1) * len(zs_mean)] = cov_CV_per_tracer np.save(covfn, cov_CV) else: cov_CV = 0 # impose smoothness D = obtain_generalized_D(s_mean, A_smooth, dz_thr) # compute total covariance of noise cov_total = cov_noise + cov_CV # compute precision with and without the smoothing matrix D P0 = np.linalg.inv(cov_total) P = P0 + D # get the smoothed N(z) for all tracers s_smooth = np.dot(np.dot(np.linalg.inv(P0 + D), P0), s0) #s_smooth = s0 tr = [] for i in range(N_tracers): T = sacc.Tracer('bin_%d' % i, 'point', zs_mean, s_smooth[i * Nz_per_tracer * upsample:(i + 1) * Nz_per_tracer * upsample], exp_sample='HSC_DESC') tr.append(T) s = sacc.SACC(tr, s_data.binning, s_data.mean) # return smooth s and smoothing prior return s, P
return theo def getTheoryVec(s, cls_theory): vec=np.zeros((s.size(),)) for t1i,t2i,ells,ndx in s.sortTracers(): vec[ndx]=cls_theory[(t1i,t2i)] return sacc.MeanVec(vec) print 'Setting up cosmology' cosmo = ccl.Cosmology(ccl.Parameters(Omega_c=0.266,Omega_b=0.049,h=hhub,sigma8=0.8,n_s=0.96,),matter_power_spectrum='linear',transfer_function='eisenstein_hu') #Compute grid scale zmax=2.5 ngrid=3072 a_grid=2*ccl.comoving_radial_distance(cosmo,1./(1+zmax))*(1+2./ngrid)/ngrid*hhub print "Grid smoothing : %.3lf Mpc/h"%a_grid print 'Reading SACC file' #SACC File with the N(z) to analyze binning_sacc = sacc.SACC.loadFromHDF('../test/catalog0.sacc') #Bias file (it can also be included in the SACC file in the line before) bias_tab = astropy.table.Table.read('../test/bz_lsst.txt',format='ascii') tracers = binning_sacc.tracers print 'Got ',len(tracers),' tracers' cltracers=[ccl.ClTracerNumberCounts(cosmo,False,False,n=(t.z,t.Nz),bias=(bias_tab['col1'],bias_tab['col2']),r_smooth=0.5*a_grid) for t in tracers] print 'Cl tracers ready' theories = getTheories(cosmo,binning_sacc,cltracers) mean=getTheoryVec(binning_sacc,theories) csacc=sacc.SACC(tracers,binning_sacc.binning,mean) csacc.printInfo() csacc.saveToHDF('theory.sacc',save_precision=False)
T.addColumns({'ndens':t.ndens_perad*np.ones_like(nz)}) sacc_tracers.append(T) #Binning and mean type,ell,dell,t1,q1,t2,q2=[],[],[],[],[],[],[] for t1i in range(nbins) : for t2i in range(t1i,nbins) : for i_l,l in enumerate(ell_eff) : type.append('F') #Fourier-space ell.append(l) dell.append(lend[i_l]-lini[i_l]) t1.append(t1i) q1.append('P') t2.append(t2i) q2.append('P') sacc_binning=sacc.Binning(type,ell,t1,q1,t2,q2,deltaLS=dell,windows=windows_sacc) sacc_mean=sacc.MeanVec(cls_all.flatten()) if covar is None : sacc_precision=None else : sacc_precision=sacc.Precision(covar,"dense",is_covariance=True, binning=sacc_binning) sacc_meta={'Field':o.hsc_field,'Area_rad':area_patch} s=sacc.SACC(sacc_tracers,sacc_binning,sacc_mean,precision=sacc_precision,meta=sacc_meta) s.printInfo() s.saveToHDF(o.prefix_out+'.sacc') #Save noise sacc_binning_noise=sacc.Binning(type,ell,t1,q1,t2,q2,deltaLS=dell) sacc_mean_noise=sacc.MeanVec(nls_all.flatten()) s=sacc.SACC(sacc_tracers,sacc_binning_noise,sacc_mean_noise,precision=None,meta=sacc_meta) s.printInfo() s.saveToHDF(o.prefix_out+'_noise.sacc')
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)
sacc_tracers.append(T) #Binning and mean type, ell, dell, t1, q1, t2, q2 = [], [], [], [], [], [], [] for t1i in range(nbins): for t2i in range(t1i, nbins): for i_l, l in enumerate(ell_eff): type.append('F') #Fourier-space ell.append(l) dell.append(lend[i_l] - lini[i_l]) t1.append(t1i) q1.append('P') t2.append(t2i) q2.append('P') sacc_binning = sacc.Binning(type, ell, t1, q1, t2, q2, deltaLS=dell) sacc_mean = sacc.MeanVec(cls_all.flatten()) if covar is None: sacc_precision = None else: sacc_precision = sacc.Precision(covar, "dense", is_covariance=True, binning=sacc_binning) sacc_meta = {'Field': o.hsc_field, 'Area_rad': area_patch} s = sacc.SACC(sacc_tracers, sacc_binning, sacc_mean, precision=sacc_precision, meta=sacc_meta) s.printInfo() s.saveToHDF(o.fname_out)
q2_arr += nells * [q2] t1_arr += nells * [t1] t2_arr += nells * [t2] typ_arr += nells * [typ] bins = sacc.Binning(typ_arr, ls_arr, t1_arr, q1_arr, t2_arr, q2_arr, windows=w_arr) #SACC files s = sacc.SACC(tracers, bins, mean=meanvec, precision=precis, meta={'data_name': 'BK15_bmode_analysis'}) s_f = sacc.SACC(tracers, bins, mean=meanvec_f, meta={'data_name': 'BK15_bmode_analysis_fiducial'}) s_n = sacc.SACC(tracers, bins, mean=meanvec_n, meta={'data_name': 'BK15_bmode_analysis_noise'}) #Save SACC file s.saveToHDF("BK15.sacc") s.printInfo() s_n.saveToHDF("BK15_noise.sacc")
axis=0) / area) for i_w, ww in enumerate(sc['GAMA09H'].binning.windows) ] # Bins s_bn = sc['GAMA09H'].binning s_bn.windows = wins # Tracers s_tr = [] for i_t in range(4): T = sacc.Tracer('bin_%d' % i_t, 'point', zs[i_t], Nz[i_t], exp_sample="HSC_DESC") T.addColumns({pn: ec[pn][i_t] for pn in pz_codes}) s_tr.append(T) # Signal spectra s_mean = sacc.MeanVec(mean) s_prec = sacc.Precision(cov, "dense", is_covariance=True, binning=s_bn) s_meta = {'Area_rad': area} s = sacc.SACC(s_tr, s_bn, s_mean, precision=s_prec, meta=s_meta) s.saveToHDF("COADD/power_spectra_wdpj.sacc") # Noise spectra s_mean = sacc.MeanVec(mean_n) s_bn.windows = None s = sacc.SACC(s_tr, s_bn, s_mean, meta=s_meta) s.saveToHDF("COADD/noi_bias.sacc")
def save_to_sacc(self, fname, t, b, v, cov=None, return_sacc=False): s = sacc.SACC(t, b, mean=v, precision=cov) s.saveToHDF(fname) if return_sacc: return s