phi = one_time['phi'] psi = one_time['psi'] theta_b = one_time['t_b'] # compute related quantitites R = 3. / 4. * M.Omega_b() / M.Omega_g() / ( 1 + z_rec) # R = 3/4 * (rho_b/rho_gamma) at z_rec zero_point = -(1. + R) * psi # zero point of oscillations: -(1.+R)*psi # # get Theta0 oscillation amplitude (for vertical scale of plot) # Theta0_amp = max(Theta0.max(), -Theta0.min()) # # use table of background quantitites to find the wavenumbers corresponding to # Hubble crossing (k = 2 pi a H), sound horizon crossing (k = 2pi / rs) # background = M.get_background() # load background table #print background.viewkeys() # background_tau = background[ 'conf. time [Mpc]'] # read confromal times in background table background_z = background['z'] # read redshift background_kh = 2. * math.pi * background['H [1/Mpc]'] / ( 1. + background['z'] ) / M.h() # read kh = 2pi aH = 2pi H/(1+z) converted to [h/Mpc] background_ks = 2. * math.pi / background['comov.snd.hrz.'] / M.h( ) # read ks = 2pi/rs converted to [h/Mpc] # # define interpolation functions; we want the value of tau when the argument is equal to 2pi # kh_at_tau = interp1d(background_tau, background_kh) ks_at_tau = interp1d(background_tau, background_ks)
'attractor_ic_scf': 'no', 'write background':'yes', 'compute damping scale':'yes'} try: cosmo.set(params) # Set the parameters to the cosmological code cosmo.compute() # solve physics m_axion = 10**cosmo.log10_m_axion()*h*100/_c_ print "m_axion %f"%(m_axion) # k_res_analytical = 0.79*m_axion*Theta_initial[j]*(10**ac[i]) k_res_analytical = 0.79*m_axion*Theta_initial[j]*(10**ac[i]) one_time = cosmo.get_transfer(0) # transfer functions at each time tau k = one_time['k (h/Mpc)'] delta_phi_scf = np.abs(one_time['delta_phi_scf']) ##evaluated today k_of_delta = interp1d(delta_phi_scf,k) background = cosmo.get_background() # load background table background_tau = background['conf. time [Mpc]'] # read conformal times in background table background_z = background['z'] # read redshift background_Om_scf = background['(.)Omega_scf'] # read redshift background_z_at_tau = interp1d(background_tau,background_z) phi_enveloppe = Theta_initial[j]*10**cosmo.log10_f_axion()*(2/(10**ac[i]))**(-3.*(1+wn)/2/n_axion) ##evaluated today delta_max = np.sqrt(delta_phi_scf*delta_phi_scf*A_s*(k/K_star)**(n_s-1))/(phi_enveloppe) print max(delta_max), np.where(delta_max==max(delta_max)) k_res_numerical = k[np.where(delta_max==max(delta_max))]*h ##evaluated today print "k_res analytical %f Mpc-1, k_res numerical %f Mpc-1"%(k_res_analytical,k_res_numerical) except CosmoComputationError: # this happens when CLASS fails print "bug!" k_res_numerical = 0 k_nl_scf[i][j] = 100 #arbitrary large number: bug z_nl_scf[i][j] = 0 #arbitrary large number: bug Omega_nl_scf[i][j] = 1e-30 #arbitrary small number
from scipy.interpolate import interp1d import math common_settings = {# we need to set the output field to something although # the really releveant outpout here will be set with 'k_output_values' 'output':'mPk', # value of k we want to polot in [1/Mpc] # LambdaCDM parameters 'h':0.67556, 'omega_b':0.022032, 'omega_cdm':0.12038, 'A_s':2.215e-9, 'n_s':0.9619, 'tau_reio':0.0925, # Take fixed value for primordial Helium (instead of automatic BBN adjustment) 'YHe':0.246, # other options and settings 'compute damping scale':'yes', # needed to output the time of damping scale crossing 'gauge':'newtonian'} M = Class() M.set(common_settings) M.compute() growth = M.get_background()['gr.fac. D'] zs = M.get_background()['z'] scalefactor = 1/zs #plt.semilogx(zs, growth,label = "D(z)") plt.semilogx(scalefactor, growth,label = "D(a)") plt.legend() plt.show()
'adptative_stepsize': 100, 'scf_evolve_as_fluid': 'no' }) # 2.258053e-02 1.298650e-01 9.880137e-01 2.176655e-09 6.833666e-02 1.041246e+00 -3.736778e+00 4.717743e-09 2.791761e+00 M.compute() # # get Cls # # clM = M.raw_cl(2500 clM = M.lensed_cl(2500) ll = clM['ell'][2:] clTT = clM['tt'][2:] clTE = clM['te'][2:] clEE = clM['ee'][2:] bg = M.get_background() Omega_scf = bg['(.)Omega_scf'] H = bg['H [1/Mpc]'] Da = bg['ang.diam.dist.'] z = bg['z'] tau = bg['conf. time [Mpc]'] tau_interp = interp1d(z, tau) tau_0 = tau_interp(0) derived = M.get_current_derived_parameters(['z_rec', 'tau_rec']) tau_rec = derived['tau_rec'] for j in range(len(Omega_scf)): if Omega_scf[j] > 0.01: k = H[j] / (1 + z[j]) # l.append(k*Da[j]) l.append(k * (tau_0 - tau_rec)) print(450. / (tau_0 - tau_rec))
# define conformal time sampling array # times = M.get_current_derived_parameters(['tau_rec','conformal_age']) tau_rec=times['tau_rec'] tau_0 = times['conformal_age'] tau1 = np.logspace(math.log10(tau_ini),math.log10(tau_rec),tau_num_early) tau2 = np.logspace(math.log10(tau_rec),math.log10(tau_0),tau_num_late)[1:] tau2[-1] *= 0.999 # this tiny shift avoids interpolation errors tau = np.concatenate((tau1,tau2)) tau_num = len(tau) # # use table of background and thermodynamics quantitites to define some functions # returning some characteristic scales # (of Hubble crossing, sound horizon crossing, etc.) at different time # background = M.get_background() # load background table #print background.viewkeys() thermodynamics = M.get_thermodynamics() # load thermodynamics table #print thermodynamics.viewkeys() # background_tau = background['conf. time [Mpc]'] # read conformal times in background table background_z = background['z'] # read redshift background_aH = 2.*math.pi*background['H [1/Mpc]']/(1.+background['z'])/M.h() # read 2pi * aH in [h/Mpc] background_ks = 2.*math.pi/background['comov.snd.hrz.']/M.h() # read 2pi/(comoving sound horizon) in [h/Mpc] background_rho_m_over_r = (background['(.)rho_b']+background['(.)rho_cdm']) /(background['(.)rho_g']+background['(.)rho_ur']) # read rho_r / rho_m (to find time of equality) background_rho_l_over_m = background['(.)rho_lambda'] /(background['(.)rho_b']+background['(.)rho_cdm']) # read rho_m / rho_lambda (to find time of equality) thermodynamics_tau = thermodynamics['conf. time [Mpc]'] # read confromal times in thermodynamics table thermodynamics_kd = 2.*math.pi/thermodynamics['r_d']/M.h() # read 2pi(comoving diffusion scale) in [h/Mpc] # # define a bunch of interpolation functions based on previous quantities #
class Binning(): def __init__(self, fname, outdir='./'): self._cosmo = Class() self._fname = fname self._outdir = outdir self._set_default_values() def _set_full_filenames(self, filesuffixes): """ Return a list with the fullnames of the others, increasing their number in case they exist Additionally, set the full file names, of self._fparamsname and self.fshootname. """ fullfilenames = [] for suffix in filesuffixes + ['params', 'shooting']: fullfilenames.append( os.path.join(self._outdir, self._fname + '-' + suffix)) i = 0 bools = [True] * len(fullfilenames) while 1: for n, f in enumerate(fullfilenames): bools[n] = os.path.exists(f + '-%s.txt' % i) if True not in bools: break i += 1 self._fparamsname = fullfilenames[-2] + '-%s.txt' % i self._fshootname = fullfilenames[-1] + '-%s.txt' % i return [f + '-%s.txt' % i for f in fullfilenames[:-2]] def _set_default_values(self): """ Set default values of parameters lists. """ self.params_smg = [] self.params_2_smg = [] self.h = [] self.Omega_cdm = [] self.gravity_model = [] self._params = { "Omega_Lambda": 0, "Omega_fld": 0, "Omega_smg": -1, 'output': 'mPk', # 'z_max_pk': 1000 } # Added for relative errors in f. self._computed = False self._path = [] self._binType = '' def set_Pade(self, n_num, m_den, xvar='a', xReverse=False, accuracy=1e-3, increase=False, maxfev=0): """ Set what Pade polynomial orders, temporal variable and its ordering use. """ self.reset() self._PadeOrder = [n_num, m_den] self._Pade_xvar = xvar self._Pade_xReverse = xReverse self._Pade_maxfev = maxfev self._Pade_increase = increase self._Pade_accuracy = accuracy self._binType = 'Pade' def set_fit(self, fit_function, n_coeffs, variable_to_fit, fit_function_label='', z_max_pk=1000, bounds=(-np.inf, np.inf), p0=[], xvar='ln(1+z)'): """ Set the fitting_function and the number of coefficients. variable_to_fit must be one of 'F'or 'w'. fit_function_label will be written in the header of fit files. """ self.reset() self._fit_function = fit_function self._n_coeffs = n_coeffs self._list_variables_to_fit = ['F', 'w', 'logRho', 'logX', 'X'] if variable_to_fit in self._list_variables_to_fit: self._variable_to_fit = variable_to_fit else: raise ValueError('variable_to_fit must be one of {}'.format( self._list_variables_to_fit)) self._fit_function_label = fit_function_label self._binType = 'fit' self._fFitname = self._set_full_filenames(['fit-' + variable_to_fit ])[0] self._params.update({'z_max_pk': z_max_pk}) self._fit_bounds = bounds self._p0 = p0 list_fit_xvar = ['ln(1+z)', 'lna', 'a', '(1-a)'] if xvar in list_fit_xvar: self._fit_xvar = xvar else: raise ValueError('xvar must be one of {}'.format(list_fit_xvar)) def set_bins(self, zbins, abins): """ Set what bins to use and reset to avoid confusions. """ self.reset() self._zbins = zbins self._abins = abins self._binType = 'bins' self._fwzname, self._fwaname = self._set_full_filenames( ['wz-bins', 'wa-bins']) def _read_from_file(self, path): """ Return params for class from files used in quintessence Marsh. """ with open(path) as f: f.readline() header = f.readline().split()[3:] # Remove '#', 'w0', and 'wa' columns = np.loadtxt(path, unpack=True)[2:] # Remove columns w0, wa for index_h, head in enumerate(header): if head[-1] == 'h': break self.params_smg = zip(*columns[:index_h]) self.params_2_smg = [ list(row[~np.isnan(row)]) for row in np.array(zip(*columns[index_h + 2:])) ] self.h = columns[index_h] self.Omega_cdm = columns[index_h + 1] self.gravity_model = os.path.basename(path).split('-')[0] def _params_from_row(self, row): """ Set parameters. """ params = self._params params.update({ 'parameters_smg': str(self.params_smg[row]).strip('[()]'), 'h': self.h[row], 'Omega_cdm': self.Omega_cdm[row], 'gravity_model': self.gravity_model }) if len(self.params_2_smg): params.update({ 'parameters_2_smg': str(self.params_2_smg[row]).strip('[()]') }) return params def compute_bins(self, params): """ Compute the w_i bins for the model with params. """ wzbins = np.empty(len(self._zbins)) wabins = np.empty(len(self._abins)) self._params = params self._cosmo.set(params) try: self._cosmo.compute() for n, z in enumerate(self._zbins): wzbins[n] = self._cosmo.w_smg(z) for n, a in enumerate(self._abins): wabins[n] = self._cosmo.w_smg(1. / a - 1.) shoot = self._cosmo.get_current_derived_parameters( ['tuning_parameter'])['tuning_parameter'] except Exception as e: self._cosmo.struct_cleanup() self._cosmo.empty() raise e self._cosmo.struct_cleanup() self._cosmo.empty() return wzbins, wabins, shoot def _compute_common_init(self, params): """ Common first steps for compute methods """ self._params.update(params) self._cosmo.set(self._params) try: self._cosmo.compute() b = self._cosmo.get_background() shoot = self._cosmo.get_current_derived_parameters( ['tuning_parameter'])['tuning_parameter'] except Exception as e: self._cosmo.struct_cleanup() self._cosmo.empty() raise e return b, shoot def _fit(self, X, Y): """ Fits self._fit_function to X, Y, with self._n_coeffs. """ return wicm.fit(self._fit_function, X, Y, self._n_coeffs, bounds=self._fit_bounds, p0=self._p0) def _get_fit_xvar_and_log1Plusz(self, z): """ Return the X array to fit and log(1+z) """ if self._fit_xvar == 'ln(1+z)': X = np.log(z + 1) lna = X elif self._fit_xvar == 'lna': X = -np.log(z + 1) lna = -X elif self._fit_xvar == 'a': X = 1. / (1 + z) lna = np.log(z + 1) elif self._fit_xvar == '(1-a)': X = (z / (1 + z)) lna = np.log(z + 1) return X, lna def compute_fit_coefficients_for_F(self, params): """ Returns the coefficients of the polynomial fit of f(a) = \int w and the maximum and minimum residual in absolute value. """ b, shoot = self._compute_common_init(params) # Compute the exact \int dlna a ############################### z, w = b['z'], b['w_smg'] Fint = [] lna = -np.log(1 + z)[::-1] for i in lna: Fint.append(integrate.trapz(w[::-1][lna >= i], lna[lna >= i])) Fint = np.array(Fint) ##### zlim = self._params['z_max_pk'] # Note that lna is log(1+z). I used this name because is more convenient X, lna = self._get_fit_xvar_and_log1Plusz(z[z <= zlim]) ##################### zTMP = z[z <= zlim] Y1 = Fint[::-1][z < zlim] # Ordered as in CLASS ##################### # Fit to fit_function ##################### popt1, yfit1 = self._fit(X, Y1) # Obtain max. rel. dev. for DA and f. ##################### rhoDE_fit = b['(.)rho_smg'][-1] * np.exp(-3 * yfit1) * ( 1 + zTMP)**3 ###### CHANGE WITH CHANGE OF FITTED THING Xw_fit, w_fit = wicm.diff(lna, yfit1) w_fit = -interp1d( Xw_fit, w_fit, bounds_error=False, fill_value='extrapolate')(lna) DA_reldev, f_reldev = self._compute_maximum_relative_error_DA_f( rhoDE_fit, w_fit) # Free structures ############### self._cosmo.struct_cleanup() self._cosmo.empty() return np.concatenate([popt1, [DA_reldev, f_reldev]]), shoot def compute_fit_coefficients_for_logX(self, params): """ Returns the coefficients of the polynomial fit of log(rho/rho_0) = -3 \int dlna (w+1) and the maximum and minimum residual in absolute value. """ b, shoot = self._compute_common_init(params) # Compute the exact -3 \int dlna (w + 1) ############################### z = b['z'] logX = np.log(b['(.)rho_smg'] / b['(.)rho_smg'][-1]) ##### zlim = self._params['z_max_pk'] # Note that lna is log(1+z). I used this name because is more convenient X, lna = self._get_fit_xvar_and_log1Plusz(z[z <= zlim]) ##################### Y1 = logX[z <= zlim] ##################### # Fit to fit_function ##################### popt1, yfit1 = self._fit(X, Y1) # Obtain max. rel. dev. for DA and f. ##################### rhoDE_fit = b['(.)rho_smg'][-1] * np.exp( yfit1) ###### CHANGE WITH CHANGE OF FITTED THING Xw_fit, ThreewPlus1 = wicm.diff(lna, yfit1) w_fit = ThreewPlus1 / 3. - 1 # The minus sign is taken into account by the CLASS ordering. w_fit = interp1d(Xw_fit, w_fit, bounds_error=False, fill_value='extrapolate')(lna) DA_reldev, f_reldev = self._compute_maximum_relative_error_DA_f( rhoDE_fit, w_fit) # Free structures ############### self._cosmo.struct_cleanup() self._cosmo.empty() return np.concatenate([popt1, [DA_reldev, f_reldev]]), shoot def compute_fit_coefficients_for_X(self, params): """ Returns the coefficients of the polynomial fit of rho/rho_0 = exp[-3 \int dlna (w+1)] and the maximum and minimum residual in absolute value. """ b, shoot = self._compute_common_init(params) # Compute the exact -3 \int dlna (w + 1) ############################### z = b['z'] Y = b['(.)rho_smg'] / b['(.)rho_smg'][-1] ##### zlim = self._params['z_max_pk'] # Note that lna is log(1+z). I used this name because is more convenient X, lna = self._get_fit_xvar_and_log1Plusz(z[z <= zlim]) ##################### Y1 = Y[z <= zlim] ##################### # Fit to fit_function ##################### popt1, yfit1 = self._fit(X, Y1) # Obtain max. rel. dev. for DA and f. ##################### rhoDE_fit = b['(.)rho_smg'][ -1] * yfit1 ###### CHANGE WITH CHANGE OF FITTED THING Xw_fit, diff = wicm.diff(lna, yfit1) diff = interp1d(Xw_fit, diff, bounds_error=False, fill_value='extrapolate')(lna) ThreewPlus1 = diff / yfit1 w_fit = ThreewPlus1 / 3. - 1 # The minus sign is taken into account by the CLASS ordering. DA_reldev, f_reldev = self._compute_maximum_relative_error_DA_f( rhoDE_fit, w_fit) # Free structures ############### self._cosmo.struct_cleanup() self._cosmo.empty() return np.concatenate([popt1, [DA_reldev, f_reldev]]), shoot def compute_fit_coefficients_for_logRho(self, params): """ Returns the coefficients of the fit of ln(rho_de) and the maximum and minimum residual in absolute value. """ b, shoot = self._compute_common_init(params) # Compute the exact log(rho) ############################### z = b['z'] logX = np.log(b['(.)rho_smg']) ##### zlim = self._params['z_max_pk'] # Note that lna is log(1+z). I used this name because is more convenient X, lna = self._get_fit_xvar_and_log1Plusz(z[z <= zlim]) ##################### Y1 = logX[z <= zlim] ##################### # Fit to fit_function ##################### popt1, yfit1 = self._fit(X, Y1) # Obtain max. rel. dev. for DA and f. ##################### rhoDE_fit = np.exp(yfit1) ###### CHANGE WITH CHANGE OF FITTED THING Xw_fit, ThreewPlus1 = wicm.diff(lna, yfit1 - yfit1[-1]) w_fit = ThreewPlus1 / 3. - 1 # The minus sign is taken into account by the CLASS ordering. w_fit = interp1d(Xw_fit, w_fit, bounds_error=False, fill_value='extrapolate')(lna) DA_reldev, f_reldev = self._compute_maximum_relative_error_DA_f( rhoDE_fit, w_fit) # Free structures ############### self._cosmo.struct_cleanup() self._cosmo.empty() return np.concatenate([popt1, [DA_reldev, f_reldev]]), shoot def compute_fit_coefficients_for_w(self, params): """ Returns the coefficients of the polynomial fit of f(a) = \int w and the maximum and minimum residual in absolute value. """ b, shoot = self._compute_common_init(params) # Compute the exact \int dlna a ############################### z, w = b['z'], b['w_smg'] zlim = self._params['z_max_pk'] # Note that lna is log(1+z). I used this name because is more convenient X, lna = self._get_fit_xvar_and_log1Plusz(z[z <= zlim]) ##################### zTMP = z[z <= zlim] Y1 = w[z <= zlim] # Fit to fit_function ##################### popt1, yfit1 = self._fit(X, Y1) # Obtain max. rel. dev. for DA and f. ##################### Fint = [] lna = -np.log(1 + zTMP)[::-1] for i in lna: Fint.append(integrate.trapz(yfit1[::-1][lna >= i], lna[lna >= i])) Fint = np.array(Fint[::-1]) rhoDE_fit = b['(.)rho_smg'][-1] * np.exp( -3 * Fint) * (1 + zTMP)**3 # CHANGE WITH CHANGE OF FITTED THING # TODO: needed? # Xw_fit, w_fit = X, yfit1 # w_fit = interp1d(Xw_fit, w_fit, bounds_error=False, fill_value='extrapolate')(X) w_fit = yfit1 DA_reldev, f_reldev = self._compute_maximum_relative_error_DA_f( rhoDE_fit, w_fit) # Free structures ############### self._cosmo.struct_cleanup() self._cosmo.empty() return np.concatenate([popt1, [DA_reldev, f_reldev]]), shoot def _compute_maximum_relative_error_DA_f(self, rhoDE_fit, w_fit): """ Return the relative error for the diameter angular distance and the growth factor, f. rhoDE_fit = array wfit = interp1d(w) """ b = self._cosmo.get_background() # Compute the exact growth rate ##################### z_max_pk = self._params['z_max_pk'] zlim = z_max_pk z, w = b['z'], b['w_smg'] zTMP = z[z <= zlim] rhoM = (b['(.)rho_b'] + b['(.)rho_cdm']) rhoR = (b['(.)rho_g'] + b['(.)rho_ur']) DA = b['ang.diam.dist.'] OmegaDEwF_exact = interp1d(z[z <= z_max_pk], (b['(.)rho_smg'] / b['(.)rho_crit'] * w)[z <= z_max_pk]) OmegaMF = interp1d(z[z <= z_max_pk], (rhoM / b['(.)rho_crit'])[z <= z_max_pk]) time_boundaries = [z[z <= z_max_pk][0], z[z <= z_max_pk][-1]] # Use LSODA integrator as some solutions were wrong with RK45 and OK # with this. f = integrate.solve_ivp( cosmo_extra.fprime(OmegaDEwF_exact, OmegaMF), time_boundaries, [cosmo_extra.growthrate_at_z(self._cosmo, z_max_pk)], method='LSODA', dense_output=True) # Compute D_A for fitted model ################ H_fit = np.sqrt(rhoM[z <= zlim] + rhoR[z <= zlim] + rhoDE_fit) DA_fit = cosmo_extra.angular_distance(z[z <= zlim], H_fit[zTMP <= zlim]) # Compute the growth rate for fitted model ############### OmegaMF_fit = interp1d( zTMP, 1 - rhoDE_fit / H_fit**2 - rhoR[z <= zlim] / H_fit**2) ####### THIS FITS OBSERVABLES CORRECTLY # OmegaMF_fit = interp1d(zTMP, rhoM[z<=zlim]/H_fit**2) ####### THIS FITS OBSERVABLES CORRECTLY OmegaDEwF_fit = interp1d(zTMP, rhoDE_fit / H_fit**2 * w_fit) f_fit = integrate.solve_ivp( cosmo_extra.fprime(OmegaDEwF_fit, OmegaMF_fit), [zTMP[0], zTMP[-1]], [cosmo_extra.growthrate_at_z(self._cosmo, zTMP[0])], method='LSODA', dense_output=True) # Obtain rel. deviations. ################ # Remove close to 0 points as rel.dev diverges. z = 0.05 is the lowest # redshift observed and is done in BOSS survey. arXiv: 1308.4164 # DA_reldev = max(np.abs(DA_fit[zTMP>=0.04]/DA[ (z>=0.04) & (z<=zlim)] - 1)) DA_reldev = max(np.abs(DA_fit / DA[z <= zlim] - 1)) f_reldev = max(np.abs(f_fit.sol(zTMP)[0] / f.sol(zTMP)[0] - 1)) return DA_reldev, f_reldev def compute_Pade_coefficients(self, params): """ Returns the Pade coefficients for w computed from params and the maximum and minimum residual in absolute value. """ self._params = params self._cosmo.set(params) try: self._cosmo.compute() b = self._cosmo.get_background() shoot = self._cosmo.get_current_derived_parameters( ['tuning_parameter'])['tuning_parameter'] except Exception as e: self._cosmo.struct_cleanup() self._cosmo.empty() raise e self._cosmo.struct_cleanup() self._cosmo.empty() xDict = { 'z': b['z'], 'z+1': b['z'] + 1, 'a': 1. / (b['z'] + 1), 'log(a)': -np.log(b['z'] + 1), 'log(z+1)': np.log(b['z'] + 1) } X = xDict[self._Pade_xvar] w = b['w_smg'] if self._Pade_xReverse: X = X[::-1] w = w[::-1] PadeOrder = np.array(self._PadeOrder) if not self._Pade_increase: reduceOrder = [[0, 0], [1, 0], [0, 1], [2, 0], [2, 1], [3, 1]] orderList = PadeOrder - reduceOrder else: orderList = [[1, 1], [2, 0], [3, 0], [2, 1], [2, 2], [3, 1], [4, 0], [2, 3], [3, 2], [4, 1], [5, 0], [3, 3], [4, 2], [5, 1], [3, 4], [4, 3], [5, 2], [3, 5], [4, 4], [5, 3], [4, 5], [5, 4], [5, 5]] r = np.array([np.inf]) for order in orderList: # Increase order of Pade up to [5/5]. try: padeCoefficientsTMP, padeFitTMP = fit_pade( X, w, *order, maxfev=self._Pade_maxfev) rTMP = np.abs(padeFitTMP / w - 1.) if self._Pade_increase and (np.max(rTMP) > self._Pade_accuracy): if np.max(rTMP) < np.max(r): padeCoefficients = padeCoefficientsTMP r = rTMP continue else: padeCoefficients = padeCoefficientsTMP r = rTMP break except Exception as e: if (order == orderList[-1]) and (len(r) == 1): raise e continue zeros = (PadeOrder - order) numCoefficients = np.append(padeCoefficients[:order[0] + 1], [0.] * zeros[0]) denCoefficients = np.append(padeCoefficients[order[0] + 1:], [0.] * zeros[1]) padeCoefficients = np.concatenate([numCoefficients, denCoefficients]) return np.concatenate([padeCoefficients, [np.min(r), np.max(r)]]), shoot def compute_bins_from_params(self, params_func, number_of_rows): """ Compute the w_i bins for the models given by the function params_func iterated #iterations. """ self._create_output_files() wzbins = [] wabins = [] params = [] shoot = [] for row in range(number_of_rows): sys.stdout.write("{}/{}\n".format(row + 1, number_of_rows)) params_tmp = params_func().copy() try: wzbins_tmp, wabins_tmp, shoot_tmp = self.compute_bins( params_tmp) wzbins.append(wzbins_tmp) wabins.append(wabins_tmp) params.append(params_tmp) shoot.append(shoot_tmp) # Easily generalizable. It could be inputted a list with the # desired derived parameters and store the whole dictionary. except Exception as e: sys.stderr.write(str(self._params) + '\n') sys.stderr.write(str(e)) sys.stderr.write('\n') continue if len(wzbins) == 5: self._save_computed(params, shoot, [wzbins, wabins]) params = [] wzbins = [] wabins = [] shoot = [] self._save_computed(params, shoot, [wzbins, wabins]) def compute_Pade_from_params(self, params_func, number_of_rows): """ Compute the w_i bins for the models given by the function params_func iterated #iterations. """ self._create_output_files() wbins = [] params = [] shoot = [] for row in range(number_of_rows): sys.stdout.write("{}/{}\n".format(row + 1, number_of_rows)) params_tmp = params_func().copy() try: wbins_tmp, shoot_tmp = self.compute_Pade_coefficients( params_tmp) wbins.append(wbins_tmp) params.append(params_tmp) shoot.append(shoot_tmp) # Easily generalizable. It could be inputted a list with the # desired derived parameters and store the whole dictionary. except Exception as e: sys.stderr.write(str(self._params) + '\n') sys.stderr.write(str(e)) sys.stderr.write('\n') continue if len(wbins) == 5: self._save_computed(params, shoot, wbins) params = [] wbins = [] shoot = [] self._save_computed(params, shoot, wbins) def compute_fit_from_params(self, params_func, number_of_rows): """ Compute the fit for the models given by the function params_func iterated #iterations. The variable to fit is chosen in self.set_fit """ # TODO: If this grows, consider creating a separate method if self._variable_to_fit == 'F': fit_variable_function = self.compute_fit_coefficients_for_F elif self._variable_to_fit == 'w': fit_variable_function = self.compute_fit_coefficients_for_w elif self._variable_to_fit == 'logRho': fit_variable_function = self.compute_fit_coefficients_for_logRho elif self._variable_to_fit == 'logX': fit_variable_function = self.compute_fit_coefficients_for_logX elif self._variable_to_fit == 'X': fit_variable_function = self.compute_fit_coefficients_for_X self._create_output_files() coeffs = [] params = [] shoot = [] for row in range(number_of_rows): sys.stdout.write("{}/{}\n".format(row + 1, number_of_rows)) # params_tmp = params_func().copy() try: coeffs_tmp, shoot_tmp = fit_variable_function(params_func()) coeffs.append(coeffs_tmp) params.append(self._params.copy()) shoot.append(shoot_tmp) # Easily generalizable. It could be inputted a list with the # desired derived parameters and store the whole dictionary. except Exception as e: sys.stderr.write(str(self._params) + '\n') sys.stderr.write(str(e)) sys.stderr.write('\n') continue if len(coeffs) == 5: self._save_computed(params, shoot, coeffs) params = [] coeffs = [] shoot = [] self._save_computed(params, shoot, coeffs) def compute_bins_from_file(self, path): """ Compute the w_i bins for the models given in path. """ if self._computed is True: print( "Bins already computed. Use reset if you want to compute it again" ) return self._path = path self._read_from_file(path) def params_gen(length): row = 0 while row < length: yield self._params_from_row(row) row += 1 params = params_gen(len(self.params_smg)) self.compute_bins_from_params(params.next, len(self.params_smg)) def _create_output_files(self): """ Initialize the output files. """ # TODO: Add check if files exist with open(self._fparamsname, 'a') as f: f.write('# ' + "Dictionary of params to use with cosmo.set()" + '\n') with open(self._fshootname, 'a') as f: f.write('# ' + "Shooting variable value" + '\n') if self._binType == 'bins': with open(self._fwzname, 'a') as f: f.write('# ' + "Bins on redshift" + '\n') f.write('# ' + str(self._zbins).strip('[]').replace('\n', '') + '\n') with open(self._fwaname, 'a') as f: f.write('# ' + "Bins on scale factor" + '\n') f.write('# ' + str(self._abins).strip('[]').replace('\n', '') + '\n') elif self._binType == 'Pade': with open(self._fPadename, 'a') as f: f.write('# ' + "Pade fit for temporal variable {} \n".format( self._Pade_xvar)) coeff_header_num = [ 'num_{}'.format(n) for n in range(self._PadeOrder[0] + 1) ] coeff_header_den = [ 'den_{}'.format(n + 1) for n in range(self._PadeOrder[1]) ] res_header = ['min(residual)', 'max(residual)'] f.write('# ' + ' '.join(coeff_header_num + coeff_header_den + res_header) + '\n') elif self._binType == 'fit': with open(self._fFitname, 'a') as f: f.write('# ' + "{} fit for temporal variable {} of {}\n".format( self._fit_function_label, self._fit_xvar, self._variable_to_fit)) coeff_header_num = [ 'c_{}'.format(n) for n in range(self._n_coeffs) ] res_header = ['max(rel.dev. D_A)', 'max(rel.dev. f)'] f.write('# ' + ' '.join(coeff_header_num + res_header) + '\n') def _save_computed(self, params, shoot, wbins): """ Save stored iterations in file. """ with open(self._fparamsname, 'a') as f: for i in params: f.write(str(i) + '\n') with open(self._fshootname, 'a') as f: np.savetxt(f, shoot) if self._binType == 'bins': wzbins, wabins = wbins with open(self._fwzname, 'a') as f: np.savetxt(f, wzbins) with open(self._fwaname, 'a') as f: np.savetxt(f, wabins) elif self._binType == 'Pade': with open(self._fPadename, 'a') as f: np.savetxt(f, wbins) elif self._binType == 'fit': with open(self._fFitname, 'a') as f: np.savetxt(f, wbins) def reset(self): """ Reset class """ self._cosmo.struct_cleanup() self._cosmo.empty() self._set_default_values()
#Einstein-de Sitter CDM = Class() CDM.set({'Omega_cdm': 0.95, 'Omega_b': 0.05}) CDM.compute() # Just to cross-check that Omega_Lambda is negligible # (but not exactly zero because we neglected radiation) derived = CDM.get_current_derived_parameters(['Omega0_lambda']) print derived print "Omega_Lambda =", derived['Omega0_lambda'] # In[ ]: #Get background quantities and recover their names: baLCDM = LCDM.get_background() baCDM = CDM.get_background() baCDM.viewkeys() # In[ ]: #Get H_0 in order to plot the distances in this unit fLCDM = LCDM.Hubble(0) fCDM = CDM.Hubble(0) # In[ ]: namelist = ['lum. dist.', 'comov. dist.', 'ang.diam.dist.'] colours = ['b', 'g', 'r'] for name in namelist: idx = namelist.index(name)
#Einstein-de Sitter CDM = Class() CDM.set({'Omega_cdm':0.95,'Omega_b':0.05}) CDM.compute() # Just to cross-check that Omega_Lambda is negligible # (but not exactly zero because we neglected radiation) derived = CDM.get_current_derived_parameters(['Omega0_lambda']) print derived print "Omega_Lambda =",derived['Omega0_lambda'] # In[ ]: #Get background quantities and recover their names: baLCDM = LCDM.get_background() baCDM = CDM.get_background() baCDM.viewkeys() # In[ ]: #Get H_0 in order to plot the distances in this unit fLCDM = LCDM.Hubble(0) fCDM = CDM.Hubble(0) # In[ ]: namelist = ['lum. dist.','comov. dist.','ang.diam.dist.'] colours = ['b','g','r']
lcdm = Class() lcdm.set({ 'h': df["H0*"].values[i]/100.0, 'omega_b': df.omegabh2.values[i], 'omega_cdm': df.omegach2.values[i], 'Omega_Lambda': 0., 'w0_fld': -1.0, 'wa_fld': 0.0, 'background_verbose':1, 'input_verbose':1, 'gauge':'Newtonian', }) lcdm.compute() b = lcdm.get_background() x = b["comov. dist"] z = b["xz"] Chi = int.interpd1(z,x) Z_s = 0.8 Z = 0.4 Chi_s = Chi(Z_s) Chi_z = Chi(Z) Omega_m = np.mean(df["omegach2"].values) H0 = np.mean(df["H0"].values) sigma8 = np.mean(df["sigma8*"].values) for x in range(10000): a[i] = random.uniform(0.5,1.6,size=5)
#Perform rescaling if necessary D_0 = cosmo.scale_independent_growth_factor(0) D_f = cosmo.scale_independent_growth_factor(z_f) D_lin = cosmo.scale_independent_growth_factor(z_lin) print("D_0: ", D_0) print("D_f: ", D_f) print("D_lin: ", D_lin) #MeshPT needs a z=0 power spectrum, so one can rescale a power spectrum to z=0 #if a different input redshift is desired if (not z_lin == 0): print("Rescaling the linear theory power spectrum") Pvec *= (D_0 / D_lin)**2 #Get background quantities from CLASS (reverse the order of the arrays) background = cosmo.get_background() bg_t = background['proper time [Gyr]'][::-1] bg_H = background['H [1/Mpc]'][::-1] bg_D = background['gr.fac. D'][::-1] bg_f = background['gr.fac. f'][::-1] bg_z = background['z'][::-1] bg_a = 1. / (1 + bg_z) bg_rho = background['(.)rho_tot'][::-1] bg_p = background['(.)p_tot'][::-1] #Size of arrays of background quantities nz = 1000 zmax = max(1000, z_f * 1.05, z_i * 1.05) zmin = 0 #Curvature parameter
def constraints(params, zs): cosmo = Class() cosmo.set(params) cosmo.compute() h = cosmo.Hubble(0) * 299792.458 om0 = cosmo.Omega0_m() #print(cosmo.pars) zarr2 = cosmo.get_background().get('z') hz = cosmo.get_background().get('H [1/Mpc]') hf = interpolate.InterpolatedUnivariateSpline(zarr2[-1:0:-1], hz[-1:0:-1]) chiz = cosmo.get_background().get('comov. dist.') chif = interpolate.InterpolatedUnivariateSpline(zarr2[-1:0:-1], chiz[-1:0:-1]) pkz = np.zeros((nk, nz)) pklz2 = np.zeros((nk, nz)) dprime = np.zeros((nk, 1)) zarr = np.linspace(0, zmax, nz) karr = np.logspace(-3, np.log10(20), nk) rcollarr = np.zeros(nz) kcarr = np.zeros(nz) delz = 0.01 for i in np.arange(nz): Dz = (cosmo.scale_independent_growth_factor(zarr[i]) / cosmo.scale_independent_growth_factor(0)) sigz = lambda x: Dz * cosmo.sigma(x, zarr[i]) - 1.192182033080519 if (sigz(1e-5) > 0) & (sigz(10) < 0): rcollarr[i] = optimize.brentq(sigz, 1e-5, 10) else: rcollarr[i] = 0 for j in np.arange(nk): pkz[j, i] = cosmo.pk(karr[j], zarr[i]) for i in np.arange(nk): pklz0 = np.log(cosmo.pk(karr[i], zs - delz) / cosmo.pk(karr[i], 0)) pklz1 = np.log(cosmo.pk(karr[i], zs + delz) / cosmo.pk(karr[i], 0)) pklz2[i] = cosmo.pk(karr[i], 0) dprime[i] = -hf(zs) * np.sqrt( cosmo.pk(karr[i], zs) / pklz2[i, 0]) * (pklz1 - pklz0) / 4 / delz #divided by 2 for step size, another for defining D' w0 = params.get('w0_fld') wa = params.get('wa_fld') mt = 5 * np.log10(cosmo.luminosity_distance(zs)) #mt = 5*np.log10(fanal.dlatz(zs, om0, og0, w0, wa)) Rc = (2 * 4.302e-9 * Mc / h**2 / om0)**(1 / 3) mask = (0 < rcollarr) & (rcollarr < Rc) kcarr[mask] = 2 * np.pi / rcollarr[mask] mask = (rcollarr >= Rc) kcarr[mask] = 2 * np.pi / Rc #plt.semilogy(zarr, kcarr) pksmooth = pdf.pkint(karr, zarr, pkz, kcarr) par2 = {'w0': w0, 'wa': wa, 'Omega_m': om0} print(par2) #kmin = conv.kmin(zs, chif, hf)*(-3./2.*hf(0)**2*om0) kvar = conv.kvar(zs, pksmooth, chif, hf) * (3. / 2. * hf(0)**2 * om0)**2 #sigln = np.log(1+kvar/np.abs(kmin)**2) #L = pdf.convpdf(kmin, sigln, sig, mfid-mt) #sigln = np.sqrt(sig**2+(5/np.log(10))**2*kvar) #L = pdf.gausspdf(sig, mfid-mt) #lnL = mt/sig vvar = np.trapz(pklz2[:, 0] * dprime[:, 0]**2, karr) / 6 / np.pi**2 * (1 - (1 + zs) / hf(zs) / chif(zs))**2 #var_tot = norm*kvar+sig**2 lnL = -mt**2 / 2 print('Sigmasq = {}, {}, Likelihood = {}'.format(kvar, vvar, lnL)) cosmo.struct_cleanup() cosmo.empty() return [mt, kvar, vvar] #[mt, var_tot]
class MultiCorr(object): """ This class computes the relativistic 2PCF and power-spectra multipoles !!! -> Fiducial cosmology must be directly altered in this file! <- !!! This makes the code more flexible, so you can compute the multipoles at any redshift and with all the parameters you wish. OBS: non-Gaussian corrections have not been implemented here yet. Once it is functional, this class will depend on halo tools. No variables are needed to initialize the class """ init = False def __init__(self): print '[Initializing MultiCorr]: Relativistic 2PCF and power-spectra multipoles\n' # Fiducial cosmology c = 299792.458 self.c = c h = 0.67556 self.h = h n_s = 0.9619 self.n_s = n_s A_s = 2.215e-9 self.A_s = A_s omega_cdm = 0.12038 self.omega_cdm = omega_cdm omega_b = 0.022032 self.omega_b = omega_b omega_k = 0.0 self.omega_k = omega_k k_pivot = 0.05 self.k_pivot = k_pivot N_ur = 3.046 self.N_ur = N_ur N_ncdm = 0.0 self.N_ncdm = N_ncdm T_cmb = 2.7255 self.T_cmb = T_cmb Omega_m = (omega_cdm + omega_b) / h**2 self.Omega_m = Omega_m w = -1.0 self.w = w print '(Pre-defined cosmology)' print 'h:', h print 'n_s:', n_s print 'A_s:', A_s print 'N_ur:', N_ur print 'N_ncdm:', N_ncdm print 'T_cmb:', T_cmb print 'Omega_m:', Omega_m print 'w:', w print '\n' self.kvec = np.logspace(-7., np.log10(500), 1000) self.k_ = np.logspace(-3, 2, 2000) # Linear power-spectrum class_settings = { 'output': 'mPk', 'lensing': 'no', 'h': h, 'n_s': n_s, 'A_s': A_s, 'omega_cdm': omega_cdm, 'omega_b': omega_b, 'Omega_k': 0.0, 'k_pivot': k_pivot, 'z_max_pk': 10., 'N_ur': N_ur, 'N_ncdm': N_ncdm, 'T_cmb': T_cmb, 'P_k_max_1/Mpc': 500 } self.pclass = Class() self.pclass.set(class_settings) self.pclass.compute() # These are the CLASS functions (has 0.5% accuracy wrt to the ones I implement by hand) self.bg = self.pclass.get_background() self.H = interp1d(self.bg['z'], (c / h) * self.bg['H [1/Mpc]']) self.comov = interp1d(self.bg['z'], h * self.bg['comov. dist.']) self.fz = interp1d(self.bg['z'], self.bg['gr.fac. f']) # Non-linear power-spectrum class_settings_nl = { 'output': 'mPk', 'lensing': 'no', 'h': h, 'n_s': n_s, 'A_s': A_s, 'omega_cdm': omega_cdm, 'omega_b': omega_b, 'Omega_k': 0.0, 'k_pivot': k_pivot, 'z_max_pk': 10., 'non linear': 'halofit', 'N_ur': N_ur, 'N_ncdm': N_ncdm, 'T_cmb': T_cmb, 'P_k_max_1/Mpc': 500 } self.pnlclass = Class() self.pnlclass.set(class_settings_nl) self.pnlclass.compute() print '[MultiCorr Initialized]' self.init = True ###################################################################################################### # Useful functions def Om(self, z): """ Returns the evolving matter density Omega_m(z) """ self.z = z self.H0Hz2 = pow(1 + self.z, 3.0) * self.Omega_m + (1 - self.Omega_m) return pow(1 + self.z, 3.0) * self.Omega_m / self.H0Hz2 ###################################################################################################### # RSD def Doppler(self, z_, be_): """ Computes the doppler assuming the magnification bias s = 0. """ self.z_ = z_ self.be_ = be_ self.scale_factor = 1.0 / (1.0 + self.z_) self.Hubble = self.H(self.z_) # (h/Mpc) (Km/s) self.R_at_z = self.comov(self.z_) # (Mpc/h) return self.be_ - (1.0 - 1.5 * self.Om(self.z_)) - ( 2.0 / (self.scale_factor * (self.Hubble / self.c) * self.R_at_z)) def DopplerMag(self, z_, be_, sm_): """ Computes the doppler assuming a non-vanishing magnification bias s != 0. """ self.z_ = z_ self.be_ = be_ self.sm_ = sm_ self.scale_factor = 1.0 / (1.0 + self.z_) self.Hubble = self.H(self.z_) # (h/Mpc) (Km/s) self.R_at_z = self.comov(self.z_) # (Mpc/h) return self.be_ - 5 * self.sm_ - (1.0 - 1.5 * self.Om(self.z_)) - ( 1.0 / (self.scale_factor * (self.Hubble / self.c) * self.R_at_z)) * (2.0 - 5 * self.sm_) def c0(self, z_, b_alpha_, b_beta_): self.z_ = z_ self.b_alpha_ = b_alpha_ self.b_beta_ = b_beta_ return self.b_alpha_ * self.b_beta_ + (1.0 / 3.0) * self.fz( self.z_) * (self.b_alpha_ + self.b_beta_) + (1.0 / 5.0) * pow( self.fz(self.z_), 2.0) def c1(self, z_, b_alpha_, b_beta_, be_alpha_, be_beta_): self.z_ = z_ self.scale_factor = 1.0 / (1.0 + self.z_) self.b_alpha_ = b_alpha_ self.b_beta_ = b_beta_ self.be_alpha_ = be_alpha_ self.be_beta_ = be_beta_ self.Hubble = self.H(self.z_) # (h/Mpc) (Km/s) self.term1 = self.Doppler(self.z_, self.be_alpha_) * ( 3 * self.fz(self.z_) + 5 * self.b_beta_) self.term2 = self.Doppler(self.z_, self.be_beta_) * ( 3 * self.fz(self.z_) + 5 * self.b_alpha_) return (self.fz(self.z_) / 5.0) * (self.Hubble / (self.c * self.k_)) * (self.term1 - self.term2) def c1_Mag(self, z_, b_alpha_, b_beta_, be_alpha_, be_beta_, s_alpha, s_beta): self.z_ = z_ self.scale_factor = 1.0 / (1.0 + self.z_) self.b_alpha_ = b_alpha_ self.b_beta_ = b_beta_ self.be_alpha_ = be_alpha_ self.be_beta_ = be_beta_ self.s_alpha = s_alpha self.s_beta = s_beta self.Hubble = self.H(self.z_) # (h/Mpc) (Km/s) self.term1 = self.DopplerMag(self.z_, self.be_alpha_, self.s_alpha) * ( 3 * self.fz(self.z_) + 5 * self.b_beta_) self.term2 = self.DopplerMag(self.z_, self.be_beta_, self.s_beta) * ( 3 * self.fz(self.z_) + 5 * self.b_alpha_) return (self.fz(self.z_) / 5.0) * (self.scale_factor * self.Hubble / (self.c * self.k_)) * (self.term1 - self.term2) def c2(self, z_, b_alpha_, b_beta_): self.z_ = z_ self.b_alpha_ = b_alpha_ self.b_beta_ = b_beta_ return (2.0 / 3.0) * self.fz( self.z_) * (self.b_alpha_ + self.b_beta_) + (4.0 / 7.0) * pow( self.fz(self.z_), 2.0) def c3(self, z_, b_alpha_, b_beta_, be_alpha_, be_beta_): self.z_ = z_ self.scale_factor = 1.0 / (1.0 + self.z_) self.b_alpha_ = b_alpha_ self.b_beta_ = b_beta_ self.be_alpha_ = be_alpha_ self.be_beta_ = be_beta_ self.Hubble = self.H(self.z_) # (h/Mpc) (Km/s) self.term1 = self.Doppler(self.z_, self.be_alpha_) self.term2 = self.Doppler(self.z_, self.be_beta_) return (2.0 / 5.0) * pow(self.fz( self.z_), 2.0) * (self.scale_factor * self.Hubble / (self.c * self.k_)) * (self.term1 - self.term2) def c4(self, z_): self.z_ = z_ return (8.0 / 35.0) * pow(self.fz(self.z_), 2.0) ###################################################################################################### # Plane-parallel power-spectrum ## First order in $\mathcal{H}/k$ def P0_pp(self, z_, b_alpha_, b_beta_, linear): self.z_ = z_ self.b_alpha_ = b_alpha_ self.b_beta_ = b_beta_ self.linear = linear if linear == 'linear' or linear == True: self.Pk = interp1d( self.kvec / self.h, np.array([self.pclass.pk(_k, self.z_) for _k in self.kvec]) * (self.h**3.)) else: self.Pk = interp1d( np.logspace(-5, 2, 1000) / self.h, np.array([ self.pnlclass.pk(_k, self.z_) for _k in np.logspace(-5, 2, 1000) ]) * (self.h**3.)) return self.c0(self.z_, self.b_alpha_, self.b_beta_) * self.Pk(k_) def P1_pp(self, z_, b_alpha_, b_beta_, be_alpha_, be_beta_, linear): self.z_ = z_ self.b_alpha_ = b_alpha_ self.b_beta_ = b_beta_ self.be_alpha_ = be_alpha_ self.be_beta_ = be_beta_ self.linear = linear if linear == 'linear' or linear == True: self.Pk = interp1d( self.kvec / self.h, np.array([self.pclass.pk(_k, self.z_) for _k in self.kvec]) * (self.h**3.)) else: self.Pk = interp1d( np.logspace(-5, 2, 1000) / self.h, np.array([ self.pnlclass.pk(_k, self.z_) for _k in np.logspace(-5, 2, 1000) ]) * (self.h**3.)) return self.c1(self.z_, self.b_alpha_, self.b_beta_, self.be_alpha_, self.be_beta_) * self.Pk(self.k_) def P1Mag_pp(self, z_, b_alpha_, b_beta_, be_alpha_, be_beta_, s_alpha, s_beta, linear): self.z_ = z_ self.b_alpha_ = b_alpha_ self.b_beta_ = b_beta_ self.be_alpha_ = be_alpha_ self.be_beta_ = be_beta_ self.s_alpha = s_alpha self.s_beta = s_beta self.linear = linear if linear == 'linear' or linear == True: self.Pk = interp1d( self.kvec / self.h, np.array([self.pclass.pk(_k, self.z_) for _k in self.kvec]) * (self.h**3.)) else: self.Pk = interp1d( np.logspace(-5, 2, 1000) / self.h, np.array([ self.pnlclass.pk(_k, self.z_) for _k in np.logspace(-5, 2, 1000) ]) * (self.h**3.)) return self.c1_Mag(self.z_, self.b_alpha_, self.b_beta_, self.be_alpha_, self.be_beta_, self.s_alpha, self.s_beta) * self.Pk(self.k_) def P2_pp(self, z_, b_alpha_, b_beta_, linear): self.z_ = z_ self.b_alpha_ = b_alpha_ self.b_beta_ = b_beta_ self.linear = linear if linear == 'linear' or linear == True: self.Pk = interp1d( self.kvec / self.h, np.array([self.pclass.pk(_k, self.z_) for _k in self.kvec]) * (self.h**3.)) else: self.Pk = interp1d( np.logspace(-5, 2, 1000) / self.h, np.array([ self.pnlclass.pk(_k, self.z_) for _k in np.logspace(-5, 2, 1000) ]) * (self.h**3.)) return self.c2(self.z_, self.b_alpha_, self.b_beta_) * self.Pk(self.k_) def P3_pp(self, z_, b_alpha_, b_beta_, be_alpha_, be_beta_, linear): self.z_ = z_ self.b_alpha_ = b_alpha_ self.b_beta_ = b_beta_ self.be_alpha_ = be_alpha_ self.be_beta_ = be_beta_ self.linear = linear if linear == 'linear' or linear == True: self.Pk = interp1d( self.kvec / self.h, np.array([self.pclass.pk(_k, self.z_) for _k in self.kvec]) * (self.h**3.)) else: self.Pk = interp1d( np.logspace(-5, 2, 1000) / self.h, np.array([ self.pnlclass.pk(_k, self.z_) for _k in np.logspace(-5, 2, 1000) ]) * (self.h**3.)) return self.c3(self.k_, self.z_, self.b_alpha_, self.b_beta_, self.be_alpha_, self.be_beta_) * self.Pk(self.k_) def P4_pp(self, z_, b_alpha_, b_beta_, linear): self.z_ = z_ self.b_alpha_ = b_alpha_ self.b_beta_ = b_beta_ self.linear = linear if linear == 'linear' or linear == True: self.Pk = interp1d( self.kvec / self.h, np.array([self.pclass.pk(_k, self.z_) for _k in self.kvec]) * (self.h**3.)) else: self.Pk = interp1d( np.logspace(-5, 2, 1000) / self.h, np.array([ self.pnlclass.pk(_k, self.z_) for _k in np.logspace(-5, 2, 1000) ]) * (self.h**3.)) return self.c4(self.z_) * self.Pk(self.k_) ################################################################################################################################# # Correlation function multipoles import scipy def integrand(self, s, ell): self.s = s self.ell = ell return (pow(self.k_, 2.) * scipy.special.spherical_jn( self.ell, self.k_ * self.s)) / (2 * pow(np.pi, 2.)) def matter_real_space(self, s, z_, args): self.s = s self.z_ = z_ self.args = args self.linear = self.args[0] if self.linear == 'linear' or self.linear == True: self.interpol = interp1d( self.kvec / self.h, np.array([self.pclass.pk(_k, self.z_) for _k in self.kvec]) * (self.h**3.)) else: self.interpol = interp1d( np.logspace(-5, 2, 1000) / self.h, np.array([ self.pnlclass.pk(_k, self.z_) for _k in np.logspace(-5, 2, 1000) ]) * (self.h**3.)) self.MONO = [] for i in s: self.MONO.append( integrate.simps( self.integrand(i, 0) * self.interpol(self.k_) * np.exp(-self.k_**5), self.k_)) self.MONO = np.array(self.MONO) return self.MONO def multipoles(self, s, z_, b_alpha_, b_beta_, be_alpha_, be_beta_, args): self.s = s self.z_ = z_ self.b_alpha_ = b_alpha_ self.b_beta_ = b_beta_ self.be_alpha_ = be_alpha_ self.be_beta_ = be_beta_ self.args = args """ This gives the non-vanishing ODD multipoles (l=1,3) for the correlation function. Inputs are: 1) s: a vector of configuration space positions; 2) z: redshift of calculation; 3) b_alpha, b_beta: linear biases of tracers alpha and beta (may be the same); 4) be_alpha, be_beta: evolution biases for the tracers computed at z; 5) args: a list or array with like args = ['linear',s_alpha,s_beta] (s = magnification biases) or args = ['linear'] or True/False to select linear or non-linear correlation functions; """ if len(self.args) > 1: self.linear, self.s_alpha, self.s_beta = self.args[0], self.args[ 1], self.args[2] self.coef_dipo = self.c1_Mag(self.z_, self.b_alpha_, self.b_beta_, self.be_alpha_, self.be_beta_, self.s_alpha, self.s_beta) if len(self.args) == 1: self.linear = self.args[0] self.coef_dipo = self.c1(self.z_, self.b_alpha_, self.b_beta_, self.be_alpha_, self.be_beta_) self.coef_mono = self.c0(self.z_, self.b_alpha_, self.b_beta_) self.coef_quad = self.c2(self.z_, self.b_alpha_, self.b_beta_) self.coef_octu = self.c3(self.z_, self.b_alpha_, self.b_beta_, self.be_alpha_, self.be_beta_) self.coef_hexa = self.c4(self.z_) if self.linear == 'linear' or self.linear == True: self.interpol = interp1d( self.kvec / self.h, np.array([self.pclass.pk(_k, self.z_) for _k in self.kvec]) * (self.h**3.)) else: self.interpol = interp1d( np.logspace(-5, 2, 1000) / self.h, np.array([ self.pnlclass.pk(_k, self.z_) for _k in np.logspace(-5, 2, 1000) ]) * (self.h**3.)) self.MONO = [] self.DIPO = [] self.QUAD = [] self.OCTU = [] self.HEXA = [] for i in s: self.MONO.append( integrate.simps( self.coef_mono * self.integrand(i, 0) * self.interpol(self.k_) * np.exp(-self.k_**5), self.k_)) self.DIPO.append( integrate.simps( self.coef_dipo * self.integrand(i, 1) * self.interpol(self.k_) * np.exp(-self.k_**5), self.k_)) self.QUAD.append( integrate.simps( self.coef_quad * self.integrand(i, 2) * self.interpol(self.k_) * np.exp(-self.k_**5), self.k_)) self.OCTU.append( integrate.simps( self.coef_octu * self.integrand(i, 3) * self.interpol(self.k_) * np.exp(-self.k_**5), self.k_)) self.HEXA.append( integrate.simps( self.coef_hexa * self.integrand(i, 4) * self.interpol(self.k_) * np.exp(-self.k_**5), self.k_)) self.MONO = pow(1j, 0).real * np.array(self.MONO) self.DIPO = pow(1j, 1).imag * np.array(self.DIPO) self.QUAD = pow(1j, 2).real * np.array(self.QUAD) self.OCTU = pow(1j, 3).imag * np.array(self.OCTU) self.HEXA = pow(1j, 4).real * np.array(self.HEXA) return self.MONO, self.DIPO, self.QUAD, self.OCTU, self.HEXA def odd_multipoles(self, s, z_, b_alpha_, b_beta_, be_alpha_, be_beta_, args): self.s = s self.z_ = z_ self.b_alpha_ = b_alpha_ self.b_beta_ = b_beta_ self.be_alpha_ = be_alpha_ self.be_beta_ = be_beta_ self.args = args """ This gives the non-vanishing ODD multipoles (l=1,3) for the correlation function. Inputs are: 1) s: a vector of configuration space positions; 2) z: redshift of calculation; 3) b_alpha, b_beta: linear biases of tracers alpha and beta (may be the same); 4) be_alpha, be_beta: evolution biases for the tracers computed at z; 5) args: a list or array with like args = ['linear',s_alpha,s_beta] (s = magnification biases) or args = ['linear'] or True/False to select linear or non-linear correlation functions; """ if len(self.args) > 1: self.linear, self.s_alpha, self.s_beta = self.args[0], self.args[ 1], self.args[2] self.coef_dipo = self.c1_Mag(self.z_, self.b_alpha_, self.b_beta_, self.be_alpha_, self.be_beta_, self.s_alpha, self.s_beta) if len(self.args) == 1: self.linear = self.args[0] self.coef_dipo = self.c1(self.z_, self.b_alpha_, self.b_beta_, self.be_alpha_, self.be_beta_) self.coef_octu = self.c3(self.z_, self.b_alpha_, self.b_beta_, self.be_alpha_, self.be_beta_) if self.linear == 'linear' or self.linear == True: self.interpol = interp1d( self.kvec / self.h, np.array([self.pclass.pk(_k, self.z_) for _k in self.kvec]) * (self.h**3.)) else: self.interpol = interp1d( np.logspace(-5, 2, 1000) / self.h, np.array([ self.pnlclass.pk(_k, self.z_) for _k in np.logspace(-5, 2, 1000) ]) * (self.h**3.)) self.DIPO = [] self.OCTU = [] for i in s: self.DIPO.append( integrate.simps( self.coef_dipo * self.integrand(i, 1) * self.interpol(self.k_) * np.exp(-self.k_**5), self.k_)) self.OCTU.append( integrate.simps( self.coef_octu * self.integrand(i, 3) * self.interpol(self.k_) * np.exp(-self.k_**5), self.k_)) self.DIPO = pow(1j, 1).imag * np.array(self.DIPO) self.OCTU = pow(1j, 3).imag * np.array(self.OCTU) return self.DIPO, self.OCTU def help(self): print '[Reaching help for MultiCorr]\n' print 'Full list of functions and their entries:\n' print '(Auxiliary functions)' print 'Om(z): Evolving matter density Omega_m(z) - Inputs: z (redshift).' print 'Doppler(z, be): Doppler term assuming magnification bias s = 0 - Inputs: z (redshift) and be (evolution bias at z).' print 'DopplerMag(z, be,s): Doppler term - Inputs: z (redshift), be (evolution bias at z) and s (magnification bias at z).' print 'c0(z,ba,bb): Monopole coefficient - Inputs: z (redshift) and bi (linear bias of tracer i at z).' print 'c1(z,ba,bb,be_a,be_b): Dipole coefficient - Inputs: z (redshift), bi (linear bias of tracer i at z) and be_i (evolution bias of tracer i at z).' print 'c1_Mag(z,ba,bb,be_a,be_b,sa,sb): Dipole coefficient with magnification - Inputs: z (redshift), bi (linear bias of tracer i at z), be_i (evolution bias of tracer i at z) and si (magnification of tracer i at z).' print 'c2(z,ba,bb): Quadrupole coefficient - Inputs: z (redshift) and bi (linear bias of tracer i at z).' print 'c3(z,ba,bb,be_a,be_b): Octupole coefficient assuming no magnification - Inputs: z (redshift), bi (linear bias of tracer i at z) and be_i (evolution bias of tracer i at z).' print 'c4(z): Hexadecapole coefficient - Inputs: z (redshift).\n' print '(Power-spectrum multipoles)' print 'P0_pp(z,ba,bb,linear) - linear = True or False' print 'P1_pp(z,ba,bb,be_a,be_b,linear) - linear = True or False' print 'P1Mag_pp(z,ba,bb,be_a,be_b,sa,sb,linear) - linear = True or False' print 'P2_pp(z,ba,bb,linear) - linear = True or False' print 'P3_pp(z,ba,bb,be_a,be_b,linear) - linear = True or False' print 'P4_pp(z,ba,bb,linear) - linear = True or False\n' print '(Correlation function multipoles)' print 'integrand(s,ell): returns the integrand of the correlation function.' print 'multipoles(s,z,ba,bb,be_a,be_b,args) - args: [True] or [True, sa, sb], si (magnification bias of tracer i)' print 'odd_multipoles(s,z,ba,bb,be_a,be_b,args) - args: [True] or [True, sa, sb], si (magnification bias of tracer i)\n' print '[End of help]'
M = Class() # Table I of 1908.06995, third column, best-fit values # Note: f and m found by trial-and-error to give the best-fit fEDE=.12, zc=10^3.562=3647. M.set({'f_scf': 3.98e+26, 'm_scf': 5.31e-28, 'thetai_scf': 2.83, 'A_s': 2.215e-09, 'n_s': 0.9889, '100*theta_s': 1.04152, 'omega_b': 0.02253, 'omega_cdm': 0.1306, 'm_ncdm': 0.06, 'tau_reio': 0.072}) #'non linear':can choose 'halofit' or 'HMCODE' M.set({'non linear':'HMCODE','N_ncdm':1, 'N_ur':2.0328, 'Omega_Lambda':0.0, 'Omega_fld':0, 'Omega_scf':-1, 'n_scf':3, 'CC_scf':1, 'scf_parameters':'1, 1, 1, 1, 1, 0.0', 'scf_tuning_index':3, 'attractor_ic_scf':'no', 'output':'tCl pCl lCl mPk', 'lensing':'yes', 'l_max_scalars':2508, 'P_k_max_h/Mpc':20,'z_max_pk':4.}) M.compute() print(M.Omega_m()) baM = M.get_background() fEDE = M.fEDE() z_c = M.z_c() baH = baM['H [1/Mpc]'] baT = baM['conf. time [Mpc]'] baa = 1/(1 + baM['z']) bV = baM['V_e_scf'] bpp = baM["phi'_scf"] baCrit = baM['(.)rho_crit'] rho_scf = (bpp*bpp/(2*baa*baa) + bV)/3. plt.figure(figsize=(10,10)) plt.rcParams.update({'font.size': 18})