def sn(self, C): ## there are fixed (1+z)**2 factors here for lum distance, which cancel out sn = ccl.comoving_angular_distance(C, self.aar) sn0 = ccl.comoving_angular_distance(self.CBase, self.aar) ratio = sn / sn0 fact = (interp1d(self.zar, ratio)(self.snz) / self.snerr**2).sum() / (1 / self.snerr**2).sum() # now normalize ratio so that error weighted is one ratio /= fact return ratio
def GetCosmo(self, addict): ## find the correct h, to kee distance t acmb = 1 / (1150.0) target = ccl.comoving_angular_distance(self.CBase, acmb) / self.rd( self.CBase) def _C(h): CP = { "Omega_c": self.Och2 / h**2, "Omega_b": self.Obh2 / h**2, "h": h, "n_s": self.ns, "m_nu": 0.06, "A_s": np.exp(self.lnttAs) / 1e10, } CP.update(addict) print(CP) return ccl.Cosmology(**CP), CP def _t(h): C, _ = _C(h) d = ccl.comoving_angular_distance(C, acmb) / self.rd(C) return d - target print(_t(0.3), _t(1.0)) hout = so.bisect(_t, 0.3, 1.0) # ,xtol=1e-5,rtol=1e-2) return _C(hout)
def comoving_dimensions_from_survey(cosmo, angular_extent, freq_range=None, z_range=None, line_freq=1420.405752): """ Return the comoving dimensions and central redshift of a survey volume, given its angular extent and redshift/frequency range. Parameters: cosmo (ccl.Cosmology object): CCL object that defines the cosmology to use. angular_extent (tuple): Angular extent of the survey in the x and y directions on the sky, given in degrees. For example, `(10, 30)` denotes a 10 deg x 30 deg survey area. freq_range (tuple, optional): The frequency range of the survey, given in MHz. z_range (tuple, optional): The redshift range of the survey. line_freq (float, optional): Frequency of the emission line used as redshift reference, in MHz. Returns: zc (float): Redshift of the centre of the comoving box. dimensions (tuple): Tuple of comoving dimensions of the survey volume, (Lx, Ly, Lz), in Mpc. """ # Check inputs if (freq_range is not None and z_range is not None) \ or (freq_range is None and z_range is None): raise ValueError("Must specify either freq_range of z_range.") assert len(angular_extent) == 2, "angular_extent must be tuple of length 2" # Convert frequency range to z range if needed if freq_range is not None: assert len(freq_range) == 2, "freq_range must be tuple of length 2" z_range = (line_freq/freq_range[0] - 1., line_freq/freq_range[1] - 1.) assert len(z_range) == 2, "z_range must be tuple of length 2" # Sort z_range zmin, zmax = sorted(z_range) # Convert z_range to comoving r range rmin = ccl.comoving_radial_distance(cosmo, 1./(1.+zmin)) rmax = ccl.comoving_radial_distance(cosmo, 1./(1.+zmax)) Lz = rmax - rmin # Get comoving centroid of volume _z = np.linspace(zmin, zmax, 100) _r = ccl.comoving_radial_distance(cosmo, 1./(1.+_z)) rc = 0.5 * (rmax + rmin) zc = interp1d(_r, _z, kind='linear')(rc) # Get transverse extent of box, evaluated at centroid redshift r_trans = ccl.comoving_angular_distance(cosmo, 1./(1.+zc)) Lx = angular_extent[0] * np.pi/180. * r_trans Ly = angular_extent[1] * np.pi/180. * r_trans return zc, (Lx, Ly, Lz)
def pixel_array(self, redshift=None): """ Return angular pixel coordinate array in degrees. Parameters: redshift (float, optional): Redshift to evaluate the centre of the box at. Default: Same value as ``self.redshift``. Returns: pix_x, pix_y (array_like): Coordinates of pixel centres in the x and y directions, in degrees. The origin is the centre of the box. """ # Check redshift if redshift is None: redshift = self.redshift scale_factor = 1. / (1. + redshift) # Calculate comoving distance to box redshift r = ccl.comoving_angular_distance(self.cosmo, scale_factor) # Comoving pixel size x_px = self.x[1] - self.x[0] y_px = self.y[1] - self.y[0] # Angular pixel size ang_x = (180. / np.pi) * (x_px / r) ang_y = (180. / np.pi) * (y_px / r) # Pixel index grid; place origin in centre of box grid = np.arange(self.N) - 0.5 * (self.N - 1.) return ang_x * grid, ang_y * grid
def test_background_a_interface(a, func): if func is ccl.distance_modulus and np.any(a == 1): with pytest.raises(ccl.CCLError): func(COSMO, a) else: val = func(COSMO, a) assert np.all(np.isfinite(val)) assert np.shape(val) == np.shape(a) if (func is ccl.angular_diameter_distance): val = func(COSMO, a, a) assert np.all(np.isfinite(val)) assert np.shape(val) == np.shape(a) if (isinstance(a, float) or isinstance(a, int)): val1 = ccl.angular_diameter_distance(COSMO, 1., a) val2 = ccl.comoving_angular_distance(COSMO, a) * a else: val1 = ccl.angular_diameter_distance(COSMO, np.ones(len(a)), a) val2 = ccl.comoving_angular_distance(COSMO, a) * a assert np.allclose(val1, val2)
def create_y_map(painted_planes, z, resolution, map_size, cosmo, order=3, verbose=True): def L_pix(cosmo, chi, theta): a = ccl.scale_factor_of_chi(cosmo, chi) return chi*a*theta def A_pix_mean(cosmo, chi_lo, chi_hi, theta): f = lambda chi: L_pix(cosmo, chi, theta)**2 L = scipy.integrate.quad(f, chi_lo, chi_hi)[0]/(chi_hi-chi_lo) return L y_map = np.zeros((resolution, resolution)) h = cosmo.cosmo.params.h d_A = ccl.comoving_angular_distance(cosmo, 1/(1+np.array(z))) d_A -= 252.5/h/2 if d_A[0] < 0: d_A[0] = 0 d_A = np.append(d_A, d_A[-1] + 252.5/h) theta_pix = map_size/resolution*pi/180 # Pixel size in radians A_pix_eff = np.array([A_pix_mean(cosmo, d_A[i], d_A[i+1], theta_pix) for i in range(len(z))]) # Low redshift seems to constribute too much # Effective distance/redshift might better be estimated by considering volume # contributing to that redshift range (i.e., weighted towards higher # redshift, with diminishing effect). # d_A_eff = d_A[:-1] # z is already the slice mid-point # a_eff = np.array([ccl.scale_factor_of_chi(cosmo, d) for d in d_A_eff]) y_fac = 8.125561e-16 # sigma_T/m_e*c^2 in SI mpc = 3.086e22 # m/Mpc eV = 1.60218e-19 # Electronvolt in Joules cm = 0.01 # Centimetre in metres Xe = 1.17 Xi = 1.08 V_c = (400/h/2048*mpc/cm)**3 # Volume of cell in cm^3 y_fac = y_fac*eV*mpc**-2 # sigma_T/m_e*c^2 in Mpc^2 eV^-1 # theta_pix = map_size/resolution*pi/180 # Pixel size in radians # L_pix = theta_pix*d_A_eff*a_eff # Physical pixel size in Mpc for i, d in enumerate(painted_planes): zoom_factor = resolution/d.shape[0] d = d.copy() d[np.isnan(d)] = 0 d *= V_c*(Xe+Xi)/Xe*y_fac/A_pix_eff[i]/zoom_factor**2 if verbose: print(f"z : {z[i]:0.3f}, plane shape: {d.shape}, zoom_factor: {zoom_factor:0.3f}") if verbose: print(f"{np.isnan(d).sum()}") y_map += scipy.ndimage.zoom(d, zoom=zoom_factor, order=order, mode="mirror") return y_map
def _func(m, a): abs_dzda = 1 / a / a dc = ccl.comoving_angular_distance(cosmo, a) ez = ccl.h_over_h0(cosmo, a) dh = ccl.physical_constants.CLIGHT_HMPC / cosmo['h'] dvdz = dh * dc**2 / ez dvda = dvdz * abs_dzda val = hmf.get_mass_function(cosmo, 10**m, a, mdef_other=mdef) val *= sel(10**m, a) return val[0, 0] * dvda
def check_get_tile(): import matplotlib.pyplot as plt import matplotlib.patches as patches import pyccl as ccl import cosmotools.plotting as plotting # WMAP9 Omega_m = 0.2905 Omega_b = 0.0473 Omega_L = 0.7095 h = 0.6898 sigma_8 = 0.826 n_s = 0.969 cosmo = ccl.Cosmology(Omega_c=(1-Omega_L-Omega_b), Omega_b=Omega_b, Omega_k=0, h=h, sigma8=sigma_8, n_s=n_s) z_SLICS = 0.042 d_A_SLICS = ccl.comoving_angular_distance(cosmo, 1/(1+z_SLICS))*h # units of Mpc/h shifts = np.loadtxt("../data/training_data/SLICS/random_shift_LOS1097")[::-1] tile_relative_size = d_A_SLICS*10/180*pi/505 plane = np.fromfile(f"../data/training_data/SLICS/massplanes/{z_SLICS:.3f}proj_half_finer_xy.dat_LOS1097", dtype=np.float32)[1:].reshape(4096*3, -1).T plane *= 64 plane -= plane.min() delta = np.fromfile(f"../data/training_data/SLICS/delta/{z_SLICS:.3f}delta.dat_bicubic_LOS1097", dtype=np.float32).reshape(7745, -1).T delta *= 64 delta -= delta.min() delta = delta[::7, ::7] expansion_factor = 1.5 tile = get_tile(plane, shifts[0], tile_relative_size, expansion_factor=expansion_factor) delta_region = patches.Rectangle(xy=(0,0), width=1, height=1, fill=False) # Plot stuff fig, ax = plt.subplots(1, 2, figsize=(10, 5)) im = ax[0].imshow(np.log(tile+1), extent=(-(expansion_factor-1)/2, 1.0+(expansion_factor-1)/2, -(expansion_factor-1)/2, 1.0+(expansion_factor-1)/2)) plotting.subplot_colorbar(im, ax[0]) ax[0].add_artist(delta_region) im = ax[1].imshow(np.log(delta+1), extent=(0.0, 1.0, 0.0, 1.0)) plotting.subplot_colorbar(im, ax[1]) ax[0].set_title("Mass plane") ax[1].set_title("Delta") fig.suptitle("Extract tiles from SLICS")
def angularDiameterDistance(self, z): """Compute the distance modulus as a function of redshift Parameters ---------- z : array redshifts to compute angular diameter distance at Returns ------- d_a : array comoving angular diameter distance at input redshifts """ d_a = ccl.comoving_angular_distance(self._cosmo, 1 / (z + 1.)) return d_a
def test_distances_flat(): # We first define equivalent CCL and jax_cosmo cosmologies cosmo_ccl = ccl.Cosmology( Omega_c=0.3, Omega_b=0.05, h=0.7, sigma8=0.8, n_s=0.96, Neff=0, transfer_function="eisenstein_hu", matter_power_spectrum="linear", ) cosmo_jax = Cosmology( Omega_c=0.3, Omega_b=0.05, h=0.7, sigma8=0.8, n_s=0.96, Omega_k=0.0, w0=-1.0, wa=0.0, ) # Test array of scale factors a = np.linspace(0.01, 1.0) chi_ccl = ccl.comoving_radial_distance(cosmo_ccl, a) chi_jax = bkgrd.radial_comoving_distance(cosmo_jax, a) / cosmo_jax.h assert_allclose(chi_ccl, chi_jax, rtol=0.5e-2) chi_ccl = ccl.comoving_angular_distance(cosmo_ccl, a) chi_jax = bkgrd.transverse_comoving_distance(cosmo_jax, a) / cosmo_jax.h assert_allclose(chi_ccl, chi_jax, rtol=0.5e-2) chi_ccl = ccl.angular_diameter_distance(cosmo_ccl, a) chi_jax = bkgrd.angular_diameter_distance(cosmo_jax, a) / cosmo_jax.h assert_allclose(chi_ccl, chi_jax, rtol=0.5e-2)
def kmax2lmax(kmax, zeff, cosmo=None): """ Determine lmax corresponding to given kmax at an effective redshift zeff according to kmax = (lmax + 1/2)/chi(zeff) :param kmax: maximal wavevector in h Mpc^-1 :param zeff: effective redshift of sample :return lmax: maximal angular multipole corresponding to kmax """ if cosmo is None: print( 'CCL cosmology object not supplied. Initializing with Planck 2018 cosmological parameters.' ) cosmo = ccl.Cosmology(n_s=0.9649, A_s=2.1e-9, h=0.6736, Omega_c=0.264, Omega_b=0.0493) # Comoving angular diameter distance in Mpc/h chi_A = ccl.comoving_angular_distance(cosmo, 1. / (1. + zeff)) * cosmo['h'] lmax = kmax * chi_A - 1. / 2. return lmax
def check_background(cosmo): """ Check that background and growth functions can be run. """ # Types of scale factor input (scalar, list, array) a_scl = 0.5 is_comoving = 0 a_lst = [0.2, 0.4, 0.6, 0.8, 1.] a_arr = np.linspace(0.2, 1., 5) # growth_factor assert_(all_finite(ccl.growth_factor(cosmo, a_scl))) assert_(all_finite(ccl.growth_factor(cosmo, a_lst))) assert_(all_finite(ccl.growth_factor(cosmo, a_arr))) # growth_factor_unnorm assert_(all_finite(ccl.growth_factor_unnorm(cosmo, a_scl))) assert_(all_finite(ccl.growth_factor_unnorm(cosmo, a_lst))) assert_(all_finite(ccl.growth_factor_unnorm(cosmo, a_arr))) # growth_rate assert_(all_finite(ccl.growth_rate(cosmo, a_scl))) assert_(all_finite(ccl.growth_rate(cosmo, a_lst))) assert_(all_finite(ccl.growth_rate(cosmo, a_arr))) # comoving_radial_distance assert_(all_finite(ccl.comoving_radial_distance(cosmo, a_scl))) assert_(all_finite(ccl.comoving_radial_distance(cosmo, a_lst))) assert_(all_finite(ccl.comoving_radial_distance(cosmo, a_arr))) # comoving_angular_distance assert_(all_finite(ccl.comoving_angular_distance(cosmo, a_scl))) assert_(all_finite(ccl.comoving_angular_distance(cosmo, a_lst))) assert_(all_finite(ccl.comoving_angular_distance(cosmo, a_arr))) # h_over_h0 assert_(all_finite(ccl.h_over_h0(cosmo, a_scl))) assert_(all_finite(ccl.h_over_h0(cosmo, a_lst))) assert_(all_finite(ccl.h_over_h0(cosmo, a_arr))) # luminosity_distance assert_(all_finite(ccl.luminosity_distance(cosmo, a_scl))) assert_(all_finite(ccl.luminosity_distance(cosmo, a_lst))) assert_(all_finite(ccl.luminosity_distance(cosmo, a_arr))) # scale_factor_of_chi assert_(all_finite(ccl.scale_factor_of_chi(cosmo, a_scl))) assert_(all_finite(ccl.scale_factor_of_chi(cosmo, a_lst))) assert_(all_finite(ccl.scale_factor_of_chi(cosmo, a_arr))) # omega_m_a assert_(all_finite(ccl.omega_x(cosmo, a_scl, 'matter'))) assert_(all_finite(ccl.omega_x(cosmo, a_lst, 'matter'))) assert_(all_finite(ccl.omega_x(cosmo, a_arr, 'matter'))) # Fractional density of different types of fluid assert_(all_finite(ccl.omega_x(cosmo, a_arr, 'dark_energy'))) assert_(all_finite(ccl.omega_x(cosmo, a_arr, 'radiation'))) assert_(all_finite(ccl.omega_x(cosmo, a_arr, 'curvature'))) assert_(all_finite(ccl.omega_x(cosmo, a_arr, 'neutrinos_rel'))) assert_(all_finite(ccl.omega_x(cosmo, a_arr, 'neutrinos_massive'))) # Check that omega_x fails if invalid component type is passed assert_raises(ValueError, ccl.omega_x, cosmo, a_scl, 'xyz') # rho_crit_a assert_(all_finite(ccl.rho_x(cosmo, a_scl, 'critical', is_comoving))) assert_(all_finite(ccl.rho_x(cosmo, a_lst, 'critical', is_comoving))) assert_(all_finite(ccl.rho_x(cosmo, a_arr, 'critical', is_comoving))) # rho_m_a assert_(all_finite(ccl.rho_x(cosmo, a_scl, 'matter', is_comoving))) assert_(all_finite(ccl.rho_x(cosmo, a_lst, 'matter', is_comoving))) assert_(all_finite(ccl.rho_x(cosmo, a_arr, 'matter', is_comoving)))
p = params cosmo = ccl.Cosmology(Omega_c=p['omegaM'] - p['omegaB'], Omega_b=p['omegaB'], h=p['h'], Omega_k=0., w0=-1., A_s=2.1e-9, n_s=0.96, m_nu=0.06) # Plot low-redshift D_A(z) and H(z) z = np.logspace(-3., 3.1, 1000) a = 1. / (1. + z) # CCL quantities ccl_DA = a * ccl.comoving_angular_distance(cosmo, a) ccl_Hz = (100. * p['h']) * ccl.h_over_h0(cosmo, a) # My quantities this_Hz = model.Hz(a, params) this_DA = model.DAz(a, params) #------------------------------------------------------------------------------- # Load CCL benchmark file dat = np.genfromtxt("CCL_TEST_CHI.dat").T bench_z = dat[0] #bench_chi = dat[1] # flat, no massive neutrinos, 3 massless bench_chi = dat[3] # flat, 1 massive neutrino, 0.1 eV #P.title("massless")
Neff=3.046, Omega_k=0., baryons_power_spectrum='bcm', bcm_log10Mc=14.079181246047625, bcm_etab=0.5, bcm_ks=55.0) # Cosmology where the power spectrum will be computed with an emulator. cosmo_emu = ccl.Cosmology(Omega_c=0.27, Omega_b=0.05, h=0.67, sigma8=0.83, n_s=0.96, Neff=3.04, Omega_k=0., transfer_function='emulator', matter_power_spectrum="emu") # background quantities z = np.linspace(0.0001, 5., 100) a = 1. / (1.+z) # Compute distances chi_rad = ccl.comoving_radial_distance(cosmo, a) chi_ang = ccl.comoving_angular_distance(cosmo,a) lum_dist = ccl.luminosity_distance(cosmo, a) dist_mod = ccl.distance_modulus(cosmo, a) # Plot the comoving radial distance as a function of redshift, as an example. plt.figure() plt.plot(z, chi_rad, 'k', linewidth=2) plt.xlabel('$z$', fontsize=20) plt.ylabel('Comoving distance, Mpc', fontsize=15) plt.tick_params(labelsize=13) # plt.show() plt.close() # Compute growth quantities : D = ccl.growth_factor(cosmo, a)
def plot_lss_deviations(): """ Plot D_V, D_M, and D_H, relative to a LambdaCDM model """ P.subplot(111) colours = {'DV': 'b', 'DM': 'r', 'DH': 'g'} for dp in data: dname, dtype, zc, dval, derr = dp # Data have already been divided by r_d DV, DM, DH = lss_distances(zc, pdict(w0=-1., winf=-1., zc=2., deltaz=0.5)) if dtype == 'DV': fac = DV / r_d if dtype == 'DM': fac = DM / r_d if dtype == 'DH': fac = DH / r_d P.errorbar(zc, dval / fac - 1., yerr=derr / fac, color=colours[dtype], label=dname, marker='.', mew=1.8, capsize=5.) # Plot theory curves #z = np.logspace(-3., np.log10(3.), 200) z = np.logspace(-3., np.log10(1500.), 500) P.axhline(0., color='k', lw=1.8, alpha=0.4) # LambdaCDM DV0, DM0, DH0 = lss_distances(z, pdict(w0=-1., winf=-1., zc=0., deltaz=0.5)) # Alternative model (1) pmodel = pdict(w0=-1., winf=-0.5, zc=0.3, deltaz=0.2, omegaK=0.03) DV, DM, DH = lss_distances(z, pmodel) P.plot(z, DV / DV0 - 1., lw=1.8, color=colours['DV'], ls='dashed', alpha=0.5) P.plot(z, DM / DM0 - 1., lw=1.8, color=colours['DM'], ls='dashed', alpha=0.5) P.plot(z, DH / DH0 - 1., lw=1.8, color=colours['DH'], ls='dashed', alpha=0.5) # Alternative model (1) #pmodel = pdict(w0=-1., winf=-0.5, zc=0.3, deltaz=0.2, omegaK=0.0) pmodel = pdict(omegaM=0.323, omegaK=-0.199, w0=-1.298, h=0.743, deltaz=4.748, omegaB=0.100, winf=-0.297, z_eq=13434.643, zc=147.897) DV, DM, DH = lss_distances(z, pmodel) P.plot(z, DV / DV0 - 1., lw=1.8, color=colours['DV'], ls='dotted', alpha=0.5) P.plot(z, DM / DM0 - 1., lw=1.8, color=colours['DM'], ls='dotted', alpha=0.5) P.plot(z, DH / DH0 - 1., lw=1.8, color=colours['DH'], ls='dotted', alpha=0.5) # FIXME: Planck 2015 CMB plcdm = pdict(w0=-1., winf=-1., zc=0., deltaz=0.5, zeq=3394.) DVs, DMs, DHs = lss_distances(1090., plcdm) ob = (0.02222, 0.00023) om = (0.1426, 0.0020) rstar = (144.61, 0.49) theta_s = (1.04105, 0.00046) # theta_* = r_s(z*) / D_A(z*) #theta_s = (1.04085, x) # theta_* = r_s(z*) / D_A(z*) zq = 3393. #DM = da / a theta_s_model = 144.61 / DMs print("Delta(100 theta_s) =", (theta_s_model * 100. - theta_s[0])) print("Frac(100 theta_s) =", (theta_s_model * 100. - theta_s[0]) / theta_s[1]) #print("D_A,model =", DAz(1./(1.+1090.), plcdm)) import pyccl as ccl cosmo = ccl.Cosmology(Omega_c=plcdm['omegaM'] - plcdm['omegaB'], Omega_b=plcdm['omegaB'], h=plcdm['h'], Omega_k=0., w0=-1., wa=0., A_s=2.1e-9, n_s=0.96, m_nu=0.06) zstar = 1090. da_co = ccl.comoving_angular_distance(cosmo, 1. / (1. + zstar)) theta_s_ccl = 144.61 / da_co print("Delta(100 theta_s) =", (theta_s_ccl * 100. - theta_s[0])) print("Frac(100 theta_s) =", (theta_s_ccl * 100. - theta_s[0]) / theta_s[1]) exit() """ # Try CCL plot import pyccl as ccl p = default_params OmegaB = 0.045 cosmo = ccl.Cosmology(Omega_c=p['omegaM']-OmegaB, Omega_b=OmegaB, h=p['h'], Omega_k=0.02, w0=-1., wa=0., A_s=2.1e-9, n_s=0.96, m_nu=0.06) P.plot(z, ccl.comoving_angular_distance(cosmo, 1./(1.+z)) / DM0 - 1., 'm-') """ # Physical matter fraction cmb_om = 0.1386 cmb_om_err = 0.019 * 0.1386 # 1.9% this_om = pmodel['omegaM'] * pmodel['h']**2. P.text(30., -0.1, "$\Delta\omega_m/\sigma_{\omega_m} = %+3.3f$" % ((this_om - cmb_om) / cmb_om_err), fontsize=13) P.xlabel("$z$", fontsize=16.) P.ylabel(r"$\Delta D / D$", fontsize=16.) #P.xlim((0.08, 3.)) P.xlim((0.08, 1500.)) #P.ylim((-0.5, 30.)) P.xscale('log') P.legend(loc='upper right', frameon=False, ncol=2) P.tight_layout() P.show()
import pyccl as ccl import matplotlib.pyplot as plt zcmb, mb, mberr = np.loadtxt("Pantheon/lcparam_full_long_zhel.txt", skiprows=1, usecols=[1, 4, 5], unpack=True) N = len(zcmb) cov = np.loadtxt("Pantheon/sys_full_long.txt", skiprows=1).reshape((N, N)) cov += np.diag(mberr**2) assert (cov[3, 2] == cov[2, 3]) ## sanity ## Ok, now we will subtract magnitude in standard cosmology so that we can bin numbers than don't vary much across the inb t = tc.ThinCandy() D = ccl.comoving_angular_distance(t.CBase, 1 / (1 + zcmb)) * (1 + zcmb) mu = 5 * np.log10(D) mb -= mu dz = 0.1 print("zmax=", zcmb.max()) #bins = np.digitize(zcmb,list(np.linspace(0,0.1,20))+list(np.logspace(np.log10(0.1),np.log10(zcmb.max()+0.1),20))) binl = list(np.arange(0.1, 1.1, 0.15)) + list(np.arange(1.2, 2.5, 0.3)) bins = np.digitize(zcmb, binl) Nbins = bins.max() out = [] for bin in range(Nbins): w = np.where(bins == bin)[0] if (len(w) == 0): continue
def realise_foreground_amp(self, amp, beta, monopole, smoothing_scale=None, redshift=None): """ Create realisation of the matter power spectrum by randomly sampling from Gaussian distributions of variance P(k) for each k mode. Parameters: amp (float): Amplitude of foreground power spectrum, in units of the field squared (e.g. if the field is in units of mK, this should be in [mK]^2). beta (float): Angular power-law index. monopole (float): Zero-point offset of the foreground at the reference frequency. Should be in the same units as the field, e.g. mK. smoothing_scale (float, optional): Additional angular smoothing scale, in degrees. Default: None (no smoothing). redshift (float, optional): Redshift to evaluate the centre of the box at. Default: Same value as `self.box.redshift`. """ # Check redshift if redshift is None: redshift = self.box.redshift scale_factor = 1. / (1. + redshift) # Calculate comoving distance to box redshift r = ccl.comoving_angular_distance(self.box.cosmo, scale_factor) # Angular Fourier modes (in 2D) k_perp = 2. * np.pi * np.sqrt( (self.box.Kx[:, :, 0] / self.box.Lx)**2. + (self.box.Ky[:, :, 0] / self.box.Ly)**2.) # Foreground angular power spectrum # \ell ~ k_perp r / 2 # Use FG power spectrum model from Santos et al. (2005) C_ell = amp * (0.5 * k_perp * r / 1000.)**(beta) C_ell[np.isinf(C_ell)] = 0. # Remove inf at k=0 # Normalise the power spectrum properly (factor of area, and norm. # factor of 2D DFT) C_ell *= (self.box.N**4.) / (self.box.Lx * self.box.Ly) # Generate Gaussian random field with given power spectrum re = np.random.normal(0.0, 1.0, np.shape(k_perp)) im = np.random.normal(0.0, 1.0, np.shape(k_perp)) fg_k = (re + 1.j * im) * np.sqrt(C_ell) # factor of 2x larger variance fg_k[k_perp == 0.] = 0. # remove zero mode # Transform to real space. Discarding the imag part fixes the extra # factor of 2x in variance from above fg_x = fft.ifftn(fg_k).real + monopole # Apply angular smoothing if smoothing_scale is not None: ang_x, ang_y = self.box.pixel_array(redshift=redshift) sigma = smoothing_scale / (ang_x[1] - ang_x[0]) fg_x = scipy.ndimage.gaussian_filter(fg_x, sigma=sigma, mode='wrap') return fg_x
def bgplot(self): print(ccl.sigma8(self.CBase), self.rd(self.CBase)) print("getting open") # [(aiso,'isotropic BAO'), (aperp, 'transverse BAO'), (apar, #'radial BAO'), (sn, 'SN distance '), (fs8, 'fsigma8'), # (shearshear, 'WL shear auto')]): self.getModels() f, axl = plt.subplots( 3, 2, facecolor="w", gridspec_kw={ "width_ratios": (3, 1), "hspace": 0.0, "wspace": 0.05 }, figsize=(10, 6), ) print(axl) # [(self.aiso,'BAO $\\bigcirc$'), for i, ((fun, name), (axl, axr)) in enumerate( zip( [ (self.aperp, "BAO $\perp$"), (self.apar, "BAO $\parallel$"), (self.sn, "SN"), ], axl, )): for model, label, style in [ (self.CBase, "LCDM", "k:"), (self.Copen, "OLCDM", "r--"), (self.Cw, "wCDM", "g-."), (self.Cmnu, "$\\nu$CDM", "b-"), ]: vals = fun(model) axl.plot(self.zar[:self.Nl], vals[:self.Nl], style, label=label) axr.plot(self.zar[-self.Nr:], vals[-self.Nr:], style) if "perp" in name: for zb, iso, isoe, perp, perpe, par, pare in self.baodata: axr.errorbar(1150, 1, yerr=0.000605211, fmt="ko") if perp > 0: norm = ccl.comoving_angular_distance( self.CBase, 1 / (1 + zb)) / self.rd(self.CBase) # print (zb,norm,perp,perpe,perp/norm,perpe/norm) axl.errorbar(zb, perp / norm, yerr=perpe / norm, fmt="ko") if iso > 0: print(self.rd(self.CBase)) normperp = ccl.comoving_angular_distance( self.CBase, 1 / (1 + zb)) / self.rd(self.CBase) normpar = 299792.45 / (ccl.h_over_h0( self.CBase, 1 / (1 + zb)) * self.CBase["H0"] * self.rd(self.CBase)) norm = (zb * normpar)**(1 / 3) * normperp**(2 / 3) axl.errorbar(zb, iso / norm, yerr=isoe / norm, fmt="ko") elif "par" in name: for zb, iso, isoe, perp, perpe, par, pare in self.baodata: if par > 0: norm = 299792.45 / (ccl.h_over_h0( self.CBase, 1 / (1 + zb)) * self.CBase["H0"] * self.rd(self.CBase)) # print (zb,norm,par,pare,par/norm,pare/norm) axl.errorbar(zb, par / norm, yerr=pare / norm, fmt="ko") elif "SN" in name: axl.errorbar(self.snz, self.snval, yerr=self.snerr, fmt="ko") if i == 1: axl.legend(fontsize=12, ncol=2, frameon=False, loc="lower center") axl.set_ylabel(name, fontsize=14) axl.spines["right"].set_visible(False) axr.spines["left"].set_visible(False) # axl.yaxis.tick_left() # axl.tick_params(labelright='off') axl.tick_params(axis="x", direction="inout", length=5) axr.tick_params(axis="x", direction="inout", length=5) axl.patch.set_alpha(0.0) axr.patch.set_alpha(0.0) axl.set_xlim(0.0, 3.1) axr.set_xlim(1100, 1200) axr.set_xticks([1120, 1200]) if i < 2: axl.set_ylim(0.85, 1.15) axl.set_yticks([0.90, 1.0, 1.1]) else: axl.set_ylim(0.8, 1.2) axl.set_yticks([0.9, 1.0, 1.1]) if i == 0: axr.set_ylim(0.995, 1.005) axr.set_yticks([0.997, 1.0, 1.003]) elif i == 1: axr.set_ylim(0.995, 1.005) axr.set_yticks([0.997, 1.0, 1.003]) elif i == 2: axr.set_ylim(0.8, 1.2) axr.set_yticks([0.9, 1.0, 1.1]) if i < 2: for l in axl.get_xticklabels(): l.set_visible(False) for l in axr.get_xticklabels(): l.set_visible(False) for l in axr.get_yticklabels(): l.set_visible(False) axr.get_yaxis().tick_right() # set_visible(False) d = 0.05 kwargs = dict(transform=axl.transAxes, color="k", clip_on=False) axl.plot((1 - d / 5, 1 + d / 5), (-d, +d), **kwargs) axl.plot((1 - d / 5, 1 + d / 5), (1 - d, 1 + d), **kwargs) kwargs = dict(transform=axr.transAxes, color="k", clip_on=False) axr.plot((-d * 3 / 5, +d * 3 / 5), (-d, +d), **kwargs) axr.plot((-d * 3 / 5, +d * 3 / 5), (1 - d, 1 + d), **kwargs) if i == 2: axl.set_xlabel("$z$", fontsize=14) # plt.tight_layout() plt.savefig(f"output/thincandy_bg.pdf") plt.show()
def shearpower(self, C, z): tracer = ccl.WeakLensingTracer( C, dndz=(self.zar, np.exp(-((z - self.zar)**2) / (2 * 0.1**2)))) ell = 0.2 * ccl.comoving_angular_distance(C, 1 / (1 + z)) return ccl.angular_cl(C, tracer, tracer, ell)
def _t(h): C, _ = _C(h) d = ccl.comoving_angular_distance(C, acmb) / self.rd(C) return d - target
def aperp(self, C): aperp = ccl.comoving_angular_distance(C, self.aar) / self.rd(C) aperp0 = ccl.comoving_angular_distance(self.CBase, self.aar) / self.rd( self.CBase) return aperp / aperp0