def __init__(self, command_line, path):
"""
The Data class holds the cosmological information, the parameters from
the MCMC run, the information coming from the likelihoods. It is a wide
collections of information, with in particular two main dictionaries:
cosmo_arguments and mcmc_parameters.
It defines several useful **methods**. The following ones are called
just once, at initialization:
* :func:`fill_mcmc_parameters`
* :func:`read_file`
* :func:`read_version`
* :func:`group_parameters_in_blocks`
On the other hand, these two following functions are called every step.
* :func:`check_for_slow_step`
* :func:`update_cosmo_arguments`
Finally, the convenient method :func:`get_mcmc_parameters` will be
called in many places, to return the proper list of desired parameters.
It has a number of different **attributes**, and the more important
ones are listed here:
* :attr:`boundary_loglike`
* :attr:`cosmo_arguments`
* :attr:`mcmc_parameters`
* :attr:`need_cosmo_update`
* :attr:`log_flag`
.. note::
The `experiments` attribute is extracted from the parameter file,
and contains the list of likelihoods to use
.. note::
The path argument will be used in case it is a first run, and hence
a new folder is created. If starting from an existing folder, this
dictionary will be compared with the one extracted from the
log.param, and will use the latter while warning the user.
.. warning::
New in version 2.0.0, you can now specify an oversampling of the
nuisance parameters, to hasten the execution of a run with
likelihoods that have many of them. You should specify a new field
in the parameter file, `data.over_sampling = [1, ...]`, that
contains a 1 on the first element, and then the over sampling of
the desired likelihoods. This array must have the same size as the
number of blocks (1 for the cosmo + 1 for each likelihood with
varying nuisance parameters). You need to call the code with the
flag `-j jast` for it to be used.
To create an instance of this class, one must feed the following
parameters and keyword arguments:
Parameters
----------
command_line : NameSpace
NameSpace containing the input from the :mod:`parser_mp`. It
stores the input parameter file, the jumping methods, the output
folder, etc... Most of the information extracted from the
command_file will be transformed into :class:`Data` attributes,
whenever it felt meaningful to do so.
path : dict
Contains a dictionary of important local paths. It is used here to
find the cosmological module location.
"""
# Initialisation of the random seed
rd.seed()
# Store the parameter file
self.param = command_line.param
# Recover jumping method from command_line
self.jumping = command_line.jumping
self.jumping_factor = command_line.jumping_factor
# Initialise the path dictionnary.
self.path = {}
self.boundary_loglike = -1e30
"""
Define the boundary loglike, the value used to defined a loglike
that is out of bounds. If a point in the parameter space is affected to
this value, it will be automatically rejected, hence increasing the
multiplicity of the last accepted point.
"""
# Creation of the two main dictionnaries:
self.cosmo_arguments = {}
"""
Simple dictionary that will serve as a communication interface with the
cosmological code. It contains all the parameters for the code that
will not be set to their default values. It is updated from
:attr:`mcmc_parameters`.
:rtype: dict
"""
self.mcmc_parameters = od()
"""
Ordered dictionary of dictionaries, it contains everything needed by
the :mod:`mcmc` module for the MCMC procedure. Every parameter name
will be the key of a dictionary, containing the initial configuration,
role, status, last accepted point and current point.
:rtype: ordereddict
"""
# Arguments for PyMultiNest
self.NS_arguments = {}
"""
Dictionary containing the parameters needed by the PyMultiNest sampler.
It is filled just before the run of the sampler. Those parameters not
defined will be set to the default value of PyMultiNest.
TODO: ADD PROPER REFERENCES TO DOCUMENTATION.
:rtype: dict
"""
# Initialise the experiments attribute
self.experiments = []
# Initialise the oversampling setting
self.over_sampling = []
"""
List storing the respective over sampling of the parameters. The first
entry, applied to the cosmological parameters, will always be 1.
Setting it to anything else would simply rescale the whole process. If
not specified otherwise in the parameter file, all other numbers will
be set to 1 as well.
:rtype: list
"""
# Default value for the number of steps
self.N = 10
# Create the variable out, and out_name, which will be initialised
# later by the :mod:`io_mp` module
self.out = None
self.out_name = ''
# If the parameter file is not a log.param, the path will be read
# before reading the parameter file.
if self.param.find('log.param') == -1:
self.path.update(path)
# Read from the parameter file to fill properly the mcmc_parameters
# dictionary.
self.fill_mcmc_parameters()
# Test if the recovered path agrees with the one extracted from
# the configuration file.
if self.path != {}:
if not self.path.has_key('root'):
self.path.update({'root': path['root']})
if self.path != path:
warnings.warn(
"Your code location in the log.param file is "
"in contradiction with your .conf file. "
"I will use the one from log.param.")
# Determine which cosmological code is in use
if self.path['cosmo'].find('class') != -1:
self.cosmological_module_name = 'CLASS'
else:
self.cosmological_module_name = None
# Recover the cosmological code version (and git hash if relevant).
# To implement a new cosmological code, please add another case to the
# test below.
if self.cosmological_module_name == 'CLASS':
# Official version number
common_file_path = os.path.join(
self.path['cosmo'], os.path.join('include', 'common.h'))
with open(common_file_path, 'r') as common_file:
for line in common_file:
if line.find('_VERSION_') != -1:
self.version = line.split()[-1].replace('"', '')
break
print 'with CLASS %s' % self.version
# Git version number and branch
try:
# This nul_file helps to get read of a potential useless error
# message
with open(os.devnull, "w") as nul_file:
self.git_version = sp.check_output(
["git", "rev-parse", "HEAD"],
cwd=self.path['cosmo'],
stderr=nul_file).strip()
self.git_branch = sp.check_output(
["git", "rev-parse", "--abbrev-ref", "HEAD"],
cwd=self.path['cosmo'],
stderr=nul_file).strip()
except sp.CalledProcessError:
warnings.warn(
"Running CLASS from a non version-controlled repository")
self.git_version, self.git_branch = '', ''
# If using an existing log.param, read in and compare this number
# to the already stored one
if self.param.find('log.param') != -1:
try:
version, git_version, git_branch = self.read_version(
self.param_file)
if version != self.version:
warnings.warn(
"Your version of CLASS: %s" % self.version +
" does not match the one used previously" +
" in this folder (%s)." % version +
" Proceed with caution")
else:
if self.git_branch != git_branch:
warnings.warn(
"CLASS set to branch %s" % self.git_branch +
", wrt. the one used in the log.param:" +
" %s." % git_branch)
if self.git_version != git_version:
warnings.warn(
"CLASS set to version %s" % self.git_version +
", wrt. the one used in the log.param:" +
" %s." % git_version)
except AttributeError:
# This error is raised when the regular expression match
# failed - due to comparing to an old log.param that did
# not have this feature properly implemented. Ignore this.
pass
else:
raise io_mp.CosmologicalModuleError(
"If you want to check for another cosmological module version"
" please add an elif clause to this part")
# End of initialisation with the parameter file
self.param_file.close()
self.log_flag = False
"""
Stores the information whether or not the likelihood data files need to
be written down in the log.param file. Initially at False.
:rtype: bool
"""
self.need_cosmo_update = True
"""
`added in version 1.1.1`. It stores the truth value of whether the
cosmological block of parameters was changed from one step to another.
See :meth:`group_parameters_in_blocks`
:rtype: bool
"""
# logging the parameter file (only if folder does not exist !)
## temporary variable for readability
log_param = os.path.join(command_line.folder, 'log.param')
if (os.path.exists(command_line.folder) and
not os.path.exists(log_param)):
if command_line.param is not None:
warnings.warn(
"Detecting empty folder, logging the parameter file")
io_mp.log_parameters(self, command_line)
self.log_flag = True
if not os.path.exists(command_line.folder):
os.makedirs(command_line.folder)
# Logging of parameters
io_mp.log_parameters(self, command_line)
self.log_flag = True
self.lkl = od()
# adding the likelihood directory to the path, to import the module
# then, for each library, calling an instance of the likelihood.
# Beware, though, if you add new likelihoods, they should go to the
# folder likelihoods/yourlike/yourlike.py, and contain a yourlike.data,
# otherwise the following set of commands will not work anymore.
# For the logging if log_flag is True, each likelihood will log its
# parameters
print '\nTesting likelihoods for:\n ->',
print ', '.join(self.experiments)+'\n'
# Due to problems in relative import, this line must be there. Until a
# better solution is found. It adds the root folder of the MontePython
# used as the first element in the sys.path
sys.path.insert(0, self.path['root'])
for elem in self.experiments:
folder = os.path.abspath(os.path.join(
path['MontePython'], os.path.join("likelihoods", "%s" % elem)))
# add the folder of the likelihood to the path of libraries to...
# ... import easily the likelihood.py program
exec "from likelihoods.%s import %s" % (
elem, elem)
# Initialize the likelihoods. Depending on the values of
# command_line and log_flag, the routine will call slightly
# different things. If log_flag is True, the log.param will be
# appended.
exec "self.lkl['%s'] = %s('%s/%s.data',\
self,command_line)" % (
elem, elem, folder, elem)
# Storing parameters by blocks of speed
self.group_parameters_in_blocks()
# Finally, log the cosmo_arguments used. This comes in the end, because
# it can be modified inside the likelihoods init functions
if self.log_flag:
io_mp.log_cosmo_arguments(self, command_line)
io_mp.log_default_configuration(self, command_line)
def __init__(self, command_line, path):
"""
The data class holds the cosmological information, the parameters from
the MCMC run, the information coming from the likelihoods. It is a wide
collections of information, with in particular two main dictionaries:
cosmo_arguments and mcmc_parameters.
It defines several useful **methods**. The following ones are called
just once, at initialization:
* :func:`fill_mcmc_parameters`
* :func:`from_input_to_mcmc_parameters`
* :func:`read_file`
* :func:`read_version`
* :func:`group_parameters_in_blocks`
On the other hand, these two following functions are called every step.
* :func:`check_for_slow_step`
* :func:`update_cosmo_arguments`
Finally, the convenient method :func:`get_mcmc_parameters` will be
called in many places, to return the proper list of desired parameters.
It has a number of different **attributes**, and the more important
ones are listed here:
* :attr:`cosmo_arguments`
* :attr:`mcmc_parameters`
* :attr:`need_cosmo_update`
* :attr:`log_flag`
* :attr:`boundary_loglike`
.. note::
The `experiments` attribute is extracted from the parameter file,
and contains the list of likelihoods to use
To create an instance of this class, one must feed the following
parameters and keyword arguments:
:Parameters:
- **command_line** (`dict`) - dictionary containing the input from the
:mod:`parser_mp`. It stores the input parameter file, the
jumping methods, the output folder, etc...
Most of the information extracted from the command_file will
be transformed into :class:`data` attributes, whenever it felt
meaningful to do so.
- **path** (`dict`) - contains a dictionary of important local paths.
It is used here to find the cosmological module location.
"""
# Initialisation of the random seed
rd.seed()
# Store the parameter file
self.param = command_line.param
# Recover jumping method from command_line
self.jumping = command_line.jumping
self.jumping_factor = command_line.jumping_factor
self.path = path
self.boundary_loglike = -1e30
"""
Define the boundary loglike, the value used to defined a loglike that
is out of bounds. If a point in the parameter space is affected to this
value, it will be automatically rejected, hence increasing the
multiplicity of the last accepted point.
"""
# Creation of the two main dictionnaries:
self.cosmo_arguments = {}
"""
Simple dictionary that will serve as a communication interface with the
cosmological code. It contains all the parameters for the code that
will not be set to their default values. It is updated from
:attr:`mcmc_parameters`.
:rtype: dict
"""
self.mcmc_parameters = od()
"""
Ordered dictionary of dictionaries, it contains everything needed by
the :mod:`mcmc` module for the MCMC procedure. Every parameter name
will be the key of a dictionary, containing the initial configuration,
role, status, last accepted point and current point.
:rtype: ordereddict
"""
# Read from the parameter file to fill properly the mcmc_parameters
# dictionary.
self.fill_mcmc_parameters()
# Determine which cosmological code is in use
if path['cosmo'].find('class') != -1:
self.cosmological_module_name = 'Class'
else:
self.cosmological_module_name = None
# Recover the cosmological code version (and subversion if relevant).
# To implement a new cosmological code, please add another case to the
# test below.
if self.cosmological_module_name == 'Class':
svn_file = open(path['cosmo']+'/include/svnversion.h', 'r')
self.subversion = svn_file.readline().split()[-1].\
replace('"', '')
svn_file.close()
for line in open(path['cosmo']+'/include/common.h', 'r'):
if line.find('_VERSION_') != -1:
self.version = line.split()[-1].replace('"', '')
break
else: # read in the existing parameter file
self.read_version(self.param_file)
# End of initialisation with the parameter file
self.param_file.close()
self.log_flag = False
"""
Stores the information whether or not the likelihood data files need to
be written down in the log.param file. Initially at False.
:rtype: bool
"""
self.need_cosmo_update = True
"""
`added in version 1.1.1`. It stores the truth value of whether the
cosmological block of parameters was changed from one step to another.
See :meth:`group_parameters_in_blocks`
:rtype: bool
"""
sys.stdout.write('Testing likelihoods for:\n -> ')
for i in range(len(self.experiments)):
sys.stdout.write(self.experiments[i]+', ')
sys.stdout.write('\n')
# logging the parameter file (only if folder does not exist !)
if command_line.folder[-1] != '/':
command_line.folder += '/'
if (os.path.exists(command_line.folder) and
not os.path.exists(command_line.folder+'log.param')):
if command_line.param is not None:
io_mp.message(
"Detecting empty folder, logging the parameter file",
"warning")
io_mp.log_parameters(self, command_line)
self.log_flag = True
if not os.path.exists(command_line.folder):
os.mkdir(command_line.folder)
# Logging of parameters
io_mp.log_parameters(self, command_line)
self.log_flag = True
self.lkl = od()
# adding the likelihood directory to the path, to import the module
# then, for each library, calling an instance of the likelihood.
# Beware, though, if you add new likelihoods, they should go to the
# folder likelihoods/yourlike/yourlike.py, and contain a yourlike.data,
# otherwise the following set of commands will not work anymore.
# For the logging if log_flag is True, each likelihood will log its
# parameters
for elem in self.experiments:
folder = os.path.abspath(
path['MontePython'])+"/../likelihoods/%s" % elem
# add the folder of the likelihood to the path of libraries to...
if folder not in sys.path:
sys.path.insert(0, folder)
# ... import easily the likelihood.py program
exec "import %s" % elem
# Initialize the likelihoods. Depending on the values of
# command_line and log_flag, the routine will call slightly different
# things. If log_flag is True, the log.param will be appended.
exec "self.lkl['%s'] = %s.%s('%s/%s.data',\
self,command_line)" % (
elem, elem, elem, folder, elem)
# Storing parameters by blocks of speed
self.group_parameters_in_blocks()
# Finally, log the cosmo_arguments used. This comes in the end, because
# it can be modified inside the likelihoods init functions
if self.log_flag:
io_mp.log_cosmo_arguments(self, command_line)
io_mp.log_default_configuration(self, command_line)
def __init__(self, command_line, path):
"""
The Data class holds the cosmological information, the parameters from
the MCMC run, the information coming from the likelihoods. It is a wide
collections of information, with in particular two main dictionaries:
cosmo_arguments and mcmc_parameters.
It defines several useful **methods**. The following ones are called
just once, at initialization:
* :func:`fill_mcmc_parameters`
* :func:`read_file`
* :func:`read_version`
* :func:`group_parameters_in_blocks`
On the other hand, these two following functions are called every step.
* :func:`check_for_slow_step`
* :func:`update_cosmo_arguments`
Finally, the convenient method :func:`get_mcmc_parameters` will be
called in many places, to return the proper list of desired parameters.
It has a number of different **attributes**, and the more important
ones are listed here:
* :attr:`boundary_loglike`
* :attr:`cosmo_arguments`
* :attr:`mcmc_parameters`
* :attr:`need_cosmo_update`
* :attr:`log_flag`
.. note::
The `experiments` attribute is extracted from the parameter file,
and contains the list of likelihoods to use
.. note::
The path argument will be used in case it is a first run, and hence
a new folder is created. If starting from an existing folder, this
dictionary will be compared with the one extracted from the
log.param, and will use the latter while warning the user.
.. warning::
New in version 2.0.0, you can now specify an oversampling of the
nuisance parameters, to hasten the execution of a run with
likelihoods that have many of them. You should specify a new field
in the parameter file, `data.over_sampling = [1, ...]`, that
contains a 1 on the first element, and then the over sampling of
the desired likelihoods. This array must have the same size as the
number of blocks (1 for the cosmo + 1 for each likelihood with
varying nuisance parameters). You need to call the code with the
flag `-j jast` for it to be used.
To create an instance of this class, one must feed the following
parameters and keyword arguments:
Parameters
----------
command_line : NameSpace
NameSpace containing the input from the :mod:`parser_mp`. It
stores the input parameter file, the jumping methods, the output
folder, etc... Most of the information extracted from the
command_file will be transformed into :class:`Data` attributes,
whenever it felt meaningful to do so.
path : dict
Contains a dictionary of important local paths. It is used here to
find the cosmological module location.
"""
# Initialisation of the random seed
rd.seed()
# Store the parameter file
self.param = command_line.param
# Recover jumping method from command_line
self.jumping = command_line.jumping
self.jumping_factor = command_line.jumping_factor
# Store the rest of the command line
self.command_line = command_line
# Initialise the path dictionnary.
self.path = {}
self.boundary_loglike = -1e30
"""
Define the boundary loglike, the value used to defined a loglike
that is out of bounds. If a point in the parameter space is affected to
this value, it will be automatically rejected, hence increasing the
multiplicity of the last accepted point.
"""
# Creation of the two main dictionnaries:
self.cosmo_arguments = {}
"""
Simple dictionary that will serve as a communication interface with the
cosmological code. It contains all the parameters for the code that
will not be set to their default values. It is updated from
:attr:`mcmc_parameters`.
:rtype: dict
"""
self.mcmc_parameters = od()
"""
Ordered dictionary of dictionaries, it contains everything needed by
the :mod:`mcmc` module for the MCMC procedure. Every parameter name
will be the key of a dictionary, containing the initial configuration,
role, status, last accepted point and current point.
:rtype: ordereddict
"""
# Arguments for PyMultiNest
self.NS_param_names = []
self.NS_arguments = {}
"""
Dictionary containing the parameters needed by the PyMultiNest sampler.
It is filled just before the run of the sampler. Those parameters not
defined will be set to the default value of PyMultiNest.
:rtype: dict
"""
# Initialise the experiments attribute
self.experiments = []
# Initialise the oversampling setting
self.over_sampling = []
"""
List storing the respective over sampling of the parameters. The first
entry, applied to the cosmological parameters, will always be 1.
Setting it to anything else would simply rescale the whole process. If
not specified otherwise in the parameter file, all other numbers will
be set to 1 as well.
:rtype: list
"""
# Default value for the number of steps
self.N = 10
# Create the variable out, and out_name, which will be initialised
# later by the :mod:`io_mp` module
self.out = None
self.out_name = ''
# If the parameter file is not a log.param, the path will be read
# before reading the parameter file.
if self.param.find('log.param') == -1:
self.path.update(path)
# Read from the parameter file to fill properly the mcmc_parameters
# dictionary.
self.fill_mcmc_parameters()
# Test if the recovered path agrees with the one extracted from
# the configuration file.
if self.path != {}:
if not self.path.has_key('root'):
self.path.update({'root': path['root']})
if self.path != path:
warnings.warn("Your code location in the log.param file is "
"in contradiction with your .conf file. "
"I will use the one from log.param.")
# Determine which cosmological code is in use
if self.path['cosmo'].find('class') != -1:
self.cosmological_module_name = 'CLASS'
else:
self.cosmological_module_name = None
# check for MPI
try:
from mpi4py import MPI
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
except ImportError:
# set all chains to master if no MPI
rank = 0
# Recover the cosmological code version (and git hash if relevant).
# To implement a new cosmological code, please add another case to the
# test below.
if self.cosmological_module_name == 'CLASS':
# Official version number
common_file_path = os.path.join(self.path['cosmo'], 'include',
'common.h')
with open(common_file_path, 'r') as common_file:
for line in common_file:
if line.find('_VERSION_') != -1:
self.version = line.split()[-1].replace('"', '')
break
if not command_line.silent and not rank:
print 'with CLASS %s' % self.version
# Git version number and branch
try:
# This nul_file helps to get read of a potential useless error
# message
with open(os.devnull, "w") as nul_file:
self.git_version = sp.Popen(
["git", "rev-parse", "HEAD"],
cwd=self.path['cosmo'],
stdout=sp.PIPE,
stderr=nul_file).communicate()[0].strip()
self.git_branch = sp.Popen(
["git", "rev-parse", "--abbrev-ref", "HEAD"],
cwd=self.path['cosmo'],
stdout=sp.PIPE,
stderr=nul_file).communicate()[0].strip()
except (sp.CalledProcessError, OSError):
# Note, OSError seems to be raised on some systems, instead of
# sp.CalledProcessError - which seems to be linked to the
# existence of os.devnull, so now both error are caught.
warnings.warn(
"Running CLASS from a non version-controlled repository")
self.git_version, self.git_branch = '', ''
# If using an existing log.param, read in and compare this number
# to the already stored one
if self.param.find('log.param') != -1:
try:
version, git_version, git_branch = self.read_version(
self.param_file)
if version != self.version:
warnings.warn(
"Your version of CLASS: %s" % self.version +
" does not match the one used previously" +
" in this folder (%s)." % version +
" Proceed with caution")
else:
if self.git_branch != git_branch:
warnings.warn(
"CLASS set to branch %s" % self.git_branch +
", wrt. the one used in the log.param:" +
" %s." % git_branch)
if self.git_version != git_version:
warnings.warn(
"CLASS set to version %s" % self.git_version +
", wrt. the one used in the log.param:" +
" %s." % git_version)
except AttributeError:
# This error is raised when the regular expression match
# failed - due to comparing to an old log.param that did
# not have this feature properly implemented. Ignore this.
pass
else:
raise io_mp.CosmologicalModuleError(
"If you want to check for another cosmological module version"
" please add an elif clause to this part")
# End of initialisation with the parameter file
self.param_file.close()
self.log_flag = False
"""
Stores the information whether or not the likelihood data files need to
be written down in the log.param file. Initially at False.
:rtype: bool
"""
self.need_cosmo_update = True
"""
`added in version 1.1.1`. It stores the truth value of whether the
cosmological block of parameters was changed from one step to another.
See :meth:`group_parameters_in_blocks`
:rtype: bool
"""
# logging the parameter file (only if folder does not exist !)
## temporary variable for readability
log_param = os.path.join(command_line.folder, 'log.param')
if (os.path.exists(command_line.folder)
and not os.path.exists(log_param)):
if command_line.param is not None:
warnings.warn(
"Detecting empty folder, logging the parameter file")
io_mp.log_parameters(self, command_line)
self.log_flag = True
if not os.path.exists(command_line.folder):
os.makedirs(command_line.folder)
# Logging of parameters
io_mp.log_parameters(self, command_line)
self.log_flag = True
if not command_line.silent and not rank:
print '\nTesting likelihoods for:\n ->',
print ', '.join(self.experiments) + '\n'
self.initialise_likelihoods(self.experiments)
# Storing parameters by blocks of speed
self.group_parameters_in_blocks()
# Finally, log the cosmo_arguments used. This comes in the end, because
# it can be modified inside the likelihoods init functions
if self.log_flag:
io_mp.log_cosmo_arguments(self, command_line)
io_mp.log_default_configuration(self, command_line)
# Log plotting parameter names file for compatibility with GetDist
io_mp.log_parameter_names(self, command_line)
def __init__(self, command_line, path):
"""
The Data class holds the cosmological information, the parameters from
the MCMC run, the information coming from the likelihoods. It is a wide
collections of information, with in particular two main dictionaries:
cosmo_arguments and mcmc_parameters.
It defines several useful **methods**. The following ones are called
just once, at initialization:
* :func:`fill_mcmc_parameters`
* :func:`read_file`
* :func:`read_version`
* :func:`group_parameters_in_blocks`
On the other hand, these two following functions are called every step.
* :func:`check_for_slow_step`
* :func:`update_cosmo_arguments`
Finally, the convenient method :func:`get_mcmc_parameters` will be
called in many places, to return the proper list of desired parameters.
It has a number of different **attributes**, and the more important
ones are listed here:
* :attr:`boundary_loglike`
* :attr:`cosmo_arguments`
* :attr:`mcmc_parameters`
* :attr:`need_cosmo_update`
* :attr:`log_flag`
.. note::
The `experiments` attribute is extracted from the parameter file,
and contains the list of likelihoods to use
.. note::
The path argument will be used in case it is a first run, and hence
a new folder is created. If starting from an existing folder, this
dictionary will be compared with the one extracted from the
log.param, and will use the latter while warning the user.
.. warning::
New in version 2.0.0, you can now specify an oversampling of the
nuisance parameters, to hasten the execution of a run with
likelihoods that have many of them. You should specify a new field
in the parameter file, `data.over_sampling = [1, ...]`, that
contains a 1 on the first element, and then the over sampling of
the desired likelihoods. This array must have the same size as the
number of blocks (1 for the cosmo + 1 for each likelihood with
varying nuisance parameters). You need to call the code with the
flag `-j jast` for it to be used.
To create an instance of this class, one must feed the following
parameters and keyword arguments:
Parameters
----------
command_line : NameSpace
NameSpace containing the input from the :mod:`parser_mp`. It
stores the input parameter file, the jumping methods, the output
folder, etc... Most of the information extracted from the
command_file will be transformed into :class:`Data` attributes,
whenever it felt meaningful to do so.
path : dict
Contains a dictionary of important local paths. It is used here to
find the cosmological module location.
"""
# Initialisation of the random seed
rd.seed()
# Store the parameter file
self.param = command_line.param
# Recover jumping method from command_line
self.jumping = command_line.jumping
self.jumping_factor = command_line.jumping_factor
# Store the rest of the command line
self.command_line = command_line
# Initialise the path dictionnary.
self.path = {}
self.boundary_loglike = -1e30
"""
Define the boundary loglike, the value used to defined a loglike
that is out of bounds. If a point in the parameter space is affected to
this value, it will be automatically rejected, hence increasing the
multiplicity of the last accepted point.
"""
# Creation of the two main dictionnaries:
self.cosmo_arguments = {}
"""
Simple dictionary that will serve as a communication interface with the
cosmological code. It contains all the parameters for the code that
will not be set to their default values. It is updated from
:attr:`mcmc_parameters`.
:rtype: dict
"""
self.mcmc_parameters = od()
"""
Ordered dictionary of dictionaries, it contains everything needed by
the :mod:`mcmc` module for the MCMC procedure. Every parameter name
will be the key of a dictionary, containing the initial configuration,
role, status, last accepted point and current point.
:rtype: ordereddict
"""
# Arguments for PyMultiNest
self.NS_param_names = []
self.NS_arguments = {}
"""
Dictionary containing the parameters needed by the PyMultiNest sampler.
It is filled just before the run of the sampler. Those parameters not
defined will be set to the default value of PyMultiNest.
:rtype: dict
"""
# Initialise the experiments attribute
self.experiments = []
# Initialise the oversampling setting
self.over_sampling = []
"""
List storing the respective over sampling of the parameters. The first
entry, applied to the cosmological parameters, will always be 1.
Setting it to anything else would simply rescale the whole process. If
not specified otherwise in the parameter file, all other numbers will
be set to 1 as well.
:rtype: list
"""
# Default value for the number of steps
self.N = 10
# Create the variable out, and out_name, which will be initialised
# later by the :mod:`io_mp` module
self.out = None
self.out_name = ""
# If the parameter file is not a log.param, the path will be read
# before reading the parameter file.
if self.param.find("log.param") == -1:
self.path.update(path)
# Read from the parameter file to fill properly the mcmc_parameters
# dictionary.
self.fill_mcmc_parameters()
# Test if the recovered path agrees with the one extracted from
# the configuration file.
if self.path != {}:
if not self.path.has_key("root"):
self.path.update({"root": path["root"]})
if self.path != path:
warnings.warn(
"Your code location in the log.param file is "
"in contradiction with your .conf file. "
"I will use the one from log.param."
)
# Determine which cosmological code is in use
if self.path["cosmo"].find("class") != -1:
self.cosmological_module_name = "CLASS"
else:
self.cosmological_module_name = None
# check for MPI
try:
from mpi4py import MPI
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
except ImportError:
# set all chains to master if no MPI
rank = 0
# Recover the cosmological code version (and git hash if relevant).
# To implement a new cosmological code, please add another case to the
# test below.
if self.cosmological_module_name == "CLASS":
# Official version number
common_file_path = os.path.join(self.path["cosmo"], "include", "common.h")
with open(common_file_path, "r") as common_file:
for line in common_file:
if line.find("_VERSION_") != -1:
self.version = line.split()[-1].replace('"', "")
break
if not command_line.silent and not rank:
print "with CLASS %s" % self.version
# Git version number and branch
try:
# This nul_file helps to get read of a potential useless error
# message
with open(os.devnull, "w") as nul_file:
self.git_version = (
sp.Popen(["git", "rev-parse", "HEAD"], cwd=self.path["cosmo"], stdout=sp.PIPE, stderr=nul_file)
.communicate()[0]
.strip()
)
self.git_branch = (
sp.Popen(
["git", "rev-parse", "--abbrev-ref", "HEAD"],
cwd=self.path["cosmo"],
stdout=sp.PIPE,
stderr=nul_file,
)
.communicate()[0]
.strip()
)
except (sp.CalledProcessError, OSError):
# Note, OSError seems to be raised on some systems, instead of
# sp.CalledProcessError - which seems to be linked to the
# existence of os.devnull, so now both error are caught.
warnings.warn("Running CLASS from a non version-controlled repository")
self.git_version, self.git_branch = "", ""
# If using an existing log.param, read in and compare this number
# to the already stored one
if self.param.find("log.param") != -1:
try:
version, git_version, git_branch = self.read_version(self.param_file)
if version != self.version:
warnings.warn(
"Your version of CLASS: %s" % self.version
+ " does not match the one used previously"
+ " in this folder (%s)." % version
+ " Proceed with caution"
)
else:
if self.git_branch != git_branch:
warnings.warn(
"CLASS set to branch %s" % self.git_branch
+ ", wrt. the one used in the log.param:"
+ " %s." % git_branch
)
if self.git_version != git_version:
warnings.warn(
"CLASS set to version %s" % self.git_version
+ ", wrt. the one used in the log.param:"
+ " %s." % git_version
)
except AttributeError:
# This error is raised when the regular expression match
# failed - due to comparing to an old log.param that did
# not have this feature properly implemented. Ignore this.
pass
else:
raise io_mp.CosmologicalModuleError(
"If you want to check for another cosmological module version" " please add an elif clause to this part"
)
# End of initialisation with the parameter file
self.param_file.close()
self.log_flag = False
"""
Stores the information whether or not the likelihood data files need to
be written down in the log.param file. Initially at False.
:rtype: bool
"""
self.need_cosmo_update = True
"""
`added in version 1.1.1`. It stores the truth value of whether the
cosmological block of parameters was changed from one step to another.
See :meth:`group_parameters_in_blocks`
:rtype: bool
"""
# logging the parameter file (only if folder does not exist !)
## temporary variable for readability
log_param = os.path.join(command_line.folder, "log.param")
if os.path.exists(command_line.folder) and not os.path.exists(log_param):
if command_line.param is not None:
warnings.warn("Detecting empty folder, logging the parameter file")
io_mp.log_parameters(self, command_line)
self.log_flag = True
if not os.path.exists(command_line.folder):
os.makedirs(command_line.folder)
# Logging of parameters
io_mp.log_parameters(self, command_line)
self.log_flag = True
if not command_line.silent and not rank:
print "\nTesting likelihoods for:\n ->",
print ", ".join(self.experiments) + "\n"
self.initialise_likelihoods(self.experiments)
# Storing parameters by blocks of speed
self.group_parameters_in_blocks()
# Finally, log the cosmo_arguments used. This comes in the end, because
# it can be modified inside the likelihoods init functions
if self.log_flag:
io_mp.log_cosmo_arguments(self, command_line)
io_mp.log_default_configuration(self, command_line)
# Log plotting parameter names file for compatibility with GetDist
io_mp.log_parameter_names(self, command_line)