def get_xiauto_mass_avg(emu, rs, M1min, M1max, M2min, M2max, z): ''' Averages the halo-halo correlation function over mass ranges to return the weighted-by-mass-function mean version ''' from scipy.interpolate import InterpolatedUnivariateSpline as ius from scipy.interpolate import RectBivariateSpline as rbs from scipy.integrate import dblquad # Parameters epsabs = 1e-3 # Integration accuracy nM = 6 # Number of halo-mass bins in each of M1 and M2 directions # Calculations nr = len(rs) # Number densities of haloes in each sample n1 = ndenshalo(emu, M1min, M1max, z) n2 = ndenshalo(emu, M2min, M2max, z) # Arrays for halo masses M1s = mead.logspace(M1min, M1max, nM) M2s = mead.logspace(M2min, M2max, nM) # Get mass function interpolation Ms = emu.massfunc.Mlist dndM = emu.massfunc.get_dndM(z) log_dndM_interp = ius(np.log(Ms), np.log(dndM)) # Loop over radii xiauto_avg = np.zeros((nr)) for ir, r in enumerate(rs): # Get correlation function interpolation # Note that this is not necessarily symmetric because M1, M2 run over different ranges xiauto_mass = np.zeros((nM, nM)) for iM1, M1 in enumerate(M1s): for iM2, M2 in enumerate(M2s): xiauto_mass[iM1, iM2] = emu.get_xiauto_mass(r, M1, M2, z) xiauto_interp = rbs(np.log(M1s), np.log(M2s), xiauto_mass) # Integrate interpolated functions xiauto_avg[ir], _ = dblquad( lambda M1, M2: xiauto_interp(np.log(M1), np.log(M2)) * np.exp( log_dndM_interp(np.log(M1)) + log_dndM_interp(np.log(M2))), M1min, M1max, lambda M1: M2min, lambda M1: M2max, epsabs=epsabs) return xiauto_avg / (n1 * n2)
def plot_growth(self): plt.figure(1, figsize=(20, 6)) amin = 1e-4 amax = 1. na = 128 a_lin = np.linspace(amin, amax, na) a_log = mead.logspace(amin, amax, na) # Linear scale plt.subplot(121) plt.plot(a_lin, self.g(a_lin), 'b-', label='Growth function') plt.plot(a_lin, self.f(a_lin), 'r-', label='Growth rate') plt.legend() plt.xlabel(r'$a$') plt.xlim((0, 1.0)) plt.ylabel(r'$g(a)$ or $f(a)$') plt.ylim((0, 1.05)) # Log scale plt.subplot(122) plt.semilogx(a_log, self.g(a_log), 'b-', label=r'interpolation') plt.semilogx(a_log, self.f(a_log), 'r-', label=r'interpolation') plt.xlabel(r'$a$') plt.ylabel(r'$g(a)$ or $f(a)$') plt.ylim((0, 1.05)) # Show the plot plt.show()
def plot_distances(self): plt.subplots(3, figsize=(20, 6)) amin = 1e-4 amax = 1. na = 128 a_lin = np.linspace(amin, amax, na) a_log = mead.logspace(amin, amax, na) # Plot cosmic distance (dimensionless) vs. a on linear scale plt.subplot(121) plt.plot(a_lin, self.r(a_lin), 'g-', label='Comoving distance') plt.plot(a_lin, self.rp(a_lin), 'b-', label='Particle horizon') plt.plot(a_lin, self.t(a_lin), 'r-', label='Age') plt.legend() plt.xlabel(r'$a$') plt.ylabel(r'$r(a)$ or $t(a)$') # Plot cosmic distance (dimensionless) vs. a on log scale plt.subplot(122) plt.loglog(a_log, self.r(a_log), 'g-', label='interpolation') plt.loglog(a_log, self.rp(a_log), 'b-', label='interpolation') plt.loglog(a_log, self.t(a_log), 'r-', label='interpolation') plt.xlabel(r'$a$') plt.ylabel(r'$r(a)$ or $t(a)$') plt.show()
def plot_Omegas(self): # a range amin = 1e-3 amax = 1. na = 129 a_lintab = np.linspace(amin, amax, na) a_logtab = mead.logspace(amin, amax, na) plt.figure(1, figsize=(20, 6)) # Omegas - Linear plt.subplot(122) plt.plot(a_logtab, self.Omega_r(a_logtab), label=r'$\Omega_r(a)$') plt.plot(a_logtab, self.Omega_m(a_logtab), label=r'$\Omega_m(a)$') plt.plot(a_logtab, self.Omega_w(a_logtab), label=r'$\Omega_w(a)$') plt.plot(a_logtab, self.Omega_v(a_logtab), label=r'$\Omega_v(a)$') plt.xlabel(r'$a$') plt.ylabel(r'$\Omega_i(a)$') plt.legend() # Omegas - Log plt.subplot(121) plt.semilogx(a_logtab, self.Omega_r(a_logtab), label=r'$\Omega_r(a)$') plt.semilogx(a_logtab, self.Omega_m(a_logtab), label=r'$\Omega_m(a)$') plt.semilogx(a_logtab, self.Omega_w(a_logtab), label=r'$\Omega_w(a)$') plt.semilogx(a_logtab, self.Omega_v(a_logtab), label=r'$\Omega_v(a)$') plt.xlabel(r'$a$') plt.ylabel(r'$\Omega_i(a)$') plt.legend() plt.figure(2, figsize=(20, 6)) # w(a) - Linear plt.subplot(121) plt.axhline(0, c='k', ls=':') plt.axhline(1, c='k', ls=':') plt.axhline(-1, c='k', ls=':') plt.plot(a_lintab, self.w_de(a_lintab)) plt.xlabel(r'$a$') plt.ylabel(r'$w(a)$') plt.ylim((-1.05, 1.05)) # w(a) - Log plt.subplot(122) plt.axhline(0, c='k', ls=':') plt.axhline(1, c='k', ls=':') plt.axhline(-1, c='k', ls=':') plt.semilogx(a_logtab, self.w_de(a_logtab)) plt.xlabel(r'$a$') plt.ylabel(r'$w(a)$') plt.ylim((-1.05, 1.05)) plt.show()
def init_growth(self): print('Initialise_growth: Solving growth equations') # Calculate things associated with the linear growth amin = 1e-5 amax = 1. na = 64 a_tab = mead.logspace(amin, amax, na) # Set initial conditions for the ODE integration #d_init = a_lintab_nozero[0] d_init = amin v_init = 1. # Function to calculate delta' def dd(v, d, a): dd = 1.5 * self.Omega_m(a) * d / a**2 - ( 2. + self.AH(a) / self.H2(a)) * v / a return dd # Function to get delta' and v' in the correct format for odeint # Note that it returns [v',delta'] in the 'wrong' order def dv(X, t): return [X[1], dd(X[1], X[0], t)] # Use odeint to get g(a) and f(a) = d ln(g)/d ln(a) #gv=odeint(dv,[d_init,v_init],a_lintab_nozero) gv = odeint(dv, [d_init, v_init], a_tab) g_tab = gv[:, 0] f_tab = a_tab * gv[:, 1] / gv[:, 0] print('Initialise_growth: ODE solved') # Add in the values g(a=0) and f(a=0) if using the 'nonzero' tab #g_tab=np.insert(g_tab,0,0.) #f_tab=np.insert(f_tab,0,1.) print('Initialise_growth: Creating interpolators') # Create interpolation function for g(a) g_func = interpolate.log_interp1d(a_tab, g_tab, kind='cubic', fill_value='extrapolate') def g_vectorize(a): if (a < amin): return a elif (a > 1.): print('Error, g(a>1) called:', a) return None else: return g_func(a) self.g = np.vectorize(g_vectorize) # Create interpolation function for f(a) = dln(g)/dln(a) f_func = interpolate.log_interp1d(a_tab, f_tab, kind='cubic', fill_value='extrapolate') def f_vectorize(a): if (a < amin): return 1. elif (a > 1.): print('Error, f(a>1) called:', a) return None else: return f_func(a) self.f = np.vectorize(f_vectorize) print('Initialise_growth: Interpolators done') # Check values print('Initialise_growth: g(0):', self.g(0.)) print('Initialise_growth: g(amin):', self.g(amin)) print('Initialise_growth: g(1):', self.g(1.)) print('Initialise_growth: f(0):', self.f(0.)) print('Initialise_growth: f(amin):', self.f(amin)) print('Initialise_growth: f(1):', self.f(1.)) print()
def init_distances(self): #global r_tab, t_tab, rp_tab #global r, t, rp #global r0, t0 # A small number small = 0. # a values for interpolation amin = 1e-5 amax = 1. na = 64 a_tab = mead.logspace(amin, amax, na) ### # Integrand for the r(a) calculations and vectorise def r_integrand(a): return 1. / (self.H(a) * a**2) r_integrand_vec = np.vectorize(r_integrand) # Function to integrate to get rp(a) (PARTICLE HORIZON) and vectorise def rp_integrate(a): rp, _ = integrate.quad(r_integrand_vec, 0., a) return rp rp_integrate_vec = np.vectorize(rp_integrate) # Function to integrate to get r(a) and vectorise def r_integrate(a): r, _ = integrate.quad(r_integrand_vec, a, 1.) return r r_integrate_vec = np.vectorize(r_integrate) ### # Integrand for the t(a) calculation and vectorise def t_integrand(a): return 1. / (self.H(a) * a) t_integrand_vec = np.vectorize(t_integrand) # Function to integrate to get r(a) and vectorise def t_integrate(a): t, _ = integrate.quad(t_integrand_vec, 0., a) return t t_integrate_vec = np.vectorize(t_integrate) ### # Call the vectorised integration routine r_tab = r_integrate_vec(a_tab) rp_tab = rp_integrate_vec(a_tab) t_tab = t_integrate_vec(a_tab) # Add in values r(a=0) and t(a=0) if the 'nonzero' table has been used #r_tab=np.insert(r_tab,0,0.) #t_tab=np.insert(t_tab,0,0.) # Interpolaton function for r(a) r_func = interp1d( a_tab, r_tab, kind='cubic', fill_value='extrapolate') #This needs to be linear, not log def r_vectorize(a): if (a <= small): return rp_integrate(1.) elif (a > 1.): print('Error, r(a>1) called:', a) return None else: return r_func(a) self.r = np.vectorize(r_vectorize) # Interpolaton function for rp(a) rp_func = interpolate.log_interp1d(a_tab, rp_tab, kind='cubic', fill_value='extrapolate') def rp_vectorize(a): if (a <= small): return 0. elif (a > 1.): print('Error, rp(a>1) called:', a) return None else: return rp_func(a) self.rp = np.vectorize(rp_vectorize) # Interpolaton function for t(a) t_func = interpolate.log_interp1d(a_tab, t_tab, kind='cubic', fill_value='extrapolate') def t_vectorize(a): if (a <= small): return 0. elif (a > 1.): print('Error, t(a>1) called:', a) return None else: return t_func(a) self.t = np.vectorize(t_vectorize) r0 = self.rp(1.) t0 = self.t(1.) print('Initialise_distances: Horizon size [dimensionless]:', r0) print('Initialise_distances: Horizon size [Mpc/h]:', const.Hdist * r0) print('Initialise_distances: Universe age [dimensionless]:', t0) print('Initialise_distances: Universe age [Gyr/h]:', const.Htime * t0) print('Initialise_distances: r(0):', self.r(0.)) print('Initialise_distances: rp(0):', self.rp(0.)) print('Initialise_distances: t(0):', self.t(0.)) print()