def execute(block, config): nz_dir = config['nz_dir'] r_array = config['r_array'] do_save_xi = config['do_save_xi'] use_mean_z = config['use_mean_z'] k_hres = config['k_hres'] Pkth_array_khres = config['Pkth_array_khres'] xi_all = config['xi_all'] bias_section = config['bias_section'] constraint_b2 = config['constraint_b2'] pt_type = config['pt_type'] nbins = config['nbins'] xi_mm = xi_all[1] Pk_mm = Pkth_array_khres[1] z_pk = config['z_pk'] block.put_double_array_1d("pk_to_xi", "r", r_array) block.put_double_array_1d("pk_to_xi", "k", k_hres) for j in range(nbins): xi_gm_bin_f, xi_gg_bin_f, xi_mm_bin_f = np.zeros(len(r_array)), np.zeros(len(r_array)), np.zeros(len(r_array)) xi_gm_mm_bin_f, xi_gg_mm_bin_f = np.zeros(len(r_array)), np.zeros(len(r_array)) filename = nz_dir + 'nz_g_m_' + '_zbin_' + str(j + 1) + '_dsg_' + str(1) + '_dsm_' + str(1) + '.pk' nz_data = pk.load(open(filename, 'rb')) nz_g, nz_m, nz_z = nz_data['nz_g'], nz_data['nz_m'], nz_data['nz_z'] zmean_g = get_zmean(nz_z, nz_g) zmean_m = get_zmean(nz_z, nz_m) zmean_gm = (zmean_g + zmean_m) / 2. param_array_bin1 = get_bias_param_bin_i(block, j, bias_section, constraint_b2, pt_type=pt_type) param_array_bin2 = get_bias_param_bin_i(block, j, bias_section, constraint_b2, pt_type=pt_type) xi_gg, _ = get_xiXX_terms_bins(param_array_bin1, param_array_bin2, xi_all, pt_type=pt_type) xi_gm, _ = get_xiXm_terms(param_array_bin1, xi_all, pt_type=pt_type) for k in range(len(r_array)): xi_gm_temp = intspline(z_pk, xi_gm[:, k]) xi_gg_temp = intspline(z_pk, xi_gg[:, k]) xi_mm_temp = intspline(z_pk, xi_mm[:, k]) if use_mean_z: xi_gm_bin_f[k] = xi_gm_temp(zmean_gm) xi_gg_bin_f[k] = xi_gg_temp(zmean_g) xi_mm_bin_f[k] = xi_mm_temp(zmean_m) xi_gg_mm_bin_f[k] = xi_gg_bin_f[k] / xi_mm_bin_f[k] xi_gm_mm_bin_f[k] = xi_gm_bin_f[k] / xi_mm_bin_f[k] else: xi_gm_bin_f[k] = (sp.integrate.simps(xi_gm_temp(nz_z) * nz_g * nz_m, nz_z)) / ( sp.integrate.simps(nz_g * nz_m, nz_z)) xi_gg_bin_f[k] = (sp.integrate.simps(xi_gg_temp(nz_z) * nz_g * nz_g, nz_z)) / ( sp.integrate.simps(nz_g * nz_g, nz_z)) if j == 0: xi_mm_bin_f[k] = (sp.integrate.simps(xi_mm_temp(nz_z) * nz_m * nz_m, nz_z)) // ( sp.integrate.simps(nz_m * nz_m, nz_z)) if do_save_xi: Pk_gg, _ = get_PXX_terms_bins(param_array_bin1, param_array_bin2, Pkth_array_khres, pt_type=pt_type) Pk_gm, _ = get_PXm_terms(param_array_bin1, Pkth_array_khres, pt_type=pt_type) Pk_gm_bin_f, Pk_gg_bin_f, Pk_mm_bin_f = np.zeros(len(k_hres)), np.zeros(len(k_hres)), np.zeros(len(k_hres)) for i in range(len(k_hres)): Pk_gm_temp = intspline(z_pk, Pk_gm[:, i]) Pk_gg_temp = intspline(z_pk, Pk_gg[:, i]) Pk_mm_temp = intspline(z_pk, Pk_mm[:, i]) Pk_gm_bin_f[i] = Pk_gm_temp(zmean_gm) Pk_gg_bin_f[i] = Pk_gg_temp(zmean_g) Pk_mm_bin_f[i] = Pk_mm_temp(zmean_m) block.put_double_array_1d("pk_to_xi", "Pk_gg_bin % s" % (j + 1), Pk_gg_bin_f) block.put_double_array_1d("pk_to_xi", "Pk_gm_bin % s" % (j + 1), Pk_gm_bin_f) block.put_double_array_1d("pk_to_xi", "Pk_mm_bin % s" % (j + 1), Pk_mm_bin_f) block.put_grid("pk_to_xi", "z", z_pk, "r", r_array, "xi_gg_mat_bin % s" % (j + 1), xi_gg) block.put_grid("pk_to_xi", "z", z_pk, "r", r_array, "xi_gm_mat_bin % s" % (j + 1), xi_gm) block.put_grid("pk_to_xi", "z", z_pk, "r", r_array, "xi_gg_mm_mat_bin % s" % (j + 1), xi_gg / xi_mm) block.put_grid("pk_to_xi", "z", z_pk, "r", r_array, "xi_gm_mm_mat_bin % s" % (j + 1), xi_gm / xi_mm) if j == 0: block.put("pk_to_xi", "Pk_all", Pkth_array_khres) block.put("pk_to_xi", "xi_all", xi_all) block.put_grid("pk_to_xi", "z", z_pk, "r", r_array, "xi_mm_mat", xi_mm) block.put_double_array_1d("pk_to_xi", "xi_gg_bin % s" % (j + 1), xi_gg_bin_f) block.put_double_array_1d("pk_to_xi", "xi_gm_bin % s" % (j + 1), xi_gm_bin_f) block.put_double_array_1d("pk_to_xi", "xi_mm_bin % s" % (j + 1), xi_mm_bin_f) block.put_double_array_1d("pk_to_xi", "xi_gg_mm_bin % s" % (j + 1), xi_gg_mm_bin_f) block.put_double_array_1d("pk_to_xi", "xi_gm_mm_bin % s" % (j + 1), xi_gm_mm_bin_f) block.put_double("pk_to_xi", "zmean_gg_bin % s" % (j + 1), zmean_g) block.put_double("pk_to_xi", "zmean_gm_bin % s" % (j + 1), zmean_gm) block.put_double("pk_to_xi", "zmean_gg_mm_bin % s" % (j + 1), zmean_g) block.put_double("pk_to_xi", "zmean_gm_mm_bin % s" % (j + 1), zmean_gm) # import pdb; pdb.set_trace() # xi_mm_comb = [] # for j in range(5): # if len(xi_mm_comb) == 0: # xi_mm_comb = block.get_double_array_1d("pk_to_xi", "xi_mm_bin % s" % (j + 1)) # else: # xi_mm_comb = np.hstack((xi_mm_comb,block.get_double_array_1d("pk_to_xi", "xi_mm_bin % s" % (j + 1)))) # np.savez('mice_xi_mm_all_bin.npz',r=r_array,xi=xi_mm_comb) # import pdb; pdb.set_trace() return 0
def get_Pktharray(output_nl_grid, klin, knl, Pkzlin, Pnl_kz, usePNL_for_Pk=True, pt_type=None, Pk_terms_names=None, z_array=None): klinlog = np.log(klin) Pk0lin = Pkzlin[0, :] ind = np.where(klin > 0.03)[0][0] Growth = np.sqrt(Pkzlin[:, ind] / Pkzlin[0, ind]) nk = 4 * len(klin) # higher res increases runtime, decreases potential ringing at low-k # eps = 1e-6 # eps = 0. # kmin = np.log10((1. + eps) * klin[0]) # kmax = np.log10((1. - eps) * klin[-1]) kmin = -6.0 kmax = 3.0 klin_fpt = np.logspace(kmin, kmax, nk) k1log = np.log(klin_fpt) # pinterp=interp1d(klinlog,np.log(Pk0lin),bounds_error=False, fill_value="extrapolate") plininterp = interp1d(klinlog, np.log(Pk0lin), fill_value='extrapolate', bounds_error=False) ## This interpolation should be at the input bounds. Extrapolate used to avoid failure due to numerical noise. No actual extrapolation is done. We could handle this using a margin or something else Plin_klin_fpt = np.exp(plininterp(k1log)) if (knl[0] < klin_fpt[0]) or (knl[-1] > klin_fpt[-1]): EK1 = k_extend(klin_fpt, np.log10(knl[0]), np.log10(knl[-1])) klin_fpt = EK1.extrap_k() Plin_klin_fpt = EK1.extrap_P_low(Plin_klin_fpt) Plin_klin_fpt = EK1.extrap_P_high(Plin_klin_fpt) klin_fpt_log = np.log(klin_fpt) knl_log = np.log(knl) if pt_type in ['lin_oneloop_eul_bk','nohf_oneloop_eul_bk']: # if pt_type == 'lin_oneloop_eul_bk': usePNL_for_Pk = False if output_nl_grid: temp = intspline(klin_fpt_log, np.log(Plin_klin_fpt)) Plin = np.exp(temp(knl_log)) Pnl1 = Pnl_kz if usePNL_for_Pk: knl2mat = np.tile(knl ** 2, (Pnl_kz.shape[0], 1)) k2Pnl1 = np.multiply(knl2mat, Pnl_kz) else: k2Pnl1 = np.outer(Growth ** 2, (knl ** 2) * Plin) else: Plin = Plin_klin_fpt Pnl1 = Pnl_kz if usePNL_for_Pk: k2Pnl1 = np.outer(Growth ** 2, (klin_fpt ** 2) * Pnl[0, :]) else: k2Pnl1 = np.outer(Growth ** 2, (klin_fpt ** 2) * Plin) Plin_kz = np.outer(Growth ** 2, Plin) n_pad = len(klin_fpt) if pt_type in ['oneloop_eul_bk','lin_oneloop_eul_bk','nohf_oneloop_eul_bk']: fastpt = FASTPT.FASTPT(klin_fpt, to_do=['one_loop_dd'], low_extrap=-5, high_extrap=3, n_pad=n_pad) PXXNL_b1b2bsb3nl = fastpt.one_loop_dd_bias_b3nl(Plin_klin_fpt, C_window=.75) if output_nl_grid: temp = intspline(klin_fpt_log, (PXXNL_b1b2bsb3nl[0])) P1loop = np.outer(Growth ** 4, (temp(knl_log))) Pmm_linp1loop = Plin_kz + P1loop temp = intspline(klin_fpt_log, (PXXNL_b1b2bsb3nl[2])) Pd1d2 = np.outer(Growth ** 4, (temp(knl_log))) temp = intspline(klin_fpt_log, np.log(PXXNL_b1b2bsb3nl[3])) Pd2d2 = np.outer(Growth ** 4, np.exp(temp(knl_log))) temp = intspline(klin_fpt_log, (PXXNL_b1b2bsb3nl[4])) Pd1s2 = np.outer(Growth ** 4, (temp(knl_log))) temp = intspline(klin_fpt_log, (PXXNL_b1b2bsb3nl[5])) Pd2s2 = np.outer(Growth ** 4, (temp(knl_log))) temp = intspline(klin_fpt_log, np.log(PXXNL_b1b2bsb3nl[6])) Ps2s2 = np.outer(Growth ** 4, np.exp(temp(knl_log))) temp = intspline(klin_fpt_log, (PXXNL_b1b2bsb3nl[7])) sig3nl = np.outer(Growth ** 4, (temp(knl_log))) sig4 = np.outer(Growth ** 4, PXXNL_b1b2bsb3nl[8] * np.ones_like(knl)) else: [P1loop,Pd1d2, Pd2d2, Pd1s2, Pd2s2, Ps2s2, sig3nl, sig4] = [ np.outer(Growth ** 4, PXXNL_b1b2bsb3nl[0]), np.outer(Growth ** 4, PXXNL_b1b2bsb3nl[2]), np.outer(Growth ** 4, PXXNL_b1b2bsb3nl[3]), np.outer(Growth ** 4, PXXNL_b1b2bsb3nl[4]), np.outer(Growth ** 4, PXXNL_b1b2bsb3nl[5]), np.outer(Growth ** 4, PXXNL_b1b2bsb3nl[6]), np.outer(Growth ** 4, PXXNL_b1b2bsb3nl[7]), np.outer(Growth ** 4, PXXNL_b1b2bsb3nl[8] * np.ones_like( PXXNL_b1b2bsb3nl[0]))] Pmm_linp1loop = Plin_kz + P1loop Pk_th_array = [Plin_kz, Pnl1, Pd1d2, Pd2d2, Pd1s2, Pd2s2, Ps2s2, sig3nl, k2Pnl1, Pmm_linp1loop, sig4] elif pt_type in ['oneloop_cleft_bk']: cl = cpool.CLEFT(k=klin_fpt, p=Plin_klin_fpt) Pk_th_array = np.zeros((len(Pk_terms_names), len(Growth), len(knl))) kinput_ind = np.where((knl < 4.) & (knl > 1e-3))[0] kinput = knl[kinput_ind] pk_table_f = cpool.get_nonlinear_kernels_wgroth(cl, kinput, koutput=knl, Growth=Growth, do_analysis=False, Pnl_toplot=Pnl1, z_array=z_array) Pk_th_array[1:-1, :, :] = pk_table_f Pk_th_array[0, :, :] = Plin_kz Pk_th_array[1, :, :] = Pnl1 Pk_th_array[-1, :, :] = k2Pnl1 else: Pk_th_array = None print('give correct pt_type') if output_nl_grid: kout = knl else: kout = klin_fpt return Pk_th_array, kout
def setup(options): nz_dir = options.get_string(option_section, "nz_dir") rmin = options.get_double(option_section, "rmin", 0.1) rmax = options.get_double(option_section, "rmax", 50) nrbin = options.get_double(option_section, "nrbin", 90) bins_all = ast.literal_eval(options.get_string(option_section, "bins_all", "[1, 2, 3, 4, 5]")) nbins = len(bins_all) k_hres_min = options.get_double(option_section, "k_hres_min", 0.0001) k_hres_max = options.get_double(option_section, "k_hres_max", 100) n_k_hres_bin = options.get_double(option_section, "n_k_hres_max", 50000) output_nl_grid = options.get_bool(option_section, "output_nl_grid", True) pklin_file = options.get_string(option_section, "pklin_file") pknl_file = options.get_string(option_section, "pknl_file") constraint_b2 = options.get_bool(option_section, "constraint_b2", False) do_regularize_pk = options.get_bool(option_section, "do_regularize", False) do_reg_all = options.get_bool(option_section, "do_reg_all", False) reg_k = options.get_double(option_section, "reg_k", 0.3) reg_c = options.get_double(option_section, "reg_c", 1000.) usePNL_for_Pk = options.get_bool(option_section, "usePNL_for_Pk", True) do_save_xi = options.get_bool(option_section, "do_save_xi", False) save_xi_def = options.get_string(option_section, "save_xi_def", '') use_mean_z = options.get_bool(option_section, "use_mean_z", True) pt_type = options.get_string(option_section, "pt_type_g", '') r_array = np.logspace(np.log10(rmin), np.log10(rmax), nrbin) k_hres = np.logspace(np.log10(k_hres_min), np.log10(k_hres_max), n_k_hres_bin) Pkz_lin_f = np.load(pklin_file) Pkz_nl_f = np.load(pknl_file) klin, zlin, Pkzlin = Pkz_lin_f['k'], Pkz_lin_f['z'], Pkz_lin_f['pkz'] knl, znl, Pnl_kz = Pkz_nl_f['k'], Pkz_nl_f['z'], Pkz_nl_f['pkz'] if pt_type in ['oneloop_eul_bk','lin_oneloop_eul_bk','nohf_oneloop_eul_bk']: Pk_terms_names = ['Plin', 'Pmm', 'Pd1d2', 'Pd2d2', 'Pd1s2', 'Pd2s2', 'Ps2s2', 'Pd1d3nl', 'k2Pk', 'Pmm_linp1loop', 'sig4'] xi_gg = np.zeros((len(Pk_terms_names) - 1, len(znl), len(r_array))) elif pt_type in ['oneloop_cleft_bk']: Pk_terms_names = ['Plin', 'Pnl1', 'Pzel', 'PA', 'PW', 'Pd1', 'Pd1d1', 'Pd2', 'Pd2d2', 'Pd1d2', 'Ps2', 'Pd1s2', 'Pd2s2', 'Ps2s2', 'PD2', 'Pd1D2', 'k2Pk'] xi_gg = np.zeros((len(Pk_terms_names), len(znl), len(r_array))) else: print 'No predefined pt_type given' Pk_terms_names = None Pkth_array, karray = get_Pktharray(output_nl_grid, klin, knl, Pkzlin, Pnl_kz, pt_type=pt_type, Pk_terms_names=Pk_terms_names, z_array=znl,usePNL_for_Pk=usePNL_for_Pk) Pkth_array_khres = np.zeros((len(Pk_terms_names), len(znl), len(k_hres))) for j1 in range(len(Pk_terms_names)): print 'processing Pk ' + str(Pk_terms_names[j1]) P_gg_khres = np.zeros((len(znl), len(k_hres))) for i in range(len(znl)): P_gg_j1_i = Pkth_array[j1][i, :] Pgg_temp = intspline(karray, P_gg_j1_i) Pgg_term_interp = Pgg_temp(k_hres) P_gg_khres[i, :] = Pgg_term_interp if Pk_terms_names[j1] == 'Plin': P_lin_khres = P_gg_khres P_gg_khres_reg = P_gg_khres else: if do_regularize_pk: if do_reg_all: # P_gg_khres_reg = reg_Pk(P_gg_khres, P_lin_khres, k_hres, reg_k, c_val=reg_c) P_gg_khres_reg = reg_Pk_mat_expmult(P_gg_khres, k_hres, reg_c) else: if Pk_terms_names[j1] == 'k2Pk': # P_gg_khres_reg = reg_Pk(P_gg_khres, P_lin_khres, k_hres, reg_k, c_val=reg_c) # P_gg_khres_reg = reg_Pk_gaussian(P_gg_khres, k_hres, reg_k, c_val=reg_c) P_gg_khres_reg = reg_Pk_mat_expmult(P_gg_khres, k_hres, reg_c) else: P_gg_khres_reg = P_gg_khres else: P_gg_khres_reg = P_gg_khres if Pk_terms_names[j1] != 'sig4': for k in range(len(r_array)): xi_gg_f = Pk2corr_mat(r_array[k], k_hres, P_gg_khres_reg) xi_gg[j1, :, k] = xi_gg_f # import matplotlib # matplotlib.use('Agg') # import matplotlib.pyplot as plt # fig, ax_all = plt.subplots(1, 1, figsize=(8, 6)) # ax = ax_all # ax.plot(r_array, xi_gg[j1,0,:], color='b', lw=2, marker='', linestyle='-') # ax.set_ylabel(r'xi', size=22) # ax.set_xlabel(r'r', size=22) # ax.set_xscale('log') # ax.set_yscale('log') # ax.tick_params(axis='both', which='major', labelsize=15) # ax.tick_params(axis='both', which='minor', labelsize=15) # ax.legend(fontsize=20) # plt.tight_layout() # fig.savefig('/global/project/projectdirs/des/shivamp/cosmosis/y3kp-bias-model/3d_stats/plots/test_bk/xi_' + Pk_terms_names[j1] + '.pdf',dpi=240) Pkth_array_khres[j1, :, :] = P_gg_khres_reg config = {'nz_dir': nz_dir, 'r_array': r_array, 'k_hres': k_hres, 'xi_all': xi_gg, 'bias_section': str( options.get_string(option_section, "bias_section")), 'z_pk': znl, 'constraint_b2': constraint_b2, 'do_save_xi': do_save_xi, 'Pkth_array_khres': Pkth_array_khres, 'save_xi_def': save_xi_def, 'Pk_terms_names': Pk_terms_names, 'use_mean_z': use_mean_z, 'pt_type': pt_type, 'nbins': nbins} return config
def get_Pk_basis_funcs(block, pt_type, matter_power_lin_name=names.matter_power_lin, matter_power_nl_name=names.matter_power_nl, output_nl_grid=True, use_pnl_for_k2=True, k_growth=1.e-3, fpt_upsample=4): """ Get the z=0,k-dependent basis functions required to construct the galaxy-galaxy and galaxy-matter power spectra for a given pt_type Parameters ---------- block: DataBlock instance block from which to read data pt_type: str string indicating the type of perturbation theory model to use - one of "linear", "oneloop_lag_bk", "oneloop_eul_bk". matter_power_lin_name : str (default = names.matter_power_lin) Name of the section for the linear matter P(k) matter_power_nl_name : str (default = names.matter_power_nl) Name of the section for the non-linear matter P(k) output_on_nl_grid: bool (default=True) Output the terms at the same k values as the non-linear P(k). If False, interpolate P_nl and P_lin onto the fast-pt k grid. It shouldn't matter which we do here. use_pnl_for_k2 : bool (default=True) Use the non-linear matter power for the k^2 term k_growth : float (default=1.e-3) k value at which to calcaulate growth factor fpt_upsample : upsample the linear P(k) by this factor when passing it to fast-pt. Returns ------- k_out: float array array of k values at which P(k) terms are sampled PXXNL_out: dict Dictionary of pt basis functions """ #Read in linear and non-linear P(k)s from block zlin, klin, Plin = block.get_grid(matter_power_lin_name, "z", "k_h", "p_k") znl, knl, Pnl = block.get_grid(matter_power_nl_name, "z", "k_h", "p_k") assert np.allclose(zlin, znl) #shit is already convoluted enough #without different z values for the linear and non-linear P(k)s log_klin = np.log(klin) Plin_z0 = Plin[0] #Calculate the growth factor from linear P(k) at k closest to k_growth k_growth_ind = np.argmin(np.abs(klin-k_growth)) growth = np.sqrt(Plin[:, k_growth_ind] / Plin[0, k_growth_ind]) # NM: This whole next section is quite confusing. nk = fpt_upsample * len(klin) # higher res increases runtime, decreases potential ringing at low-k # eps = 1e-6 eps = 0. kmin = np.log10((1. + eps) * klin[0]) kmax = np.log10((1. - eps) * klin[-1]) klin_fpt = np.logspace(kmin, kmax, nk) log_klin_fpt = np.log(klin_fpt) plin_interp = interp1d(log_klin, np.log(Plin_z0)) # This interpolation should be at the input bounds. # Extrapolate used to avoid failure due to numerical noise. # No actual extrapolation is done. # We could handle this using a margin or something else Plin_fpt = np.exp(plin_interp(log_klin_fpt)) if (knl[0] < klin_fpt[0]) or (knl[-1] > klin_fpt[-1]): EK1 = k_extend(klin_fpt, np.log10(knl[0]), np.log10(knl[-1])) klin_fpt = EK1.extrap_k() Plin_fpt = EK1.extrap_P_low(Plin_fpt) Plin_fpt = EK1.extrap_P_high(Plin_fpt) log_klin_fpt = np.log(klin_fpt) log_knl = np.log(knl) n_pad = len(klin_fpt) fastpt = FASTPT.FASTPT(klin_fpt, to_do=['one_loop_dd'], low_extrap=-5, high_extrap=3, n_pad=n_pad) if pt_type in ['oneloop_lag_bk']: PXXNL_lpt = fastpt.one_loop_dd_bias_lpt_NL(Plin_klin_fpt, C_window=.75) PXXNL_lpt_z0 = {"Pb1L" : PXXNL_lpt[1], "Pb1L2" : PXXNL_lpt[2], "Pb1Lb2L" : PXXNL_lpt[3], "Pb2L" : PXXNL_lpt[4], "Pb2L2" : PXXNL_lpt[5], "sig4" : PXXNL_lpt[6]*np.ones_like(klin_fpt)} if output_nl_grid: # interpolate to nl k grid. for key, pk in PXXNL_lpt_z0: if key == "sig4": PXXNL_lpt_z0[key] = PXXNL_lpt[6]*np.ones_like(knl) PXXNL_lpt_z0[key] = intspline(log_klin_fpt, pk)(log_knl) #Apply growth factor to make k,z arrays PXXNL_out = {} for key, pk in PXXNL_lpt_z0: PXXNL_out[key] = np.outer(growth**4, pk) elif pt_type in ['oneloop_eul_bk']: PXXNL_b1b2bsb3nl = fastpt.one_loop_dd_bias_b3nl(Plin_fpt, C_window=.75) PXXNL_b1b2bsb3nl_z0 = {"Pd1d2" : PXXNL_b1b2bsb3nl[2], "Pd2d2" : PXXNL_b1b2bsb3nl[3], "Pd1s2" : PXXNL_b1b2bsb3nl[4], "Pd2s2" : PXXNL_b1b2bsb3nl[5], "Ps2s2" : PXXNL_b1b2bsb3nl[6], "sig3nl" : PXXNL_b1b2bsb3nl[7], "sig4" : PXXNL_b1b2bsb3nl[8]} if output_nl_grid: # interpolate to nl k grid. for key, pk in PXXNL_b1b2bsb3nl_z0.items(): if key == "sig4": PXXNL_b1b2bsb3nl_z0[key] = pk*np.ones_like(knl) else: PXXNL_b1b2bsb3nl_z0[key] = intspline(log_klin_fpt, pk)(log_knl) #Apply growth factor to make k,z arrays PXXNL_out = {} for key, pk in PXXNL_b1b2bsb3nl_z0.items(): PXXNL_out[key] = np.outer(growth**4, pk) else: raise ValueError("pt_type %s not valid"%pt_type) #We also need to add P_nl, P_lin and k^2P terms to this dictionary #if output_nl_grid=True, resample P_lin onto k_nl. Otherwise, #resample P_nl onto the fast-pt grid. if output_nl_grid: PXXNL_out["Pnl"] = Pnl #start of by assuming we don't need to resample, #then check whether we do.... resample_P_lin = False #we certainly need to resample P_lin if klin and knl #have different lengths if len(klin) != len(knl): resample_P_lin = True #if they have the same length, still need to resample #if the k values are different elif not np.allclose(klin, knl): resample_P_lin = True plin_z0_interp = intspline(log_klin_fpt, np.log(Plin_fpt)) Plin_z0_on_nl_grid = np.exp(plin_z0_interp(log_knl)) PXXNL_out["Plin_from_growth"] = np.outer(growth**2, Plin_z0_on_nl_grid) #Now add k^2P(k) term knl2_matrix = np.tile(knl ** 2, (Pnl.shape[0], 1)) if use_pnl_for_k2: PXXNL_out["k2P"] = np.multiply(knl2_matrix, Pnl) else: PXXNL_out["k2P"] = np.multiply(knl2_matrix, Plin_on_nl_grid) #Set k_out to knl k_out = knl else: #In this case work out if we need to resample P_nl resample_P_nl = False if len(knl) != len(klin_fpt): resample_P_nl = True elif not np.allclose(knl, klin_fpt): resample_P_lin = True if resample_P_nl: pnl_interp = RectBivariateSpline(znl, log_knl, np.log(Pnl)) pnl_on_fpt_grid = np.exp(pnl_interp(znl, log_knl, grid=True)) else: pnl_on_fpt_grid = Pnl PXXNL_out["Pnl"] = pnl_on_fpt_grid Plin_out = np.outer(growth**2, Plin_klin_fpt) PXXNL_out["Plin_from_growth"] = Plin_out #Now add k^2P(k) term knl2_matrix = np.tile(klin_fpt ** 2, (Pnl.shape[0], 1)) if use_pnl_for_k2: PXXNL_out["k2P"] = np.multiply(knl2_matrix, pnl_on_fpt_grid) else: PXXNL_out["k2P"] = np.multiply(klin_fpt, Plin_out) #Set k_out to klin_fpt k_out = klin_fpt return k_out, PXXNL_out
def get_theory_terms(block, r_data, stat_type, bins_array): xi_theory_rdata = [] r_array = block.get_double_array_1d("pk_to_xi", "r"), if stat_type == 'gg': nbins = len(bins_array) for j in range(nbins): bin_j = bins_array[j] xi_gg = block.get_double_array_1d("pk_to_xi", "xi_gg_bin % s" % bin_j) xi_gg_temp = intspline(r_array, xi_gg) xi_gg_f = xi_gg_temp(r_data[j]) if len(xi_theory_rdata) == 0: xi_theory_rdata = xi_gg_f else: xi_theory_rdata = np.hstack((xi_theory_rdata, xi_gg_f)) elif stat_type == 'gm': nbins = len(bins_array) for j in range(nbins): bin_j = bins_array[j] xi_gm = block.get_double_array_1d("pk_to_xi", "xi_gm_bin % s" % bin_j) xi_gm_temp = intspline(r_array, xi_gm) xi_gm_f = xi_gm_temp(r_data[j]) if len(xi_theory_rdata) == 0: xi_theory_rdata = xi_gm_f else: xi_theory_rdata = np.hstack((xi_theory_rdata, xi_gm_f)) elif stat_type == 'gg_gm': nbins = len(bins_array) for j in range(nbins): bin_j = bins_array[j] xi_gg = block.get_double_array_1d("pk_to_xi", "xi_gg_bin % s" % bin_j) xi_gg_temp = intspline(r_array, xi_gg) xi_gg_f = xi_gg_temp(r_data[j]) if len(xi_theory_rdata) == 0: xi_theory_rdata = xi_gg_f else: xi_theory_rdata = np.hstack((xi_theory_rdata, xi_gg_f)) for j in range(nbins): bin_j = bins_array[j] xi_gm = block.get_double_array_1d("pk_to_xi", "xi_gm_bin % s" % bin_j) xi_gm_temp = intspline(r_array, xi_gm) xi_gm_f = xi_gm_temp(r_data[j + nbins]) xi_theory_rdata = np.hstack((xi_theory_rdata, xi_gm_f)) elif stat_type == 'gg_mm__gm_mm': nbins = len(bins_array) for j in range(nbins): bin_j = bins_array[j] xi_gg_mm = block.get_double_array_1d("pk_to_xi", "xi_gg_mm_bin % s" % bin_j) xi_gg_mm_temp = intspline(r_array, xi_gg_mm) xi_gg_mm_f = xi_gg_mm_temp(r_data[j]) if len(xi_theory_rdata) == 0: xi_theory_rdata = xi_gg_mm_f else: xi_theory_rdata = np.hstack((xi_theory_rdata, xi_gg_mm_f)) for j in range(nbins): bin_j = bins_array[j] xi_gm_mm = block.get_double_array_1d("pk_to_xi", "xi_gm_mm_bin % s" % bin_j) xi_gm_mm_temp = intspline(r_array, xi_gm_mm) xi_gm_mm_f = xi_gm_mm_temp(r_data[j + nbins]) xi_theory_rdata = np.hstack((xi_theory_rdata, xi_gm_mm_f)) return xi_theory_rdata
def setup(options): nz_dir = options.get_string(option_section, "nz_dir") rmin = options.get_double(option_section, "rmin", 0.1) rmax = options.get_double(option_section, "rmax", 50) nrbin = options.get_double(option_section, "nrbin", 90) bins_all = ast.literal_eval( options.get_string(option_section, "bins_all", "[1, 2, 3, 4, 5]")) nbins = len(bins_all) k_hres_min = options.get_double(option_section, "k_hres_min", 0.0001) k_hres_max = options.get_double(option_section, "k_hres_max", 100) n_k_hres_bin = options.get_double(option_section, "n_k_hres_max", 50000) output_nl_grid = options.get_bool(option_section, "output_nl_grid", True) pklin_file = options.get_string(option_section, "pklin_file") pknl_file = options.get_string(option_section, "pknl_file") constraint_b2 = options.get_bool(option_section, "constraint_b2", False) do_regularize_pk = options.get_bool(option_section, "do_regularize", False) do_reg_all = options.get_bool(option_section, "do_reg_all", False) reg_k = options.get_double(option_section, "reg_k", 0.3) reg_c = options.get_double(option_section, "reg_c", 1000.) do_save_xi = options.get_bool(option_section, "do_save_xi", False) save_xi_def = options.get_string(option_section, "save_xi_def", '') use_mean_z = options.get_bool(option_section, "use_mean_z", True) pt_type = options.get_string(option_section, "pt_type_g", '') r_array = np.logspace(np.log10(rmin), np.log10(rmax), nrbin) k_hres = np.logspace(np.log10(k_hres_min), np.log10(k_hres_max), n_k_hres_bin) Pkz_lin_f = np.load(pklin_file) Pkz_nl_f = np.load(pknl_file) klin, zlin, Pkzlin = Pkz_lin_f['k'], Pkz_lin_f['z'], Pkz_lin_f['pkz'] knl, znl, Pnl_kz = Pkz_nl_f['k'], Pkz_nl_f['z'], Pkz_nl_f['pkz'] if pt_type in ['oneloop_eul_bk']: Pk_terms_names = [ 'Plin', 'Pmm', 'Pd1d2', 'Pd2d2', 'Pd1s2', 'Pd2s2', 'Ps2s2', 'Pd1d3nl', 'k2Pk', 'sig4' ] xi_gg = np.zeros((len(Pk_terms_names) - 1, len(znl), len(r_array))) elif pt_type in ['oneloop_cleft_bk']: Pk_terms_names = [ 'Plin', 'Pnl1', 'Pzel', 'PA', 'PW', 'Pd1', 'Pd1d1', 'Pd2', 'Pd2d2', 'Pd1d2', 'Ps2', 'Pd1s2', 'Pd2s2', 'Ps2s2', 'PD2', 'Pd1D2', 'k2Pk' ] xi_gg = np.zeros((len(Pk_terms_names), len(znl), len(r_array))) else: print 'No predefined pt_type given' Pk_terms_names = None # pdb.set_trace() Pkth_array, karray = get_Pktharray(output_nl_grid, klin, knl, Pkzlin, Pnl_kz, pt_type=pt_type, Pk_terms_names=Pk_terms_names, z_array=znl) Pkth_array_khres = np.zeros((len(Pk_terms_names), len(znl), len(k_hres))) for j1 in range(len(Pk_terms_names)): print 'processing Pk ' + str(Pk_terms_names[j1]) P_gg_khres = np.zeros((len(znl), len(k_hres))) for i in range(len(znl)): P_gg_j1_i = Pkth_array[j1][i, :] Pgg_temp = intspline(karray, P_gg_j1_i) Pgg_term_interp = Pgg_temp(k_hres) P_gg_khres[i, :] = Pgg_term_interp if Pk_terms_names[j1] == 'Plin': P_gg_khres_reg = P_gg_khres else: if do_regularize_pk: if do_reg_all: # P_gg_khres_reg = reg_Pk(P_gg_khres, P_lin_khres, k_hres, reg_k, c_val=reg_c) P_gg_khres_reg = reg_Pk_mat_expmult( P_gg_khres, k_hres, reg_c) else: if Pk_terms_names[j1] == 'k2Pk': # P_gg_khres_reg = reg_Pk(P_gg_khres, P_lin_khres, k_hres, reg_k, c_val=reg_c) # P_gg_khres_reg = reg_Pk_gaussian(P_gg_khres, k_hres, reg_k, c_val=reg_c) P_gg_khres_reg = reg_Pk_mat_expmult( P_gg_khres, k_hres, reg_c) else: P_gg_khres_reg = P_gg_khres else: P_gg_khres_reg = P_gg_khres if Pk_terms_names[j1] != 'sig4': for k in range(len(r_array)): xi_gg_f = Pk2corr_mat(r_array[k], k_hres, P_gg_khres_reg) xi_gg[j1, :, k] = xi_gg_f Pkth_array_khres[j1, :, :] = P_gg_khres_reg config = { 'nz_dir': nz_dir, 'r_array': r_array, 'k_hres': k_hres, 'xi_all': xi_gg, 'bias_section': str(options.get_string(option_section, "bias_section")), 'z_pk': znl, 'constraint_b2': constraint_b2, 'do_save_xi': do_save_xi, 'Pkth_array_khres': Pkth_array_khres, 'save_xi_def': save_xi_def, 'Pk_terms_names': Pk_terms_names, 'use_mean_z': use_mean_z, 'pt_type': pt_type, 'nbins': nbins } return config
Pkth_array, karray, xi_all, r_array = ptx.get_Pktharray(output_nl_grid, klin, knl, Pkzlin, Pnl_kz,pt_type=pt_type,Pk_terms_names = Pk_terms_names, z_array=znl, output_xi=True, use_fftlog=False) Pkth_array_khres = np.zeros((len(Pk_terms_names), len(znl), len(k_hres))) do_regularize_pk = True do_reg_all = False for j1 in range(len(Pk_terms_names)): print 'processing Pk ' + str(Pk_terms_names[j1]) P_gg_khres = np.zeros((len(znl), len(k_hres))) for i in range(len(znl)): P_gg_j1_i = Pkth_array[j1][i, :] Pgg_temp = intspline(karray, P_gg_j1_i) Pgg_term_interp = Pgg_temp(k_hres) P_gg_khres[i, :] = Pgg_term_interp if Pk_terms_names[j1] == 'Plin': P_gg_khres_reg = P_gg_khres else: if do_regularize_pk: if do_reg_all: # P_gg_khres_reg = reg_Pk(P_gg_khres, P_lin_khres, k_hres, reg_k, c_val=reg_c) P_gg_khres_reg = ptx.reg_Pk_mat_expmult(P_gg_khres, k_hres, reg_c) else: if Pk_terms_names[j1] == 'k2Pk': # P_gg_khres_reg = reg_Pk(P_gg_khres, P_lin_khres, k_hres, reg_k, c_val=reg_c) # P_gg_khres_reg = reg_Pk_gaussian(P_gg_khres, k_hres, reg_k, c_val=reg_c) P_gg_khres_reg = ptx.reg_Pk_mat_expmult(P_gg_khres, k_hres, reg_c)
'_MICE_cosmogg_mm__gm_mm_nocov_crosszbinsgmgg_False_crosszbinsall_False_gmgg_False_covdiag_False_njk_180.npz' ) xi_gm_file = np.load( '/global/u1/s/spandey/cosmosis_exp/cosmosis/y3kp-bias-model/3d_stats/bestfits/measurements/xi_gm_total_bin_' + str(binval) + '_MICE_cosmogg_mm__gm_mm_nocov_crosszbinsgmgg_False_crosszbinsall_False_gmgg_False_covdiag_False_njk_180.npz' ) xi_mm_file = np.load( '/global/u1/s/spandey/cosmosis_exp/cosmosis/y3kp-bias-model/3d_stats/bestfits/measurements/xi_mm_total_bin_' + str(binval) + '_MICE_cosmogg_mm__gm_mm_nocov_crosszbinsgmgg_False_crosszbinsall_False_gmgg_False_covdiag_False_njk_180.npz' ) r_array_theory = xi_gg_file['r'] xi_gg_th, xi_gm_th, xi_mm_th = xi_gg_file['xi'], xi_gm_file[ 'xi'], xi_mm_file['xi'] xi_gg_temp = intspline(r_array_theory, xi_gg_th) xi_gg = xi_gg_temp(r_gg_data) xi_gg_mat_diag = np.diag(xi_gg) xi_mm_temp = intspline(r_array_theory, xi_mm_th) xi_mm = xi_mm_temp(r_gg_data) xi_mm_mat_diag = np.diag(xi_mm) if stat_type == 'gg_mm': inv_xi_mm1 = np.tile((1. / xi_mm).reshape(nr, 1), (1, nr)) inv_xi_mm2 = np.tile((1. / xi_mm).reshape(1, nr), (nr, 1)) factor_mult = inv_xi_mm1 * inv_xi_mm2 if stat_type == 'gg': factor_mult = 1.
def execute(block, config): nz_dir = config['nz_dir'] r_array = config['r_array'] do_save_xi = config['do_save_xi'] use_mean_z = config['use_mean_z'] k_hres = config['k_hres'] bias_section = config['bias_section'] constraint_b2 = config['constraint_b2'] pt_type = config['pt_type'] output_nl_grid = config['output_nl_grid'] do_regularize_pk = config['do_regularize_pk'] do_reg_all = config['do_reg_all'] reg_k = config['reg_k'] reg_c = config['reg_c'] block.put_double_array_1d("pk_to_xi", "r", r_array) block.put_double_array_1d("pk_to_xi", "k", k_hres) name_lin = names.matter_power_lin name_nl = names.matter_power_nl klin, zlin, Pkzlin = block[name_lin, "k_h"], block[name_lin, "z"], block[name_lin, "P_k"] knl, znl, Pnl_kz = block[name_nl, "k_h"], block[name_nl, "z"], block[name_nl, "P_k"] z_pk = znl if pt_type in ['oneloop_eul_bk']: Pk_terms_names = [ 'Plin', 'Pmm', 'Pd1d2', 'Pd2d2', 'Pd1s2', 'Pd2s2', 'Ps2s2', 'Pd1d3nl', 'k2Pk', 'sig4' ] xi_gg = np.zeros((len(Pk_terms_names) - 1, len(znl), len(r_array))) elif pt_type in ['oneloop_cleft_bk']: Pk_terms_names = [ 'Plin', 'Pnl1', 'Pzel', 'PA', 'PW', 'Pd1', 'Pd1d1', 'Pd2', 'Pd2d2', 'Pd1d2', 'Ps2', 'Pd1s2', 'Pd2s2', 'Ps2s2', 'PD2', 'Pd1D2', 'k2Pk' ] xi_gg = np.zeros((len(Pk_terms_names), len(znl), len(r_array))) else: print 'No predefined pt_type given' Pk_terms_names = None Pkth_array, karray = get_Pktharray(output_nl_grid, klin, knl, Pkzlin, Pnl_kz, pt_type=pt_type, Pk_terms_names=Pk_terms_names) Pkth_array_khres = np.zeros((len(Pk_terms_names), len(znl), len(k_hres))) for j1 in range(len(Pk_terms_names)): print 'processing Pk ' + str(Pk_terms_names[j1]) P_gg_khres = np.zeros((len(znl), len(k_hres))) for i in range(len(znl)): P_gg_j1_i = Pkth_array[j1][i, :] Pgg_temp = intspline(karray, P_gg_j1_i) Pgg_term_interp = Pgg_temp(k_hres) P_gg_khres[i, :] = Pgg_term_interp if Pk_terms_names[j1] == 'Plin': P_lin_khres = P_gg_khres P_gg_khres_reg = P_gg_khres else: if do_regularize_pk: if do_reg_all: P_gg_khres_reg = reg_Pk(P_gg_khres, P_lin_khres, k_hres, reg_k, c_val=reg_c) else: if Pk_terms_names[j1] == 'k2Pk': # P_gg_khres_reg = reg_Pk(P_gg_khres, P_lin_khres, k_hres, reg_k, c_val=reg_c) P_gg_khres_reg = reg_Pk_gaussian(P_gg_khres, k_hres, reg_k, c_val=reg_c) else: P_gg_khres_reg = P_gg_khres else: P_gg_khres_reg = P_gg_khres if Pk_terms_names[j1] != 'sig4': for k in range(len(r_array)): xi_gg_f = Pk2corr_mat(r_array[k], k_hres, P_gg_khres_reg) xi_gg[j1, :, k] = xi_gg_f Pkth_array_khres[j1, :, :] = P_gg_khres_reg xi_all = xi_gg xi_mm = xi_all[1] Pk_mm = Pkth_array_khres[1] for j in range(5): xi_gm_bin_f, xi_gg_bin_f, xi_mm_bin_f = np.zeros( len(r_array)), np.zeros(len(r_array)), np.zeros(len(r_array)) xi_gm_mm_bin_f, xi_gg_mm_bin_f = np.zeros(len(r_array)), np.zeros( len(r_array)) filename = nz_dir + 'nz_g_m_' + '_zbin_' + str(j + 1) + '_dsg_' + str( 1) + '_dsm_' + str(1) + '.pk' nz_data = pk.load(open(filename, 'rb')) nz_g, nz_m, nz_z = nz_data['nz_g'], nz_data['nz_m'], nz_data['nz_z'] zmean_g = get_zmean(nz_z, nz_g) zmean_m = get_zmean(nz_z, nz_m) zmean_gm = (zmean_g + zmean_m) / 2. param_array_bin1 = get_bias_param_bin_i(block, j, bias_section, constraint_b2, pt_type=pt_type) param_array_bin2 = get_bias_param_bin_i(block, j, bias_section, constraint_b2, pt_type=pt_type) xi_gg, _ = get_xiXX_terms_bins(param_array_bin1, param_array_bin2, xi_all, pt_type=pt_type) xi_gm, _ = get_xiXm_terms(param_array_bin1, xi_all, pt_type=pt_type) for k in range(len(r_array)): xi_gm_temp = intspline(z_pk, xi_gm[:, k]) xi_gg_temp = intspline(z_pk, xi_gg[:, k]) xi_mm_temp = intspline(z_pk, xi_mm[:, k]) if use_mean_z: xi_gm_bin_f[k] = xi_gm_temp(zmean_gm) xi_gg_bin_f[k] = xi_gg_temp(zmean_g) xi_mm_bin_f[k] = xi_mm_temp(zmean_m) xi_gg_mm_bin_f[k] = xi_gg_bin_f[k] / xi_mm_bin_f[k] xi_gm_mm_bin_f[k] = xi_gm_bin_f[k] / xi_mm_bin_f[k] else: xi_gm_bin_f[k] = (sp.integrate.simps( xi_gm_temp(nz_z) * nz_g * nz_m, nz_z)) / (sp.integrate.simps(nz_g * nz_m, nz_z)) xi_gg_bin_f[k] = (sp.integrate.simps( xi_gg_temp(nz_z) * nz_g * nz_g, nz_z)) / (sp.integrate.simps(nz_g * nz_g, nz_z)) if j == 0: xi_mm_bin_f[k] = (sp.integrate.simps( xi_mm_temp(nz_z) * nz_m * nz_m, nz_z)) // (sp.integrate.simps(nz_m * nz_m, nz_z)) if do_save_xi: Pk_gg, _ = get_PXX_terms_bins(param_array_bin1, param_array_bin2, Pkth_array_khres, pt_type=pt_type) Pk_gm, _ = get_PXm_terms(param_array_bin1, Pkth_array_khres, pt_type=pt_type) Pk_gm_bin_f, Pk_gg_bin_f, Pk_mm_bin_f = np.zeros( len(k_hres)), np.zeros(len(k_hres)), np.zeros(len(k_hres)) for i in range(len(k_hres)): Pk_gm_temp = intspline(z_pk, Pk_gm[:, i]) Pk_gg_temp = intspline(z_pk, Pk_gg[:, i]) Pk_mm_temp = intspline(z_pk, Pk_mm[:, i]) Pk_gm_bin_f[i] = Pk_gm_temp(zmean_gm) Pk_gg_bin_f[i] = Pk_gg_temp(zmean_g) Pk_mm_bin_f[i] = Pk_mm_temp(zmean_m) block.put_double_array_1d("pk_to_xi", "Pk_gg_bin % s" % (j + 1), Pk_gg_bin_f) block.put_double_array_1d("pk_to_xi", "Pk_gm_bin % s" % (j + 1), Pk_gm_bin_f) block.put_double_array_1d("pk_to_xi", "Pk_mm_bin % s" % (j + 1), Pk_mm_bin_f) block.put_grid("pk_to_xi", "z", z_pk, "r", r_array, "xi_gg_mat_bin % s" % (j + 1), xi_gg) block.put_grid("pk_to_xi", "z", z_pk, "r", r_array, "xi_gm_mat_bin % s" % (j + 1), xi_gm) block.put_grid("pk_to_xi", "z", z_pk, "r", r_array, "xi_gg_mm_mat_bin % s" % (j + 1), xi_gg / xi_mm) block.put_grid("pk_to_xi", "z", z_pk, "r", r_array, "xi_gm_mm_mat_bin % s" % (j + 1), xi_gm / xi_mm) if j == 0: block.put("pk_to_xi", "Pk_all", Pkth_array_khres) block.put("pk_to_xi", "xi_all", xi_all) block.put_grid("pk_to_xi", "z", z_pk, "r", r_array, "xi_mm_mat", xi_mm) block.put_double_array_1d("pk_to_xi", "xi_gg_bin % s" % (j + 1), xi_gg_bin_f) block.put_double_array_1d("pk_to_xi", "xi_gm_bin % s" % (j + 1), xi_gm_bin_f) block.put_double_array_1d("pk_to_xi", "xi_mm_bin % s" % (j + 1), xi_mm_bin_f) block.put_double_array_1d("pk_to_xi", "xi_gg_mm_bin % s" % (j + 1), xi_gg_mm_bin_f) block.put_double_array_1d("pk_to_xi", "xi_gm_mm_bin % s" % (j + 1), xi_gm_mm_bin_f) block.put_double("pk_to_xi", "zmean_gg_bin % s" % (j + 1), zmean_g) block.put_double("pk_to_xi", "zmean_gm_bin % s" % (j + 1), zmean_gm) block.put_double("pk_to_xi", "zmean_gg_mm_bin % s" % (j + 1), zmean_g) block.put_double("pk_to_xi", "zmean_gm_mm_bin % s" % (j + 1), zmean_gm) return 0
def get_Pktharray(output_nl_grid, klin, knl, Pkzlin, Pnl_kz, usePNL_for_Pk=True, pt_type=None, Pk_terms_names=None, z_array=None, output_xi=False, use_fftlog=False): klinlog = np.log(klin) Pk0lin = Pkzlin[0, :] ind = np.where(klin > 0.03)[0][0] Growth = np.sqrt(Pkzlin[:, ind] / Pkzlin[0, ind]) nk = 4 * len( klin ) # higher res increases runtime, decreases potential ringing at low-k # eps = 1e-6 # eps = 0. # kmin = np.log10((1. + eps) * klin[0]) # kmax = np.log10((1. - eps) * klin[-1]) kmin = -6.0 kmax = 3.0 klin_fpt = np.logspace(kmin, kmax, nk) k1log = np.log(klin_fpt) # pinterp=interp1d(klinlog,np.log(Pk0lin),bounds_error=False, fill_value="extrapolate") plininterp = interp1d(klinlog, np.log(Pk0lin), fill_value='extrapolate', bounds_error=False) ## This interpolation should be at the input bounds. Extrapolate used to avoid failure due to numerical noise. No actual extrapolation is done. We could handle this using a margin or something else Plin_klin_fpt = np.exp(plininterp(k1log)) if (knl[0] < klin_fpt[0]) or (knl[-1] > klin_fpt[-1]): EK1 = k_extend(klin_fpt, np.log10(knl[0]), np.log10(knl[-1])) klin_fpt = EK1.extrap_k() Plin_klin_fpt = EK1.extrap_P_low(Plin_klin_fpt) Plin_klin_fpt = EK1.extrap_P_high(Plin_klin_fpt) klin_fpt_log = np.log(klin_fpt) knl_log = np.log(knl) # print output_nl_grid if output_nl_grid: temp = intspline(klin_fpt_log, np.log(Plin_klin_fpt)) Plin = np.exp(temp(knl_log)) Pnl1 = Pnl_kz if usePNL_for_Pk: knl2mat = np.tile(knl**2, (Pnl_kz.shape[0], 1)) k2Pnl1 = np.multiply(knl2mat, Pnl_kz) else: k2Pnl1 = np.outer(Growth**2, (knl**2) * Plin) if output_xi: renorm = np.sqrt(np.pi / 2.) if use_fftlog: myfftlog = fftlog(knl, (knl**3) * Plin, nu=1.5, c_window_width=0.2) r_lin, xi_lin_z0 = myfftlog.fftlog(0) else: r_lin, xitemp = sph(knl, nu=0, q=1.5)(Plin * renorm, extrap=True) xi_lin_z0 = (1 / (2 * np.pi**2)) * xitemp xi_lin = np.outer(Growth**2, xi_lin_z0) xi_nl = np.zeros(xi_lin.shape) xi_k2Pk = np.zeros(xi_lin.shape) for j in range(len(z_array)): if use_fftlog: myfftlog = fftlog(knl, (knl**3) * Pnl_kz[j, :], nu=1.5, c_window_width=0.2) _, xi_basis = myfftlog.fftlog(0) else: _, xitemp = sph(knl, nu=0, q=1.5)(Pnl_kz[j, :] * renorm, extrap=True) xi_basis = (1 / (2 * np.pi**2)) * xitemp xi_nl[j, :] = xi_basis if use_fftlog: myfftlog = fftlog(knl, (knl**3) * k2Pnl1[j, :], nu=1.5, c_window_width=0.2) _, xi_basis = myfftlog.fftlog(0) else: _, xitemp = sph(knl, nu=0, q=1.5)(k2Pnl1[j, :] * renorm, extrap=True) xi_basis = (1 / (2 * np.pi**2)) * xitemp xi_k2Pk[j, :] = xi_basis else: Plin = Plin_klin_fpt Pnl1 = Pnl_kz if usePNL_for_Pk: k2Pnl1 = np.outer(Growth**2, (klin_fpt**2) * Pnl1[0, :]) else: k2Pnl1 = np.outer(Growth**2, (klin_fpt**2) * Plin) Plin_kz = np.outer(Growth**2, Plin) n_pad = len(klin_fpt) if pt_type in ['oneloop_eul_bk']: fastpt = FASTPT.FASTPT(klin_fpt, to_do=['one_loop_dd'], low_extrap=-5, high_extrap=3, n_pad=n_pad) PXXNL_b1b2bsb3nl = fastpt.one_loop_dd_bias_b3nl(Plin_klin_fpt, C_window=.75) if output_nl_grid: temp = intspline(klin_fpt_log, (PXXNL_b1b2bsb3nl[2])) Pd1d2 = np.outer(Growth**4, (temp(knl_log))) if output_xi: if use_fftlog: myfftlog = fftlog(knl, (knl**3) * temp(knl_log), nu=1.5, c_window_width=0.2) _, xi_d1d2_z0 = myfftlog.fftlog(0) else: _, xitemp = sph(knl, nu=0, q=1.5)(temp(knl_log) * renorm, extrap=True) xi_d1d2_z0 = (1 / (2 * np.pi**2)) * xitemp xi_d1d2 = np.outer(Growth**4, xi_d1d2_z0) temp = intspline(klin_fpt_log, np.log(PXXNL_b1b2bsb3nl[3])) Pd2d2 = np.outer(Growth**4, np.exp(temp(knl_log))) if output_xi: if use_fftlog: myfftlog = fftlog(knl, (knl**3) * np.exp(temp(knl_log)), nu=1.5, c_window_width=0.2) _, xi_d2d2_z0 = myfftlog.fftlog(0) else: _, xitemp = sph(knl, nu=0, q=1.5)(np.exp(temp(knl_log)) * renorm, extrap=True) xi_d2d2_z0 = (1 / (2 * np.pi**2)) * xitemp xi_d2d2 = np.outer(Growth**4, xi_d2d2_z0) temp = intspline(klin_fpt_log, (PXXNL_b1b2bsb3nl[4])) Pd1s2 = np.outer(Growth**4, (temp(knl_log))) if output_xi: if use_fftlog: myfftlog = fftlog(knl, (knl**3) * temp(knl_log), nu=1.5, c_window_width=0.2) _, xi_d1s2_z0 = myfftlog.fftlog(0) else: _, xitemp = sph(knl, nu=0, q=1.5)(temp(knl_log) * renorm, extrap=True) xi_d1s2_z0 = (1 / (2 * np.pi**2)) * xitemp xi_d1s2 = np.outer(Growth**4, xi_d1s2_z0) temp = intspline(klin_fpt_log, (PXXNL_b1b2bsb3nl[5])) Pd2s2 = np.outer(Growth**4, (temp(knl_log))) if output_xi: if use_fftlog: myfftlog = fftlog(knl, (knl**3) * temp(knl_log), nu=1.5, c_window_width=0.2) _, xi_d2s2_z0 = myfftlog.fftlog(0) else: rval, xitemp = sph(knl, nu=0, q=1.5)(temp(knl_log) * renorm, extrap=False) xi_d2s2_z0 = (1 / (2 * np.pi**2)) * xitemp # pdb.set_trace() xi_d2s2 = np.outer(Growth**4, xi_d2s2_z0) temp = intspline(klin_fpt_log, np.log(PXXNL_b1b2bsb3nl[6])) Ps2s2 = np.outer(Growth**4, np.exp(temp(knl_log))) if output_xi: if use_fftlog: myfftlog = fftlog(knl, (knl**3) * np.exp(temp(knl_log)), nu=1.5, c_window_width=0.2) _, xi_s2s2_z0 = myfftlog.fftlog(0) else: _, xitemp = sph(knl, nu=0, q=1.5)(np.exp(temp(knl_log)) * renorm, extrap=True) xi_s2s2_z0 = (1 / (2 * np.pi**2)) * xitemp xi_s2s2 = np.outer(Growth**4, xi_s2s2_z0) temp = intspline(klin_fpt_log, (PXXNL_b1b2bsb3nl[7])) sig3nl = np.outer(Growth**4, (temp(knl_log))) if output_xi: if use_fftlog: myfftlog = fftlog(knl, (knl**3) * temp(knl_log), nu=1.5, c_window_width=0.2) _, xi_sig3nl_z0 = myfftlog.fftlog(0) else: _, xitemp = sph(knl, nu=0, q=1.5)(temp(knl_log) * renorm, extrap=True) xi_sig3nl_z0 = (1 / (2 * np.pi**2)) * xitemp xi_sig3nl = np.outer(Growth**4, xi_sig3nl_z0) sig4 = np.outer(Growth**4, PXXNL_b1b2bsb3nl[8] * np.ones_like(knl)) else: [Pd1d2, Pd2d2, Pd1s2, Pd2s2, Ps2s2, sig3nl, sig4] = [ np.outer(Growth**4, PXXNL_b1b2bsb3nl[2]), np.outer(Growth**4, PXXNL_b1b2bsb3nl[3]), np.outer(Growth**4, PXXNL_b1b2bsb3nl[4]), np.outer(Growth**4, PXXNL_b1b2bsb3nl[5]), np.outer(Growth**4, PXXNL_b1b2bsb3nl[6]), np.outer(Growth**4, PXXNL_b1b2bsb3nl[7]), np.outer( Growth**4, PXXNL_b1b2bsb3nl[8] * np.ones_like(PXXNL_b1b2bsb3nl[0])) ] pdb.set_trace() Pk_th_array = [ Plin_kz, Pnl1, Pd1d2, Pd2d2, Pd1s2, Pd2s2, Ps2s2, sig3nl, k2Pnl1, sig4 ] if output_xi: xi_th_array = [ xi_lin, xi_nl, xi_d1d2, xi_d2d2, xi_d1s2, xi_d2s2, xi_s2s2, xi_sig3nl, xi_k2Pk ] elif pt_type in ['oneloop_cleft_bk']: cl = cpool.CLEFT(k=klin_fpt, p=Plin_klin_fpt) Pk_th_array = np.zeros((len(Pk_terms_names), len(Growth), len(knl))) kinput_ind = np.where((knl < 4.) & (knl > 1e-3))[0] kinput = knl[kinput_ind] # pdb.set_trace() pk_table_f = cpool.get_nonlinear_kernels_wgroth(cl, kinput, koutput=knl, Growth=Growth, do_analysis=False, Pnl_toplot=Pnl1, z_array=z_array) Pk_th_array[1:-1, :, :] = pk_table_f Pk_th_array[0, :, :] = Plin_kz Pk_th_array[1, :, :] = Pnl1 Pk_th_array[-1, :, :] = k2Pnl1 else: Pk_th_array = None print('give correct pt_type') if output_nl_grid: kout = knl else: kout = klin_fpt if output_xi: return Pk_th_array, kout, xi_th_array, r_lin else: return Pk_th_array, kout