def test_reload(backend):
with backend() as backend1:
run_sampler(backend1)
# Test the state
state = backend1.random_state
np.random.set_state(state)
# Load the file using a new backend object.
if backend == backends.TempHDFBackend:
backend2 = backends.HDFBackend(backend1.filename, backend1.name,
read_only=True)
elif backend == backends.TempFITSBackend:
backend2 = backends.FITSBackend(backend1.filename,
backend1.pickle_filename,
read_only=True)
else:
assert False
with pytest.raises(RuntimeError):
backend2.reset(32, 3)
assert state[0] == backend2.random_state[0]
assert all(np.allclose(a, b)
for a, b in zip(state[1:], backend2.random_state[1:]))
# Check all of the components.
for k in ["chain", "log_prob"]:
a = backend1.get_value(k)
b = backend2.get_value(k)
assert np.allclose(a, b), "inconsistent {0}".format(k)
a = backend1.accepted
b = backend2.accepted
assert np.allclose(a, b), "inconsistent accepted"
def test_hdf_reload():
with backends.hdf.TempHDFBackend() as backend1:
run_sampler(backend1)
# Test the state
state = backend1.random_state
np.random.set_state(state)
# Load the file using a new backend object.
backend2 = backends.HDFBackend(backend1.filename, backend1.name)
assert state[0] == backend2.random_state[0]
assert all(
np.allclose(a, b)
for a, b in zip(state[1:], backend2.random_state[1:]))
# Check all of the components.
for k in ["chain", "log_prob"]:
a = backend1.get_value(k)
b = backend2.get_value(k)
assert np.allclose(a, b), "inconsistent {0}".format(k)
a = backend1.accepted
b = backend2.accepted
assert np.allclose(a, b), "inconsistent accepted"
def test_uninit(tmpdir):
fn = str(tmpdir.join("EMCEE_TEST_FILE_DO_NOT_USE.h5"))
if os.path.exists(fn):
os.remove(fn)
with backends.HDFBackend(fn) as be:
run_sampler(be)
assert os.path.exists(fn)
os.remove(fn)
def get_inference_data_reader(self, **kwargs):
from emcee import backends # pylint: disable=no-name-in-module
here = os.path.dirname(os.path.abspath(__file__))
data_directory = os.path.join(here, "..", "saved_models")
filepath = os.path.join(data_directory, "reader_testfile.h5")
assert os.path.exists(filepath)
assert os.path.getsize(filepath)
reader = backends.HDFBackend(filepath, read_only=True)
return from_emcee(reader, **kwargs)
def test_multi_hdf5():
with backends.TempHDFBackend() as backend1:
run_sampler(backend1)
backend2 = backends.HDFBackend(backend1.filename, name="mcmc2")
run_sampler(backend2)
chain2 = backend2.get_chain()
with h5py.File(backend1.filename, "r") as f:
assert set(f.keys()) == {backend1.name, "mcmc2"}
backend1.reset(10, 2)
assert np.allclose(backend2.get_chain(), chain2)
with pytest.raises(AttributeError):
backend1.get_chain()
def test_reload(backend, dtype):
with backend() as backend1:
run_sampler(backend1, dtype=dtype)
# Test the state
state = backend1.random_state
np.random.set_state(state)
# Load the file using a new backend object.
backend2 = backends.HDFBackend(backend1.filename,
backend1.name,
read_only=True)
with pytest.raises(RuntimeError):
backend2.reset(32, 3)
assert state[0] == backend2.random_state[0]
assert all(
np.allclose(a, b)
for a, b in zip(state[1:], backend2.random_state[1:]))
# Check all of the components.
for k in ["chain", "log_prob", "blobs"]:
a = backend1.get_value(k)
b = backend2.get_value(k)
_custom_allclose(a, b)
last1 = backend1.get_last_sample()
last2 = backend2.get_last_sample()
assert np.allclose(last1.coords, last2.coords)
assert np.allclose(last1.log_prob, last2.log_prob)
assert all(
np.allclose(l1, l2)
for l1, l2 in zip(last1.random_state[1:], last2.random_state[1:]))
_custom_allclose(last1.blobs, last2.blobs)
a = backend1.accepted
b = backend2.accepted
assert np.allclose(a, b), "inconsistent accepted"
guess = [
0.2522, 0.0964, 0.1997, 0.0101, 16.8852, 0.1311, 0.1776, 0.01, 0.1194,
0.0019, 0.0135, 5000., 1000.
]
params0 = np.tile(guess, nwalk).reshape(nwalk, 13)
params0[:, :11] += np.random.rand(nwalk, 11) * 0.01 # Perturb Model Parameters
params0.T[11] += np.random.rand(nwalk) * 500 # Perturb E0
params0.T[12] += np.random.rand(nwalk) * 100 # Perturb I0
params0 = np.absolute(params0) # ...and force >= 0
# Set up the backend
# Don't forget to clear it in case the file already exists
from emcee import backends
filename = "backend.h5"
backend = backends.HDFBackend(filename)
backend.reset(nwalk, 13)
print("\nInitializing the sampler and burning in walkers")
s = EnsembleSampler(nwalk, params0.shape[-1], bre, backend=backend)
#pos, prob, state = s.run_mcmc(params0, 1000, progress=True)
#s.reset()
print("\nSampling the posterior density for the problem")
#s.run_mcmc(pos, 20000, progress=True)
#print("Mean acceptance fraction: {0:.3f}".format(np.mean(s.acceptance_fraction)))
#print("Mean autocorrelation time: {0:.3f} steps".format(np.mean(s.get_autocorr_time())))
#
#convergence-based MCMC
#
max_n = 1000000
def measure_spf_errors(yaml_file_str,
Number_rand_mcmc,
Norm_90_inplot=1.,
save=False):
"""
take a set of scatt angles and a set of HG parameter and return
the log of a 2g HG SPF (usefull to fit from a set of points)
Args:
yaml_file_str: name of the yaml_ parameter file
Number_rand_mcmc: number of randomnly selected psf we use to
plot the error bars
Norm_90_inplot: the value at which you want to normalize the spf
in the plot ay 90 degree (to re-measure the error
bars properly)
Returns:
a dic that contains the 'best_spf', 'errorbar_sup',
'errorbar_sup', 'errorbar'
"""
with open(os.path.join('initialization_files', yaml_file_str + '.yaml'),
'r') as yaml_file:
params_mcmc_yaml = yaml.load(yaml_file, Loader=yaml.FullLoader)
dico_return = dict()
nwalkers = params_mcmc_yaml['NWALKERS']
n_dim_mcmc = params_mcmc_yaml['N_DIM_MCMC']
datadir = os.path.join(basedir, params_mcmc_yaml['BAND_DIR'])
mcmcresultdir = os.path.join(datadir, 'results_MCMC')
file_prefix = params_mcmc_yaml['FILE_PREFIX']
SPF_MODEL = params_mcmc_yaml['SPF_MODEL'] #Type of description for the SPF
name_h5 = file_prefix + "_backend_file_mcmc"
chain_name = os.path.join(mcmcresultdir, name_h5 + ".h5")
reader = backends.HDFBackend(chain_name)
#we only exctract the last itearations, assuming it converged
chain_flat = reader.get_chain(discard=0, flat=True)
burnin = np.clip(reader.iteration - 10 * Number_rand_mcmc // nwalkers, 0,
None)
chain_flat = reader.get_chain(discard=burnin, flat=True)
if (SPF_MODEL == 'hg_1g'):
norm_chain = np.exp(chain_flat[:, 7])
g1_chain = chain_flat[:, 8]
bestmodel_Norm = np.percentile(norm_chain, 50)
bestmodel_g1 = np.percentile(g1_chain, 50)
Normalization = Norm_90_inplot
if save == True:
Normalization = bestmodel_Norm
best_hg_mcmc = hg_1g(scattered_angles, bestmodel_g1, Normalization)
elif SPF_MODEL == 'hg_2g':
norm_chain = np.exp(chain_flat[:, 7])
g1_chain = chain_flat[:, 8]
g2_chain = chain_flat[:, 9]
alph1_chain = chain_flat[:, 10]
bestmodel_Norm = np.percentile(norm_chain, 50)
bestmodel_g1 = np.percentile(g1_chain, 50)
bestmodel_g2 = np.percentile(g2_chain, 50)
bestmodel_alpha1 = np.percentile(alph1_chain, 50)
Normalization = Norm_90_inplot
if save == True:
Normalization = bestmodel_Norm
best_hg_mcmc = hg_2g(scattered_angles, bestmodel_g1, bestmodel_g2,
bestmodel_alpha1, Normalization)
elif SPF_MODEL == 'hg_3g':
# temporary, the 3g is not finish so we remove some of the
# chains that are obvisouly bad. When 3g is finally converged,
# we removed that
# incl_chain = np.degrees(np.arccos(chain_flat[:, 3]))
# where_incl_is_ok = np.where(incl_chain > 76)
# norm_chain = np.exp(chain_flat[where_incl_is_ok, 7]).flatten()
# g1_chain = chain_flat[where_incl_is_ok, 8].flatten()
# g2_chain = chain_flat[where_incl_is_ok, 9].flatten()
# alph1_chain = chain_flat[where_incl_is_ok, 10].flatten()
# g3_chain = chain_flat[where_incl_is_ok, 11].flatten()
# alph2_chain = chain_flat[where_incl_is_ok, 12].flatten()
# log_prob_samples_flat = reader.get_log_prob(discard=burnin,
# flat=True)
# log_prob_samples_flat = log_prob_samples_flat[where_incl_is_ok]
# wheremin = np.where(
# log_prob_samples_flat == np.max(log_prob_samples_flat))
# wheremin0 = np.array(wheremin).flatten()[0]
# bestmodel_g1 = g1_chain[wheremin0]
# bestmodel_g2 = g2_chain[wheremin0]
# bestmodel_g3 = g3_chain[wheremin0]
# bestmodel_alpha1 = alph1_chain[wheremin0]
# bestmodel_alpha2 = alph2_chain[wheremin0]
# bestmodel_Norm = norm_chain[wheremin0]
norm_chain = np.exp(chain_flat[:, 7])
g1_chain = chain_flat[:, 8]
g2_chain = chain_flat[:, 9]
alph1_chain = chain_flat[:, 10]
g3_chain = chain_flat[:, 11]
alph2_chain = chain_flat[:, 12]
bestmodel_Norm = np.percentile(norm_chain, 50)
bestmodel_g1 = np.percentile(g1_chain, 50)
bestmodel_g2 = np.percentile(g2_chain, 50)
bestmodel_alpha1 = np.percentile(alph1_chain, 50)
bestmodel_g3 = np.percentile(g3_chain, 50)
bestmodel_alpha2 = np.percentile(alph2_chain, 50)
Normalization = Norm_90_inplot
# we normalize the best model at 90 either by the value found
# by the MCMC if we want to save or by the value in the
# Norm_90_inplot if we want to plot
Normalization = Norm_90_inplot
if save == True:
Normalization = bestmodel_Norm
best_hg_mcmc = hg_3g(scattered_angles, bestmodel_g1, bestmodel_g2,
bestmodel_g3, bestmodel_alpha1, bestmodel_alpha2,
Normalization)
dico_return['best_spf'] = best_hg_mcmc
random_param_number = np.random.randint(1,
len(g1_chain) - 1,
Number_rand_mcmc)
if (SPF_MODEL == 'hg_1g') or (SPF_MODEL == 'hg_2g') or (SPF_MODEL
== 'hg_3g'):
g1_rand = g1_chain[random_param_number]
norm_rand = norm_chain[random_param_number]
if (SPF_MODEL == 'hg_2g') or (SPF_MODEL == 'hg_3g'):
g2_rand = g2_chain[random_param_number]
alph1_rand = alph1_chain[random_param_number]
if SPF_MODEL == 'hg_3g':
g3_rand = g3_chain[random_param_number]
alph2_rand = alph2_chain[random_param_number]
hg_mcmc_rand = np.zeros((len(best_hg_mcmc), len(random_param_number)))
errorbar_sup = scattered_angles * 0.
errorbar_inf = scattered_angles * 0.
errorbar = scattered_angles * 0.
for num_model in range(Number_rand_mcmc):
norm_here = norm_rand[num_model]
# we normalize the random SPF at 90 either by the value of
# the SPF by the MCMC if we want to save or around the
# Norm_90_inplot if we want to plot
Normalization = norm_here * Norm_90_inplot / bestmodel_Norm
if save == True:
Normalization = norm_here
if (SPF_MODEL == 'hg_1g'):
g1_here = g1_rand[num_model]
if (SPF_MODEL == 'hg_2g'):
g1_here = g1_rand[num_model]
g2_here = g2_rand[num_model]
alph1_here = alph1_rand[num_model]
hg_mcmc_rand[:,
num_model] = hg_2g(scattered_angles, g1_here, g2_here,
alph1_here, Normalization)
if SPF_MODEL == 'hg_3g':
g3_here = g3_rand[num_model]
alph2_here = alph2_rand[num_model]
hg_mcmc_rand[:, num_model] = hg_3g(scattered_angles, g1_here,
g2_here, g3_here, alph1_here,
alph2_here, Normalization)
for anglei in range(len(scattered_angles)):
errorbar_sup[anglei] = np.max(hg_mcmc_rand[anglei, :])
errorbar_inf[anglei] = np.min(hg_mcmc_rand[anglei, :])
errorbar[anglei] = (np.max(hg_mcmc_rand[anglei, :]) -
np.min(hg_mcmc_rand[anglei, :])) / 2.
dico_return['errorbar_sup'] = errorbar_sup
dico_return['errorbar_inf'] = errorbar_inf
dico_return['errorbar'] = errorbar
if save == True:
savefortext = np.transpose(
[scattered_angles, best_hg_mcmc, errorbar_sup, errorbar_inf])
path_and_name_txt = os.path.join(folder_save_pdf,
file_prefix + '_spf.txt')
np.savetxt(path_and_name_txt, savefortext, delimiter=',',
fmt='%10.2f') # save the array in a txt
return dico_return
import os
import cPickle as pickle
from tqdm import tqdm
isoc_age = 10e9
isoc_ext = 2.63
isoc_dist = 7.971e3
isoc_phase = 'RGB'
isoc_met = 0.0
isoc_atm_func = 'phoenix'
# Read in data
trial_num = 1
chains_file = '../chains/chains_try{0}.h5'.format(trial_num)
reader = backends.HDFBackend(chains_file, read_only=True)
samples = reader.get_chain()
(num_steps, num_chains, num_params) = samples.shape
samples = reader.get_chain(flat=True)
print("Number of Steps: {0}".format(num_steps))
print("Number of Chains: {0}".format(num_chains))
print("Number of Parameters: {0}".format(num_params))
log_prob_samples = reader.get_log_prob(flat=True)
log_prior_samples = reader.get_blobs(flat=True)
# Check if any rows can be ignored that have been calculated already
rows_ignore = 0
def measure_spf_errors(params_mcmc_yaml,
Number_rand_mcmc,
Norm_90_inplot=1.,
median_or_max='median',
save=False):
"""
take a set of scatt angles and a set of HG parameter and return
the log of a 2g HG SPF (usefull to fit from a set of points)
Args:
params_mcmc_yaml: dic, all the parameters of the MCMC and klip
read from yaml file
Number_rand_mcmc: number of randomnly selected psf we use to
plot the error bars
Norm_90_inplot: the value at which you want to normalize the spf
in the plot ay 90 degree (to re-measure the error
bars properly)
median_or_max: 'median' or 'max' use 50% percentile
or maximum of likelyhood as "best model". default 'median'
save:
Returns:
a dic that contains the 'best_spf', 'errorbar_sup',
'errorbar_sup', 'errorbar'
"""
dico_return = dict()
burnin = params_mcmc_yaml['BURNIN']
nwalkers = params_mcmc_yaml['NWALKERS']
DATADIR = os.path.join(basedir, params_mcmc_yaml['BAND_DIR'])
mcmcresultdir = os.path.join(DATADIR, 'results_MCMC')
file_prefix = params_mcmc_yaml['FILE_PREFIX']
diskfit_mcmc.SPF_MODEL = params_mcmc_yaml[
'SPF_MODEL'] #Type of description for the SPF
name_h5 = file_prefix + "_backend_file_mcmc"
chain_name = os.path.join(mcmcresultdir, name_h5 + ".h5")
reader = backends.HDFBackend(chain_name)
min_scat = 90 - params_mcmc_yaml['inc_init']
max_scat = 90 + params_mcmc_yaml['inc_init']
scattered_angles = np.arange(np.round(max_scat - min_scat)) + np.round(
np.min(min_scat))
#we only exctract the last itearations, assuming it converged
chain_flat = reader.get_chain(discard=burnin, flat=True)
#if we use the argmax(chi2) as the 'best model' we need to find this maximum
if median_or_max == 'max':
log_prob_samples_flat = reader.get_log_prob(discard=burnin, flat=True)
wheremax = np.where(
log_prob_samples_flat == np.max(log_prob_samples_flat))
wheremax0 = np.array(wheremax).flatten()[0]
if (diskfit_mcmc.SPF_MODEL == 'hg_1g'):
norm_chain = np.exp(chain_flat[:, 7])
g1_chain = chain_flat[:, 8]
if median_or_max == 'median':
bestmodel_Norm = np.percentile(norm_chain, 50)
bestmodel_g1 = np.percentile(g1_chain, 50)
elif median_or_max == 'max':
bestmodel_Norm = norm_chain[wheremax0]
bestmodel_g1 = g1_chain[wheremax0]
Normalization = Norm_90_inplot
if save == True:
Normalization = bestmodel_Norm
best_hg_mcmc = hg_1g(scattered_angles, bestmodel_g1, Normalization)
elif diskfit_mcmc.SPF_MODEL == 'hg_2g':
norm_chain = np.exp(chain_flat[:, 7])
g1_chain = chain_flat[:, 8]
g2_chain = chain_flat[:, 9]
alph1_chain = chain_flat[:, 10]
if median_or_max == 'median':
bestmodel_Norm = np.percentile(norm_chain, 50)
bestmodel_g1 = np.percentile(g1_chain, 50)
bestmodel_g2 = np.percentile(g2_chain, 50)
bestmodel_alpha1 = np.percentile(alph1_chain, 50)
elif median_or_max == 'max':
bestmodel_Norm = norm_chain[wheremax0]
bestmodel_g1 = g1_chain[wheremax0]
bestmodel_g2 = g2_chain[wheremax0]
bestmodel_alpha1 = alph1_chain[wheremax0]
Normalization = Norm_90_inplot
if save == True:
Normalization = bestmodel_Norm
best_hg_mcmc = hg_2g(scattered_angles, bestmodel_g1, bestmodel_g2,
bestmodel_alpha1, Normalization)
elif diskfit_mcmc.SPF_MODEL == 'hg_3g':
norm_chain = np.exp(chain_flat[:, 7])
g1_chain = chain_flat[:, 8]
g2_chain = chain_flat[:, 9]
alph1_chain = chain_flat[:, 10]
g3_chain = chain_flat[:, 11]
alph2_chain = chain_flat[:, 12]
if median_or_max == 'median':
bestmodel_Norm = np.percentile(norm_chain, 50)
bestmodel_g1 = np.percentile(g1_chain, 50)
bestmodel_g2 = np.percentile(g2_chain, 50)
bestmodel_alpha1 = np.percentile(alph1_chain, 50)
bestmodel_g3 = np.percentile(g3_chain, 50)
bestmodel_alpha2 = np.percentile(alph2_chain, 50)
elif median_or_max == 'max':
bestmodel_Norm = norm_chain[wheremax0]
bestmodel_g1 = g1_chain[wheremax0]
bestmodel_g2 = g2_chain[wheremax0]
bestmodel_alpha1 = alph1_chain[wheremax0]
bestmodel_g3 = g3_chain[wheremax0]
bestmodel_alpha2 = alph2_chain[wheremax0]
Normalization = Norm_90_inplot
# we normalize the best model at 90 either by the value found
# by the MCMC if we want to save or by the value in the
# Norm_90_inplot if we want to plot
Normalization = Norm_90_inplot
if save == True:
Normalization = bestmodel_Norm
best_hg_mcmc = hg_3g(scattered_angles, bestmodel_g1, bestmodel_g2,
bestmodel_g3, bestmodel_alpha1, bestmodel_alpha2,
Normalization)
dico_return['best_spf'] = best_hg_mcmc
random_param_number = np.random.randint(1,
len(g1_chain) - 1,
Number_rand_mcmc)
if (diskfit_mcmc.SPF_MODEL
== 'hg_1g') or (diskfit_mcmc.SPF_MODEL
== 'hg_2g') or (diskfit_mcmc.SPF_MODEL == 'hg_3g'):
g1_rand = g1_chain[random_param_number]
norm_rand = norm_chain[random_param_number]
if (diskfit_mcmc.SPF_MODEL == 'hg_2g') or (diskfit_mcmc.SPF_MODEL
== 'hg_3g'):
g2_rand = g2_chain[random_param_number]
alph1_rand = alph1_chain[random_param_number]
if diskfit_mcmc.SPF_MODEL == 'hg_3g':
g3_rand = g3_chain[random_param_number]
alph2_rand = alph2_chain[random_param_number]
hg_mcmc_rand = np.zeros((len(best_hg_mcmc), len(random_param_number)))
errorbar_sup = scattered_angles * 0.
errorbar_inf = scattered_angles * 0.
errorbar = scattered_angles * 0.
for num_model in range(Number_rand_mcmc):
norm_here = norm_rand[num_model]
# we normalize the random SPF at 90 either by the value of
# the SPF by the MCMC if we want to save or around the
# Norm_90_inplot if we want to plot
Normalization = norm_here * Norm_90_inplot / bestmodel_Norm
if save == True:
Normalization = norm_here
if (diskfit_mcmc.SPF_MODEL == 'hg_1g'):
g1_here = g1_rand[num_model]
if (diskfit_mcmc.SPF_MODEL == 'hg_2g'):
g1_here = g1_rand[num_model]
g2_here = g2_rand[num_model]
alph1_here = alph1_rand[num_model]
hg_mcmc_rand[:,
num_model] = hg_2g(scattered_angles, g1_here, g2_here,
alph1_here, Normalization)
if diskfit_mcmc.SPF_MODEL == 'hg_3g':
g3_here = g3_rand[num_model]
alph2_here = alph2_rand[num_model]
hg_mcmc_rand[:, num_model] = hg_3g(scattered_angles, g1_here,
g2_here, g3_here, alph1_here,
alph2_here, Normalization)
for anglei in range(len(scattered_angles)):
errorbar_sup[anglei] = np.max(hg_mcmc_rand[anglei, :])
errorbar_inf[anglei] = np.min(hg_mcmc_rand[anglei, :])
errorbar[anglei] = (np.max(hg_mcmc_rand[anglei, :]) -
np.min(hg_mcmc_rand[anglei, :])) / 2.
dico_return['errorbar_sup'] = errorbar_sup
dico_return['errorbar_inf'] = errorbar_inf
dico_return['errorbar'] = errorbar
dico_return['all_rando_spfs'] = hg_mcmc_rand
dico_return['scattered_angles'] = scattered_angles
return dico_return
def print_geometry_parameter(params_mcmc_yaml, hdr):
""" Print some of the important values from the header to put in
excel
Args:
params_mcmc_yaml: dic, all the parameters of the MCMC and klip
read from yaml file
hdr: the header obtained from create_header
Returns:
None
"""
file_prefix = params_mcmc_yaml['FILE_PREFIX']
distance_star = params_mcmc_yaml['DISTANCE_STAR']
name_h5 = file_prefix + '_backend_file_mcmc'
reader = backends.HDFBackend(os.path.join(mcmcresultdir, name_h5 + '.h5'))
f1 = open(
os.path.join(mcmcresultdir, name_h5 + '_fit_geometrical_params.txt'),
'w+')
f1.write("\n'{0} / {1}".format(reader.iteration, reader.iteration * 192))
f1.write("\n")
to_print_str = 'R1'
to_print = [
hdr[to_print_str + '_MC'], hdr[to_print_str + '_M'],
hdr[to_print_str + '_P']
]
to_print = convert.au_to_mas(to_print, distance_star)
f1.write("\n'{0:.3f} {1:.3f} +{2:.3f}".format(to_print[0], to_print[1],
to_print[2]))
to_print_str = 'R2'
to_print = [
hdr[to_print_str + '_MC'], hdr[to_print_str + '_M'],
hdr[to_print_str + '_P']
]
to_print = convert.au_to_mas(to_print, distance_star)
f1.write("\n'{0:.3f} {1:.3f} +{2:.3f}".format(to_print[0], to_print[1],
to_print[2]))
to_print_str = 'PA'
to_print = [
hdr[to_print_str + '_MC'], hdr[to_print_str + '_M'],
hdr[to_print_str + '_P']
]
f1.write("\n'{0:.3f} {1:.3f} +{2:.3f}".format(to_print[0], to_print[1],
to_print[2]))
to_print_str = 'RA'
to_print = [
hdr[to_print_str + '_MC'], hdr[to_print_str + '_M'],
hdr[to_print_str + '_P']
]
f1.write("\n'{0:.3f} {1:.3f} +{2:.3f}".format(to_print[0], to_print[1],
to_print[2]))
to_print_str = 'Decl'
to_print = [
hdr[to_print_str + '_MC'], hdr[to_print_str + '_M'],
hdr[to_print_str + '_P']
]
f1.write("\n'{0:.3f} {1:.3f} +{2:.3f}".format(to_print[0], to_print[1],
to_print[2]))
to_print_str = 'dx'
to_print = [
hdr[to_print_str + '_MC'], hdr[to_print_str + '_M'],
hdr[to_print_str + '_P']
]
to_print = convert.au_to_mas(to_print, distance_star)
f1.write("\n'{0:.3f} {1:.3f} +{2:.3f}".format(to_print[0], to_print[1],
to_print[2]))
to_print_str = 'dy'
to_print = [
hdr[to_print_str + '_MC'], hdr[to_print_str + '_M'],
hdr[to_print_str + '_P']
]
to_print = convert.au_to_mas(to_print, distance_star)
f1.write("\n'{0:.3f} {1:.3f} +{2:.3f}".format(to_print[0], to_print[1],
to_print[2]))
f1.write("\n")
f1.write("\n")
to_print_str = 'Rkowa'
to_print = [
hdr[to_print_str + '_MC'], hdr[to_print_str + '_M'],
hdr[to_print_str + '_P']
]
f1.write("\n'{0:.3f} {1:.3f} +{2:.3f}".format(to_print[0], to_print[1],
to_print[2]))
to_print_str = 'eKOWA'
to_print = [
hdr[to_print_str + '_MC'], hdr[to_print_str + '_M'],
hdr[to_print_str + '_P']
]
f1.write("\n'{0:.3f} {1:.3f} +{2:.3f}".format(to_print[0], to_print[1],
to_print[2]))
to_print_str = 'ikowa'
to_print = [
hdr[to_print_str + '_MC'], hdr[to_print_str + '_M'],
hdr[to_print_str + '_P']
]
f1.write("\n'{0:.3f} {1:.3f} +{2:.3f}".format(to_print[0], to_print[1],
to_print[2]))
to_print_str = 'Omega'
to_print = [
hdr[to_print_str + '_MC'], hdr[to_print_str + '_M'],
hdr[to_print_str + '_P']
]
f1.write("\n'{0:.3f} {1:.3f} +{2:.3f}".format(to_print[0], to_print[1],
to_print[2]))
to_print_str = 'Argpe'
to_print = [
hdr[to_print_str + '_MC'], hdr[to_print_str + '_M'],
hdr[to_print_str + '_P']
]
f1.write("\n'{0:.3f} {1:.3f} +{2:.3f}".format(to_print[0], to_print[1],
to_print[2]))
f1.close()
def best_model_plot(params_mcmc_yaml, hdr):
""" Make the best models plot and save fits of
BestModel
BestModel_Conv
BestModel_FM
BestModel_Res
Args:
params_mcmc_yaml: dic, all the parameters of the MCMC and klip
read from yaml file
hdr: the header obtained from create_header
Returns:
None
"""
# I am going to plot the model, I need to define some of the
# global variables to do so
# global ALIGNED_CENTER, PIXSCALE_INS, DISTANCE_STAR, WHEREMASK2GENERATEDISK, DIMENSION, SPF_MODEL
diskfit_mcmc.DISTANCE_STAR = params_mcmc_yaml['DISTANCE_STAR']
diskfit_mcmc.PIXSCALE_INS = params_mcmc_yaml['PIXSCALE_INS']
quality_plot = params_mcmc_yaml['QUALITY_PLOT']
file_prefix = params_mcmc_yaml['FILE_PREFIX']
band_name = params_mcmc_yaml['BAND_NAME']
name_h5 = file_prefix + '_backend_file_mcmc'
numbasis = [params_mcmc_yaml['KLMODE_NUMBER']]
diskfit_mcmc.ALIGNED_CENTER = params_mcmc_yaml['ALIGNED_CENTER']
diskfit_mcmc.SPF_MODEL = params_mcmc_yaml[
'SPF_MODEL'] #Type of description for the SPF
thin = params_mcmc_yaml['THIN']
burnin = params_mcmc_yaml['BURNIN']
reader = backends.HDFBackend(os.path.join(mcmcresultdir, name_h5 + '.h5'))
chain_flat = reader.get_chain(discard=burnin, thin=thin, flat=True)
log_prob_samples_flat = reader.get_log_prob(discard=burnin,
flat=True,
thin=thin)
wheremin = np.where(
log_prob_samples_flat == np.nanmax(log_prob_samples_flat))
wheremin0 = np.array(wheremin).flatten()[0]
theta_ml = chain_flat[wheremin0, :]
if (diskfit_mcmc.SPF_MODEL == 'spf_fix'):
# we fix the SPF using a HG parametrization with parameters in the init file
n_points = 21 # odd number to ensure that scattangl=pi/2 is in the list for normalization
scatt_angles = np.linspace(0, np.pi, n_points)
# 2g henyey greenstein, normalized at 1 at 90 degrees
spf_norm90 = hg_2g(np.degrees(scatt_angles),
params_mcmc_yaml['g1_init'],
params_mcmc_yaml['g2_init'],
params_mcmc_yaml['alpha1_init'], 1)
#measure fo the spline and save as global value
diskfit_mcmc.F_SPF = phase_function_spline(scatt_angles, spf_norm90)
#initial poinr (3g spf fitted to Julien's)
# theta_ml[3] = 0.99997991
# theta_ml[4] = 0.05085574
# theta_ml[5] = 0.04775487
# theta_ml[6] = 0.99949596
# theta_ml[7] = -0.03397267
psf = fits.getdata(os.path.join(klipdir, file_prefix + '_SmallPSF.fits'))
mask2generatedisk = fits.getdata(
os.path.join(klipdir, file_prefix + '_mask2generatedisk.fits'))
mask2generatedisk[np.where(mask2generatedisk == 0.)] = np.nan
diskfit_mcmc.WHEREMASK2GENERATEDISK = (mask2generatedisk !=
mask2generatedisk)
instrument = params_mcmc_yaml['INSTRUMENT']
# load the data
reduced_data = fits.getdata(
os.path.join(klipdir, file_prefix + '-klipped-KLmodes-all.fits'))[
0] ### we take only the first KL mode
diskfit_mcmc.DIMENSION = reduced_data.shape[1]
# load the noise
noise = fits.getdata(os.path.join(klipdir,
file_prefix + '_noisemap.fits')) / 3.
disk_ml = diskfit_mcmc.call_gen_disk(theta_ml)
fits.writeto(os.path.join(mcmcresultdir, name_h5 + '_BestModel.fits'),
disk_ml,
header=hdr,
overwrite=True)
# find the position of the pericenter in the model
argpe = hdr['ARGPE_MC']
pa = hdr['PA_MC']
model_rot = np.clip(
rotate(disk_ml, argpe + pa, mode='wrap', reshape=False), 0., None)
argpe_direction = model_rot[int(diskfit_mcmc.ALIGNED_CENTER[0]):,
int(diskfit_mcmc.ALIGNED_CENTER[1])]
radius_argpe = np.where(argpe_direction == np.nanmax(argpe_direction))[0]
x_peri_true = radius_argpe * np.cos(
np.radians(argpe + pa + 90)) # distance to star, in pixel
y_peri_true = radius_argpe * np.sin(
np.radians(argpe + pa + 90)) # distance to star, in pixel
#convolve by the PSF
disk_ml_convolved = convolve(disk_ml, psf, boundary='wrap')
fits.writeto(os.path.join(mcmcresultdir, name_h5 + '_BestModel_Conv.fits'),
disk_ml_convolved,
header=hdr,
overwrite=True)
# load the KL numbers
diskobj = DiskFM(None,
numbasis,
None,
disk_ml_convolved,
basis_filename=os.path.join(klipdir,
file_prefix + '_klbasis.h5'),
load_from_basis=True)
#do the FM
diskobj.update_disk(disk_ml_convolved)
disk_ml_FM = diskobj.fm_parallelized()[0]
### we take only the first KL modemode
fits.writeto(os.path.join(mcmcresultdir, name_h5 + '_BestModel_FM.fits'),
disk_ml_FM,
header=hdr,
overwrite=True)
fits.writeto(os.path.join(mcmcresultdir, name_h5 + '_BestModel_Res.fits'),
np.abs(reduced_data - disk_ml_FM),
header=hdr,
overwrite=True)
#Measure the residuals
residuals = reduced_data - disk_ml_FM
snr_residuals = (reduced_data - disk_ml_FM) / noise
#Set the colormap
vmin = 0.3 * np.min(disk_ml_FM)
vmax = 0.9 * np.max(disk_ml_FM)
dim_crop_image = int(4 * params_mcmc_yaml['OWA'] // 2) + 1
disk_ml_crop = crop_center_odd(disk_ml, dim_crop_image)
disk_ml_convolved_crop = crop_center_odd(disk_ml_convolved, dim_crop_image)
disk_ml_FM_crop = crop_center_odd(disk_ml_FM, dim_crop_image)
reduced_data_crop = crop_center_odd(reduced_data, dim_crop_image)
residuals_crop = crop_center_odd(residuals, dim_crop_image)
snr_residuals_crop = crop_center_odd(snr_residuals, dim_crop_image)
caracsize = 40 * quality_plot / 2.
fig = plt.figure(figsize=(6.4 * 2 * quality_plot, 4.8 * 2 * quality_plot))
#The data
ax1 = fig.add_subplot(235)
cax = plt.imshow(reduced_data_crop + 0.1,
origin='lower',
vmin=int(np.round(vmin)),
vmax=int(np.round(vmax)),
cmap=plt.cm.get_cmap('viridis'))
if file_prefix == 'Hband_hd48524_fake':
ax1.set_title("Injected Disk (KLIP)",
fontsize=caracsize,
pad=caracsize / 3.)
else:
ax1.set_title("KLIP reduced data",
fontsize=caracsize,
pad=caracsize / 3.)
cbar = fig.colorbar(cax, fraction=0.046, pad=0.04)
cbar.ax.tick_params(labelsize=caracsize * 3 / 4.)
plt.axis('off')
#The residuals
ax1 = fig.add_subplot(233)
cax = plt.imshow(residuals_crop,
origin='lower',
vmin=0,
vmax=int(np.round(vmax) // 3),
cmap=plt.cm.get_cmap('viridis'))
ax1.set_title("Residuals", fontsize=caracsize, pad=caracsize / 3.)
# make the colobar ticks integer only for gpi
if instrument == 'SPHERE':
tick_int = list(np.arange(int(np.round(vmax) // 2) + 1))
tick_int_st = [str(i) for i in tick_int]
cbar = fig.colorbar(cax, ticks=tick_int, fraction=0.046, pad=0.04)
cbar.ax.tick_params(labelsize=caracsize * 3 / 4.)
cbar.ax.set_yticklabels(tick_int_st)
else:
cbar = fig.colorbar(cax, fraction=0.046, pad=0.04)
cbar.ax.tick_params(labelsize=caracsize * 3 / 4.)
plt.axis('off')
#The SNR of the residuals
ax1 = fig.add_subplot(236)
cax = plt.imshow(snr_residuals_crop,
origin='lower',
vmin=0,
vmax=2,
cmap=plt.cm.get_cmap('viridis'))
ax1.set_title("SNR Residuals", fontsize=caracsize, pad=caracsize / 3.)
cbar = fig.colorbar(cax, ticks=[0, 1, 2], fraction=0.046, pad=0.04)
cbar.ax.tick_params(labelsize=caracsize * 3 / 4.)
cbar.ax.set_yticklabels(['0', '1', '2'])
plt.axis('off')
# The model
ax1 = fig.add_subplot(231)
vmax_model = int(np.round(np.max(disk_ml_crop) / 1.5))
if instrument == 'SPHERE':
vmax_model = 433
cax = plt.imshow(disk_ml_crop,
origin='lower',
vmin=-2,
vmax=vmax_model,
cmap=plt.cm.get_cmap('plasma'))
ax1.set_title("Best Model", fontsize=caracsize, pad=caracsize / 3.)
cbar = fig.colorbar(cax, fraction=0.046, pad=0.04)
cbar.ax.tick_params(labelsize=caracsize * 3 / 4.)
pos_argperi = plt.Circle(
(x_peri_true + dim_crop_image // 2, y_peri_true + dim_crop_image // 2),
3,
color='g',
alpha=0.8)
pos_star = plt.Circle((dim_crop_image // 2, dim_crop_image // 2),
2,
color='r',
alpha=0.8)
ax1.add_artist(pos_argperi)
ax1.add_artist(pos_star)
plt.axis('off')
rect = Rectangle((9.5, 9.5),
psf.shape[0],
psf.shape[1],
edgecolor='white',
facecolor='none',
linewidth=2)
disk_ml_convolved_crop[10:10 + psf.shape[0],
10:10 + psf.shape[1]] = 2 * vmax * psf
ax1 = fig.add_subplot(234)
cax = plt.imshow(disk_ml_convolved_crop,
origin='lower',
vmin=int(np.round(vmin)),
vmax=int(np.round(vmax * 2)),
cmap=plt.cm.get_cmap('viridis'))
ax1.add_patch(rect)
ax1.set_title("Model Convolved", fontsize=caracsize, pad=caracsize / 3.)
cbar = fig.colorbar(cax, fraction=0.046, pad=0.04)
cbar.ax.tick_params(labelsize=caracsize * 3 / 4.)
plt.axis('off')
#The FM convolved model
ax1 = fig.add_subplot(232)
cax = plt.imshow(disk_ml_FM_crop,
origin='lower',
vmin=int(np.round(vmin)),
vmax=int(np.round(vmax)),
cmap=plt.cm.get_cmap('viridis'))
ax1.set_title("Model Convolved + FM",
fontsize=caracsize,
pad=caracsize / 3.)
cbar = fig.colorbar(cax, fraction=0.046, pad=0.04)
cbar.ax.tick_params(labelsize=caracsize * 3 / 4.)
plt.axis('off')
fig.subplots_adjust(hspace=-0.4, wspace=0.2)
fig.suptitle(band_name + ': Best Model and Residuals',
fontsize=5 / 4. * caracsize,
y=0.985)
fig.tight_layout()
plt.savefig(os.path.join(mcmcresultdir, name_h5 + '_BestModel_Plot.jpg'))
plt.close()
def create_header(params_mcmc_yaml):
""" measure all the important parameters and exctract their error bars
and print them and save them in a hdr file
Args:
params_mcmc_yaml: dic, all the parameters of the MCMC and klip
read from yaml file
Returns:
header for all the fits
"""
thin = params_mcmc_yaml['THIN']
burnin = params_mcmc_yaml['BURNIN']
comments = params_mcmc_yaml['COMMENTS']
names = params_mcmc_yaml['NAMES']
distance_star = params_mcmc_yaml['DISTANCE_STAR']
sigma = params_mcmc_yaml['sigma']
nwalkers = params_mcmc_yaml['NWALKERS']
file_prefix = params_mcmc_yaml['FILE_PREFIX']
name_h5 = file_prefix + '_backend_file_mcmc'
diskfit_mcmc.SPF_MODEL = params_mcmc_yaml[
'SPF_MODEL'] #Type of description for the SPF
reader = backends.HDFBackend(os.path.join(mcmcresultdir, name_h5 + '.h5'))
log_prob_samples_flat = reader.get_log_prob(discard=burnin,
flat=True,
thin=thin)
chain = reader.get_chain(discard=burnin, thin=thin)
chain_flat = chains_to_params(chain, flatten=True)
n_dim_mcmc = chain_flat.shape[1]
for j in range(n_dim_mcmc):
chain4thatparam = chain_flat[:, j]
wherenotnan = np.where(~np.isnan(chain4thatparam))
chainflatnonan = np.zeros(
(len(chain4thatparam[wherenotnan]), n_dim_mcmc))
for i in range(n_dim_mcmc):
chainflatnonan[:, i] = chain_flat[wherenotnan, i]
chain_flat = chainflatnonan
log_prob_samples_flat = log_prob_samples_flat[wherenotnan]
samples_dict = dict()
comments_dict = comments
MLval_mcmc_val_mcmc_err_dict = dict()
for i, key in enumerate(names[:n_dim_mcmc]):
samples_dict[key] = chain_flat[:, i]
for i, key in enumerate(names[n_dim_mcmc:]):
samples_dict[key] = chain_flat[:, i] * 0.
# measure of 2 other parameters: eccentricity and argument
# of the perihelie
for modeli in range(chain_flat.shape[0]):
r1_here = samples_dict['R1'][modeli]
dx_here = samples_dict['dx'][modeli]
dy_here = samples_dict['dy'][modeli]
a = r1_here
c = np.sqrt(dx_here**2 + dy_here**2)
eccentricity = c / a
samples_dict['ecc'][modeli] = eccentricity
samples_dict['Argpe'][modeli] = np.degrees(np.arctan2(
dx_here, dy_here))
samples_dict['R1mas'][modeli] = convert.au_to_mas(
r1_here, distance_star)
# dAlpha, dDelta = offset_2_RA_dec(dx_here, dy_here, inc_here, pa_here,
# distance_star)
# samples_dict['RA'][modeli] = dAlpha
# samples_dict['Decl'][modeli] = dDelta
# semimajoraxis = convert.au_to_mas(r1_here, distance_star)
# ecc = np.sin(np.radians(inc_here))
# semiminoraxis = semimajoraxis*np.sqrt(1- ecc**2)
# samples_dict['Smaj'][modeli] = semimajoraxis
# samples_dict['ecc'][modeli] = ecc
# samples_dict['Smin'][modeli] = semiminoraxis
# true_a, true_ecc, argperi, inc, longnode = kowalsky(
# semimajoraxis, ecc, pa_here, dAlpha, dDelta)
# samples_dict['Rkowa'][modeli] = true_a
# samples_dict['ekowa'][modeli] = true_ecc
# samples_dict['ikowa'][modeli] = inc
# samples_dict['Omega'][modeli] = longnode
# samples_dict['Argpe'][modeAli] = argperi
wheremin = np.where(log_prob_samples_flat == np.max(log_prob_samples_flat))
wheremin0 = np.array(wheremin).flatten()[0]
if sigma == 1:
quants = [15.9, 50., 84.1]
if sigma == 2:
quants = [2.3, 50., 97.77]
if sigma == 3:
quants = [0.1, 50., 99.9]
for key in samples_dict.keys():
MLval_mcmc_val_mcmc_err_dict[key] = np.zeros(4)
percent = np.percentile(samples_dict[key], quants)
MLval_mcmc_val_mcmc_err_dict[key][0] = samples_dict[key][wheremin0]
MLval_mcmc_val_mcmc_err_dict[key][1] = percent[1]
MLval_mcmc_val_mcmc_err_dict[key][2] = percent[0] - percent[1]
MLval_mcmc_val_mcmc_err_dict[key][3] = percent[2] - percent[1]
# MLval_mcmc_val_mcmc_err_dict['RAp'] = convert.mas_to_pix(
# MLval_mcmc_val_mcmc_err_dict['RA'], PIXSCALE_INS)
# MLval_mcmc_val_mcmc_err_dict['Declp'] = convert.mas_to_pix(
# MLval_mcmc_val_mcmc_err_dict['Decl'], PIXSCALE_INS)
# MLval_mcmc_val_mcmc_err_dict['R2mas'] = convert.au_to_mas(
# MLval_mcmc_val_mcmc_err_dict['R2'], distance_star)
# print(" ")
# for key in MLval_mcmc_val_mcmc_err_dict.keys():
# print(key +
# '_ML: {0:.3f}, MCMC {1:.3f}, -/+1sig: {2:.3f}/+{3:.3f}'.format(
# MLval_mcmc_val_mcmc_err_dict[key][0],
# MLval_mcmc_val_mcmc_err_dict[key][1],
# MLval_mcmc_val_mcmc_err_dict[key][2],
# MLval_mcmc_val_mcmc_err_dict[key][3]) + comments_dict[key])
# print(" ")
print(" ")
if (diskfit_mcmc.SPF_MODEL
== 'hg_1g') or (diskfit_mcmc.SPF_MODEL
== 'hg_2g') or (diskfit_mcmc.SPF_MODEL == 'hg_3g'):
just_these_params = ['g1', 'g2', 'Alph1']
for key in just_these_params:
print(key + ' MCMC {0:.3f}, -/+1sig: {1:.3f}/+{2:.3f}'.format(
MLval_mcmc_val_mcmc_err_dict[key][1],
MLval_mcmc_val_mcmc_err_dict[key][2],
MLval_mcmc_val_mcmc_err_dict[key][3]))
print(" ")
hdr = fits.Header()
hdr['COMMENT'] = 'Best model of the MCMC reduction'
hdr['COMMENT'] = 'PARAM_ML are the parameters producing the best LH'
hdr['COMMENT'] = 'PARAM_MM are the parameters at the 50% percentile in the MCMC'
hdr['COMMENT'] = 'PARAM_M and PARAM_P are the -/+ sigma error bars (16%, 84%)'
hdr['KL_FILE'] = name_h5
hdr['FITSDATE'] = str(datetime.now())
hdr['BURNIN'] = burnin
hdr['THIN'] = thin
hdr['TOT_ITER'] = reader.iteration
hdr['n_walker'] = nwalkers
hdr['n_param'] = n_dim_mcmc
hdr['MAX_LH'] = (np.max(log_prob_samples_flat),
'Max likelyhood, obtained for the ML parameters')
for key in samples_dict.keys():
hdr[key + '_ML'] = (MLval_mcmc_val_mcmc_err_dict[key][0],
comments_dict[key])
hdr[key + '_MC'] = MLval_mcmc_val_mcmc_err_dict[key][1]
hdr[key + '_M'] = MLval_mcmc_val_mcmc_err_dict[key][2]
hdr[key + '_P'] = MLval_mcmc_val_mcmc_err_dict[key][3]
return hdr
def make_corner_plot(params_mcmc_yaml):
""" make corner plot reading the .h5 file from emcee
Args:
params_mcmc_yaml: dic, all the parameters of the MCMC and klip
read from yaml file
Returns:
None
"""
thin = params_mcmc_yaml['THIN']
burnin = params_mcmc_yaml['BURNIN']
labels = params_mcmc_yaml['LABELS']
names = params_mcmc_yaml['NAMES']
sigma = params_mcmc_yaml['sigma']
nwalkers = params_mcmc_yaml['NWALKERS']
file_prefix = params_mcmc_yaml['FILE_PREFIX']
name_h5 = file_prefix + '_backend_file_mcmc'
band_name = params_mcmc_yaml['BAND_NAME']
diskfit_mcmc.SPF_MODEL = params_mcmc_yaml[
'SPF_MODEL'] #Type of description for the SPF
reader = backends.HDFBackend(os.path.join(mcmcresultdir, name_h5 + '.h5'))
chain = reader.get_chain(discard=burnin, thin=thin)
chain_flat = chains_to_params(chain, flatten=True)
n_dim_mcmc = chain_flat.shape[1]
for j in range(n_dim_mcmc):
chain4thatparam = chain_flat[:, j]
wherenotnan = np.where(~np.isnan(chain4thatparam))
chainflatnonan = np.zeros(
(len(chain4thatparam[wherenotnan]), n_dim_mcmc))
for i in range(n_dim_mcmc):
chainflatnonan[:, i] = chain_flat[wherenotnan, i]
chain_flat = chainflatnonan
rcParams['axes.labelsize'] = 19
rcParams['axes.titlesize'] = 14
rcParams['xtick.labelsize'] = 13
rcParams['ytick.labelsize'] = 13
### cumulative percentiles
### value at 50% is the center of the Normal law
### value at 50% - value at 15.9% is -1 sigma
### value at 84.1%% - value at 50% is 1 sigma
if sigma == 1:
quants = (0.159, 0.5, 0.841)
if sigma == 2:
quants = (0.023, 0.5, 0.977)
if sigma == 3:
quants = (0.001, 0.5, 0.999)
#### Check truths = bests parameters
if 'Fake' in file_prefix:
shouldweplotalldatapoints = True
else:
shouldweplotalldatapoints = False
labels_hash = [labels[names[i]] for i in range(n_dim_mcmc)]
fig = corner.corner(chain_flat,
labels=labels_hash,
quantiles=quants,
show_titles=True,
plot_datapoints=shouldweplotalldatapoints,
verbose=False)
if 'Fake' in file_prefix:
initial_values = [
params_mcmc_yaml['r1_init'], params_mcmc_yaml['r2_init'],
params_mcmc_yaml['beta_init'], params_mcmc_yaml['inc_init'],
params_mcmc_yaml['pa_init'], params_mcmc_yaml['dx_init'],
params_mcmc_yaml['dy_init'], params_mcmc_yaml['N_init'],
params_mcmc_yaml['g1_init'], params_mcmc_yaml['g2_init'],
params_mcmc_yaml['alpha1_init']
]
# initial_values = [
# params_mcmc_yaml['r1_init'], params_mcmc_yaml['r2_init'],
# params_mcmc_yaml['beta_init'], params_mcmc_yaml['beta_out_init'],
# params_mcmc_yaml['inc_init'],
# params_mcmc_yaml['pa_init'], params_mcmc_yaml['dx_init'],
# params_mcmc_yaml['dy_init'], params_mcmc_yaml['N_init']
# ]
green_line = mlines.Line2D([], [],
color='red',
label='True injected values')
plt.legend(handles=[green_line],
loc='center right',
bbox_to_anchor=(0.5, 8),
fontsize=30)
# log_prob_samples_flat = reader.get_log_prob(discard=burnin,
# flat=True,
# thin=thin)
# wheremin = np.where(
# log_prob_samples_flat == np.max(log_prob_samples_flat))
# wheremin0 = np.array(wheremin).flatten()[0]
# red_line = mlines.Line2D([], [],
# color='red',
# label='Maximum likelyhood values')
# plt.legend(handles=[green_line, red_line],
# loc='upper right',
# bbox_to_anchor=(-1, 10),
# fontsize=30)
# Extract the axes
axes = np.array(fig.axes).reshape((n_dim_mcmc, n_dim_mcmc))
# Loop over the diagonal
for i in range(n_dim_mcmc):
ax = axes[i, i]
ax.axvline(initial_values[i], color="r")
# ax.axvline(samples[wheremin0, i], color="r")
# Loop over the histograms
for yi in range(n_dim_mcmc):
for xi in range(yi):
ax = axes[yi, xi]
ax.axvline(initial_values[xi], color="r")
ax.axhline(initial_values[yi], color="r")
# ax.axvline(samples[wheremin0, xi], color="r")
# ax.axhline(samples[wheremin0, yi], color="r")
fig.subplots_adjust(hspace=0)
fig.subplots_adjust(wspace=0)
fig.gca().annotate(band_name,
xy=(0.55, 0.99),
xycoords="figure fraction",
xytext=(-20, -10),
textcoords="offset points",
ha="center",
va="top",
fontsize=44)
fig.gca().annotate("{0:,} iterations (+ {1:,} burn-in)".format(
reader.iteration - burnin, burnin),
xy=(0.55, 0.95),
xycoords="figure fraction",
xytext=(-20, -10),
textcoords="offset points",
ha="center",
va="top",
fontsize=44)
fig.gca().annotate("with {0:,} walkers: {1:,} models".format(
nwalkers, reader.iteration * nwalkers),
xy=(0.55, 0.91),
xycoords="figure fraction",
xytext=(-20, -10),
textcoords="offset points",
ha="center",
va="top",
fontsize=44)
plt.savefig(os.path.join(mcmcresultdir, name_h5 + '_pdfs.pdf'))
plt.close()
def make_chain_plot(params_mcmc_yaml):
""" make_chain_plot reading the .h5 file from emcee
Args:
params_mcmc_yaml: dic, all the parameters of the MCMC and klip
read from yaml file
Returns:
None
"""
thin = params_mcmc_yaml['THIN']
burnin = params_mcmc_yaml['BURNIN']
quality_plot = params_mcmc_yaml['QUALITY_PLOT']
labels = params_mcmc_yaml['LABELS']
names = params_mcmc_yaml['NAMES']
file_prefix = params_mcmc_yaml['FILE_PREFIX']
name_h5 = file_prefix + '_backend_file_mcmc'
reader = backends.HDFBackend(os.path.join(mcmcresultdir, name_h5 + '.h5'))
iter = reader.iteration
if iter < burnin - 1:
burnin = 0
params_mcmc_yaml['BURNIN'] = 0
chain = reader.get_chain(discard=0, thin=thin)
log_prob_samples_flat = reader.get_log_prob(discard=burnin,
flat=True,
thin=thin)
# print(log_prob_samples_flat)
tau = reader.get_autocorr_time(tol=0)
if burnin > reader.iteration - 1:
raise ValueError(
"the burnin cannot be larger than the # of iterations")
print("")
print("")
print(name_h5)
print("# of iteration in the backend chain initially: {0}".format(
reader.iteration))
print("Max Tau times 50: {0}".format(50 * np.max(tau)))
print("")
print("Maximum Likelyhood: {0}".format(np.nanmax(log_prob_samples_flat)))
print("burn-in: {0}".format(burnin))
print("chain shape: {0}".format(chain.shape))
n_dim_mcmc = chain.shape[2]
nwalkers = chain.shape[1]
diskfit_mcmc.SPF_MODEL = params_mcmc_yaml[
'SPF_MODEL'] #Type of description for the SPF
chain = chains_to_params(chain)
_, axarr = plt.subplots(n_dim_mcmc,
sharex=True,
figsize=(6.4 * quality_plot, 4.8 * quality_plot))
for i in range(n_dim_mcmc):
axarr[i].set_ylabel(labels[names[i]], fontsize=5 * quality_plot)
axarr[i].tick_params(axis='y', labelsize=4 * quality_plot)
for j in range(nwalkers):
axarr[i].plot(chain[:, j, i], linewidth=quality_plot)
axarr[i].axvline(x=burnin, color='black', linewidth=1.5 * quality_plot)
axarr[n_dim_mcmc - 1].tick_params(axis='x', labelsize=6 * quality_plot)
axarr[n_dim_mcmc - 1].set_xlabel('Iterations', fontsize=10 * quality_plot)
plt.savefig(os.path.join(mcmcresultdir, name_h5 + '_chains.jpg'))
plt.close()
