def getLikelihood(self, paramtag, datatag, want_unbinned=False):
# get python likelihood, assuming TT or TTTEEE likelihood, plik or Camspec
jobItem = self.getJobItem(paramtag, datatag)
ini = IniFile(jobItem.chainRoot + '.inputparams')
plik_file = ini.string('clik_data_plik', '')
if plik_file:
params = ini.string('clik_params_plik', '')
if not os.path.exists(plik_file):
plik_file = os.path.join(os.path.dirname(__file__), r'../',
plik_file.replace('%DATASETDIR%', 'data/'))
params = os.path.join(os.path.dirname(__file__), r'../',
params.replace('%DATASETDIR%', 'data/'))
if not os.path.exists(plik_file):
raise Exception('plik file to found %s' % plik_file)
from planck.CMB_plik import plik_likelihood
like = plik_likelihood(plik_file, params)
if want_unbinned:
return like, plik_likelihood(plik_file.replace('.clik', '_bin1.clik'), params)
else:
return like
else:
from planck.CMB_CamSpec import CamSpec_likelihood
fname = os.path.join(os.path.dirname(__file__), r'../data/planck_internal/CamSpecHM_10_7.dataset')
if '_TT_' in jobItem.chainRoot:
like = CamSpec_likelihood(fname, {'use_cl': '100x100 143x143 217x217 143x217'})
else:
like = CamSpec_likelihood(fname)
if want_unbinned:
return like, like
else:
return like
def getLikelihood(self, paramtag, datatag, want_unbinned=False):
# get python likelihood, assuming TT or TTTEEE likelihood, plik or Camspec
jobItem = self.getJobItem(paramtag, datatag)
ini = IniFile(jobItem.chainRoot + '.inputparams')
plik_file = ini.string('clik_data_plik', '')
if plik_file:
params = ini.string('clik_params_plik', '')
if not os.path.exists(plik_file):
plik_file = os.path.join(
os.path.dirname(__file__), r'../',
plik_file.replace('%DATASETDIR%', 'data/'))
params = os.path.join(os.path.dirname(__file__), r'../',
params.replace('%DATASETDIR%', 'data/'))
if not os.path.exists(plik_file):
raise Exception('plik file to found %s' % plik_file)
from planck.CMB_plik import plik_likelihood
like = plik_likelihood(plik_file, params)
if want_unbinned:
return like, plik_likelihood(
plik_file.replace('.clik', '_bin1.clik'), params)
else:
return like
else:
from planck.CMB_CamSpec import CamSpec_likelihood
fname = os.path.join(
os.path.dirname(__file__),
r'../data/planck_internal/CamSpecHM_10_7.dataset')
if '_TT_' in jobItem.chainRoot:
like = CamSpec_likelihood(
fname, {'use_cl': '100x100 143x143 217x217 143x217'})
else:
like = CamSpec_likelihood(fname)
if want_unbinned:
return like, like
else:
return like
def load_dataset(self, filename, dataset_params):
from getdist import IniFile
ini = IniFile(filename)
ini.params.update(dataset_params)
self.indices = []
self.used_indices = []
self.used_items = []
self.fullcov = np.loadtxt(ini.relativeFileName('cov_file'))
ntheta = ini.int('num_theta_bins')
self.theta_bins = np.loadtxt(ini.relativeFileName('theta_bins_file'))
self.iintrinsic_alignment_model = ini.string(
'intrinsic_alignment_model')
self.data_types = ini.string('data_types').split()
self.used_types = ini.list('used_data_types', self.data_types)
with open(ini.relativeFileName('data_selection')) as f:
header = f.readline()
assert ('# type bin1 bin2 theta_min theta_max' == header.strip())
lines = f.readlines()
ranges = {}
for tp in self.data_types:
ranges[tp] = np.empty((6, 6), dtype=object)
for line in lines:
items = line.split()
if items[0] in self.used_types:
bin1, bin2 = [int(x) - 1 for x in items[1:3]]
ranges[items[0]][bin1][bin2] = [
np.float64(x) for x in items[3:]
]
self.ranges = ranges
self.nzbins = ini.int('num_z_bins') # for lensing sources
self.nwbins = ini.int('num_gal_bins', 0) # for galaxies
maxbin = max(self.nzbins, self.nwbins)
cov_ix = 0
self.bin_pairs = []
self.data_arrays = []
self.thetas = []
for i, tp in enumerate(self.data_types):
xi = np.loadtxt(ini.relativeFileName('measurements[%s]' % tp))
bin1 = xi[:, 0].astype(np.int) - 1
bin2 = xi[:, 1].astype(np.int) - 1
tbin = xi[:, 2].astype(np.int) - 1
corr = np.empty((maxbin, maxbin), dtype=np.object)
corr[:, :] = None
self.data_arrays.append(corr)
self.bin_pairs.append([])
for f1, f2, ix, dat in zip(bin1, bin2, tbin, xi[:, 3]):
self.indices.append((i, f1, f2, ix))
if not (f1, f2) in self.bin_pairs[i]:
self.bin_pairs[i].append((f1, f2))
corr[f1, f2] = np.zeros(ntheta)
corr[f1, f2][ix] = dat
if ranges[tp][f1, f2] is not None:
mn, mx = ranges[tp][f1, f2]
if self.theta_bins[ix] > mn and self.theta_bins[ix] < mx:
self.thetas.append(self.theta_bins[ix])
self.used_indices.append(cov_ix)
self.used_items.append(self.indices[-1])
cov_ix += 1
nz_source = np.loadtxt(ini.relativeFileName('nz_file'))
self.zmid = nz_source[:, 1]
self.zbin_sp = []
for b in range(self.nzbins):
self.zbin_sp += [
UnivariateSpline(self.zmid, nz_source[:, b + 3], s=0)
]
nz_lens = np.loadtxt(ini.relativeFileName('nz_gal_file'))
assert (np.array_equal(nz_lens[:, 1], self.zmid))
self.zbin_w_sp = []
for b in range(self.nwbins):
self.zbin_w_sp += [
UnivariateSpline(self.zmid, nz_lens[:, b + 3], s=0)
]
self.zmax = self.zmid[-1]
self.kmax = ini.float(
'kmax', 15) # Actually computed, assumes extrapolated beyond that
self._initialize()
def __init__(self, dataset, dataset_params={}, alpha_beta_names=['alpha', 'beta'],
marginalize=False, marginalize_params=_marge_params, precompute_covmats=True, silent=False):
"""
:param dataset: .dataset file with settings
:param dataset_params: dictionary of any parameter to override in teh .dataset file
:param alpha_beta_names: names of alpha and beta parameters if used and varied
:param marginalize: Marginalize over alpha, beta by dumb grid integration (slow, but useful for importance sampling)
:param marginalize_params: Dictionary of options for the grid marguinalization
:param precompute_covmats: if marginalizing, pre-compute covariance inverses at expense of memory (~600MB).
:param silent: Don't print out stuff
"""
def relative_path(tag):
name = ini.string(tag).replace('data/', '').replace('Pantheon/', '')
if ini.original_filename is not None:
return os.path.join(os.path.dirname(ini.original_filename), name)
return name
# has_absdist = F, intrinsicdisp=0, idispdataset=False
if not silent: print('loading: %s' % dataset)
ini = IniFile(dataset)
ini.params.update(dataset_params)
self.name = ini.string('name')
data_file = relative_path('data_file')
self.twoscriptmfit = ini.bool('twoscriptmfit')
if self.twoscriptmfit:
scriptmcut = ini.float('scriptmcut', 10.)
assert not ini.float('intrinsicdisp', 0) and not ini.float('intrinsicdisp0', 0)
self.alpha_beta_names = alpha_beta_names
if alpha_beta_names is not None:
self.alpha_name = alpha_beta_names[0]
self.beta_name = alpha_beta_names[1]
self.marginalize = marginalize
self.pecz = ini.float('pecz', 0.001)
cols = None
self.has_third_var = False
if not silent:
print('Supernovae name: %s' % self.name)
print('Reading %s' % data_file)
supernovae = {}
self.names = []
ix = 0
with io.open(data_file, 'r') as f:
lines = f.readlines()
for line in lines:
if '#' in line:
cols = line[1:].split()
for rename, new in zip(['mb', 'color', 'x1', '3rdvar', 'd3rdvar', 'cov_m_s', 'cov_m_c', 'cov_s_c'],
['mag', 'colour', 'stretch', 'third_var', 'dthird_var', 'cov_mag_stretch',
'cov_mag_colour', 'cov_stretch_colour']):
if rename in cols:
cols[cols.index(rename)] = new
self.has_third_var = 'third_var' in cols
zeros = np.zeros(len(lines) - 1)
self.third_var = zeros.copy()
self.dthird_var = zeros.copy()
self.set = zeros.copy()
for col in cols:
setattr(self, col, zeros.copy())
elif line.strip():
if cols is None: raise Exception('Data file must have comment header')
vals = line.split()
for i, (col, val) in enumerate(zip(cols, vals)):
if col == 'name':
supernovae[val] = ix
self.names.append(val)
else:
getattr(self, col)[ix] = np.float64(val)
ix += 1
self.z_var = self.dz ** 2
self.mag_var = self.dmb ** 2
self.stretch_var = self.dx1 ** 2
self.colour_var = self.dcolor ** 2
self.thirdvar_var = self.dthird_var ** 2
self.nsn = ix
if not silent: print('Number of SN read: %s ' % self.nsn)
if self.twoscriptmfit and not self.has_third_var:
raise Exception('twoscriptmfit was set but thirdvar information not present')
if ini.bool('absdist_file'): raise Exception('absdist_file not supported')
covmats = ['mag', 'stretch', 'colour', 'mag_stretch', 'mag_colour', 'stretch_colour']
self.covs = {}
for name in covmats:
if ini.bool('has_%s_covmat' % name):
if not silent: print('Reading covmat for: %s ' % name)
self.covs[name] = self._read_covmat(relative_path('%s_covmat_file' % name))
self.alphabeta_covmat = len(self.covs.items()) > 1 or self.covs.get('mag', None) is None
self._last_alpha = np.inf
self._last_beta = np.inf
if alpha_beta_names is None and not marginalize: raise ValueError('Must give alpha, beta')
assert self.covs
# jla_prep
zfacsq = 25.0 / np.log(10.0) ** 2
self.pre_vars = self.mag_var + zfacsq * self.pecz ** 2 * (
(1.0 + self.zcmb) / (self.zcmb * (1 + 0.5 * self.zcmb))) ** 2
if self.twoscriptmfit:
A1 = np.zeros(self.nsn)
A2 = np.zeros(self.nsn)
A1[self.third_var <= scriptmcut] = 1
A2[self.third_var > scriptmcut] = 1
has_A1 = np.any(A1)
has_A2 = np.any(A2)
if not has_A1:
# swap
A1 = A2
A2 = np.zeros(self.nsn)
has_A2 = False
if not has_A2:
self.twoscriptmfit = False
self.A1 = A1
self.A2 = A2
if marginalize:
self.marge_params = _marge_params.copy()
self.marge_params.update(marginalize_params)
self.step_width_alpha = self.marge_params['step_width_alpha']
self.step_width_beta = self.marge_params['step_width_beta']
_marge_steps = self.marge_params['marge_steps']
self.alpha_grid = np.empty((2 * _marge_steps + 1) ** 2)
self.beta_grid = self.alpha_grid.copy()
_int_points = 0
for alpha_i in range(-_marge_steps, _marge_steps + 1):
for beta_i in range(-_marge_steps, _marge_steps + 1):
if alpha_i ** 2 + beta_i ** 2 <= _marge_steps ** 2:
self.alpha_grid[_int_points] = self.marge_params[
'alpha_centre'] + alpha_i * self.step_width_alpha
self.beta_grid[_int_points] = self.marge_params['beta_centre'] + beta_i * self.step_width_beta
_int_points += 1
if not silent: print('Marignalizing alpha, beta over %s points' % _int_points)
self.marge_grid = np.empty(_int_points)
self.int_points = _int_points
self.alpha_grid = self.alpha_grid[:_int_points]
self.beta_grid = self.beta_grid[:_int_points]
self.invcovs = np.empty(_int_points, dtype=np.object)
if precompute_covmats:
for i, (alpha, beta) in enumerate(zip(self.alpha_grid, self.beta_grid)):
self.invcovs[i] = self.inverse_covariance_matrix(alpha, beta)
elif not self.alphabeta_covmat:
self.inverse_covariance_matrix()
def __init__(self, dataset=dataDir, dataset_params={}, alpha_beta_names=['alpha', 'beta'],
marginalize=False, marginalize_params=_marge_params, precompute_covmats=True, silent=False):
"""
:param dataset: .dataset file with settings
:param dataset_params: dictionary of any parameter to override in teh .dataset file
:param alpha_beta_names: names of alpha and beta parameters if used and varied
:param marginalize: Marginalize over alpha, beta by dumb grid integration (slow, but useful for importance sampling)
:param marginalize_params: Dictionary of options for the grid marguinalization
:param precompute_covmats: if marginalizing, pre-compute covariance inverses at expense of memory (~600MB).
:param silent: Don't print out stuff
"""
def relative_path(tag):
name = ini.string(tag).replace('data/', '').replace('Pantheon/', '')
if ini.original_filename is not None:
return os.path.join(os.path.dirname(ini.original_filename), name)
return name
# has_absdist = F, intrinsicdisp=0, idispdataset=False
if not silent: print('loading: %s' % dataset)
ini = IniFile(dataset)
ini.params.update(dataset_params)
self.name = ini.string('name')
data_file = relative_path('data_file')
self.twoscriptmfit = ini.bool('twoscriptmfit')
if self.twoscriptmfit:
scriptmcut = ini.float('scriptmcut', 10.)
assert not ini.float('intrinsicdisp', 0) and not ini.float('intrinsicdisp0', 0)
self.alpha_beta_names = alpha_beta_names
if alpha_beta_names is not None:
self.alpha_name = alpha_beta_names[0]
self.beta_name = alpha_beta_names[1]
self.marginalize = marginalize
self.pecz = ini.float('pecz', 0.001)
cols = None
self.has_third_var = False
if not silent:
print('Supernovae name: %s' % self.name)
print('Reading %s' % data_file)
supernovae = {}
self.names = []
ix = 0
with io.open(data_file, 'r') as f:
lines = f.readlines()
for line in lines:
if '#' in line:
cols = line[1:].split()
for rename, new in zip(['mb', 'color', 'x1', '3rdvar', 'd3rdvar', 'cov_m_s', 'cov_m_c', 'cov_s_c'],
['mag', 'colour', 'stretch', 'third_var', 'dthird_var', 'cov_mag_stretch',
'cov_mag_colour', 'cov_stretch_colour']):
if rename in cols:
cols[cols.index(rename)] = new
self.has_third_var = 'third_var' in cols
zeros = np.zeros(len(lines) - 1)
self.third_var = zeros.copy()
self.dthird_var = zeros.copy()
self.set = zeros.copy()
for col in cols:
setattr(self, col, zeros.copy())
elif line.strip():
if cols is None: raise Exception('Data file must have comment header')
vals = line.split()
for i, (col, val) in enumerate(zip(cols, vals)):
if col == 'name':
supernovae[val] = ix
self.names.append(val)
else:
getattr(self, col)[ix] = np.float64(val)
ix += 1
self.z_var = self.dz ** 2
self.mag_var = self.dmb ** 2
self.stretch_var = self.dx1 ** 2
self.colour_var = self.dcolor ** 2
self.thirdvar_var = self.dthird_var ** 2
self.nsn = ix
if not silent: print('Number of SN read: %s ' % self.nsn)
if self.twoscriptmfit and not self.has_third_var:
raise Exception('twoscriptmfit was set but thirdvar information not present')
if ini.bool('absdist_file'): raise Exception('absdist_file not supported')
covmats = ['mag', 'stretch', 'colour', 'mag_stretch', 'mag_colour', 'stretch_colour']
self.covs = {}
for name in covmats:
if ini.bool('has_%s_covmat' % name):
if not silent: print('Reading covmat for: %s ' % name)
self.covs[name] = self._read_covmat(relative_path('%s_covmat_file' % name))
self.alphabeta_covmat = len(self.covs.items()) > 1 or self.covs.get('mag', None) is None
self._last_alpha = np.inf
self._last_beta = np.inf
if alpha_beta_names is None and not marginalize: raise ValueError('Must give alpha, beta')
assert self.covs
# jla_prep
zfacsq = 25.0 / np.log(10.0) ** 2
self.pre_vars = self.mag_var + zfacsq * self.pecz ** 2 * (
(1.0 + self.zcmb) / (self.zcmb * (1 + 0.5 * self.zcmb))) ** 2
if self.twoscriptmfit:
A1 = np.zeros(self.nsn)
A2 = np.zeros(self.nsn)
A1[self.third_var <= scriptmcut] = 1
A2[self.third_var > scriptmcut] = 1
has_A1 = np.any(A1)
has_A2 = np.any(A2)
if not has_A1:
# swap
A1 = A2
A2 = np.zeros(self.nsn)
has_A2 = False
if not has_A2:
self.twoscriptmfit = False
self.A1 = A1
self.A2 = A2
if marginalize:
self.marge_params = _marge_params.copy()
self.marge_params.update(marginalize_params)
self.step_width_alpha = self.marge_params['step_width_alpha']
self.step_width_beta = self.marge_params['step_width_beta']
_marge_steps = self.marge_params['marge_steps']
self.alpha_grid = np.empty((2 * _marge_steps + 1) ** 2)
self.beta_grid = self.alpha_grid.copy()
_int_points = 0
for alpha_i in range(-_marge_steps, _marge_steps + 1):
for beta_i in range(-_marge_steps, _marge_steps + 1):
if alpha_i ** 2 + beta_i ** 2 <= _marge_steps ** 2:
self.alpha_grid[_int_points] = self.marge_params[
'alpha_centre'] + alpha_i * self.step_width_alpha
self.beta_grid[_int_points] = self.marge_params['beta_centre'] + beta_i * self.step_width_beta
_int_points += 1
if not silent: print('Marignalizing alpha, beta over %s points' % _int_points)
self.marge_grid = np.empty(_int_points)
self.int_points = _int_points
self.alpha_grid = self.alpha_grid[:_int_points]
self.beta_grid = self.beta_grid[:_int_points]
self.invcovs = np.empty(_int_points, dtype=np.object)
if precompute_covmats:
for i, (alpha, beta) in enumerate(zip(self.alpha_grid, self.beta_grid)):
self.invcovs[i] = self.inverse_covariance_matrix(alpha, beta)
elif not self.alphabeta_covmat:
self.inverse_covariance_matrix()
def getdist_script(args, exit_on_error=True):
def do_error(msg):
if exit_on_error:
print(msg)
sys.exit()
raise ValueError(msg)
result = []
def doprint(*s):
result.append(" ".join([str(x) for x in s]))
print(*s)
no_plots = False
chain_root = args.chain_root
if args.ini_file is None and chain_root is None:
do_error(
'Must give either a .ini file of parameters or a chain file root name. Run "getdist -h" for help.'
)
if '.ini' not in args.ini_file and chain_root is None:
# use default settings acting on chain_root, no plots
chain_root = args.ini_file
args.ini_file = getdist.default_getdist_settings
no_plots = True
if not os.path.isfile(args.ini_file):
do_error('Parameter file does not exist: ' + args.ini_file)
if chain_root and chain_root.endswith('.txt'):
chain_root = chain_root[:-4]
if chain_root is not None and ('*' in chain_root or '?' in chain_root):
import glob
import copy
for ending in ['.paramnames', 'updated.yaml']:
for f in glob.glob(chain_root + ending):
fileargs = copy.copy(args)
fileargs.chain_root = f.replace(ending, '')
getdist_script(fileargs)
return
# Input parameters
ini = IniFile(args.ini_file)
for item in set(ini.params.keys()).intersection({
'make_single_samples', 'single_thin', 'dump_ND_bins',
'plot_meanlikes', 'shade_meanlikes', 'plot_data_dir',
'force_twotail'
}):
if ini.string(item) not in [0, 'F']:
logging.warning(
'%s is no longer supported by getdist, value ignored' % item)
# File root
if chain_root is not None:
in_root = chain_root
else:
in_root = ini.params['file_root']
if not in_root:
do_error('Chain Root file name not given ')
rootname = os.path.basename(in_root)
if args.ignore_rows is not None:
ignorerows = args.ignore_rows
else:
ignorerows = ini.float('ignore_rows', 0.0)
samples_are_chains = ini.bool('samples_are_chains', True)
paramnames = ini.string('parameter_names', '')
# Create instance of MCSamples
mc = MCSamples(in_root,
ini=ini,
files_are_chains=samples_are_chains,
paramNamesFile=paramnames)
if ini.bool('adjust_priors', False) or ini.bool('map_params', False):
do_error(
'To adjust priors or define new parameters, use a separate python script; '
'see the python getdist docs for examples')
plot_ext = ini.string('plot_ext', 'py')
finish_run_command = ini.string('finish_run_command', '')
no_plots = ini.bool('no_plots', no_plots)
plots_only = ini.bool('plots_only', False)
no_tests = plots_only or ini.bool('no_tests', False)
thin_factor = ini.int('thin_factor', 0)
thin_cool = ini.float('thin_cool', 1.0)
cool = ini.float('cool', 1.0)
chain_exclude = ini.int_list('exclude_chain')
out_dir = ini.string('out_dir', './')
if out_dir:
if not os.path.isdir(out_dir):
os.mkdir(out_dir)
doprint('producing files in directory ', out_dir)
mc.out_dir = out_dir
out_root = ini.string('out_root', '')
if out_root:
rootname = out_root
doprint('producing files with with root ', out_root)
mc.rootname = rootname
rootdirname = os.path.join(out_dir, rootname)
mc.rootdirname = rootdirname
if 'do_minimal_1d_intervals' in ini.params:
do_error(
'do_minimal_1d_intervals no longer used; set credible_interval_threshold instead'
)
line = ini.string('PCA_params', '')
if line.lower() == 'all':
PCA_params = mc.paramNames.list()
else:
PCA_params = line.split()
PCA_num = ini.int('PCA_num', len(PCA_params))
if PCA_num != 0:
if PCA_num < 2:
do_error('Can only do PCA for 2 or more parameters')
PCA_func = ini.string('PCA_func', '')
# Characters representing functional mapping
if PCA_func == '':
PCA_func = ['N'] * PCA_num # No mapping
PCA_NormParam = ini.string('PCA_normparam', '') or None
# ==============================================================================
first_chain = ini.int('first_chain', 0)
last_chain = ini.int('chain_num', -1)
# -1 y keep reading until one not found
# Chain files
for separator in ['_', '.']:
chain_files = chains.chainFiles(in_root,
first_chain=first_chain,
last_chain=last_chain,
chain_exclude=chain_exclude,
separator=separator)
if chain_files:
break
mc.loadChains(in_root, chain_files)
mc.removeBurnFraction(ignorerows)
if chains.print_load_details:
if ignorerows:
doprint('Removed %s as burn in' % ignorerows)
else:
doprint('Removed no burn in')
mc.deleteFixedParams()
mc.makeSingle()
def filterParList(namestring, num=None):
if not namestring.strip():
_pars = mc.paramNames.list()
else:
_pars = []
for name in namestring.split():
if '?' in name or '*' in name:
_pars += mc.paramNames.getMatches(name, strings=True)
elif mc.paramNames.parWithName(name):
_pars.append(name)
if num is not None and len(_pars) != num:
doprint(
'%iD plot has missing parameter or wrong number of parameters: %s'
% (num, _pars))
_pars = None
return _pars
if cool != 1:
doprint('Cooling chains by ', cool)
mc.cool(cool)
mc.updateBaseStatistics()
if not no_tests:
mc.getConvergeTests(mc.converge_test_limit,
writeDataToFile=True,
feedback=True)
mc.writeCovMatrix()
mc.writeCorrelationMatrix()
# Output thinned data if requested
# Must do this with unsorted output
if thin_factor > 1:
thin_ix = mc.thin_indices(thin_factor)
filename = rootdirname + '_thin.txt'
mc.writeThinData(filename, thin_ix, thin_cool)
doprint(mc.getNumSampleSummaryText().strip())
if mc.likeStats:
doprint(mc.likeStats.likeSummary().strip())
if PCA_num > 0 and not plots_only:
mc.PCA(PCA_params, PCA_func, PCA_NormParam, writeDataToFile=True)
# Do 1D bins
mc._setDensitiesandMarge1D()
if not no_plots:
# Output files for 1D plots
plotparams = []
line = ini.string('plot_params', '')
if line not in ['', '0']:
plotparams = filterParList(line)
line = ini.string('plot_2D_param', '').strip()
plot_2D_param = None
if line and line != '0':
plot_2D_param = line
cust2DPlots = []
if not plot_2D_param:
# Use custom array of specific plots
num_cust2D_plots = ini.int('plot_2D_num', 0)
for i in range(1, num_cust2D_plots + 1):
line = ini.string('plot' + str(i))
pars = filterParList(line, 2)
if pars is not None:
cust2DPlots.append(pars)
else:
num_cust2D_plots -= 1
triangle_params = []
triangle_plot = ini.bool('triangle_plot', False)
if triangle_plot:
line = ini.string('triangle_params', '')
triangle_params = filterParList(line)
triangle_num = len(triangle_params)
triangle_plot = triangle_num > 1
num_3D_plots = ini.int('num_3D_plots', 0)
plot_3D = []
for ix in range(1, num_3D_plots + 1):
line = ini.string('3D_plot' + str(ix))
pars = filterParList(line, 3)
if pars is not None:
plot_3D.append(pars)
else:
num_3D_plots -= 1
make_plots = ini.bool('make_plots', False) or args.make_plots
filename = rootdirname + '.' + plot_ext
mc._writeScriptPlots1D(filename, plotparams)
if make_plots:
runScript(filename)
# Do 2D bins
if plot_2D_param == 'corr':
# In this case output the most correlated variable combinations
doprint('...doing 2D plots for most correlated variables')
cust2DPlots = mc.getCorrelatedVariable2DPlots()
plot_2D_param = None
elif plot_2D_param:
mc.paramNames.parWithName(plot_2D_param, error=True) # just check
if cust2DPlots or plot_2D_param:
doprint('...producing 2D plots')
filename = rootdirname + '_2D.' + plot_ext
mc._writeScriptPlots2D(filename, plot_2D_param, cust2DPlots)
if make_plots:
runScript(filename)
if triangle_plot:
# Add the off-diagonal 2D plots
doprint('...producing triangle plot')
filename = rootdirname + '_tri.' + plot_ext
mc._writeScriptPlotsTri(filename, triangle_params)
if make_plots:
runScript(filename)
# Do 3D plots (i.e. 2D scatter plots with coloured points)
if num_3D_plots:
doprint('...producing ', num_3D_plots, '2D colored scatter plots')
filename = rootdirname + '_3D.' + plot_ext
mc._writeScriptPlots3D(filename, plot_3D)
if make_plots:
runScript(filename)
if not plots_only:
# Write out stats marginalized
mc.getMargeStats().saveAsText(rootdirname + '.margestats')
# Limits from global likelihood
if mc.loglikes is not None:
mc.getLikeStats().saveAsText(rootdirname + '.likestats')
# System command
if finish_run_command:
finish_run_command = finish_run_command.replace('%ROOTNAME%', rootname)
os.system(finish_run_command)
return "\n".join(result)
def initialize(self):
def relative_path(tag):
return ini.relativeFileName(tag).replace('data/', '').replace(
'Pantheon/', '')
# has_absdist = F, intrinsicdisp=0, idispdataset=False
if not self.path:
if self.path_install:
from importlib import import_module
self.path = getattr(
import_module(_package + ".likelihoods." + self.name,
package=_package),
"get_path")(self.path_install)
else:
self.log.error(
"No path given to the %s likelihood. Set the likelihood"
" property 'path' or the common property '%s'.",
self.dataset_file, _path_install)
raise HandledException
self.path = os.path.normpath(self.path)
self.dataset_file_path = os.path.normpath(
os.path.join(self.path, self.dataset_file))
self.log.info("Reading data from %s", self.dataset_file_path)
if not os.path.exists(self.dataset_file_path):
self.log.error(
"The likelihood is not installed in the given path: "
"cannot find the file '%s'.", self.dataset_file_path)
raise HandledException
ini = IniFile(self.dataset_file_path)
ini.params.update(self.dataset_params or {})
self.twoscriptmfit = ini.bool('twoscriptmfit')
if self.twoscriptmfit:
scriptmcut = ini.float('scriptmcut', 10.)
assert not ini.float('intrinsicdisp', 0) and not ini.float(
'intrinsicdisp0', 0)
if hasattr(self, "alpha_beta_names"):
self.alpha_name = self.alpha_beta_names[0]
self.beta_name = self.alpha_beta_names[1]
self.pecz = ini.float('pecz', 0.001)
cols = None
self.has_third_var = False
data_file = os.path.join(self.path, ini.string("data_file"))
self.log.debug('Reading %s' % data_file)
supernovae = {}
self.names = []
ix = 0
with io.open(data_file, 'r') as f:
lines = f.readlines()
for line in lines:
if '#' in line:
cols = line[1:].split()
for rename, new in zip([
'mb', 'color', 'x1', '3rdvar', 'd3rdvar',
'cov_m_s', 'cov_m_c', 'cov_s_c'
], [
'mag', 'colour', 'stretch', 'third_var',
'dthird_var', 'cov_mag_stretch', 'cov_mag_colour',
'cov_stretch_colour'
]):
if rename in cols:
cols[cols.index(rename)] = new
self.has_third_var = 'third_var' in cols
zeros = np.zeros(len(lines) - 1)
self.third_var = zeros.copy()
self.dthird_var = zeros.copy()
self.set = zeros.copy()
for col in cols:
setattr(self, col, zeros.copy())
elif line.strip():
if cols is None:
self.log.error('Data file must have comment header')
raise HandledException
vals = line.split()
for i, (col, val) in enumerate(zip(cols, vals)):
if col == 'name':
supernovae[val] = ix
self.names.append(val)
else:
getattr(self, col)[ix] = np.float64(val)
ix += 1
self.z_var = self.dz**2
self.mag_var = self.dmb**2
self.stretch_var = self.dx1**2
self.colour_var = self.dcolor**2
self.thirdvar_var = self.dthird_var**2
self.nsn = ix
self.log.debug('Number of SN read: %s ' % self.nsn)
if self.twoscriptmfit and not self.has_third_var:
self.log.error(
'twoscriptmfit was set but thirdvar information not present')
raise HandledException
if ini.bool('absdist_file'):
self.log.error('absdist_file not supported')
raise HandledException
covmats = [
'mag', 'stretch', 'colour', 'mag_stretch', 'mag_colour',
'stretch_colour'
]
self.covs = {}
for name in covmats:
if ini.bool('has_%s_covmat' % name):
self.log.debug('Reading covmat for: %s ' % name)
self.covs[name] = self._read_covmat(
os.path.join(self.path,
ini.string('%s_covmat_file' % name)))
self.alphabeta_covmat = (len(self.covs.items()) > 1
or self.covs.get('mag', None) is None)
self._last_alpha = np.inf
self._last_beta = np.inf
self.marginalize = getattr(self, "marginalize", False)
assert self.covs
# jla_prep
zfacsq = 25.0 / np.log(10.0)**2
self.pre_vars = self.mag_var + zfacsq * self.pecz**2 * (
(1.0 + self.zcmb) / (self.zcmb * (1 + 0.5 * self.zcmb)))**2
if self.twoscriptmfit:
A1 = np.zeros(self.nsn)
A2 = np.zeros(self.nsn)
A1[self.third_var <= scriptmcut] = 1
A2[self.third_var > scriptmcut] = 1
has_A1 = np.any(A1)
has_A2 = np.any(A2)
if not has_A1:
# swap
A1 = A2
A2 = np.zeros(self.nsn)
has_A2 = False
if not has_A2:
self.twoscriptmfit = False
self.A1 = A1
self.A2 = A2
if self.marginalize:
self.step_width_alpha = self.marginalize_params['step_width_alpha']
self.step_width_beta = self.marginalize_params['step_width_beta']
_marge_steps = self.marginalize_params['marge_steps']
self.alpha_grid = np.empty((2 * _marge_steps + 1)**2)
self.beta_grid = self.alpha_grid.copy()
_int_points = 0
for alpha_i in range(-_marge_steps, _marge_steps + 1):
for beta_i in range(-_marge_steps, _marge_steps + 1):
if alpha_i**2 + beta_i**2 <= _marge_steps**2:
self.alpha_grid[_int_points] = (
self.marginalize_params['alpha_centre'] +
alpha_i * self.step_width_alpha)
self.beta_grid[_int_points] = (
self.marginalize_params['beta_centre'] +
beta_i * self.step_width_beta)
_int_points += 1
self.log.debug('Marignalizing alpha, beta over %s points' %
_int_points)
self.marge_grid = np.empty(_int_points)
self.int_points = _int_points
self.alpha_grid = self.alpha_grid[:_int_points]
self.beta_grid = self.beta_grid[:_int_points]
self.invcovs = np.empty(_int_points, dtype=np.object)
if self.precompute_covmats:
for i, (alpha,
beta) in enumerate(zip(self.alpha_grid,
self.beta_grid)):
self.invcovs[i] = self.inverse_covariance_matrix(
alpha, beta)
elif not self.alphabeta_covmat:
self.inverse_covariance_matrix()
def main(args):
no_plots = False
chain_root = args.chain_root
if args.ini_file is None and chain_root is None:
doError('Must give either a .ini file of parameters or a chain file root name. Run "GetDist.py -h" for help.')
if not '.ini' in args.ini_file and chain_root is None:
# use default settings acting on chain_root, no plots
chain_root = args.ini_file
args.ini_file = getdist.default_getdist_settings
no_plots = True
if not os.path.isfile(args.ini_file):
doError('Parameter file does not exist: ' + args.ini_file)
if chain_root and chain_root.endswith('.txt'):
chain_root = chain_root[:-4]
# Input parameters
ini = IniFile(args.ini_file)
# File root
if chain_root is not None:
in_root = chain_root
else:
in_root = ini.params['file_root']
if not in_root:
doError('Chain Root file name not given ')
rootname = os.path.basename(in_root)
if args.ignore_rows is not None:
ignorerows = args.ignore_rows
else:
ignorerows = ini.float('ignore_rows', 0.0)
samples_are_chains = ini.bool('samples_are_chains', True)
paramnames = ini.string('parameter_names', '')
# Create instance of MCSamples
mc = MCSamples(in_root, files_are_chains=samples_are_chains, paramNamesFile=paramnames)
mc.initParameters(ini)
if ini.bool('adjust_priors', False) or ini.bool('map_params', False):
doError(
'To adjust priors or define new parameters, use a separate python script; see the python getdist docs for examples')
plot_ext = ini.string('plot_ext', 'py')
finish_run_command = ini.string('finish_run_command', '')
no_plots = ini.bool('no_plots', no_plots)
plots_only = ini.bool('plots_only', False)
no_tests = plots_only or ini.bool('no_tests', False)
thin_factor = ini.int('thin_factor', 0)
thin_cool = ini.float('thin_cool', 1.0)
make_single_samples = ini.bool('make_single_samples', False)
single_thin = ini.int('single_thin', 1)
cool = ini.float('cool', 1.0)
chain_exclude = ini.int_list('exclude_chain')
shade_meanlikes = ini.bool('shade_meanlikes', False)
plot_meanlikes = ini.bool('plot_meanlikes', False)
dumpNDbins = ini.bool('dump_ND_bins', False)
out_dir = ini.string('out_dir', './')
if out_dir:
if not os.path.isdir(out_dir):
os.mkdir(out_dir)
print('producing files in directory ', out_dir)
mc.out_dir = out_dir
out_root = ini.string('out_root', '')
if out_root:
rootname = out_root
print('producing files with with root ', out_root)
mc.rootname = rootname
rootdirname = os.path.join(out_dir, rootname)
mc.rootdirname = rootdirname
if 'do_minimal_1d_intervals' in ini.params:
doError('do_minimal_1d_intervals no longer used; set credible_interval_threshold instead')
line = ini.string('PCA_params', '')
if line.lower() == 'all':
PCA_params = mc.paramNames.list()
else:
PCA_params = line.split()
PCA_num = ini.int('PCA_num', len(PCA_params))
if PCA_num != 0:
if PCA_num < 2:
doError('Can only do PCA for 2 or more parameters')
PCA_func = ini.string('PCA_func', '')
# Characters representing functional mapping
if PCA_func == '':
PCA_func = ['N'] * PCA_num # No mapping
PCA_NormParam = ini.string('PCA_normparam', '') or None
make_scatter_samples = ini.bool('make_scatter_samples', False)
# ==============================================================================
first_chain = ini.int('first_chain', 0)
last_chain = ini.int('chain_num', -1)
# -1 means keep reading until one not found
# Chain files
chain_files = chains.chainFiles(in_root, first_chain=first_chain, last_chain=last_chain,
chain_exclude=chain_exclude)
mc.loadChains(in_root, chain_files)
mc.removeBurnFraction(ignorerows)
mc.deleteFixedParams()
mc.makeSingle()
def filterParList(namestring, num=None):
if not namestring.strip():
pars = mc.paramNames.list()
else:
pars = []
for name in namestring.split():
if '?' in name or '*' in name:
pars += mc.paramNames.getMatches(name, strings=True)
elif mc.paramNames.parWithName(name):
pars.append(name)
if num is not None and len(pars) != num:
print('%iD plot has missing parameter or wrong number of parameters: %s' % (num, pars))
pars = None
return pars
if cool != 1:
print('Cooling chains by ', cool)
mc.cool(cool)
mc.updateBaseStatistics()
if not no_tests:
mc.getConvergeTests(mc.converge_test_limit, writeDataToFile=True, feedback=True)
mc.writeCovMatrix()
mc.writeCorrelationMatrix()
# Output thinned data if requested
# Must do this with unsorted output
if thin_factor != 0:
thin_ix = mc.thin_indices(thin_factor)
filename = rootdirname + '_thin.txt'
mc.writeThinData(filename, thin_ix, thin_cool)
print(mc.getNumSampleSummaryText().strip())
if mc.likeStats: print(mc.likeStats.likeSummary().strip())
if PCA_num > 0 and not plots_only:
mc.PCA(PCA_params, PCA_func, PCA_NormParam, writeDataToFile=True)
if not no_plots or dumpNDbins:
# set plot_data_dir before we generate the 1D densities below
plot_data_dir = ini.string('plot_data_dir', default='', allowEmpty=True)
if plot_data_dir and not os.path.isdir(plot_data_dir):
os.mkdir(plot_data_dir)
else:
plot_data_dir = None
mc.plot_data_dir = plot_data_dir
# Do 1D bins
mc._setDensitiesandMarge1D(writeDataToFile=not no_plots and plot_data_dir, meanlikes=plot_meanlikes)
if not no_plots:
# Output files for 1D plots
print('Calculating plot data...')
plotparams = []
line = ini.string('plot_params', '')
if line not in ['', '0']:
plotparams = filterParList(line)
line = ini.string('plot_2D_param', '').strip()
plot_2D_param = None
if line and line != '0':
plot_2D_param = line
cust2DPlots = []
if not plot_2D_param:
# Use custom array of specific plots
num_cust2D_plots = ini.int('plot_2D_num', 0)
for i in range(1, num_cust2D_plots + 1):
line = ini.string('plot' + str(i))
pars = filterParList(line, 2)
if pars is not None:
cust2DPlots.append(pars)
else:
num_cust2D_plots -= 1
triangle_params = []
triangle_plot = ini.bool('triangle_plot', False)
if triangle_plot:
line = ini.string('triangle_params', '')
triangle_params = filterParList(line)
triangle_num = len(triangle_params)
triangle_plot = triangle_num > 1
num_3D_plots = ini.int('num_3D_plots', 0)
plot_3D = []
for ix in range(1, num_3D_plots + 1):
line = ini.string('3D_plot' + str(ix))
pars = filterParList(line, 3)
if pars is not None:
plot_3D.append(pars)
else:
num_3D_plots -= 1
# Produce file of weight-1 samples if requested
if (num_3D_plots and not make_single_samples or make_scatter_samples) and not no_plots:
make_single_samples = True
single_thin = max(1, int(round(mc.norm / mc.max_mult)) // mc.max_scatter_points)
if plot_data_dir:
if make_single_samples:
filename = os.path.join(plot_data_dir, rootname.strip() + '_single.txt')
mc.makeSingleSamples(filename, single_thin)
# Write paramNames file
mc.getParamNames().saveAsText(os.path.join(plot_data_dir, rootname + '.paramnames'))
mc.getBounds().saveToFile(os.path.join(plot_data_dir, rootname + '.bounds'))
make_plots = ini.bool('make_plots', False)
done2D = {}
filename = rootdirname + '.' + plot_ext
mc.writeScriptPlots1D(filename, plotparams)
if make_plots: runScript(filename)
# Do 2D bins
if plot_2D_param == 'corr':
# In this case output the most correlated variable combinations
print('...doing 2D plots for most correlated variables')
cust2DPlots = mc.getCorrelatedVariable2DPlots()
plot_2D_param = None
elif plot_2D_param:
mc.paramNames.parWithName(plot_2D_param, error=True) # just check
if cust2DPlots or plot_2D_param:
print('...producing 2D plots')
filename = rootdirname + '_2D.' + plot_ext
done2D = mc.writeScriptPlots2D(filename, plot_2D_param, cust2DPlots,
writeDataToFile=plot_data_dir, shade_meanlikes=shade_meanlikes)
if make_plots: runScript(filename)
if triangle_plot:
# Add the off-diagonal 2D plots
print('...producing triangle plot')
filename = rootdirname + '_tri.' + plot_ext
mc.writeScriptPlotsTri(filename, triangle_params)
for i, p2 in enumerate(triangle_params):
for p1 in triangle_params[i + 1:]:
if not done2D.get((p1, p2)) and plot_data_dir:
mc.get2DDensityGridData(p1, p2, writeDataToFile=True, meanlikes=shade_meanlikes)
if make_plots: runScript(filename)
# Do 3D plots (i.e. 2D scatter plots with coloured points)
if num_3D_plots:
print('...producing ', num_3D_plots, '2D colored scatter plots')
filename = rootdirname + '_3D.' + plot_ext
mc.writeScriptPlots3D(filename, plot_3D)
if make_plots: runScript(filename)
if not plots_only:
# Write out stats marginalized
mc.getMargeStats().saveAsText(rootdirname + '.margestats')
# Limits from global likelihood
if mc.loglikes is not None: mc.getLikeStats().saveAsText(rootdirname + '.likestats')
if dumpNDbins:
num_bins_ND = ini.int('num_bins_ND', 10)
line = ini.string('ND_params','')
if line not in ["",'0']:
ND_params = filterParList(line)
print(ND_params)
ND_dim=len(ND_params)
print(ND_dim)
mc.getRawNDDensityGridData(ND_params, writeDataToFile=True,
meanlikes=shade_meanlikes)
# System command
if finish_run_command:
finish_run_command = finish_run_command.replace('%ROOTNAME%', rootname)
finish_run_command = finish_run_command.replace('%PLOTDIR%', plot_data_dir)
finish_run_command = finish_run_command.replace('%PLOTROOT%', os.path.join(plot_data_dir, rootname))
os.system(finish_run_command)
def main(args):
no_plots = False
chain_root = args.chain_root
if args.ini_file is None and chain_root is None:
doError('Must give either a .ini file of parameters or a chain file root name. Run "GetDist.py -h" for help.')
if not ".ini" in args.ini_file and chain_root is None:
# use default settings acting on chain_root, no plots
chain_root = args.ini_file
args.ini_file = getdist.default_getdist_settings
no_plots = True
if not os.path.isfile(args.ini_file):
doError("Parameter file does not exist: " + args.ini_file)
if chain_root and chain_root.endswith(".txt"):
chain_root = chain_root[:-4]
# Input parameters
ini = IniFile(args.ini_file)
# File root
if chain_root is not None:
in_root = chain_root
else:
in_root = ini.params["file_root"]
if not in_root:
doError("Chain Root file name not given ")
rootname = os.path.basename(in_root)
if args.ignore_rows is not None:
ignorerows = args.ignore_rows
else:
ignorerows = ini.float("ignore_rows", 0.0)
samples_are_chains = ini.bool("samples_are_chains", True)
# Create instance of MCSamples
mc = MCSamples(in_root, files_are_chains=samples_are_chains)
mc.initParameters(ini)
if ini.bool("adjust_priors", False) or ini.bool("map_params", False):
doError(
"To adjust priors or define new parameters, use a separate python script; see the python getdist docs for examples"
)
plot_ext = ini.string("plot_ext", "py")
finish_run_command = ini.string("finish_run_command", "")
no_plots = ini.bool("no_plots", no_plots)
plots_only = ini.bool("plots_only", False)
no_tests = plots_only or ini.bool("no_tests", False)
thin_factor = ini.int("thin_factor", 0)
thin_cool = ini.float("thin_cool", 1.0)
make_single_samples = ini.bool("make_single_samples", False)
single_thin = ini.int("single_thin", 1)
cool = ini.float("cool", 1.0)
chain_exclude = ini.int_list("exclude_chain")
shade_meanlikes = ini.bool("shade_meanlikes", False)
plot_meanlikes = ini.bool("plot_meanlikes", False)
out_dir = ini.string("out_dir", "./")
if out_dir:
if not os.path.isdir(out_dir):
os.mkdir(out_dir)
print("producing files in directory ", out_dir)
mc.out_dir = out_dir
out_root = ini.string("out_root", "")
if out_root:
rootname = out_root
print("producing files with with root ", out_root)
mc.rootname = rootname
rootdirname = os.path.join(out_dir, rootname)
mc.rootdirname = rootdirname
if "do_minimal_1d_intervals" in ini.params:
doError("do_minimal_1d_intervals no longer used; set credible_interval_threshold instead")
line = ini.string("PCA_params", "")
if line.lower() == "all":
PCA_params = mc.paramNames.list()
else:
PCA_params = line.split()
PCA_num = ini.int("PCA_num", len(PCA_params))
if PCA_num != 0:
if PCA_num < 2:
doError("Can only do PCA for 2 or more parameters")
PCA_func = ini.string("PCA_func", "")
# Characters representing functional mapping
if PCA_func == "":
PCA_func = ["N"] * PCA_num # No mapping
PCA_NormParam = ini.string("PCA_normparam", "") or None
make_scatter_samples = ini.bool("make_scatter_samples", False)
# ==============================================================================
first_chain = ini.int("first_chain", 0)
last_chain = ini.int("chain_num", -1)
# -1 means keep reading until one not found
# Chain files
chain_files = chains.chainFiles(
in_root, first_chain=first_chain, last_chain=last_chain, chain_exclude=chain_exclude
)
mc.loadChains(in_root, chain_files)
mc.removeBurnFraction(ignorerows)
mc.deleteFixedParams()
mc.makeSingle()
def filterParList(namestring, num=None):
if not namestring.strip():
pars = mc.paramNames.list()
else:
pars = []
for name in namestring.split():
if "?" in name or "*" in name:
pars += mc.paramNames.getMatches(name, strings=True)
elif mc.paramNames.parWithName(name):
pars.append(name)
if num is not None and len(pars) != num:
raise Exception("%iD plot has missing parameter or wrong number of parameters: %s" % (num, pars))
return pars
if cool != 1:
print("Cooling chains by ", cool)
mc.cool(cool)
mc.updateBaseStatistics()
if not no_tests:
mc.getConvergeTests(mc.converge_test_limit, writeDataToFile=True, feedback=True)
mc.writeCovMatrix()
mc.writeCorrelationMatrix()
# Output thinned data if requested
# Must do this with unsorted output
if thin_factor != 0:
thin_ix = mc.thin_indices(thin_factor)
filename = rootdirname + "_thin.txt"
mc.writeThinData(filename, thin_ix, thin_cool)
print(mc.getNumSampleSummaryText().strip())
if mc.likeStats:
print(mc.likeStats.likeSummary().strip())
if PCA_num > 0 and not plots_only:
mc.PCA(PCA_params, PCA_func, PCA_NormParam, writeDataToFile=True)
if not no_plots:
# set plot_data_dir before we generate the 1D densities below
plot_data_dir = ini.string("plot_data_dir", default="", allowEmpty=True)
if plot_data_dir and not os.path.isdir(plot_data_dir):
os.mkdir(plot_data_dir)
else:
plot_data_dir = None
mc.plot_data_dir = plot_data_dir
# Do 1D bins
mc._setDensitiesandMarge1D(writeDataToFile=not no_plots and plot_data_dir, meanlikes=plot_meanlikes)
if not no_plots:
# Output files for 1D plots
print("Calculating plot data...")
plotparams = []
line = ini.string("plot_params", "")
if line not in ["", "0"]:
plotparams = filterParList(line)
line = ini.string("plot_2D_param", "").strip()
plot_2D_param = None
if line and line != "0":
plot_2D_param = line
cust2DPlots = []
if not plot_2D_param:
# Use custom array of specific plots
num_cust2D_plots = ini.int("plot_2D_num", 0)
for i in range(1, num_cust2D_plots + 1):
line = ini.string("plot" + str(i))
pars = filterParList(line, 2)
cust2DPlots.append(pars)
triangle_params = []
triangle_plot = ini.bool("triangle_plot", False)
if triangle_plot:
line = ini.string("triangle_params", "")
triangle_params = filterParList(line)
triangle_num = len(triangle_params)
triangle_plot = triangle_num > 1
num_3D_plots = ini.int("num_3D_plots", 0)
plot_3D = []
for ix in range(1, num_3D_plots + 1):
line = ini.string("3D_plot" + str(ix))
plot_3D.append(filterParList(line, 3))
# Produce file of weight-1 samples if requested
if (num_3D_plots and not make_single_samples or make_scatter_samples) and not no_plots:
make_single_samples = True
single_thin = max(1, int(round(mc.norm / mc.max_mult)) // mc.max_scatter_points)
if plot_data_dir:
if make_single_samples:
filename = os.path.join(plot_data_dir, rootname.strip() + "_single.txt")
mc.makeSingleSamples(filename, single_thin)
# Write paramNames file
mc.getParamNames().saveAsText(os.path.join(plot_data_dir, rootname + ".paramnames"))
mc.getBounds().saveToFile(os.path.join(plot_data_dir, rootname + ".bounds"))
make_plots = ini.bool("make_plots", False)
done2D = {}
filename = rootdirname + "." + plot_ext
mc.writeScriptPlots1D(filename, plotparams)
if make_plots:
runScript(filename)
# Do 2D bins
if plot_2D_param == "corr":
# In this case output the most correlated variable combinations
print("...doing 2D plots for most correlated variables")
cust2DPlots = mc.getCorrelatedVariable2DPlots()
plot_2D_param = None
elif plot_2D_param:
mc.paramNames.parWithName(plot_2D_param, error=True) # just check
if cust2DPlots or plot_2D_param:
print("...producing 2D plots")
filename = rootdirname + "_2D." + plot_ext
done2D = mc.writeScriptPlots2D(
filename, plot_2D_param, cust2DPlots, writeDataToFile=plot_data_dir, shade_meanlikes=shade_meanlikes
)
if make_plots:
runScript(filename)
if triangle_plot:
# Add the off-diagonal 2D plots
print("...producing triangle plot")
filename = rootdirname + "_tri." + plot_ext
mc.writeScriptPlotsTri(filename, triangle_params)
for i, p2 in enumerate(triangle_params):
for p1 in triangle_params[i + 1 :]:
if not done2D.get((p1, p2)) and plot_data_dir:
mc.get2DDensityGridData(p1, p2, writeDataToFile=True, meanlikes=shade_meanlikes)
if make_plots:
runScript(filename)
# Do 3D plots (i.e. 2D scatter plots with coloured points)
if num_3D_plots:
print("...producing ", num_3D_plots, "2D colored scatter plots")
filename = rootdirname + "_3D." + plot_ext
mc.writeScriptPlots3D(filename, plot_3D)
if make_plots:
runScript(filename)
if not plots_only:
# Write out stats marginalized
mc.getMargeStats().saveAsText(rootdirname + ".margestats")
# Limits from global likelihood
if mc.loglikes is not None:
mc.getLikeStats().saveAsText(rootdirname + ".likestats")
# System command
if finish_run_command:
finish_run_command = finish_run_command.replace("%ROOTNAME%", rootname)
finish_run_command = finish_run_command.replace("%PLOTDIR%", plot_data_dir)
finish_run_command = finish_run_command.replace("%PLOTROOT%", os.path.join(plot_data_dir, rootname))
os.system(finish_run_command)
def load_dataset(self, filename, dataset_params):
from getdist import IniFile
ini = IniFile(filename)
ini.params.update(dataset_params)
self.indices = []
self.used_indices = []
self.used_items = []
self.fullcov = np.loadtxt(ini.relativeFileName('cov_file'))
ntheta = ini.int('num_theta_bins')
self.theta_bins = np.loadtxt(ini.relativeFileName('theta_bins_file'))
self.iintrinsic_alignment_model = ini.string('intrinsic_alignment_model')
self.data_types = ini.string('data_types').split()
self.used_types = ini.list('used_data_types', self.data_types)
with open(ini.relativeFileName('data_selection')) as f:
header = f.readline()
assert ('# type bin1 bin2 theta_min theta_max' == header.strip())
lines = f.readlines()
ranges = {}
for tp in self.data_types:
ranges[tp] = np.empty((6, 6), dtype=object)
for line in lines:
items = line.split()
if items[0] in self.used_types:
bin1, bin2 = [int(x) - 1 for x in items[1:3]]
ranges[items[0]][bin1][bin2] = [np.float64(x) for x in items[3:]]
self.ranges = ranges
self.nzbins = ini.int('num_z_bins') # for lensing sources
self.nwbins = ini.int('num_gal_bins', 0) # for galaxies
maxbin = max(self.nzbins, self.nwbins)
cov_ix = 0
self.bin_pairs = []
self.data_arrays = []
self.thetas = []
for i, tp in enumerate(self.data_types):
xi = np.loadtxt(ini.relativeFileName('measurements[%s]' % tp))
bin1 = xi[:, 0].astype(np.int) - 1
bin2 = xi[:, 1].astype(np.int) - 1
tbin = xi[:, 2].astype(np.int) - 1
corr = np.empty((maxbin, maxbin), dtype=np.object)
corr[:, :] = None
self.data_arrays.append(corr)
self.bin_pairs.append([])
for f1, f2, ix, dat in zip(bin1, bin2, tbin, xi[:, 3]):
self.indices.append((i, f1, f2, ix))
if not (f1, f2) in self.bin_pairs[i]:
self.bin_pairs[i].append((f1, f2))
corr[f1, f2] = np.zeros(ntheta)
corr[f1, f2][ix] = dat
if ranges[tp][f1, f2] is not None:
mn, mx = ranges[tp][f1, f2]
if self.theta_bins[ix] > mn and self.theta_bins[ix] < mx:
self.thetas.append(self.theta_bins[ix])
self.used_indices.append(cov_ix)
self.used_items.append(self.indices[-1])
cov_ix += 1
nz_source = np.loadtxt(ini.relativeFileName('nz_file'))
self.zmid = nz_source[:, 1]
self.zbin_sp = []
for b in range(self.nzbins):
self.zbin_sp += [UnivariateSpline(self.zmid, nz_source[:, b + 3], s=0)]
nz_lens = np.loadtxt(ini.relativeFileName('nz_gal_file'))
assert (np.array_equal(nz_lens[:, 1], self.zmid))
self.zbin_w_sp = []
for b in range(self.nwbins):
self.zbin_w_sp += [UnivariateSpline(self.zmid, nz_lens[:, b + 3], s=0)]
self.zmax = self.zmid[-1]
self.kmax = ini.float('kmax', 15) # Actually computed, assumes extrapolated beyond that
self._initialize()
