def set_cosmology(self, c, load_pregen=True):
z = c["z"]
if self.param_dict.get("f") is not None:
f = Omega_m_z(self.get_default("om"), z)**0.55
self.set_default("f", f)
self.logger.info(
f"Setting default growth rate of structure to f={f:0.5f}")
if self.cosmology != c:
mnu = c.get("mnu", 0.0)
c["mnu"] = mnu
self.set_default("om", c["om"])
if "om" in self.fix_params:
self.camb = getCambGenerator(
om_resolution=1,
h0=c["h0"],
ob=c["ob"],
redshift=c["z"],
ns=c["ns"],
mnu=c["mnu"],
recon_smoothing_scale=c["reconsmoothscale"],
)
self.camb.omch2s = [
(self.get_default("om") - c["ob"]) * c["h0"]**2
]
else:
self.camb = getCambGenerator(
h0=c["h0"],
ob=c["ob"],
redshift=c["z"],
ns=c["ns"],
mnu=c["mnu"],
recon_smoothing_scale=c["reconsmoothscale"])
self.pregen_path = os.path.abspath(
os.path.join(self.data_location, self.get_unique_cosmo_name()))
self.cosmology = c
if load_pregen:
self._load_precomputed_data()
def __init__(self, uncert=0.01):
super().__init__()
# Set data to camb generated power spectrum
c = getCambGenerator()
r_s, pk_lin, _ = c.get_data()
ks = c.ks
dist = self.data[:, 0]
xi = pk2xi.PowerToCorrelationGauss(ks).__call__(ks, pk_lin, dist)
# Set covariance to something nice and simple to sample from
# 1% diagonal uncertainty seems pretty good.
cov = np.diag((uncert * xi)**2)
self.data = np.vstack((dist, xi)).T
self.set_cov(cov)
def getCambGeneratorAndPT(redshift=0.51,
om_resolution=101,
h0_resolution=1,
h0=0.676,
ob=0.04814,
ns=0.97,
smooth_type="hinton2017",
recon_smoothing_scale=15):
c = getCambGenerator(redshift=redshift,
om_resolution=om_resolution,
h0_resolution=h0_resolution,
h0=h0,
ob=ob,
ns=ns)
pt = PTGenerator(c,
smooth_type=smooth_type,
recon_smoothing_scale=recon_smoothing_scale)
return c, pt
def __init__(self,
name="DummyPowerSpectrum",
min_k=0.02,
max_k=0.30,
step_size=1,
postprocess=None,
dummy_window=False,
uncert=0.01):
super().__init__(name=name,
step_size=step_size,
postprocess=postprocess,
min_k=min_k,
max_k=max_k)
# Set data to camb generated power spectrum
c = getCambGenerator()
pk_lin = c.get_data()["pk_lin"]
ks = c.ks
# Apply window function identically as it was applied to data
# Note this isn't perfect because any error in the window function will propagate
if dummy_window:
pk_final = splev(self.w_ks_output, splrep(ks, pk_lin))[self.w_mask]
self.w_ks_input = self.w_ks_output
self.w_transform = np.diag(np.ones(self.w_ks_output.size))
self.w_k0_scale = 0
self.w_pk = 0
else:
pk_sampled = splev(self.w_ks_input, splrep(ks, pk_lin))
p0 = np.sum(self.w_k0_scale * pk_sampled)
integral_constraint = self.w_pk * p0
pk_convolved = np.atleast_2d(pk_sampled) @ self.w_transform
pk_normalised = (pk_convolved - integral_constraint).flatten()
pk_final = pk_normalised[self.w_mask]
# Set covariance to something nice and simple to sample from
# 1% diagonal uncertainty seems pretty good.
cov = np.diag((uncert * pk_final)**2)
self.data = pk_final
self.set_cov(cov)
sys.path.append("..")
from barry.utils import weighted_avg_and_std
from barry.datasets.dataset_power_spectrum import PowerSpectrum_DESIMockChallenge0_Z01
from barry.cosmology.camb_generator import getCambGenerator
from barry.postprocessing import BAOExtractor
from barry.config import setup
from barry.models import PowerBeutler2017
from barry.samplers import DynestySampler
from barry.fitter import Fitter
from barry.models.model import Correction
if __name__ == "__main__":
pfn, dir_name, file = setup(__file__)
c = getCambGenerator()
r_s = c.get_data()["r_s"]
p = BAOExtractor(r_s)
sampler = DynestySampler(temp_dir=dir_name, nlive=1000)
fitter = Fitter(dir_name)
cs = ["#262232", "#116A71", "#48AB75", "#D1E05B"]
for r in [False]:
t = "Recon" if r else "Prerecon"
# Fix sigma_nl for one of the Beutler models
model = PowerBeutler2017(recon=r, isotropic=False, correction=Correction.NONE)
model.set_default("sigma_nl_par", 10.9)
model.set_default("sigma_nl_perp", 5.98)
