def check_corr(cosmo): # Number density input z = np.linspace(0., 1., 200) n = np.ones(z.shape) # ClTracer test objects lens1 = ccl.ClTracerLensing(cosmo, False, n=n, z=z) lens2 = ccl.ClTracerLensing(cosmo, True, n=(z, n), bias_ia=(z, n), f_red=(z, n)) ells = np.arange(3000) cls = ccl.angular_cl(cosmo, lens1, lens2, ells) t = np.logspace(-2, np.log10(5.), 20) #degrees corrfunc = ccl.correlation(cosmo, ells, cls, t, corr_type='L+', method='FFTLog') assert_(all_finite(corrfunc))
def check_cls(cosmo): """ Check that cls functions can be run. """ # Number density input z = np.linspace(0., 1., 200) n = np.ones(z.shape) # Bias input b = np.sqrt(1. + z) # ell range input ell_scl = 4 ell_lst = [2, 3, 4, 5, 6, 7, 8, 9] ell_arr = np.arange(2, 10) # ClTracer test objects lens1 = ccl.ClTracerLensing(cosmo, False, n=n, z=z) lens2 = ccl.ClTracerLensing(cosmo, True, n=(z,n), bias_ia=(z,n), f_red=(z,n)) nc1 = ccl.ClTracerNumberCounts(cosmo, False, False, n=(z,n), bias=(z,b)) nc2 = ccl.ClTracerNumberCounts(cosmo, True, False, n=(z,n), bias=(z,b)) nc3 = ccl.ClTracerNumberCounts(cosmo, True, True, n=(z,n), bias=(z,b), mag_bias=(z,b)) cmbl=ccl.ClTracerCMBLensing(cosmo,1100.) # Check valid ell input is accepted assert_( all_finite(ccl.angular_cl(cosmo, lens1, lens1, ell_scl)) ) assert_( all_finite(ccl.angular_cl(cosmo, lens1, lens1, ell_lst)) ) assert_( all_finite(ccl.angular_cl(cosmo, lens1, lens1, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, nc1, nc1, ell_scl)) ) assert_( all_finite(ccl.angular_cl(cosmo, nc1, nc1, ell_lst)) ) assert_( all_finite(ccl.angular_cl(cosmo, nc1, nc1, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, cmbl, cmbl, ell_arr)) ) # Check various cross-correlation combinations assert_( all_finite(ccl.angular_cl(cosmo, lens1, lens2, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, lens1, nc1, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, lens1, nc2, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, lens1, nc3, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, lens1, cmbl, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, lens2, nc1, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, lens2, nc2, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, lens2, nc3, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, lens2, cmbl, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, nc1, nc2, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, nc1, nc3, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, nc1, cmbl, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, nc2, nc3, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, nc2, cmbl, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, nc3, cmbl, ell_arr)) ) # Check that reversing order of ClTracer inputs works assert_( all_finite(ccl.angular_cl(cosmo, nc1, lens1, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, nc1, lens2, ell_arr)) )
def test_two_point_some(kind, tmpdir): cosmo = ccl.Cosmology(Omega_c=0.27, Omega_b=0.045, Omega_k=0.0, w0=-1.0, wa=0.0, sigma8=0.8, n_s=0.96, h=0.67) sources = {} for i, mn in enumerate([0.25, 0.75]): sources['src%d' % i] = DummySource() z = np.linspace(0, 2, 50) nz = np.exp(-0.5 * (z - mn)**2 / 0.25 / 0.25) if ('g' in kind and i == 0) or kind == 'gg': sources['src%d' % i].tracer_ = ccl.ClTracerNumberCounts( cosmo, has_rsd=False, has_magnification=False, z=z, n=nz, bias=np.ones_like(z) * 2.0) else: sources['src%d' % i].tracer_ = ccl.ClTracerLensing( cosmo, has_intrinsic_alignment=False, z=z, n=nz) sources['src%d' % i].scale_ = i / 2.0 + 1.0 # compute the statistic tracers = [v.tracer_ for k, v in sources.items()] scale = np.prod([v.scale_ for k, v in sources.items()]) data = os.path.join(tmpdir, 'stat.csv') if kind == 'cl': ell = np.logspace(1, 3, 10) cell = ccl.angular_cl(cosmo, *tracers, ell) * scale pd.DataFrame({'l': ell, 'cl': cell}).to_csv(data, index=False) else: theta = np.logspace(1, 2, 100) ell = _ell_for_xi() cell = ccl.angular_cl(cosmo, *tracers, ell) xi = ccl.correlation(cosmo, ell, cell, theta / 60.0, corr_type=kind) * scale pd.DataFrame({'t': theta, 'xi': xi}).to_csv(data, index=False) stat = TwoPointStatistic(data=data, kind=kind, sources=['src0', 'src1']) stat.compute(cosmo, {}, sources, systematics=None) if kind == 'cl': assert np.allclose(stat.measured_statistic_, cell) else: assert np.allclose(stat.measured_statistic_, xi) assert np.allclose(stat.measured_statistic_, stat.predicted_statistic_)
def setup_data(): """Set up data for test.""" pi = np.pi # Set up ccl cosmology object cosmo = ccl.Cosmology(Omega_c=0.25, Omega_b=0.05, n_s=0.96, sigma8=0.8, h=0.7) # Set up a simple n(z) z = np.linspace(0., 1., 50) n = np.exp(-((z - 0.5) / 0.1)**2) lens_tracer = ccl.ClTracerLensing(cosmo, False, n=n, z=z) # Set up ell and get Cl's ell = np.arange(2, 4000, dtype=np.float64) Cl = ccl.angular_cl(cosmo, lens_tracer, lens_tracer, ell) # Set up theta theta_min = 0.6 / 60 # degree theta_max = 600.0 / 60 # degree n_theta = 100 theta = np.logspace(np.log10(theta_min), np.log10(theta_max), n_theta, endpoint=True) # Get CCL xi's xi_plus = ccl.correlation(cosmo, ell, Cl, theta, corr_type="L+", method="fftlog") xi_minus = ccl.correlation(cosmo, ell, Cl, theta, corr_type="L-", method="fftlog") # Get FFTLog xi's xi_plus_fftlog = fftlog.Cl2xi(Cl, ell, theta, bessel_order=0) xi_minus_fftlog = fftlog.Cl2xi(Cl, ell, theta, bessel_order=4) return (xi_plus_fftlog, xi_minus_fftlog), (xi_plus, xi_minus), (theta, theta)
def render(self, cosmo, params, systematics=None): """ Render a source by applying systematics. Parameters ---------- cosmo : pyccl.Cosmology A pyccl.Cosmology object. params : dict A dictionary mapping parameter names to their current values. systematics : dict A dictionary mapping systematic names to their objects. The default of `None` corresponds to no systematics. """ systematics = systematics or {} self.z_ = self._z_orig.copy() self.nz_ = self._nz_orig.copy() self.scale_ = self.scale if self.has_intrinsic_alignment: self.f_red_ = np.ones_like(self.z_) * params[self.f_red] self.bias_ia_ = np.ones_like(self.z_) * params[self.bias_ia] for systematic in self.systematics: systematics[systematic].apply(cosmo, params, self) if self.has_intrinsic_alignment: tracer = ccl.ClTracerLensing(cosmo, has_intrinsic_alignment=True, n=(self.z_, self.nz_), bias_ia=(self.z_, self.bias_ia_), f_red=(self.z_, self.f_red_)) else: tracer = ccl.ClTracerLensing(cosmo, has_intrinsic_alignment=False, n=(self.z_, self.nz_)) self.tracer_ = tracer
def check_corr(cosmo): # Number density input z = np.linspace(0., 1., 200) n = np.ones(z.shape) # ClTracer test objects lens1 = ccl.ClTracerLensing(cosmo, False, n=n, z=z) lens2 = ccl.ClTracerLensing(cosmo, True, n=(z,n), bias_ia=(z,n), f_red=(z,n)) ells = np.arange(3000) cls = ccl.angular_cl(cosmo, lens1, lens2, ells) t_arr = np.logspace(-2., np.log10(5.), 20) # degrees t_lst = [t for t in t_arr] t_scl = 2. t_int = 2 # Make sure correlation functions work for valid inputs corr1 = ccl.correlation(cosmo, ells, cls, t_arr, corr_type='L+', method='FFTLog') corr2 = ccl.correlation(cosmo, ells, cls, t_lst, corr_type='L+', method='FFTLog') corr3 = ccl.correlation(cosmo, ells, cls, t_scl, corr_type='L+', method='FFTLog') corr4 = ccl.correlation(cosmo, ells, cls, t_int, corr_type='L+', method='FFTLog') assert_( all_finite(corr1)) assert_( all_finite(corr2)) assert_( all_finite(corr3)) assert_( all_finite(corr4)) # Check that exceptions are raised for invalid input assert_raises(KeyError, ccl.correlation, cosmo, ells, cls, t_arr, corr_type='xx', method='FFTLog') assert_raises(KeyError, ccl.correlation, cosmo, ells, cls, t_arr, corr_type='L+', method='xx')
def get_theory(var): #Get cosmological parameters var_tot = get_cosmo(var) #Cosmology cosmo = ccl.Cosmology(h=var_tot[0], Omega_c=var_tot[1] / var_tot[0]**2., Omega_b=var_tot[2] / var_tot[0]**2., A_s=(10.**(-10.)) * np.exp(var_tot[3]), n_s=var_tot[4]) #Tracers lens = np.array([ ccl.ClTracerLensing(cosmo, False, z=z.astype(np.float64), n=pz[x].astype(np.float64)) for x in range(n_bins) ]) #Cl's ell = np.arange(n_ells) cls = np.zeros((n_bins, n_bins, n_ells)) for count1 in range(n_bins): for count2 in range(n_bins): cls[count1, count2] = ccl.angular_cl(cosmo, lens[count1], lens[count2], ell) cls = np.transpose(cls, axes=[2, 0, 1]) #Correlation function xi_th = np.zeros((2, n_bins, n_bins, n_theta)) for count1 in range(n_bins): for count2 in range(n_bins): for count3 in range(n_theta): xi_th[0, count1, count2, count3] = ccl.correlation(cosmo, ell, cls[:, count1, count2], theta[count3], corr_type='L+', method='FFTLog') xi_th[1, count1, count2, count3] = ccl.correlation(cosmo, ell, cls[:, count1, count2], theta[count3], corr_type='L-', method='FFTLog') xi_th = np.transpose(xi_th, axes=[0, 3, 1, 2]) #Reshape and eventually KL transform if is_kl: xi_th = kl_transform(xi_th, datat='corr') xi_th = reshape(xi_th, datat='corr') return xi_th
cov_mat[p_pm_1,p_theta_1,p_j_1,p_i_1,p_pm_2,p_theta_2,p_i_2,p_j_2] = cov_file[count] cov_mat[p_pm_1,p_theta_1,p_j_1,p_i_1,p_pm_2,p_theta_2,p_j_2,p_i_2] = cov_file[count] #Check that the covariance matrix is symmetric check_symm(cov_mat, (0, 1, 2, 3, 4, 5, 7, 6)) check_symm(cov_mat, (0, 1, 3, 2, 4, 5, 6, 7)) check_symm(cov_mat, (0, 1, 3, 2, 4, 5, 7, 6)) check_symm(cov_mat, (4, 5, 6, 7, 0, 1, 2, 3)) print 'Read covariance matrix' sys.stdout.flush() #Calculate theory correlation function #Cosmology cosmo = ccl.Cosmology(Omega_c=vrs.Omega_c, Omega_b=vrs.Omega_b, h=vrs.h, sigma8=vrs.sigma8, n_s=vrs.n_s) #Tracers lens = np.array([ccl.ClTracerLensing(cosmo, False, z=z.astype(np.float64), n=pz[x].astype(np.float64)) for x in range(n_bins)]) #Cl's ell = np.arange(n_ells) cls = np.zeros((n_bins, n_bins, n_ells)) for count1 in range(n_bins): for count2 in range(n_bins): cls[count1,count2] = ccl.angular_cl(cosmo, lens[count1], lens[count2], ell) cls = np.transpose(cls,axes=[2,0,1]) #Correlation function xi_th = np.zeros((2, n_bins, n_bins, n_theta)) for count1 in range(n_bins): for count2 in range(n_bins): for count3 in range(n_theta): xi_th[0,count1,count2,count3] = ccl.correlation(cosmo, ell, cls[:,count1,count2], theta[count3], corr_type='L+', method='FFTLog') xi_th[1,count1,count2,count3] = ccl.correlation(cosmo, ell, cls[:,count1,count2], theta[count3], corr_type='L-', method='FFTLog') xi_th = np.transpose(xi_th,axes=[0,3,1,2])
raise IOError('Input arrays have disagreeing shapes. z.shape = ' + str(z.shape) + '. pz.shape = ' + str(pz.shape) + '.') #Calculate cosmology cosmo = ccl.Cosmology(Omega_c=vrs.Omega_c, Omega_b=vrs.Omega_b, h=vrs.h, sigma8=vrs.sigma8, n_s=vrs.n_s) #A_s=vrs.A_s print 'Calculated cosmology' sys.stdout.flush() #Calculate tracers lens = np.array([ ccl.ClTracerLensing(cosmo, False, z=z.astype(np.float64), n=pz[x].astype(np.float64)) for x in range(len(pz)) ]) print 'Calculated tracers' sys.stdout.flush() #Calculate Cl's angular_cl = np.zeros((len(pz), len(pz), vrs.L_MAX + 1)) for count1 in range(len(pz)): for count2 in range(len(pz)): angular_cl[count1][count2] = ccl.angular_cl(cosmo, lens[count1], lens[count2], range(vrs.L_MAX + 1)) angular_cl = np.swapaxes(angular_cl, 2, 0) print 'Calculated Cl\'s' sys.stdout.flush()
def tx_data(tmpdir_factory): tmpdir = str(tmpdir_factory.mktemp("data")) cosmo = ccl.Cosmology( Omega_c=0.27, Omega_b=0.045, Omega_k=0.0, w0=-1.0, wa=0.0, sigma8=0.8, n_s=0.96, h=0.67) seed = 42 rng = np.random.RandomState(seed=seed) eps = 0.01 tracers = [] for i, mn in enumerate([0.25, 0.75]): z = np.linspace(0, 2, 50) nz = np.exp(-0.5 * (z - mn)**2 / 0.25 / 0.25) df = pd.DataFrame({'z': z, 'nz': nz}) df.to_csv( os.path.join(tmpdir, 'pz%d.csv' % i), index=False) tracers.append(ccl.ClTracerLensing( cosmo, has_intrinsic_alignment=False, z=z, n=nz)) dv = [] ndv = [] for i in range(len(tracers)): for j in range(i, len(tracers)): ell = np.logspace(1, 4, 10) pell = ccl.angular_cl(cosmo, tracers[i], tracers[j], ell) npell = pell + rng.normal(size=pell.shape[0]) * eps * pell df = pd.DataFrame({'l': ell, 'cl': npell}) df.to_csv( os.path.join(tmpdir, 'cl%d%d.csv' % (i, j)), index=False) dv.append(pell) ndv.append(npell) # a fake covariance matrix dv = np.concatenate(dv, axis=0) ndv = np.concatenate(ndv, axis=0) nelts = len(tracers) * (len(tracers) + 1) // 2 cov = np.identity(len(pell) * nelts) for i in range(len(dv)): cov[i, i] *= (eps * dv[i]) ** 2 assert len(dv) == cov.shape[0] _i = [] _j = [] _val = [] for i in range(cov.shape[0]): for j in range(cov.shape[1]): _i.append(i) _j.append(j) _val.append(cov[i, j]) df = pd.DataFrame({'i': _i, 'j': _j, 'cov': _val}) df.to_csv( os.path.join(tmpdir, 'cov.csv'), index=False) cinv = np.linalg.inv(cov) delta = ndv - dv loglike = -0.5 * np.dot(delta, np.dot(cinv, delta)) config = """\ parameters: Omega_k: 0.0 Omega_c: 0.27 Omega_b: 0.045 h: 0.67 n_s: 0.96 sigma8: 0.8 w0: -1.0 wa: 0.0 # lens bin zero src0_delta_z: 0.0 src1_delta_z: 0.0 two_point: module: firecrown.ccl.two_point sources: src0: kind: WLSource nz_data: {tmpdir}/pz0.csv has_intrinsic_alignment: False systematics: - pz_delta_0 src1: kind: WLSource nz_data: {tmpdir}/pz1.csv has_intrinsic_alignment: False systematics: - pz_delta_1 systematics: pz_delta_0: kind: PhotoZShiftBias delta_z: src0_delta_z pz_delta_1: kind: PhotoZShiftBias delta_z: src1_delta_z likelihood: kind: ConstGaussianLogLike data: {tmpdir}/cov.csv data_vector: - cl_src0_src0 - cl_src0_src1 - cl_src1_src1 statistics: cl_src0_src0: sources: ['src0', 'src0'] kind: 'cl' data: {tmpdir}/cl00.csv cl_src0_src1: sources: ['src0', 'src1'] kind: 'cl' data: {tmpdir}/cl01.csv cl_src1_src1: sources: ['src1', 'src1'] kind: 'cl' data: {tmpdir}/cl11.csv""".format(tmpdir=tmpdir) with open(os.path.join(tmpdir, 'config.yaml'), 'w') as fp: fp.write(config) return { 'cosmo': cosmo, 'tmpdir': tmpdir, 'loglike': loglike, 'config': config}
if not os.path.isfile('cls_flat.txt'): import pyccl as ccl z = np.linspace(0.2, 1.2, 256) pz = np.exp(-((z - 0.7) / 0.1)**2) bz = np.ones_like(z) plt.figure() plt.plot(z, pz) plt.xlabel('$z$', fontsize=16) plt.ylabel('$p(z)$', fontsize=16) cosmo = ccl.Cosmology(Omega_c=0.27, Omega_b=0.045, h=0.67, A_s=2.1e-9, n_s=0.96) clust = ccl.ClTracerNumberCounts(cosmo, False, False, z=z, n=pz, bias=bz) lens = ccl.ClTracerLensing(cosmo, False, z=z, n=pz) ell = np.arange(20000) cltt = ccl.angular_cl(cosmo, clust, clust, ell) clte = ccl.angular_cl(cosmo, clust, lens, ell) clee = ccl.angular_cl(cosmo, lens, lens, ell) clbb = np.zeros_like(clee) np.savetxt("cls_flat.txt", np.transpose([ell, cltt, clee, clbb, clte])) ell, cltt, clee, clbb, clte = np.loadtxt("cls_flat.txt", unpack=True) cltt[0] = 0 clee[0] = 0 clbb[0] = 0 clte[0] = 0 if plotres: plt.figure() plt.plot(ell, cltt, 'r-', label='$\\delta_g-\\delta_g$')
seed = 42 tmpdir = '.' rng = np.random.RandomState(seed=seed) eps = 0.01 tracers = [] for i, mn in enumerate([0.25, 0.75]): z = np.linspace(0, 2, 50) nz = np.exp(-0.5 * (z - mn)**2 / 0.25 / 0.25) df = pd.DataFrame({'z': z, 'nz': nz}) df.to_csv(os.path.join(tmpdir, 'pz%d.csv' % i), index=False) tracers.append( ccl.ClTracerLensing(cosmo, has_intrinsic_alignment=False, z=z, n=nz)) dv = [] ndv = [] for i in range(len(tracers)): for j in range(i, len(tracers)): ell = np.logspace(1, 4, 10) pell = ccl.angular_cl(cosmo, tracers[i], tracers[j], ell) npell = pell + rng.normal(size=pell.shape[0]) * eps * pell df = pd.DataFrame({'l': ell, 'cl': npell}) df.to_csv(os.path.join(tmpdir, 'cl%d%d.csv' % (i, j)), index=False) dv.append(pell) ndv.append(npell) # a fake covariance matrix
def check_cls_nu(cosmo): """ Check that cls functions can be run. """ # Number density input z = np.linspace(0., 1., 200) n = np.exp(-((z-0.5)/0.1)**2) # Bias input b = np.sqrt(1. + z) # ell range input ell_scl = 4 ell_lst = [2, 3, 4, 5, 6, 7, 8, 9] ell_arr = np.arange(2, 10) # Check if power spectrum type is valid for CMB cmb_ok = True if cosmo.configuration.matter_power_spectrum_method \ == ccl.core.matter_power_spectrum_types['emu']: cmb_ok = False # ClTracer test objects lens1 = ccl.ClTracerLensing(cosmo, False, n=n, z=z) lens2 = ccl.ClTracerLensing(cosmo, True, n=(z,n), bias_ia=(z,n), f_red=(z,n)) nc1 = ccl.ClTracerNumberCounts(cosmo, False, False, n=(z,n), bias=(z,b)) # Check that for massive neutrinos including rsd raises an error (not yet implemented) assert_raises(RuntimeError, ccl.ClTracerNumberCounts, cosmo, True, False, n=(z,n), bias=(z,b)) cmbl=ccl.ClTracerCMBLensing(cosmo,1100.) # Check valid ell input is accepted assert_( all_finite(ccl.angular_cl(cosmo, lens1, lens1, ell_scl)) ) assert_( all_finite(ccl.angular_cl(cosmo, lens1, lens1, ell_lst)) ) assert_( all_finite(ccl.angular_cl(cosmo, lens1, lens1, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, nc1, nc1, ell_scl)) ) assert_( all_finite(ccl.angular_cl(cosmo, nc1, nc1, ell_lst)) ) assert_( all_finite(ccl.angular_cl(cosmo, nc1, nc1, ell_arr)) ) if cmb_ok: assert_( all_finite(ccl.angular_cl(cosmo, cmbl, cmbl, ell_arr)) ) # Check various cross-correlation combinations assert_( all_finite(ccl.angular_cl(cosmo, lens1, lens2, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, lens1, nc1, ell_arr)) ) if cmb_ok: assert_( all_finite(ccl.angular_cl(cosmo, lens1, cmbl, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, lens2, nc1, ell_arr)) ) if cmb_ok: assert_( all_finite(ccl.angular_cl(cosmo, lens2, cmbl, ell_arr)) ) if cmb_ok: assert_( all_finite(ccl.angular_cl(cosmo, nc1, cmbl, ell_arr)) ) # Check that reversing order of ClTracer inputs works assert_( all_finite(ccl.angular_cl(cosmo, nc1, lens1, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, nc1, lens2, ell_arr)) ) # Check get_internal_function() a_scl = 0.5 a_lst = [0.2, 0.4, 0.6, 0.8, 1.] a_arr = np.linspace(0.2, 1., 5) assert_( all_finite(nc1.get_internal_function(cosmo, 'dndz', a_scl)) ) assert_( all_finite(nc1.get_internal_function(cosmo, 'dndz', a_lst)) ) assert_( all_finite(nc1.get_internal_function(cosmo, 'dndz', a_arr)) ) # Check that invalid options raise errors assert_raises(KeyError, nc1.get_internal_function, cosmo, 'x', a_arr) assert_raises(ValueError, ccl.ClTracerNumberCounts, cosmo, True, True, n=(z,n), bias=(z,b)) assert_raises(KeyError, ccl.ClTracer, cosmo, 'x', True, True, n=(z,n), bias=(z,b)) assert_raises(ValueError, ccl.ClTracerLensing, cosmo, has_intrinsic_alignment=True, n=(z,n), bias_ia=(z,n)) assert_no_warnings(ccl.cls._cltracer_obj, nc1) assert_no_warnings(ccl.cls._cltracer_obj, nc1.cltracer) assert_raises(TypeError, ccl.cls._cltracer_obj, None)
def check_cls(cosmo): """ Check that cls functions can be run. """ # Number density input z = np.linspace(0., 1., 200) n = np.exp(-((z-0.5)/0.1)**2) # Bias input b = np.sqrt(1. + z) # ell range input ell_scl = 4 ell_lst = [2, 3, 4, 5, 6, 7, 8, 9] ell_arr = np.arange(2, 10) # Check if power spectrum type is valid for CMB cmb_ok = True if cosmo.configuration.matter_power_spectrum_method \ == ccl.core.matter_power_spectrum_types['emu']: cmb_ok = False # ClTracer test objects lens1 = ccl.ClTracerLensing(cosmo, False, n=n, z=z) lens2 = ccl.ClTracerLensing(cosmo, True, n=(z,n), bias_ia=(z,n), f_red=(z,n)) nc1 = ccl.ClTracerNumberCounts(cosmo, False, False, n=(z,n), bias=(z,b)) nc2 = ccl.ClTracerNumberCounts(cosmo, True, False, n=(z,n), bias=(z,b)) nc3 = ccl.ClTracerNumberCounts(cosmo, True, True, n=(z,n), bias=(z,b), mag_bias=(z,b)) cmbl=ccl.ClTracerCMBLensing(cosmo,1100.) # Check valid ell input is accepted assert_( all_finite(ccl.angular_cl(cosmo, lens1, lens1, ell_scl)) ) assert_( all_finite(ccl.angular_cl(cosmo, lens1, lens1, ell_lst)) ) assert_( all_finite(ccl.angular_cl(cosmo, lens1, lens1, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, nc1, nc1, ell_scl)) ) assert_( all_finite(ccl.angular_cl(cosmo, nc1, nc1, ell_lst)) ) assert_( all_finite(ccl.angular_cl(cosmo, nc1, nc1, ell_arr)) ) if cmb_ok: assert_( all_finite(ccl.angular_cl(cosmo, cmbl, cmbl, ell_arr)) ) # Check non-limber calculations assert_( all_finite(ccl.angular_cl(cosmo, nc1, nc1, ell_arr, l_limber=20, non_limber_method="native"))) assert_( all_finite(ccl.angular_cl(cosmo, nc1, nc1, ell_arr, l_limber=20, non_limber_method="angpow"))) # Check various cross-correlation combinations assert_( all_finite(ccl.angular_cl(cosmo, lens1, lens2, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, lens1, nc1, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, lens1, nc2, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, lens1, nc3, ell_arr)) ) if cmb_ok: assert_( all_finite(ccl.angular_cl(cosmo, lens1, cmbl, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, lens2, nc1, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, lens2, nc2, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, lens2, nc3, ell_arr)) ) if cmb_ok: assert_( all_finite(ccl.angular_cl(cosmo, lens2, cmbl, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, nc1, nc2, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, nc1, nc3, ell_arr)) ) if cmb_ok: assert_( all_finite(ccl.angular_cl(cosmo, nc1, cmbl, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, nc2, nc3, ell_arr)) ) if cmb_ok: assert_( all_finite(ccl.angular_cl(cosmo, nc2, cmbl, ell_arr)) ) if cmb_ok: assert_( all_finite(ccl.angular_cl(cosmo, nc3, cmbl, ell_arr)) ) # Check that reversing order of ClTracer inputs works assert_( all_finite(ccl.angular_cl(cosmo, nc1, lens1, ell_arr)) ) assert_( all_finite(ccl.angular_cl(cosmo, nc1, lens2, ell_arr)) ) # Wrong non limber method assert_raises(KeyError, ccl.angular_cl, cosmo, lens1, lens1, ell_scl, non_limber_method='xx')