def cosmo_setup(self): """ This method runs CAMB with the cosmology specified by the configuration file `self.camb_ini_path`. From this run we take the primordial tensor BB spectrum and the lensing BB spectrum as templates for the likelihood BB model. """ saved_output_path = self.camb_ini_path.with_suffix('.h5') if saved_output_path.exists(): with h5py.File(saved_output_path.as_posix(), 'r') as f: if ('tensor' in f.keys()) and ('lensed_scalar' in f.keys()): self._Cl_BB_prim = f['tensor'][:self.lmax + 1, 2] self._Cl_BB_lens = f['lensed_scalar'][:self.lmax + 1, 2] else: pars = camb.read_ini(self.camb_ini_path.as_posix()) pars.InitPower.set_params(r=1) pars.WantTensors = True results = camb.get_results(pars) powers = results.get_cmb_power_spectra(CMB_unit='muK', raw_cl=True) with h5py.File(saved_output_path.as_posix(), 'a') as f: for key, value in powers.items(): dset = f.require_dataset(key, dtype=value.dtype, shape=value.shape) dset[...] = value self._Cl_BB_prim = np.array(powers['tensor'][:self.lmax + 1, 2]) self._Cl_BB_lens = np.array(powers['lensed_scalar'][:self.lmax + 1, 2])
def generate_spectra_from_camb_ini(self, camb_ini_file_name): """ Generates a new spectra from a CAMB ini file """ camb_ini_file_path = os.path.join(self.global_paths['camb_params_dir'], camb_ini_file_name) params = camb.read_ini(camb_ini_file_path) results = camb.get_results(params) powers = results.get_cmb_power_spectra(params, CMB_unit='muK') self.from_dict_spec(dict_spec=powers)
def main(cmdargs): parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('-i', '--ini', type=str, required=True, help='Input config file for CAMB') parser.add_argument('-o', '--out', type=str, required=True, help='Output FITS file') parser.add_argument( '--H0', type=float, required=False, default=None, help='Hubble parameter, if not given use the one from the config file') parser.add_argument('--fid-Ok', type=float, default=None, required=False, help='Omega_k(z=0) of fiducial LambdaCDM cosmology') parser.add_argument( '--fid-wl', type=float, default=None, required=False, help='Equation of state of dark energy of fiducial LambdaCDM cosmology' ) parser.add_argument( '--z-ref', type=float, required=False, default=None, help= 'Power-spectrum redshift, if not given use the one from the config file' ) parser.add_argument( '--plot', action='store_true', required=False, help='Plot the resulting correlation functions and power-spectra') args = parser.parse_args(cmdargs) ### Parameters kmin and kmax to get exactly same as DR12 minkh = 1.e-4 maxkh = 1.1525e3 npoints = 814 userprint('INFO: running CAMB on {}'.format(args.ini)) pars = camb.read_ini(os.path.expandvars(args.ini)) pars.Transfer.kmax = maxkh if not args.z_ref is None: pars.Transfer.PK_redshifts[0] = args.z_ref if not args.H0 is None: pars.H0 = args.H0 if not args.fid_Ok is None: pars.omk = args.fid_Ok if not args.fid_wl is None: pars.DarkEnergy.w = args.fid_wl results = camb.get_results(pars) k, z, pk = results.get_matter_power_spectrum(minkh=minkh, maxkh=pars.Transfer.kmax, npoints=npoints) pk = pk[1] pars = results.Params pars2 = results.get_derived_params() ### Save the parameters cat = {} cat['H0'] = pars.H0 cat['ombh2'] = pars.ombh2 cat['omch2'] = pars.omch2 cat['omnuh2'] = pars.omnuh2 cat['OK'] = pars.omk cat['OL'] = results.get_Omega('de') cat['ORPHOTON'] = results.get_Omega('photon') cat['ORNEUTRI'] = results.get_Omega('neutrino') cat['OR'] = cat['ORPHOTON'] + cat['ORNEUTRI'] cat['OM'] = (cat['ombh2'] + cat['omch2'] + cat['omnuh2']) / (cat['H0'] / 100.)**2 cat['W'] = pars.DarkEnergy.w cat['TCMB'] = pars.TCMB cat['NS'] = pars.InitPower.ns cat['ZREF'] = pars.Transfer.PK_redshifts[0] cat['SIGMA8_ZREF'] = results.get_sigma8()[0] cat['SIGMA8_Z0'] = results.get_sigma8()[1] cat['F_ZREF'] = results.get_fsigma8()[0] / results.get_sigma8()[0] cat['F_Z0'] = results.get_fsigma8()[1] / results.get_sigma8()[1] cat['ZDRAG'] = pars2['zdrag'] cat['RDRAG'] = pars2['rdrag'] c = SPEED_LIGHT / 1000. ## km/s h = cat['H0'] / 100. dh = c / (results.hubble_parameter(cat['ZREF']) / h) dm = (1. + cat['ZREF']) * results.angular_diameter_distance( cat['ZREF']) * h cat['DH'] = dh cat['DM'] = dm cat['DHoRD'] = cat['DH'] / (cat['RDRAG'] * h) cat['DMoRD'] = cat['DM'] / (cat['RDRAG'] * h) ### Get the Side-Bands ### Follow 2.2.1 of Kirkby et al. 2013: https://arxiv.org/pdf/1301.3456.pdf coef_Planck2015 = (cat['H0'] / 67.31) * (cat['RDRAG'] / 147.334271564563) sb1_rmin = 50. * coef_Planck2015 sb1_rmax = 82. * coef_Planck2015 sb2_rmin = 150. * coef_Planck2015 sb2_rmax = 190. * coef_Planck2015 xi = nbodykit.cosmology.correlation.pk_to_xi(k, pk) r = np.logspace(-7., 3.5, 10000) xi = xi(r) def f_xiSB(r, am3, am2, am1, a0, a1): par = [am3, am2, am1, a0, a1] model = np.zeros((len(par), r.size)) tw = r != 0. model[0, tw] = par[0] / r[tw]**3 model[1, tw] = par[1] / r[tw]**2 model[2, tw] = par[2] / r[tw]**1 model[3, tw] = par[3] model[4, :] = par[4] * r model = np.array(model) return model.sum(axis=0) w = ((r >= sb1_rmin) & (r < sb1_rmax)) | ((r >= sb2_rmin) & (r < sb2_rmax)) sigma = 0.1 * np.ones(xi.size) sigma[(r >= sb1_rmin - 2.) & (r < sb1_rmin + 2.)] = 1.e-6 sigma[(r >= sb2_rmax - 2.) & (r < sb2_rmax + 2.)] = 1.e-6 popt, pcov = curve_fit(f_xiSB, r[w], xi[w], sigma=sigma[w]) model = f_xiSB(r, *popt) xiSB = xi.copy() ww = (r >= sb1_rmin) & (r < sb2_rmax) xiSB[ww] = model[ww] pkSB = nbodykit.cosmology.correlation.xi_to_pk(r, xiSB, extrap=True) pkSB = pkSB(k) pkSB *= pk[-1] / pkSB[-1] out = fitsio.FITS(args.out, 'rw', clobber=True) head = [{'name': k, 'value': float(v)} for k, v in cat.items()] out.write([k, pk, pkSB], names=['K', 'PK', 'PKSB'], header=head, extname='PK') out.close() if args.plot: plt.plot(r, xi * r**2, label='Full') w = (r >= sb1_rmin) & (r < sb1_rmax) plt.plot(r[w], xi[w] * r[w]**2, label='SB1') w = (r >= sb2_rmin) & (r < sb2_rmax) plt.plot(r[w], xi[w] * r[w]**2, label='SB2') plt.plot(r, xiSB * r**2, label='noBAO') plt.xlabel(r'$r\,[h^{-1}\,\mathrm{Mpc}]$') plt.ylabel(r'$r^{2}\,\xi(r)$') plt.legend() plt.grid() plt.show() plt.plot(k, pk, label='Full') plt.plot(k, pkSB, label='noBAO') plt.xscale('log') plt.yscale('log') plt.xlabel(r'$k$') plt.ylabel(r'$P(k)$') plt.legend() plt.grid() plt.show() plt.plot(k, pk - pkSB, label='BAO') plt.xscale('log') plt.xlabel(r'$k$') plt.ylabel(r'$P(k)$') plt.legend() plt.grid() plt.show()
betaV_squared = float(sys.argv[1]) betaE_squared = float(sys.argv[2]) directory = '/Users/mac/Desktop/CircularPolarisation-project/plots/GFEmodified-spectra' # 'path_of_your_directory' Want_fig = False # if False no fig. are produced. twopi = 2.0 * np.pi fourpi = 4.0 * np.pi # this correspond to lmax=2000, this value can be change. The max value is 3987. lmax_v = 1999 lmax_e_b = 1999 tau = 0.05905 pars = camb.read_ini( '/Users/mac/Documents/Work-University/Codes/camb-puliti/CAMB-0.1.7/params.ini' ) pars.Reion.Reionization = True results = camb.get_results(pars) powers = results.get_cmb_power_spectra(pars, CMB_unit='muK') cl_tilde_R = powers['unlensed_total'] tildedle_R = cl_tilde_R[2:, 1] tildedlb_R = cl_tilde_R[2:, 2] tildedlte_R = cl_tilde_R[2:, 3] pars.Reion.Reionization = False results = camb.get_results(pars) powers = results.get_cmb_power_spectra(pars, CMB_unit='muK') cl_tilde = powers['unlensed_total']
CMB_unit='muK') tt_unlensed = unlensed['TxT'] lensed = results.get_lensed_scalar_cls(lmax=2100, CMB_unit='muK') transposed = np.transpose(lensed) tt_lensed = transposed[0] ee = transposed[1] te = transposed[3] fig, ax = plt.subplots() tt_unlensed = np.delete(tt_unlensed, [0, 1]) tt_lensed = np.delete(tt_lensed, [0, 1]) ax.plot(tt_lensed, linewidth=1, color='red') ax.plot(tt_unlensed, linewidth=1, color='blue') ax.set_xlim([None, 2500]) ax.set_ylim([None, 7000]) ax.set(xlabel='Multipole Moment (l)', ylabel='CMB_Unit (uK)', title='Cl TT Lensed CMB Power Spectrum') fig.savefig("Cl_TT_lensed.pdf") params = camb.read_ini('camb_interface/camb_params.ini') camb_plot_lensed(params, params.ombh2, params.omch2, params.omnuh2) # camb_plot_unlensed(params, params.ombh2, params.omch2, params.omnuh2) plt.show() print('done')
def testAssigments(self): ini = os.path.join(os.path.dirname(__file__), '..', 'inifiles', 'planck_2018.ini') if os.path.exists(ini): pars = camb.read_ini(ini) self.assertTrue(np.abs(camb.get_background(pars).cosmomc_theta() * 100 / 1.040909 - 1) < 2e-5) pars = camb.CAMBparams() pars.set_cosmology(H0=68.5, ombh2=0.022, mnu=0, omch2=0.1) self.assertAlmostEqual(pars.omegam, (0.022 + 0.1) / 0.685 ** 2) with self.assertRaises(AttributeError): # noinspection PyPropertyAccess pars.omegam = 1 pars.InitPower.set_params(ns=0.01) data = camb.CAMBdata() data.Params = pars self.assertEqual(data.Params.InitPower.ns, pars.InitPower.ns) d = dark_energy.DarkEnergyFluid(w=-0.95) pars.DarkEnergy = d self.assertEqual(pars.DarkEnergy.w, -0.95) pars.DarkEnergy = dark_energy.AxionEffectiveFluid(w_n=0.4) data.Params = pars self.assertEqual(pars.DarkEnergy.w_n, 0.4) pars.z_outputs = [0.1, 0.4] self.assertEqual(pars.z_outputs[1], 0.4) pars.z_outputs[0] = 0.3 self.assertEqual(pars.z_outputs[0], 0.3) pars.z_outputs = pars.z_outputs pars.z_outputs = [] pars.z_outputs = None self.assertFalse(len(pars.z_outputs)) with self.assertRaises(TypeError): pars.DarkEnergy = initialpower.InitialPowerLaw() pars.NonLinear = model.NonLinear_both printstr = str(pars) self.assertTrue('Want_CMB_lensing = True' in printstr and "NonLinear = NonLinear_both" in printstr) pars.NonLinear = model.NonLinear_lens self.assertTrue(pars.NonLinear == model.NonLinear_lens) with self.assertRaises(ValueError): pars.NonLinear = 4 pars.nu_mass_degeneracies = np.zeros(3) self.assertTrue(len(pars.nu_mass_degeneracies) == 3) pars.nu_mass_degeneracies = [1, 2, 3] self.assertTrue(pars.nu_mass_degeneracies[1] == 2) pars.nu_mass_degeneracies[1] = 5 self.assertTrue(pars.nu_mass_degeneracies[1] == 5) with self.assertRaises(CAMBParamRangeError): pars.nu_mass_degeneracies = np.zeros(7) pars.nu_mass_eigenstates = 0 self.assertFalse(len((pars.nu_mass_degeneracies[:1]))) pars = camb.set_params(**{'InitPower.ns': 1.2, 'WantTransfer': True}) self.assertEqual(pars.InitPower.ns, 1.2) self.assertTrue(pars.WantTransfer) pars.DarkEnergy = None from camb.sources import GaussianSourceWindow pars = camb.CAMBparams() pars.SourceWindows = [GaussianSourceWindow(), GaussianSourceWindow(redshift=1)] self.assertEqual(pars.SourceWindows[1].redshift, 1) pars.SourceWindows[0].redshift = 2 self.assertEqual(pars.SourceWindows[0].redshift, 2) self.assertTrue(len(pars.SourceWindows) == 2) pars.SourceWindows[0] = GaussianSourceWindow(redshift=3) self.assertEqual(pars.SourceWindows[0].redshift, 3) self.assertTrue('redshift = 3.0' in str(pars)) pars.SourceWindows = pars.SourceWindows[0:1] self.assertTrue(len(pars.SourceWindows) == 1) pars.SourceWindows = [] self.assertTrue(len(pars.SourceWindows) == 0)
boo=boo+1 print(chilow,chihigh,np.min(r),np.max(r)) if (boo==0): return True else: return False def getnearestsnap(alist,zmid): """ get the closest snapshot """ zsnap = 1/alist[:,1]-1. return alist[np.argmin(np.abs(zsnap-zmid)),0] #-------- Running camb to get comoving distances ----------- #Load all parameters from camb file pars = camb.read_ini('params_Planck15Table4LastColumn.ini') h = pars.h pars.set_for_lmax(2000, lens_potential_accuracy=3) pars.set_matter_power(redshifts=[0.], kmax=200.0) pars.NonLinearModel.set_params(halofit_version='takahashi') camb.set_feedback_level(level=100) results = camb.get_results(pars) chilow = shellwidth*(shellnum+0) chiupp = shellwidth*(shellnum+1) chimid = 0.5*(chilow+chiupp) ntiles = int(np.ceil(chiupp/boxL)) print("tiling [%dx%dx%d]"%(2*ntiles,2*ntiles,2*ntiles)) zmid = results.redshift_at_comoving_radial_distance(chimid/h) print('Generating map for halos in the range [%3.f - %.3f Mpc/h]'%(chilow,chiupp))
def testAssigments(self): ini = os.path.join(os.path.dirname(__file__), '..', 'inifiles', 'planck_2018.ini') if os.path.exists(ini): pars = camb.read_ini(ini) self.assertTrue(np.abs(camb.get_background(pars).cosmomc_theta() * 100 / 1.040909 - 1) < 2e-5) pars = camb.CAMBparams() pars.set_cosmology(H0=68.5, ombh2=0.022, mnu=0, omch2=0.1) self.assertAlmostEqual(pars.omegam, (0.022 + 0.1) / 0.685 ** 2) with self.assertRaises(AttributeError): pars.omegam = 1 pars.InitPower.set_params(ns=0.01) data = camb.CAMBdata() data.Params = pars self.assertEqual(data.Params.InitPower.ns, pars.InitPower.ns) d = dark_energy.DarkEnergyFluid(w=-0.95) pars.DarkEnergy = d self.assertEqual(pars.DarkEnergy.w, -0.95) pars.DarkEnergy = dark_energy.AxionEffectiveFluid(w_n=0.4) data.Params = pars self.assertEqual(pars.DarkEnergy.w_n, 0.4) pars.z_outputs = [0.1, 0.4] self.assertEqual(pars.z_outputs[1], 0.4) pars.z_outputs[0] = 0.3 self.assertEqual(pars.z_outputs[0], 0.3) pars.z_outputs = pars.z_outputs pars.z_outputs = [] pars.z_outputs = None self.assertFalse(len(pars.z_outputs)) with self.assertRaises(TypeError): pars.DarkEnergy = initialpower.InitialPowerLaw() pars.NonLinear = model.NonLinear_both printstr = str(pars) self.assertTrue('Want_CMB_lensing = True' in printstr and "NonLinear = NonLinear_both" in printstr) pars.NonLinear = model.NonLinear_lens self.assertTrue(pars.NonLinear == model.NonLinear_lens) with self.assertRaises(ValueError): pars.NonLinear = 4 pars.nu_mass_degeneracies = np.zeros(3) self.assertTrue(len(pars.nu_mass_degeneracies) == 3) pars.nu_mass_degeneracies = [1, 2, 3] self.assertTrue(pars.nu_mass_degeneracies[1] == 2) pars.nu_mass_degeneracies[1] = 5 self.assertTrue(pars.nu_mass_degeneracies[1] == 5) with self.assertRaises(CAMBParamRangeError): pars.nu_mass_degeneracies = np.zeros(7) pars.nu_mass_eigenstates = 0 self.assertFalse(len((pars.nu_mass_degeneracies[:1]))) pars = camb.set_params(**{'InitPower.ns': 1.2, 'WantTransfer': True}) self.assertEqual(pars.InitPower.ns, 1.2) self.assertTrue(pars.WantTransfer) pars.DarkEnergy = None from camb.sources import GaussianSourceWindow pars = camb.CAMBparams() pars.SourceWindows = [GaussianSourceWindow(), GaussianSourceWindow(redshift=1)] self.assertEqual(pars.SourceWindows[1].redshift, 1) pars.SourceWindows[0].redshift = 2 self.assertEqual(pars.SourceWindows[0].redshift, 2) self.assertTrue(len(pars.SourceWindows) == 2) pars.SourceWindows[0] = GaussianSourceWindow(redshift=3) self.assertEqual(pars.SourceWindows[0].redshift, 3) self.assertTrue('redshift = 3.0' in str(pars)) pars.SourceWindows = pars.SourceWindows[0:1] self.assertTrue(len(pars.SourceWindows) == 1) pars.SourceWindows = [] self.assertTrue(len(pars.SourceWindows) == 0)
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ @author: Pedro da Silveira Ferreira """ import numpy as np import camb import time from camb import model, initialpower from matplotlib import pyplot as plt import healpy as hp lmax = 2505 pars = camb.read_ini('planck_2018_camb_params.dat') pars.set_for_lmax(lmax) results = camb.get_results(pars) powers = results.get_cmb_power_spectra(pars, CMB_unit='muK') for name in powers: print(name) dl_camb_py = powers['lensed_scalar'][:, 0] cl_camb_py = (2 * np.pi * dl_camb_py[0:lmax + 1] / (np.arange(lmax + 1) * (np.arange(1, lmax + 2)))) / (10**12) # (10**12)->microK^2 cl_camb_py[0] = 0 calplanck = 1.000442**2 dl_planck_dat = np.loadtxt( 'COM_PowerSpect_CMB-base-plikHM-TTTEEE-lowl-lowE-lensing-minimum-theory_R3.01.txt' )
#from cosmotools import utils #from cosmotools import theory #from cosmotools import cosmo import numpy as np import healpy as hp import camb from camb import model, initialpower import sys h = 0.6777 dir_in = sys.argv[1] dir_out = sys.argv[2] cambpar = sys.argv[3] #'mdpl2_params.ini' pars = camb.read_ini(cambpar) results = camb.get_results(pars) #--------------------------------------------------------------------------- Nsnap = 146 #highest slicenumber-4+1 dchish = 25 chish = (np.arange(Nsnap + 1) + 0.5) * dchish chishuu = (np.arange(Nsnap + 1) + 1.0) * dchish chishll = (np.arange(Nsnap + 1) + 0.0) * dchish chis = chish / h # mid-z in Mpc chisuu = chishuu / h # upper edge chisll = chishll / h # lower edges dchis = dchish / h # tmpchis[1:]-tmpchis[:-1]
from cosmic_kite import cosmic_kite import matplotlib.pyplot as plt import camb import numpy as np # Let's compute a spectra with CAMB for random cosmologies pars = camb.read_ini('/home/martin/Descargas/CAMB/inifiles/planck_2018.ini') H0 = np.random.uniform(61, 74) omb = np.random.uniform(0.0213, 0.023) omc = np.random.uniform(0.11, 0.125) n = np.random.uniform(0.94, 0.985) tau = np.random.uniform(0.02, 0.092) As = np.random.uniform(1.95e-9, 2.2e-9) #calculate results for these parameters pars.set_cosmology(H0 = H0, ombh2 = omb, omch2 = omc, tau = tau) pars.set_for_lmax(3000) pars.InitPower.set_params(As = As, ns = n) results = camb.get_results(pars) #get dictionary of CAMB power spectra powers = results.get_cmb_power_spectra(pars, CMB_unit='muK') camb_tt = powers['total'][2:2650,0] camb_ee = powers['total'][2:2650,1] camb_te = powers['total'][2:2650,3] l = np.arange(2,2650) camb_ps = np.concatenate((camb_tt, camb_ee, camb_te))
parser.add_argument( '--plot', action='store_true', required=False, help='Plot the resulting correlation functions and power-spectra') args = parser.parse_args() ### Parameters kmin and kmax to get exactly same as DR12 minkh = 1.e-4 maxkh = 1.1525e3 npoints = 814 print('INFO: running CAMB on {}'.format(args.ini)) pars = camb.read_ini(os.path.expandvars(args.ini)) pars.Transfer.kmax = maxkh if not args.z_ref is None: pars.Transfer.PK_redshifts[0] = args.z_ref if not args.H0 is None: pars.H0 = args.H0 if not args.fid_Ok is None: pars.omk = args.fid_Ok if not args.fid_wl is None: pars.DarkEnergy.w = args.fid_wl results = camb.get_results(pars) k, z, pk = results.get_matter_power_spectrum(minkh=minkh, maxkh=pars.Transfer.kmax, npoints=npoints) pk = pk[1]
def testAssigments(self): ini = os.path.join(os.path.dirname(__file__), '..', 'inifiles', 'planck_2018.ini') if os.path.exists(ini): pars = camb.read_ini(ini) self.assertTrue( np.abs( camb.get_background(pars).cosmomc_theta() * 100 / 1.040909 - 1) < 2e-5) pars = camb.CAMBparams() pars.set_cosmology(H0=68.5, ombh2=0.022, mnu=0, omch2=0.1) self.assertAlmostEqual(pars.omegam, (0.022 + 0.1) / 0.685**2) with self.assertRaises(AttributeError): # noinspection PyPropertyAccess pars.omegam = 1 pars.InitPower.set_params(ns=0.01) data = camb.CAMBdata() data.Params = pars self.assertEqual(data.Params.InitPower.ns, pars.InitPower.ns) d = dark_energy.DarkEnergyFluid(w=-0.95) pars.DarkEnergy = d self.assertEqual(pars.DarkEnergy.w, -0.95) pars.DarkEnergy = dark_energy.AxionEffectiveFluid(w_n=0.4) data.Params = pars self.assertEqual(pars.DarkEnergy.w_n, 0.4) pars.z_outputs = [0.1, 0.4] self.assertEqual(pars.z_outputs[1], 0.4) pars.z_outputs[0] = 0.3 self.assertEqual(pars.z_outputs[0], 0.3) pars.z_outputs = pars.z_outputs pars.z_outputs = [] pars.z_outputs = None # noinspection PyTypeChecker self.assertFalse(len(pars.z_outputs)) with self.assertRaises(TypeError): pars.DarkEnergy = initialpower.InitialPowerLaw() pars.NonLinear = model.NonLinear_both printstr = str(pars) self.assertTrue('Want_CMB_lensing = True' in printstr and "NonLinear = NonLinear_both" in printstr) pars.NonLinear = model.NonLinear_lens self.assertTrue(pars.NonLinear == model.NonLinear_lens) with self.assertRaises(ValueError): pars.NonLinear = 4 pars.nu_mass_degeneracies = np.zeros(3) self.assertTrue(len(pars.nu_mass_degeneracies) == 3) pars.nu_mass_degeneracies = [1, 2, 3] self.assertTrue(pars.nu_mass_degeneracies[1] == 2) pars.nu_mass_degeneracies[1] = 5 self.assertTrue(pars.nu_mass_degeneracies[1] == 5) with self.assertRaises(CAMBParamRangeError): pars.nu_mass_degeneracies = np.zeros(7) pars.nu_mass_eigenstates = 0 self.assertFalse(len((pars.nu_mass_degeneracies[:1]))) pars = camb.set_params(**{'InitPower.ns': 1.2, 'WantTransfer': True}) self.assertEqual(pars.InitPower.ns, 1.2) self.assertTrue(pars.WantTransfer) pars.DarkEnergy = None pars = camb.set_params(**{ 'H0': 67, 'ombh2': 0.002, 'r': 0.1, 'Accuracy.AccurateBB': True }) self.assertEqual(pars.Accuracy.AccurateBB, True) from camb.sources import GaussianSourceWindow pars = camb.CAMBparams() pars.SourceWindows = [ GaussianSourceWindow(), GaussianSourceWindow(redshift=1) ] self.assertEqual(pars.SourceWindows[1].redshift, 1) pars.SourceWindows[0].redshift = 2 self.assertEqual(pars.SourceWindows[0].redshift, 2) self.assertTrue(len(pars.SourceWindows) == 2) pars.SourceWindows[0] = GaussianSourceWindow(redshift=3) self.assertEqual(pars.SourceWindows[0].redshift, 3) self.assertTrue('redshift = 3.0' in str(pars)) pars.SourceWindows = pars.SourceWindows[0:1] self.assertTrue(len(pars.SourceWindows) == 1) pars.SourceWindows = [] self.assertTrue(len(pars.SourceWindows) == 0) params = camb.get_valid_numerical_params() self.assertEqual( params, { 'ombh2', 'deltazrei', 'omnuh2', 'tau', 'omk', 'zrei', 'thetastar', 'nrunrun', 'meffsterile', 'nnu', 'ntrun', 'HMCode_A_baryon', 'HMCode_eta_baryon', 'HMCode_logT_AGN', 'cosmomc_theta', 'YHe', 'wa', 'cs2', 'H0', 'mnu', 'Alens', 'TCMB', 'ns', 'nrun', 'As', 'nt', 'r', 'w', 'omch2' }) params2 = camb.get_valid_numerical_params( dark_energy_model='AxionEffectiveFluid') self.assertEqual(params2.difference(params), {'fde_zc', 'w_n', 'zc', 'theta_i'})
import sys, platform, os from pylab import * import numpy as np from scipy.integrate import odeint from scipy.interpolate import interp1d #!from LCDMCosmology import * import scipy.optimize as optimize camb_path = '/Users/visinelli/Documents/CAMB2016/camb_quint/fortran/' sys.path.insert(0, camb_path) import camb from camb import model, initialpower print('Using CAMB %s installed at %s' % (camb.__version__, os.path.dirname(camb.__file__))) pars = camb.read_ini( os.path.join(camb_path, 'inifiles', 'inifiles/params_200.ini')) print(pars) class QuintCosmology_try(LCDMCosmology): def __init__(self, varylam=True, varyV0=True, varyA=True, varylB=True): ## two parameters: Om and h self.varyV0 = varyV0 self.varylam = varylam self.varyA = varyA self.varylB = varylB self.lam = lam_par.value self.lB = lB_par.value self.A = A_par.value self.V0 = V0_par.value
def map_likelihood(base_camb_param_file, base_info_file, target_dir, param_range, label, lmin, lmax, like_file, enabled_spectra=['TT', 'TE', 'TB', 'EE', 'EB', 'BB']): metadata = {} metadata['model'] = camb.read_ini(base_camb_param_file) metadata['base_cl_prefix'] = target_dir + 'cls_' + label metadata['currparam'] = [] metadata['start_clfile'] = None def execute(curr_metadata): results = camb.get_results(curr_metadata['model']) cls = results.get_total_cls(CMB_unit='muK') ells = np.arange(len(cls)).reshape(len(cls), 1) cls = np.append(ells, cls, axis=1) parstring = curr_metadata['currparam'][0] + str( curr_metadata['currparam'][1]) clfname = curr_metadata['base_cl_prefix'] + '_' + parstring + '.dat' np.savetxt(clfname, cls) if curr_metadata['start_clfile'] is None: curr_metadata['start_clfile'] = clfname curr_metadata['cl_filelist'].write( str(curr_metadata['currparam'][1]) + ' ' + clfname.split('/')[-1] + '\n') return curr_metadata def update(curr_metadata, par_name, par_val): namelist = par_name.split('.') namelist.reverse() model = curr_metadata['model'] currobj = model currname = namelist[-1] while len(namelist) > 1: currobj = getattr(currobj, namelist.pop()) currname = namelist[-1] setattr(currobj, currname, par_val) curr_metadata['model'] = model curr_metadata['currparam'] = [currname, par_val] return curr_metadata cllist_name = target_dir + 'cllist_' + label + '.dat' with open(cllist_name, 'w') as cllistfile: metadata['cl_filelist'] = cllistfile metadata = param_recursor(param_range, execute, update, metadata) commlike = '/mn/stornext/u3/eirikgje/src/Commander/commander1/src/comm_process_resfiles/comm_like_tools' base_info_file = target_dir + base_info_file + '.txt' curr_info_file = target_dir + 'info_' + label + '.txt' process_parameter_file(base_info_file, curr_info_file, new_parameter_dict={'DATAFILE': like_file}) spectra = ['TT', 'TE', 'TB', 'EE', 'EB', 'BB'] spectrum_flags = [ 't' if spec in enabled_spectra else 'f' for spec in spectra ] run_command([ commlike, 'fast_par_estimation', curr_info_file, metadata['start_clfile'], cllist_name, str(lmin), str(lmax) ] + spectrum_flags + ['.true.', target_dir + label + '_likelihood.dat'])
c3 = fits.Column(name='Z', array=totz, format='D') c4 = fits.Column(name='DZ', array=totdz, format='E') c5 = fits.Column(name='VEL_LOS', array=totvlos, format='E') hdu = fits.BinTableHDU.from_columns([c1, c2, c3, c4, c5]) hdr = fits.Header() hdr['NGALBOX'] = ngalbox # total number defined as length of ra array primary_hdu = fits.PrimaryHDU(header=hdr) hdul = fits.HDUList([primary_hdu, hdu]) hdul.writeto(out_file, overwrite=True) #-------- Running camb to get comoving distances ----------- #Load all parameters from camb file pars = camb.read_ini(file_camb) h = pars.h pars.set_for_lmax(2000, lens_potential_accuracy=3) pars.set_matter_power(redshifts=[0.], kmax=200.0) pars.NonLinearModel.set_params(halofit_version='takahashi') camb.set_feedback_level(level=100) results = camb.get_results(pars) if shellnums is None: shellnum_min = int( results.comoving_radial_distance(zmin) * h // shellwidth) shellnum_max = int( results.comoving_radial_distance(zmax) * h // shellwidth + 1) shellnums = list(range(shellnum_min, shellnum_max + 1)) else: shellnums = list(map(int, shellnums.split(",")))