def initialize(self):
if os.path.isabs(self.dataset_file):
data_file = self.dataset_file
self.path = os.path.dirname(data_file)
else:
# If no path specified and has install options (so it installed its data as an
# external package), use the external packages path
if not self.path and self.get_install_options() and self.packages_path:
self.path = self.get_path(self.packages_path)
self.path = self.path or self.get_class_path()
if not self.path:
raise LoggedError(self.log,
"No path given for %s. Set the likelihood "
"property 'path' or the common property '%s'.",
self.dataset_file, packages_path_input)
data_file = os.path.normpath(os.path.join(self.path, self.dataset_file))
if not os.path.exists(data_file):
raise NotInstalledError(
self.log, "The data file '%s' could not be found at '%s'. "
"Either you have not installed this likelihood, "
"or have given the wrong packages installation path.",
self.dataset_file, self.path)
self.load_dataset_file(data_file, getattr(self, 'dataset_params', {}))
def get_camb(packages_path):
try:
return load_module("camb",
path=os.path.join(
process_packages_path(packages_path), "code",
"CAMB"))
except ModuleNotFoundError:
raise NotInstalledError(None)
def initialize(self):
"""Importing CAMB from the correct path, if given."""
# Allow global import if no direct path specification
allow_global = not self.path
if not self.path and self.packages_path:
self.path = self.get_path(self.packages_path)
self.camb = self.is_installed(path=self.path,
allow_global=allow_global,
check=False)
if not self.camb:
raise NotInstalledError(
self.log, "Could not find CAMB. Check error message above.")
super().initialize()
self.extra_attrs = {
"Want_CMB": False,
"Want_cl_2D_array": False,
'WantCls': False
}
# Derived parameters that may not have been requested, but will be necessary later
self.derived_extra = []
# Some default settings
self.needs_perts = False
self.limber = False
self.non_linear_sources = False
self.non_linear_pk = False
self._base_params = None
self._needs_lensing_cross = False
self._sigmaR_z_indices = {}
if self.external_primordial_pk:
self.extra_args['initial_power_model'] \
= self.camb.initialpower.SplinedInitialPower
self.initial_power_args, self.power_params = {}, []
else:
power_spectrum = self.camb.CAMBparams.make_class_named(
self.extra_args.get('initial_power_model',
self.camb.initialpower.InitialPowerLaw),
self.camb.initialpower.InitialPower)
self.initial_power_args, self.power_params = \
self._extract_params(power_spectrum.set_params)
nonlin = self.camb.CAMBparams.make_class_named(
self.extra_args.get('non_linear_model',
self.camb.nonlinear.Halofit),
self.camb.nonlinear.NonLinearModel)
self.nonlin_args, self.nonlin_params = self._extract_params(
nonlin.set_params)
self.requires = str_to_list(getattr(self, "requires", []))
self._transfer_requires = [
p for p in self.requires if p not in self.get_can_support_params()
]
self.requires = [
p for p in self.requires if p not in self._transfer_requires
]
self.log.info("Initialized!")
def initialize(self):
"""Importing CLASS from the correct path, if given, and if not, globally."""
# Allow global import if no direct path specification
allow_global = not self.path
if not self.path and self.packages_path:
self.path = self.get_path(self.packages_path)
self.classy_module = self.is_installed(path=self.path,
allow_global=allow_global)
if not self.classy_module:
raise NotInstalledError(
self.log, "Could not find CLASS. Check error message above.")
self.classy = self.classy_module.Class()
super().initialize()
# Add general CLASS stuff
self.extra_args["output"] = self.extra_args.get("output", "")
if "sBBN file" in self.extra_args:
self.extra_args["sBBN file"] = (
self.extra_args["sBBN file"].format(classy=self.path))
# Derived parameters that may not have been requested, but will be necessary later
self.derived_extra = []
self.log.info("Initialized!")
def initialize(self):
"""Imports the PolyChord sampler and prepares its arguments."""
# Allow global import if no direct path specification
allow_global = not self.path
if not self.path and self.packages_path:
self.path = self.get_path(self.packages_path)
self.pc = self.is_installed(path=self.path, allow_global=allow_global)
if not self.pc:
raise NotInstalledError(
self.log,
"Could not find PolyChord. Check error message above. "
"To install it, run 'cobaya-install polychord --%s "
"[packages_path]'", _packages_path_arg)
# Prepare arguments and settings
from pypolychord.settings import PolyChordSettings
self.n_sampled = len(self.model.parameterization.sampled_params())
self.n_derived = len(self.model.parameterization.derived_params())
self.n_priors = len(self.model.prior)
self.n_likes = len(self.model.likelihood)
self.nDims = self.model.prior.d()
self.nDerived = (self.n_derived + self.n_priors + self.n_likes)
if self.logzero is None:
self.logzero = np.nan_to_num(-np.inf)
if self.max_ndead == np.inf:
self.max_ndead = -1
self._quants_d_units = ["nlive", "max_ndead"]
for p in self._quants_d_units:
if getattr(self, p) is not None:
setattr(
self, p,
NumberWithUnits(getattr(self, p),
"d",
scale=self.nDims,
dtype=int).value)
self._quants_nlive_units = ["nprior"]
for p in self._quants_nlive_units:
if getattr(self, p) is not None:
setattr(
self, p,
NumberWithUnits(getattr(self, p),
"nlive",
scale=self.nlive,
dtype=int).value)
# Fill the automatic ones
if getattr(self, "feedback", None) is None:
values = {
logging.CRITICAL: 0,
logging.ERROR: 0,
logging.WARNING: 0,
logging.INFO: 1,
logging.DEBUG: 2
}
self.feedback = values[self.log.getEffectiveLevel()]
# Prepare output folders and prefixes
if self.output:
self.file_root = self.output.prefix
self.read_resume = self.output.is_resuming()
else:
output_prefix = share_mpi(
hex(int(random() * 16**6))[2:] if is_main_process() else None)
self.file_root = output_prefix
# dummy output -- no resume!
self.read_resume = False
self.base_dir = self.get_base_dir(self.output)
self.raw_clusters_dir = os.path.join(self.base_dir, self._clusters_dir)
self.output.create_folder(self.base_dir)
if self.do_clustering:
self.clusters_folder = self.get_clusters_dir(self.output)
self.output.create_folder(self.clusters_folder)
self.mpi_info("Storing raw PolyChord output in '%s'.", self.base_dir)
# Exploiting the speed hierarchy
if self.blocking:
blocks, oversampling_factors = self.model.check_blocking(
self.blocking)
else:
if self.measure_speeds:
self.model.measure_and_set_speeds(n=self.measure_speeds)
blocks, oversampling_factors = self.model.get_param_blocking_for_sampler(
oversample_power=self.oversample_power)
self.mpi_info("Parameter blocks and their oversampling factors:")
max_width = len(str(max(oversampling_factors)))
for f, b in zip(oversampling_factors, blocks):
self.mpi_info("* %" + "%d" % max_width + "d : %r", f, b)
# Save blocking in updated info, in case we want to resume
self._updated_info["blocking"] = list(zip(oversampling_factors,
blocks))
blocks_flat = list(chain(*blocks))
self.ordering = [
blocks_flat.index(p)
for p in self.model.parameterization.sampled_params()
]
self.grade_dims = [len(block) for block in blocks]
# Steps per block
# NB: num_repeats is ignored by PolyChord when int "grade_frac" given,
# so needs to be applied by hand.
# In num_repeats, `d` is interpreted as dimension of each block
self.grade_frac = [
int(o * read_dnumber(self.num_repeats, dim_block))
for o, dim_block in zip(oversampling_factors, self.grade_dims)
]
# Assign settings
pc_args = [
"nlive", "num_repeats", "nprior", "do_clustering",
"precision_criterion", "max_ndead", "boost_posterior", "feedback",
"logzero", "posteriors", "equals", "compression_factor",
"cluster_posteriors", "write_resume", "read_resume", "write_stats",
"write_live", "write_dead", "base_dir", "grade_frac", "grade_dims",
"feedback", "read_resume", "base_dir", "file_root", "grade_frac",
"grade_dims"
]
# As stated above, num_repeats is ignored, so let's not pass it
pc_args.pop(pc_args.index("num_repeats"))
self.pc_settings = PolyChordSettings(
self.nDims,
self.nDerived,
seed=(self.seed if self.seed is not None else -1),
**{
p: getattr(self, p)
for p in pc_args if getattr(self, p) is not None
})
# prior conversion from the hypercube
bounds = self.model.prior.bounds(
confidence_for_unbounded=self.confidence_for_unbounded)
# Check if priors are bounded (nan's to inf)
inf = np.where(np.isinf(bounds))
if len(inf[0]):
params_names = self.model.parameterization.sampled_params()
params = [params_names[i] for i in sorted(list(set(inf[0])))]
raise LoggedError(
self.log,
"PolyChord needs bounded priors, but the parameter(s) '"
"', '".join(params) + "' is(are) unbounded.")
locs = bounds[:, 0]
scales = bounds[:, 1] - bounds[:, 0]
# This function re-scales the parameters AND puts them in the right order
self.pc_prior = lambda x: (locs + np.array(x)[self.ordering] * scales
).tolist()
# We will need the volume of the prior domain, since PolyChord divides by it
self.logvolume = np.log(np.prod(scales))
# Prepare callback function
if self.callback_function is not None:
self.callback_function_callable = (get_external_function(
self.callback_function))
self.last_point_callback = 0
# Prepare runtime live and dead points collections
self.live = Collection(self.model,
None,
name="live",
initial_size=self.pc_settings.nlive)
self.dead = Collection(self.model, self.output, name="dead")
# Done!
if is_main_process():
self.log.debug("Calling PolyChord with arguments:")
for p, v in inspect.getmembers(self.pc_settings,
lambda a: not (callable(a))):
if not p.startswith("_"):
self.log.debug(" %s: %s", p, v)
self.mpi_info("Initialized!")
def initialize(self):
if "2015" in self.get_name():
for line in _deprecation_msg_2015.split("\n"):
self.log.warning(line)
code_path = common_path
data_path = get_data_path(self.__class__.get_qualified_class_name())
# Allow global import if no direct path specification
allow_global = not self.path
if self.path:
self.path_clik = self.path
elif self.packages_path:
self.path_clik = self.get_code_path(self.packages_path)
else:
raise LoggedError(
self.log, "No path given to the Planck likelihood. Set the "
"likelihood property 'path' or the common property "
"'%s'.", _packages_path)
clik = is_installed_clik(path=self.path_clik, allow_global=allow_global)
if not clik:
raise NotInstalledError(
self.log, "Could not find the 'clik' Planck likelihood code. "
"Check error message above.")
# Loading the likelihood data
if not os.path.isabs(self.clik_file):
self.path_data = getattr(self, "path_data", os.path.join(
self.path or self.packages_path, "data", data_path))
self.clik_file = os.path.join(self.path_data, self.clik_file)
# Differences in the wrapper for lensing and non-lensing likes
self.lensing = clik.try_lensing(self.clik_file)
try:
self.clik = clik.clik_lensing(self.clik_file) if self.lensing \
else clik.clik(self.clik_file)
except clik.lkl.CError:
# Is it that the file was not found?
if not os.path.exists(self.clik_file):
raise NotInstalledError(
self.log, "The .clik file was not found where specified in the "
"'clik_file' field of the settings of this likelihood. "
"Maybe the 'path' given is not correct? The full path where"
" the .clik file was searched for is '%s'", self.clik_file)
# Else: unknown clik error
self.log.error("An unexpected error occurred in clik (possibly related to "
"multiple simultaneous initialization, or simultaneous "
"initialization of incompatible likelihoods (e.g. polarised "
"vs non-polarised 'lite' likelihoods. See error info below:")
raise
self.l_maxs = self.clik.get_lmax()
# calculate requirements here so class can also be separately instantiated
requested_cls = ["tt", "ee", "bb", "te", "tb", "eb"]
if self.lensing:
has_cl = [lmax != -1 for lmax in self.l_maxs]
requested_cls = ["pp"] + requested_cls
else:
has_cl = self.clik.get_has_cl()
self.requested_cls = [cl for cl, i in zip(requested_cls, has_cl) if int(i)]
self.l_maxs_cls = [lmax for lmax, i in zip(self.l_maxs, has_cl) if int(i)]
self.expected_params = list(self.clik.extra_parameter_names)
# Placeholder for vector passed to clik
length = (len(self.l_maxs) if self.lensing else len(self.clik.get_has_cl()))
self.vector = np.zeros(np.sum(self.l_maxs) + length + len(self.expected_params))
self.log.info("Initialized!")
