def pystan2getdist(fit, texdict=texdict): """ convert a pystan fit object into an A Lewis MCSamples object texdict is a dictionary mapping from stan parameter names to latex labels, if desired """ ### have to either deal with combining chains (permute=False) ### or separating vector-valued parameters (permute=True) sample_dict = fit.extract(permuted=True) names = [] labels = [] samples = [] for par, samps in iteritems(sample_dict): if par == "lp__": loglikes = -samps else: if len(samps.shape)==1: names.append(par) labels.append(texdict.get(par,par)) samples.append(samps) else: for i,s in enumerate(samps.T): samples.append(s) names.append(par+str(i+1)) labels.append(texdict.get(par,par)+"_"+str(i+1)) return getdist.MCSamples(names=labels, samples=samples, loglikes=loglikes, labels=labels)
def __init__(self,str_or_dict,trueval=None,debug=False, names=None,labels=None,px='x',**kwargs): #Get the getdist MCSamples objects for the samples, specifying same parameter #names and labels; if not specified weights are assumed to all be unity if debug: logging.basicConfig(level=logging.DEBUG) self.logger = logging.getLogger(__name__) if isinstance(str_or_dict,str): fileroot=str_or_dict self.logger.info('string passed. Loading chain from '+fileroot) self.load_from_file(fileroot,**kwargs) elif isinstance(str_or_dict,dict): d=str_or_dict self.logger.info('Chain is passed as dict: keys='+','.join(d.keys())) chain=d['samples'] loglikes=d['loglikes'] weights=d['weights'] if 'weights' in d.keys() else np.ones(len(loglikes)) ndim=chain.shape[1] if names is None: names = ["%s%s"%('p',i) for i in range(ndim)] if labels is None: labels = ["%s_%s"%(px,i) for i in range(ndim)] self.names=names self.labels=labels self.trueval=trueval self.samples = gd.MCSamples(samples=chain, loglikes=loglikes, weights=weights, names = names, labels = labels) #Removes parameters that do not vary self.samples.deleteFixedParams() #Removes samples with zero weight #self.samples.filter(weights>0) else: self.logger.info('Passed first argument type is: ',type(str_or_dict)) self.logger.error('first argument to samples2getdist should be a string or dict.') raise # a copy of the weights that can be altered to # independently to the original weights self.adjusted_weights=np.copy(self.samples.weights) # self.nparamMC=self.samples.paramNames.numNonDerived()
def make_plot(chainfile, savefile, true_parameter_values=None, pnames=None, ranges=None): """Make a getdist plot""" samples = np.loadtxt(chainfile) ticks = {} if pnames is None: #Default emulator parameters pnames = [r"d\tau_0", r"\tau_0", r"n_s", r"A_\mathrm{P} \times 10^9", r"H_S", r"H_A", r"h"] samples[:,3] *= 1e9 true_parameter_values[3] *= 1e9 #Ticks we want to show for each parameter ticks = {pnames[3]: [1.5, 2.0, 2.5], pnames[4]: [-0.6,-0.3, 0.], pnames[5]: [0.5,0.7,1.0,1.3], pnames[6]: [0.66, 0.70, 0.74]} prange = None if ranges is not None: prange = {pnames[i] : ranges[i] for i in range(len(pnames))} posterior_MCsamples = gd.MCSamples(samples=samples, names=pnames, labels=pnames, label='', ranges=prange) print("Sim=",savefile) #Get and print the confidence limits for i in range(len(pnames)): strr = pnames[i]+" 1-sigma, 2-sigma: " for j in (0.16, 1-0.16, 0.025, 1-0.025): strr += str(round(posterior_MCsamples.confidence(i, j),5)) + " " print(strr) subplot_instance = gdp.getSubplotPlotter() subplot_instance.triangle_plot([posterior_MCsamples], filled=True) # colour_array = np.array(['black', 'red', 'magenta', 'green', 'green', 'purple', 'turquoise', 'gray', 'red', 'blue']) for pi in range(samples.shape[1]): for pi2 in range(pi + 1): #Place horizontal and vertical lines for the true point ax = subplot_instance.subplots[pi, pi2] ax.yaxis.label.set_size(16) ax.xaxis.label.set_size(16) if pi == samples.shape[1]-1 and pnames[pi2] in ticks: ax.set_xticks(ticks[pnames[pi2]]) if pi2 == 0 and pnames[pi] in ticks: ax.set_yticks(ticks[pnames[pi]]) ax.axvline(true_parameter_values[pi2], color='gray', ls='--', lw=2) if pi2 < pi: ax.axhline(true_parameter_values[pi], color='gray', ls='--', lw=2) #Plot the emulator points # if parameter_index > 1: # ax.scatter(simulation_parameters_latin[:, parameter_index2 - 2], simulation_parameters_latin[:, parameter_index - 2], s=54, color=colour_array[-1], marker='+') # legend_labels = ['+ Initial Latin hypercube'] # subplot_instance.add_legend(legend_labels, legend_loc='upper right', colored_text=True, figure=True) plt.savefig(savefile)
def plot_multicomp_velo_2corr(store, group_name, outname='velo_2corr', truths=None): group = store.hdf[group_name] ncomp = group.attrs['ncomp'] assert ncomp == 2 n_params = store.hdf.attrs['n_params'] post = group['posteriors'][...][:, :-2] # param values par_names = store.model.get_par_names(ncomp) ix_v = store.model.IX_VCEN ix_s = store.model.IX_SIGM par_labels = [''] * n_params * ncomp par_labels[ncomp * ix_v] = r'$v_\mathrm{lsr}\, (1) \ [\mathrm{km\,s^{-1}}]$' par_labels[ncomp * ix_v + 1] = r'$v_\mathrm{lsr}\, (2) \ [\mathrm{km\,s^{-1}}]$' par_labels[ncomp * ix_s] = r'$\sigma_\mathrm{v}\, (1) \ [\mathrm{km\,s^{-1}}]$' par_labels[ncomp * ix_s + 1] = r'$\sigma_\mathrm{v}\, (2) \ [\mathrm{km\,s^{-1}}]$' samples = getdist.MCSamples(samples=post, names=par_names, labels=par_labels, sampler='nested') samples.updateSettings({'contours': [0.68, 0.90]}) fig = gd_plt.get_subplot_plotter() x_names = ['v1', 's1'] y_names = ['v2', 's2'] if truths is not None: xmarkers = {k: truths[k] for k in x_names} ymarkers = {k: truths[k] for k in y_names} else: xmarkers, ymarkers = None, None fig.rectangle_plot(x_names, y_names, roots=samples, filled=True, line_args={ 'lw': 2, 'color': 'peru' }, xmarkers=xmarkers, ymarkers=ymarkers) fig.export(f'{outname}.pdf') plt.close('all')
def plot_corner(group, outname='corner', truths=None): ncomp = group.attrs['ncomp'] par_labels = ammonia.TEX_LABELS.copy() par_labels[3] = r'$\log(N) \ [\log(\mathrm{cm^{-2}})]$' n_params = group.attrs['n_params'] // ncomp names = ammonia.get_par_names() post = group['posteriors'][...][:, :-2] # posterior param values if truths is not None: markers = { p: truths[i * ncomp:(i + 1) * ncomp] for i, p in zip(range(n_params), ammonia.get_par_names()) } else: markers = None # Give each model component parameter set its own sampler object so that # each can be over-plotted in its own color. samples = [ getdist.MCSamples(samples=post[:, ii::ncomp], names=names, labels=par_labels, label=f'Component {ii+1}', name_tag=f'{ii}', sampler='nested') for ii in range(ncomp) ] [s.updateSettings({'contours': [0.68, 0.90]}) for s in samples] fig = gd_plt.get_subplot_plotter() fig.triangle_plot( samples, filled=True, line_args=[{ 'lw': 2, 'color': 'tab:orange' }, { 'lw': 2, 'color': 'tab:blue' }, { 'lw': 2, 'color': 'tab:green' }], markers=markers, ) fig.export(f'{outname}.pdf') plt.close('all')
def plot_corner(store, group_name, outname='corner', truths=None): n_params = store.hdf.attrs['n_params'] par_names = store.model.get_par_names() par_labels = store.hdf.attrs['tex_labels_with_units'] group = store.hdf[group_name] ncomp = group.attrs['ncomp'] post = group['posteriors'][...][:, :-2] # posterior param values if truths is not None: markers = { p: truths[i * ncomp:(i + 1) * ncomp] for i, p in zip(range(n_params), par_names) } else: markers = None # Give each model component parameter set its own sampler object so that # each can be over-plotted in its own color. samples = [ getdist.MCSamples(samples=post[:, ii::ncomp], names=par_names, labels=par_labels, label=f'Component {ii+1}', name_tag=f'{ii}', sampler='nested') for ii in range(ncomp) ] [s.updateSettings({'contours': [0.68, 0.90]}) for s in samples] fig = gd_plt.get_subplot_plotter() fig.triangle_plot( samples, filled=True, line_args=[{ 'lw': 2, 'color': 'tab:orange' }, { 'lw': 2, 'color': 'tab:blue' }, { 'lw': 2, 'color': 'tab:green' }], markers=markers, ) fig.export(f'{outname}.pdf') plt.close('all')
def __init__(self, chain, lnprob, trueval=None, names=None, labels=None, px='x'): #Get the getdist MCSamples objects for the samples, specifying same parameter #names and labels; if not specified weights are assumed to all be unity ndim = chain.shape[-1] if names is None: names = ["%s%s" % ('p', i) for i in range(ndim)] if labels is None: labels = ["%s_%s" % (px, i) for i in range(ndim)] self.names = names self.labels = labels self.trueval = trueval self.samples = gd.MCSamples(samples=chain, loglikes=lnprob, names=names, labels=labels)
def load_chain(chain_file, parameters=None, run_name=None, chain_format="cosmosis", parameter_map="cosmomc", strict_mapping=False, values=None, burn_in=0.3, keep_raw_samples=False, ignore_inf=False, extra_ranges=None, verbose=False): with open(chain_file, "r") as f: params = f.readline()[1:] if chain_format == "cosmosis": chain_params = [p.strip().lower() for p in params.split("\t")] if len(chain_params) == 1: chain_params = [p.strip().lower() for p in params.split(" ")] elif chain_format == "montepython": chain_params = [p.strip() for p in params.split(",")] else: raise ValueError(f"Chain format {chain_format} not supported.") parameter_names = [] parameter_names_latex = [] for p in chain_params: for mapping in parameter_dictionary.values(): if chain_format in mapping and mapping[chain_format] == p: parameter_names.append(mapping[parameter_map]) parameter_names_latex.append(mapping["latex"]) break else: if strict_mapping: raise MissingParameterError(f"Parameter {p} in chain does not have mapping to {parameter_map} format.") else: warnings.warn(f"Parameter {p} in chain does not have mapping to {parameter_map} format.") parameter_names.append(p) parameter_names_latex.append(p) raw_chain_parameter_names = parameter_names[:] column_idx = list(range(len(parameter_names))) stat_column_idx = {} # remove statistics columns for s in ["weight", "lnlike"]: s_map = parameter_dictionary[s][parameter_map] if s_map in parameter_names: stat_column_idx[s] = column_idx[parameter_names.index(s_map)] # remove statistic columns from parameter list for s, i in stat_column_idx.items(): del parameter_names[i] del parameter_names_latex[i] del column_idx[i] try: chain, log_Z, log_Z_err = load_nested_sampling_file(chain_file) nested_sampling = True except: chain = np.atleast_2d(np.loadtxt(chain_file)) n_sample = chain.shape[0] if isinstance(burn_in, float) and burn_in > 0.0 and burn_in < 1.0: chain = chain[int(n_sample*burn_in):] elif isinstance(burn_in, int): chain = chain[burn_in:] else: raise ValueError(f"Invalid burn_in value: {burn_in}") if verbose: print(f"Using {chain.shape[0]} samples out of {n_sample} in the chain.") nested_sampling = False if chain.size == 0: raise RuntimeError("No samples in file.") if values: if chain_format != "cosmosis" or parameter_map != "cosmomc": raise ValueError("Loading value files is only supported for cosmosis chains and cosmomc parameters.") sampled_params_ranges = get_sampled_params_and_ranges(values) cosmomc_names = cosmosis_to_cosmomc_param_names([(s,k) for s,k,_ in sampled_params_ranges]) ranges = {cosmomc_names[i] : sampled_params_ranges[i][2] for i in range(len(cosmomc_names)) if cosmomc_names[i] in parameter_names} else: ranges = {} extra_ranges = extra_ranges or {} ranges = {**ranges, **extra_ranges} if ignore_inf: if "lnlike" in stat_column_idx and np.any(~np.isfinite(chain[:,stat_column_idx["lnlike"]])): chain = chain[np.isfinite(chain[:,stat_column_idx["lnlike"]])] if "weight" in stat_column_idx and np.any(~np.isfinite(chain[:,stat_column_idx["weight"]])): chain = chain[np.isfinite(chain[:,stat_column_idx["weight"]])] run_name = run_name or os.path.split(chain_file)[1] samples = getdist.MCSamples(name_tag=run_name, samples=chain[:,column_idx], weights=chain[:,stat_column_idx["weight"]] if "weight" in stat_column_idx else None, loglikes=chain[:,stat_column_idx["lnlike"]] if "lnlike" in stat_column_idx else None, names=parameter_names, labels=parameter_names_latex, sampler="nested" if nested_sampling else None, ranges=ranges) if keep_raw_samples: samples.raw_chain_samples = chain samples.raw_chain_parameter_names = raw_chain_parameter_names if nested_sampling: samples.log_Z = log_Z samples.log_Z_err = log_Z_err else: samples.chain_offsets = [0, chain.shape[0]] return samples
h_0_cmb_samples[:, i, j], \ h_0_loc_samples[:, i, j]), 1) print rank, i, j, eff else: all_samples = np.genfromtxt('gw_grb_h_0_' + h_0_true_str + \ '_chain_' + \ '{:d}.csv'.format(j + 1), \ delimiter=',') h_0_samples[:, i, j] = all_samples[:, 0] h_0_cmb_samples[:, i, j] = all_samples[:, 1] h_0_loc_samples[:, i, j] = all_samples[:, 2] # process using GetDist. store means and interpolated probability # distributions gd_samples = gd.MCSamples(samples=all_samples, names=pars, labels=par_names, ranges=par_ranges) post_means.append(gd_samples.getMeans()) post_stds.append(np.sqrt(gd_samples.getVars())) p_h_0.append(gd_samples.get1DDensity('h_0')) p_h_0_cmb.append(gd_samples.get1DDensity('h_0_cmb')) p_h_0_loc.append(gd_samples.get1DDensity('h_0_loc')) # gather posteriors if use_mpi: mpi.COMM_WORLD.barrier() ln_prob = complete_array(ln_prob, use_mpi) ppd_cmb = complete_array(ppd_cmb, use_mpi) ppd_loc = complete_array(ppd_loc, use_mpi) if ppd_via_sampling: h_0_samples = complete_array(h_0_samples, use_mpi)
def make_single_plot(chainfile, savefile, chainfile2=None, pi1=0, pi2=3, true_parameter_values=None, ranges=None, string=True, burnin=10000): """Make a getdist plot""" ticks = {} if string: pnames = [ r"G\mu", r"\mathrm{StMBBH}", r"\mathrm{IMRI}", r"\mathrm{EMRI}" ] else: pnames = [ r"T_\ast", r"\mathrm{StMBBH}", r"\mathrm{IMRI}", r"\mathrm{EMRI}", r"\alpha" ] #, r"\beta"] prange = None if ranges is not None: prange = {pnames[i]: ranges[i] for i in range(len(pnames))} print("Sim=", savefile) subplot_instance = gdp.get_single_plotter() samples = np.loadtxt(chainfile) posterior_MCsamples = gd.MCSamples(samples=samples[burnin:], names=pnames, labels=pnames, label='', ranges=prange) if chainfile2 is not None: samples2 = np.loadtxt(chainfile2) posterior2 = gd.MCSamples(samples=samples2[burnin:], names=pnames, labels=pnames, label='', ranges=prange) subplot_instance.plot_2d([posterior_MCsamples, posterior2], pnames[pi1], pnames[pi2], filled=True) subplot_instance.add_legend(["LIGO+LISA", "LIGO+LISA+TianGo"]) else: subplot_instance.plot_2d([posterior_MCsamples], pnames[pi1], pnames[pi2], filled=True) # colour_array = np.array(['black', 'red', 'magenta', 'green', 'green', 'purple', 'turquoise', 'gray', 'red', 'blue']) #Ticks we want to show for each parameter if string: ticks = { pnames[0]: [ np.log(1e-17), np.log(2e-17), np.log(5e-17), np.log(1e-16), np.log(2e-16), np.log(5e-16), np.log(1e-15) ] } ticklabels = { pnames[0]: [ r"$10^{-17}$", r"$2\times 10^{-17}$", r"$5\times 10^{-17}$", r"$10^{-16}$", r"$2\times 10^{-16}$", r"$5\times 10^{-16}$", r"$10^{-15}$" ] } else: ticks = { pnames[0]: [ np.log(1e3), np.log(2e3), np.log(5e3), np.log(1e4), np.log(2e4), np.log(5e4) ] } #, np.log(1e6)]}#, np.log(1e11) #pnames[4]: [np.log(1e-4), np.log(1e-3), np.log(1e-2), np.log(0.1), 0]} ticklabels = { pnames[0]: [ r"$10^{3}$", r"$2\times 10^3$", r"$5\times 10^3$", r"$10^{4}$", r"$2\times 10^4$", r"$5\times 10^{4}$" ] } #, r"$10^{6}$"]}#, r"$10^{11}$"]}, #Place horizontal and vertical lines for the true point ax = subplot_instance.subplots[0, 0] ax.yaxis.label.set_size(16) ax.xaxis.label.set_size(16) if pnames[pi2] in ticks: ax.set_yticks(ticks[pnames[pi2]]) ax.set_yticklabels(ticklabels[pnames[pi2]]) if pnames[pi1] in ticks: ax.set_xticks(ticks[pnames[pi1]]) ax.set_xticklabels(ticklabels[pnames[pi1]]) ax.axhline(true_parameter_values[pi2], color='gray', ls='--', lw=2) ax.axvline(true_parameter_values[pi1], color='gray', ls='--', lw=2) plt.savefig(savefile)
result.posterior.iota, \ result.posterior.mass_ratio, \ result.posterior.lambda_2, \ result.posterior.lambda_tilde, \ result.posterior.chi_1, \ result.posterior.mass_2, \ result.posterior.mass_1_source, \ result.posterior.mass_2_source]).T samples.append(gd.MCSamples(samples=gd_samples, \ names=['a_1', 'mass_1', \ 'distance', 'iota', \ 'q', 'lambda_2', \ 'lambda_tilde', 'chi_1', \ 'mass_2', 'mass_1_source', \ 'mass_2_source'], \ labels=['a_1', r'm_{\rm BH}', \ distance_label, r'\iota', \ r'm_{\rm NS}/m_{\rm BH}', \ r'\Lambda_{\rm NS}', \ r'\tilde{\Lambda}', \ r'\chi_1', r'm_{\rm NS}', \ r'm_{\rm BH}^{\rm source}', \ r'm_{\rm NS}^{\rm source}'], \ ranges=gd_ranges, weights=weights)) else: gd_samples = np.array([result.posterior.a_1, \ result.posterior.mass_1, \ delta_distance, \ result.posterior.iota, \ result.posterior.mass_ratio, \ result.posterior.lambda_2, \ result.posterior.lambda_tilde, \
bgw_samples = np.array([bilby_samples['luminosity_distance'], \ bilby_m_bh, \ bilby_m_ns, \ bilby_samples['chirp_mass'], \ bilby_samples['mass_ratio']]).T _, m_min_ns_bgw = chirp_q_to_comp_masses(m_c_min, q_inv_min) _, m_max_ns_bgw = chirp_q_to_comp_masses(m_c_max, q_inv_max) m_min_bh_bgw, _ = chirp_q_to_comp_masses(m_c_min, q_inv_max) m_max_bh_bgw, _ = chirp_q_to_comp_masses(m_c_max, q_inv_min) # plot! smf_gds = gd.MCSamples(samples=smf_samples, \ names=['d', 'm_1', 'm_2', 'm_c', 'q_inv'], \ labels=[r'D_L', 'm_1', 'm_2', 'M_c', '1/q'], \ ranges={'d':(d_min, d_max), \ 'm_1':(m_min_bh, m_max_bh), \ 'm_2':(m_min_ns, m_max_ns), \ 'm_c':(m_c_min, m_c_max), \ 'q_inv':(q_inv_min, q_inv_max)}, \ label='SMF Priors') bgw_gds = gd.MCSamples(samples=bgw_samples, \ names=['d', 'm_1', 'm_2', 'm_c', 'q_inv'], \ labels=[r'D_L', 'm_1', 'm_2', 'M_c', '1/q'], \ ranges={'d':(d_min, d_max), \ 'm_1':(m_min_bh_bgw, m_max_bh_bgw), \ 'm_2':(m_min_ns_bgw, m_max_ns_bgw), \ 'm_c':(m_c_min, m_c_max), \ 'q_inv':(q_inv_min, q_inv_max)}, \ label='Bilby Priors') g = gdp.get_subplot_plotter() g.settings.lw_contour = lw
par_names = ['H_0', 'q_0'] par_vals = [h_0, q_0] par_ranges = {} if sample_rate: pars.append('gamma') par_names.append(r'\Gamma') par_vals.append(rate * 1.0e9) #par_ranges['gamma'] = (0.0, None) par_ranges['gamma'] = (10.0, 1000.0) if n_bar_det_post: pars.append('n_bar_det') par_names.append(r'\bar{N}_{\rm det}') par_vals.append(n_bar_det_fid) n_pars = len(pars) gd_samples = gd.MCSamples(samples=samples[:, 0:n_pars], names=pars, labels=par_names, ranges=par_ranges) g = gdp.getSubplotPlotter() g.settings.lw_contour = lw g.settings.axes_fontsize = 8 g.triangle_plot(gd_samples, pars, filled = True, \ line_args = {'lw': lw, 'color': 'C0'}, \ contour_args = {'lws': [lw, lw]}, \ colors = ['C0']) for i in range(0, n_pars): sp_title = '$' + gd_samples.getInlineLatex(pars[i], \ limit=1) + '$' g.subplots[i, i].set_title(sp_title, fontsize=12) for ax in g.subplots[i, :i]: ax.axhline(par_vals[i], color='gray', ls='--') ax.grid(False)
n_grid = 500 h_0_min_plot = 60.0 h_0_max_plot = 80.0 h_0_grid = np.linspace(h_0_min_plot, h_0_max_plot, n_grid) d_h_0 = h_0_grid[1] - h_0_grid[0] if ntlo: fig2d, ax2d = mp.subplots(figsize=(6, 5)) n_2d_grid = 40 q_0_min_plot = 1.0 q_0_max_plot = -2.0 h_0_grid_2d = np.linspace(h_0_min_plot, h_0_max_plot, n_2d_grid) q_0_grid_2d = np.linspace(q_0_min_plot, q_0_max_plot, n_2d_grid) h_0_mgrid, q_0_mgrid = np.meshgrid(h_0_grid_2d, q_0_grid_2d) for i in range(n_overlay): gd_samps = gd.MCSamples(samples=samples[..., i_map[i_plot[i]]], \ names=pars, labels=par_names, \ ranges=par_ranges) h_0_post = norm_dist(gd_samps.get1DDensity('h_0').Prob(h_0_grid), d_h_0) axes[0].plot(h_0_grid, h_0_post, color=cols[i], alpha=0.6) if ntlo: for i in range(n_overlay): gd_samps = gd.MCSamples(samples=samples[..., i_map[i_plot[i]]], \ names=pars, labels=par_names, \ ranges=par_ranges) hq_post = gd_samps.get2DDensity('h_0', 'q_0') hq_post = hq_post.Prob(h_0_mgrid.flatten(), q_0_mgrid.flatten()) hq_post = hq_post.reshape(n_2d_grid, n_2d_grid) #mp.contour(h_0_grid_2d, q_0_grid_2d, hq_post, \ # levels=[np.exp(-2.0), np.exp(-0.5)], \ # colors=[cols[i]], linestyles=['dashed', 'solid'], \ # alpha=0.6)
def make_plot(chainfile, savefile, chainfile2=None, chainfile3=None, true_parameter_values=None, ranges=None, string=True, burnin=10000): """Make a getdist plot""" ticks = {} if string: pnames = [ r"G\mu", r"\mathrm{StMBBH}", r"\mathrm{IMRI}", r"\mathrm{EMRI}" ] else: pnames = [ r"T_\ast", r"\mathrm{StMBBH}", r"\mathrm{IMRI}", r"\mathrm{EMRI}", r"\alpha" ] #, r"\beta"] prange = None if ranges is not None: prange = {pnames[i]: ranges[i] for i in range(len(pnames))} samples = np.loadtxt(chainfile) posterior_MCsamples = gd.MCSamples(samples=samples[burnin:], names=pnames, labels=pnames, label='LIGO+LISA', ranges=prange) print("Sim=", savefile) #Get and print the confidence limits for i, pn in enumerate(pnames): strr = pn + " 1-sigma, 2-sigma: " for j in (0.16, 1 - 0.16, 0.025, 1 - 0.025): post = posterior_MCsamples.confidence(i, j) if pn == r"G\mu": post = np.exp(post) strr += " %g" % post print(strr) subplot_instance = gdp.getSubplotPlotter() if chainfile2 is not None: samples2 = np.loadtxt(chainfile2) posterior_MCsamples2 = gd.MCSamples(samples=samples2[burnin:], names=pnames, labels=pnames, label='LIGO+LISA+TianGo', ranges=prange) if chainfile3 is not None: samples3 = np.loadtxt(chainfile3) posterior_MCsamples3 = gd.MCSamples(samples=samples3[burnin:], names=pnames, labels=pnames, label='LIGO+LISA+DECIGO', ranges=prange) subplot_instance.triangle_plot([ posterior_MCsamples3, posterior_MCsamples2, posterior_MCsamples ], filled=True, legend_loc="right") else: subplot_instance.triangle_plot( [posterior_MCsamples, posterior_MCsamples2], filled=True, legend_loc="right") else: subplot_instance.triangle_plot([posterior_MCsamples], filled=True) # colour_array = np.array(['black', 'red', 'magenta', 'green', 'green', 'purple', 'turquoise', 'gray', 'red', 'blue']) #Ticks we want to show for each parameter if string: if ranges[0][0] < np.log(1e-18): ticks = {pnames[0]: [np.log(1e-20), np.log(1e-17), np.log(1e-15)]} ticklabels = { pnames[0]: [r"$10^{-20}$", r"$10^{-17}$", r"$10^{-15}$"] } else: ticks = {pnames[0]: [np.log(1e-17), np.log(1e-16), np.log(1e-15)]} ticklabels = { pnames[0]: [r"$10^{-17}$", r"$10^{-16}$", r"$10^{-15}$"] } else: if ranges[0][0] > 1e6: ticks = { pnames[0]: [np.log(1e2), np.log(1e4), np.log(1e6)] } #, np.log(1e11) #pnames[4]: [np.log(1e-4), np.log(1e-3), np.log(1e-2), np.log(0.1), 0]} ticklabels = { pnames[0]: [r"$10^{2}$", r"$10^{4}$", r"$10^{6}$"] } #, r"$10^{11}$"]}, #pnames[4]: [r"$10^{-4}$", r"$10^{-3}$", r"$0.01$", r"$0.1$", r"$1.0$"]} else: ticks = { pnames[0]: [np.log(1e2), np.log(1e4)] } #, np.log(1e6)]}#, np.log(1e11) #pnames[4]: [np.log(1e-4), np.log(1e-3), np.log(1e-2), np.log(0.1), 0]} ticklabels = { pnames[0]: [r"$10^{2}$", r"$10^{4}$"] } #, r"$10^{6}$"]}#, r"$10^{11}$"]}, if np.isnan(true_parameter_values[0]): ax = subplot_instance.subplots[0, 0] ax.set_visible(False) for pi in range(samples.shape[1]): for pi2 in range(pi + 1): #Place horizontal and vertical lines for the true point ax = subplot_instance.subplots[pi, pi2] ax.yaxis.label.set_size(16) ax.xaxis.label.set_size(16) if pi == samples.shape[1] - 1 and pnames[pi2] in ticks: ax.set_xticks(ticks[pnames[pi2]]) ax.set_xticklabels(ticklabels[pnames[pi2]]) if pi2 == 0 and pnames[pi] in ticks: ax.set_yticks(ticks[pnames[pi]]) ax.set_yticklabels(ticklabels[pnames[pi]]) if not np.isnan(true_parameter_values[pi2]): ax.axvline(true_parameter_values[pi2], color='gray', ls='--', lw=2) if pi2 < pi: if not np.isnan(true_parameter_values[pi]): ax.axhline(true_parameter_values[pi], color='gray', ls='--', lw=2) plt.savefig(savefile)
i_det = np.array([75, 86, 93]) i_det = np.argwhere(det)[i_det, 0] i_plot = np.append(i_det, i_det + n_pars / 2) plot_samples = gw_samples[:, i_plot] gd_names = ['d_{:d}'.format(j) for j in range(n_plot)] + \ ['c_{:d}'.format(j) for j in range(n_plot)] gd_labels = [r'D\,({\rm Mpc})'] * n_plot + \ [r'\cos\iota'] * n_plot gd_pairs = [['d_{:d}'.format(j), 'i_{:d}'.format(j)] \ for j in range(n_plot)] gd_limits = merge_dicts({'d_{:d}'.format(j): (0.0, d_max) \ for j in range(n_plot)}, \ {'c_{:d}'.format(j): (-1.0, 1.0) \ for j in range(n_plot)}) gd_samples = gd.MCSamples(samples=plot_samples, \ names=gd_names, \ labels=gd_labels, \ ranges=gd_limits) for j in range(n_plot): gd_name = 'i_{:d}'.format(j) gd_label = r'\iota\,(\degree)' c_j = gw_samples[:, i_plot[j] + n_pars / 2] gd_samples.addDerived(np.arccos(c_j) * 180.0 / np.pi, \ name=gd_name, label=gd_label) gd_samples.setRanges({'i_{:d}'.format(j):(0.0, 180.0)}) gd_samples.updateBaseStatistics() g = gdp.getSubplotPlotter(subplot_size=3) g.settings.lw_contour = lw g.plots_2d(gd_samples, param_pairs=gd_pairs, \ nx=3, filled=True, \ colors=[mpc.rgb2hex(cols[2])]) axes = g.subplots.flatten()
samples.append(None) continue if aligned_spins: gd_samples = np.array([result.posterior.a_1, \ result.posterior.mass_1, \ delta_distance, \ result.posterior.iota, \ result.posterior.mass_ratio, \ result.posterior.lambda_2, \ result.posterior.lambda_tilde, \ result.posterior.chi_1]).T samples.append(gd.MCSamples(samples=gd_samples, \ names=['a_1', 'mass_1', \ 'distance', 'iota', \ 'q', 'lambda_2', \ 'lambda_tilde', 'chi_1'], \ labels=['|a|_1', r'M_{\rm BH}', \ distance_label, r'\iota', \ 'm_2/m_1', r'\Lambda_{\rm NS}', \ r'\tilde{\Lambda}', r'\chi_1'], \ ranges=gd_ranges)) else: gd_samples = np.array([result.posterior.a_1, \ result.posterior.mass_1, \ delta_distance, \ result.posterior.iota, \ result.posterior.mass_ratio, \ result.posterior.lambda_2, \ result.posterior.lambda_tilde]).T samples.append(gd.MCSamples(samples=gd_samples, \ names=['a_1', 'mass_1', \ 'distance', 'iota', \
n_dims = 14 multinest_samples = np.loadtxt(args.multinest_dir + '.txt') multinest_weights = multinest_samples[:, 0] multinest_lnL = multinest_samples[:, 1] # this is actually -2.0*lnL ! multinest_params = multinest_samples[:, 2:2 + n_dims] multinest_ppd = multinest_samples[:, 2 + n_dims:] multinest_chisqs = multinest_ppd[:, -1] multinest_modelvecs = multinest_ppd[:, :-1] multinest_wps, multinest_deltasigmas = np.split(multinest_modelvecs, 2, axis=1) samples = getdist.MCSamples(samples=multinest_samples, weights=multinest_weights, loglikes=multinest_lnL) ## read datavector rmin_mock, rmax_mock, _, wp_mock = np.loadtxt( '../../lowz_mocks/data/lowz_corr.wp.txt', unpack=True) rmin_mock, rmax_mock, _, ds_mock = np.loadtxt( '../../lowz_mocks/data/lowz_corr.ds.txt', unpack=True) # rmin_mock, rmax_mock, _, wp_mock = np.loadtxt('../../lowz_mocks/data/lowz_corr_blinded.wp.txt', # unpack=True) # rmin_mock, rmax_mock, _, ds_mock = np.loadtxt('../../lowz_mocks/data/lowz_corr_blinded.ds.txt', # unpack=True) r_mock = 0.5 * (rmin_mock + rmax_mock)
test = result.posterior except ValueError: skip[i] = True samples.append(None) print('run', i, 'incomplete') continue gd_samples = np.array([result.posterior.lambda_2, \ result.posterior.a_1, \ result.posterior.iota, \ result.posterior.mass_ratio, \ result.posterior.chirp_mass]).T samples.append(gd.MCSamples(samples=gd_samples, \ names=['lambda_2', 'a_1', 'iota', \ 'q', 'm_c'], \ labels=[r'\Lambda_{\rm NS}', 'a_1', \ r'\iota', 'm_2/m_1', \ r'\mathcal{M}_{\rm c}'], \ ranges={'a_1':(0.0, 0.8), \ 'iota':(0.0, np.pi), \ 'q':(0.02, 0.6), \ 'lambda_2':(0.0, 4000.0)})) # snr-ordered colouring n_targets = len(samples) cm = mpcm.get_cmap('plasma') cols = [mpc.rgb2hex(cm(x)) for x in np.linspace(0.2, 0.8, n_targets)[::-1]] # generate figure and axes n_col = 5 n_row = 8 fig, axes = mp.subplots(n_row, n_col, figsize=(20, 30)) g = gdp.get_single_plotter()
def main(args): log_roots = glob.glob(args.root) if args.dim != 0: x_dims = [args.dim] else: x_dims = range(2, 50) for log_root in log_roots: print() print('------------------------') print(log_root) print('------------------------') print() # Find log_dim_dirs = [[] for _ in x_dims] for ix, x_dim in enumerate(x_dims): for log_dir in glob.glob(os.path.join(log_root, 'run*')): if os.path.exists(os.path.join(log_dir, 'info', 'params.txt')): with open(os.path.join(log_dir, 'info', 'params.txt')) as f: data = json.load(f) if int(data['x_dim']) == x_dim: log_dim_dirs[ix].append(log_dir) for ix, log_dim_dir in enumerate(log_dim_dirs): logzs = [] dlogzs = [] nlikes = [] ess = [] if len(log_dim_dir) > 0: print() print('--------') print('Dim: %s' % x_dims[ix]) print('--------') print() for log_dir in log_dim_dir: with open(os.path.join(log_dir, 'info', 'params.txt')) as f: data = json.load(f) if os.path.exists(os.path.join(log_dir, 'chains', 'chain.txt')): names = ['p%i' % i for i in range(int(data['x_dim']))] labels = [r'x_{%i}' % i for i in range(int(data['x_dim']))] files = getdist.chains.chainFiles( os.path.join(log_dir, 'chains', 'chain.txt')) if data['sampler'] == 'nested': mc = getdist.MCSamples(os.path.join( log_dir, 'chains', 'chain.txt'), names=names, labels=labels, ignore_rows=0.0, sampler='nested') else: mc = getdist.MCSamples(os.path.join( log_dir, 'chains', 'chain.txt'), names=names, labels=labels, ignore_rows=0.3) mc.readChains(files) if args.feedback > 0: print(mc.getMargeStats()) if args.plot: g = getdist.plots.getSubplotPlotter() g.triangle_plot(mc, filled=True) g.export( os.path.join( os.path.join(log_dir, 'plots', 'triangle.png'))) if data['sampler'] == 'nested': if os.path.exists( os.path.join(log_dir, 'results', 'final.csv')): results = pd.read_csv( os.path.join(log_dir, 'results', 'final.csv')) print(results) logzs.append(results['logz']) dlogzs.append(results['logzerr']) nlikes.append(results['ncall']) ess.append( np.sum(mc.weights)**2 / np.sum(mc.weights**2)) if len(logzs) > 1: print() print('Num runs: %s' % (len(logzs))) print(r'Log Z: $%4.2f \pm %4.2f$' % (np.mean(logzs), np.std(logzs))) print(r'Log Z error estimate: $%4.2f \pm %4.2f$' % (np.mean(dlogzs), np.std(dlogzs))) print(r'N_like: $%.0f \pm %.0f$' % (np.mean(nlikes), np.std(nlikes))) print(r'Posterior ESS: $%.0f \pm %.0f$' % (np.mean(ess), np.std(ess)))