def mcmc_planets(post, outdir, sname, mstars, addextra=False):
conf_base = sname
nwalkers = 20
nsteps = 1000
ensembles = 8
msg = "Running MCMC for {}, N_ensembles = {}, N_walkers = {}, N_steps = {} ...".format(
conf_base, ensembles, nwalkers, nsteps)
print msg
chains = radvel.mcmc(post,
nwalkers=nwalkers,
nrun=nsteps,
ensembles=ensembles)
Ks = []
err_Ks = []
Ms = []
err_Ms = []
# Get quantiles and update posterior object
post_summary = chains.quantile([0.159, 0.5, 0.841])
for n in range(1, post.params.num_planets + 1):
post_summary['Mpsini%d' % (n)] = radvel.utils.Msini(
post_summary['k%d' % (n)], post.params['per%d' % (n)].value,
mstars[0], 0.)
if writefit:
Ks.append(post_summary['k%d' % (n)][0.5])
err_Ks.append(
(post_summary['k%d' %
(n)][0.841] - post_summary['k%d' %
(n)][0.159]) / 2.)
Ms.append(post_summary['Mpsini%d' % (n)][0.5])
err_Ms.append(
(post_summary['Mpsini%d' %
(n)][0.841] - post_summary['Mpsini%d' %
(n)][0.159]) / 2.)
if addextra:
n = post.params.num_planets
post_summary['Mpsini%d' % (n)] = radvel.utils.Msini(
post_summary['k%d' % (n)], post.params['per%d' % (n)].value,
mstars[0], 0.)
if writefit:
Ks.append(post_summary['k%d' % (n)][0.5])
err_Ks.append(
(post_summary['k%d' %
(n)][0.841] - post_summary['k%d' %
(n)][0.159]) / 2.)
Ms.append(post_summary['Mpsini%d' % (n)][0.5])
err_Ms.append(
(post_summary['Mpsini%d' %
(n)][0.841] - post_summary['Mpsini%d' %
(n)][0.159]) / 2.)
print "Saving output files..."
saveto = os.path.join(outdir, sname + '_post_summary.csv')
post_summary.to_csv(saveto, sep=',')
return chains, Ks, err_Ks, Ms, err_Ms
def approximate_planetary_params(self, nrun=500, nwalkers=30):
"""
Approximate the planetary mass and semi-major axis from the estimated planetary parameters implemented in
keplerian_analysis. The mass, semi-major axis, and period are stored in a csv file labeled
_PlanetaryProperties in the directory specified, and the rest of the orbital parameters are stored in a
seperate csv labeled _MCMCAnalysisPlanetaryParameters.csv in the directory specified.
:param nrun: the MCMC number of iterations
:param nwalkers: the number of MCMC walkers
"""
df = radvel.mcmc(self.post,
nwalkers=100,
nrun=nrun,
savename='rawchains.h5') # Start MCMC analysis
# Some cool plots
Corner = mcmc_plots.CornerPlot(self.post,
df,
saveplot=self.dir + "TestCornerPlot")
Corner.plot() # A corner plot
trendplot = radvel.plot.mcmc_plots.TrendPlot(self.post,
df,
nwalkers,
outfile=self.dir +
'TestTrendFile')
trendplot.plot() # A trend plot
multipanel = radvel.plot.orbit_plots.MultipanelPlot(self.post,
saveplot=self.dir +
'TestMultipanel')
multipanel.plot_multipanel(
) # A multipanel plot with the estimated parameters
# Make the planetary properties pandas DataFrame.
mass = []
a = []
for per in list(self.periods):
mass_ = radvel.utils.Msini(np.average(self.y.values),
per,
self.smass,
e=0.0)
mass.append(mass_)
a_ = radvel.utils.semi_major_axis(per, self.smass)
a.append(a_)
params_df = pd.DataFrame({
"Plantary Period (JD)": list(self.periods),
"Semi Major Axis (AU)": list(a),
"Planetary Mass (Earth masses)": list(mass)
})
print("Saving the computed planetary properties at the directory " +
self.dir + "...")
params_df.to_csv(self.dir + self.name + '_PlanetaryProperties.csv')
print("Done!")
self.paramsdf = params_df
print("Saving the computed orbital parameters at the directory " +
self.dir + "...")
df.to_csv(self.dir + self.name +
'_MCMCAnalysisPlanetaryParameters.csv')
print("Done!")
def mcmc_planets(post, outdir, sname, mstars, addextra=False):
conf_base = sname
nwalkers = 50
nsteps = 10000
ensembles = 8
msg = "Running MCMC for {}, N_ensembles = {}, N_walkers = {}, N_steps = {} ...".format(
conf_base, ensembles, nwalkers, nsteps)
print(msg)
chains = radvel.mcmc(post,
nwalkers=nwalkers,
nrun=nsteps,
ensembles=ensembles)
Ks = []
err_Ks = []
Ms = []
err_Ms = []
# Get quantiles and update posterior object
post_summary = chains.quantile([0.159, 0.5, 0.841])
c = 1
if addextra:
c = 2
for n in range(1, post.params.num_planets + c):
post_summary['Mpsini%d' % (n)] = radvel.utils.Msini(
(post_summary['k%d' % (n)]), post.params['per%d' % (n)].value,
mstars[0], 0.)
if writefit:
# Ks.append(post.params['k%d' % (n)].value)
Ks.append(post_summary['k%d' % (n)][0.5])
sigK = (post_summary['k%d' %
(n)][0.841] - post_summary['k%d' %
(n)][0.159]) / 2.
sigK = sigK #* np.exp(post_summary['logk%d' % (n)][0.5])
err_Ks.append(sigK)
# Ms.append(radvel.utils.Msini((post.params['k%d' % (n)]).value,post.params['per%d' % (n)].value,mstars[0],0.))
Ms.append(post_summary['Mpsini%d' % (n)][0.5])
err_Ms.append(
(post_summary['Mpsini%d' %
(n)][0.841] - post_summary['Mpsini%d' %
(n)][0.159]) / 2.)
print("Saving output files...")
saveto = os.path.join(outdir, sname + '_post_summary_cps_efix_wfix.csv')
post_summary.to_csv(saveto, sep=',')
return chains, Ks, err_Ks, Ms, err_Ms
def mcmc(args):
"""Perform MCMC error analysis
Args:
args (ArgumentParser): command line arguments
"""
config_file = args.setupfn
conf_base = os.path.basename(config_file).split('.')[0]
statfile = os.path.join(args.outputdir, "{}_radvel.stat".format(conf_base))
status = load_status(statfile)
if status.getboolean('fit', 'run'):
print("Loading starting positions from previous max-likelihood fit")
post = radvel.posterior.load(status.get('fit', 'postfile'))
else:
P, post = radvel.utils.initialize_posterior(config_file,
decorr=args.decorr)
msg = "Running MCMC for {}, N_walkers = {}, N_steps = {}, N_ensembles = {} ...".format(
conf_base, args.nwalkers, args.nsteps, args.ensembles)
print(msg)
chains = radvel.mcmc(post,
nwalkers=args.nwalkers,
nrun=args.nsteps,
ensembles=args.ensembles)
# Convert chains into synth basis
synthchains = chains.copy()
for par in post.params.keys():
if not post.params[par].vary:
synthchains[par] = post.params[par].value
synthchains = post.params.basis.to_synth(synthchains)
synth_quantile = synthchains.quantile([0.159, 0.5, 0.841])
# Get quantiles and update posterior object to median
# values returned by MCMC chains
post_summary = chains.quantile([0.159, 0.5, 0.841])
for k in chains.keys():
if k in post.params.keys():
post.params[k].value = post_summary[k][0.5]
print("Performing post-MCMC maximum likelihood fit...")
post = radvel.fitting.maxlike_fitting(post, verbose=False)
synthpost = copy.deepcopy(post)
synthparams = post.params.basis.to_synth(post.params)
synthpost.params.update(synthparams)
print("Calculating uncertainties...")
synthpost.uparams = {}
synthpost.medparams = {}
synthpost.maxparams = {}
for par in synthpost.params.keys():
maxlike = synthpost.params[par].value
med = synth_quantile[par][0.5]
high = synth_quantile[par][0.841] - med
low = med - synth_quantile[par][0.159]
err = np.mean([high, low])
err = radvel.utils.round_sig(err)
if err > 0.0:
med, err, errhigh = radvel.utils.sigfig(med, err)
maxlike, err, errhigh = radvel.utils.sigfig(maxlike, err)
synthpost.uparams[par] = err
synthpost.medparams[par] = med
synthpost.maxparams[par] = maxlike
print("Final loglikelihood = %f" % post.logprob())
print("Final RMS = %f" % post.likelihood.residuals().std())
print("Best-fit parameters:")
print(synthpost)
print("Saving output files...")
saveto = os.path.join(args.outputdir, conf_base + '_post_summary.csv')
post_summary.to_csv(saveto, sep=',')
postfile = os.path.join(args.outputdir,
'{}_post_obj.pkl'.format(conf_base))
synthpost.writeto(postfile)
csvfn = os.path.join(args.outputdir, conf_base + '_chains.csv.tar.bz2')
chains.to_csv(csvfn, compression='bz2')
savestate = {
'run': True,
'postfile': os.path.abspath(postfile),
'chainfile': os.path.abspath(csvfn),
'summaryfile': os.path.abspath(saveto),
'nwalkers': args.nwalkers,
'nsteps': args.nsteps
}
save_status(statfile, 'mcmc', savestate)
def mcmc(args):
"""Perform MCMC error analysis
Args:
args (ArgumentParser): command line arguments
"""
config_file = args.setupfn
conf_base = os.path.basename(config_file).split('.')[0]
statfile = os.path.join(args.outputdir,
"{}_radvel.stat".format(conf_base))
if args.save or args.proceed:
backend_loc = os.path.join(args.outputdir, conf_base+'_rawchain.h5')
else:
backend_loc = None
status = load_status(statfile)
P, post = radvel.utils.initialize_posterior(config_file,
decorr=args.decorr)
if status.getboolean('fit', 'run'):
print("Loading starting positions from previous MAP fit")
post = radvel.posterior.load(status.get('fit', 'postfile'))
msg1 = (
"Running MCMC for {}, N_walkers = {}, N_steps = {}, N_ensembles = {}, Min Auto Factor = {}, "
).format(conf_base, args.nwalkers, args.nsteps, args.ensembles, args.minAfactor)
msg2 = (
"Max Auto Relative-Change = {}, Max G-R = {}, Min Tz = {} ..."
).format(args.maxArchange, args.maxGR, args.minTz)
print(msg1 + '\n' + msg2)
chains = radvel.mcmc(post, nwalkers=args.nwalkers, nrun=args.nsteps, ensembles=args.ensembles,
minAfactor=args.minAfactor, maxArchange=args.maxArchange, burnAfactor=args.burnAfactor,
burnGR=args.burnGR, maxGR=args.maxGR, minTz=args.minTz, minsteps=args.minsteps,
minpercent=args.minpercent, thin=args.thin, serial=args.serial, save=args.save,
savename=backend_loc, proceed=args.proceed, proceedname=backend_loc, headless=args.headless)
mintz = statevars.mintz
maxgr = statevars.maxgr
minafactor = statevars.minafactor
maxarchange = statevars.maxarchange
# Convert chains into synth basis
synthchains = chains.copy()
for par in post.params.keys():
if not post.vector.vector[post.vector.indices[par]][1]:
synthchains[par] = post.vector.vector[post.vector.indices[par]][0]
synthchains = post.params.basis.to_synth(synthchains)
synth_quantile = synthchains.quantile([0.159, 0.5, 0.841])
# Get quantiles and update posterior object to median
# values returned by MCMC chains
post_summary = chains.quantile([0.159, 0.5, 0.841])
for k in chains.columns:
if k in post.params.keys():
post.vector.vector[post.vector.indices[k]][0] = post_summary[k][0.5]
post.vector.vector_to_dict()
print("Performing post-MCMC maximum likelihood fit...")
post = radvel.fitting.maxlike_fitting(post, verbose=False)
final_logprob = post.logprob()
final_residuals = post.likelihood.residuals().std()
final_chisq = np.sum(post.likelihood.residuals()**2 / (post.likelihood.errorbars()**2))
deg_of_freedom = len(post.likelihood.y) - len(post.likelihood.get_vary_params())
final_chisq_reduced = final_chisq / deg_of_freedom
post.vector.vector_to_dict()
synthparams = post.params.basis.to_synth(post.params)
print("Calculating uncertainties...")
post.uparams = {}
post.medparams = {}
post.maxparams = {}
for par in synthparams.keys():
maxlike = synthparams[par].value
med = synth_quantile[par][0.5]
high = synth_quantile[par][0.841] - med
low = med - synth_quantile[par][0.159]
err = np.mean([high, low])
if maxlike == -np.inf and med == -np.inf and np.isnan(low) and np.isnan(high):
err = 0.0
else:
err = radvel.utils.round_sig(err)
if err > 0.0:
med, err, errhigh = radvel.utils.sigfig(med, err)
maxlike, err, errhigh = radvel.utils.sigfig(maxlike, err)
post.uparams[par] = err
post.medparams[par] = med
post.maxparams[par] = maxlike
print("Final loglikelihood = %f" % final_logprob)
print("Final RMS = %f" % final_residuals)
print("Final reduced chi-square = {}".format(final_chisq_reduced))
print("Best-fit parameters:")
print(post)
print("Saving output files...")
saveto = os.path.join(args.outputdir, conf_base+'_post_summary.csv')
post_summary.to_csv(saveto, sep=',')
postfile = os.path.join(args.outputdir,
'{}_post_obj.pkl'.format(conf_base))
post.writeto(postfile)
csvfn = os.path.join(args.outputdir, conf_base+'_chains.csv.bz2')
chains.to_csv(csvfn, compression='bz2')
auto = pd.DataFrame()
auto['autosamples'] = statevars.autosamples
auto['automin'] = statevars.automin
auto['automean'] = statevars.automean
auto['automax'] = statevars.automax
auto['factor'] = statevars.factor
autocorr = os.path.join(args.outputdir, conf_base+'_autocorr.csv')
auto.to_csv(autocorr, sep=',')
savestate = {'run': True,
'postfile': os.path.relpath(postfile),
'chainfile': os.path.relpath(csvfn),
'autocorrfile': os.path.relpath(autocorr),
'summaryfile': os.path.relpath(saveto),
'nwalkers': statevars.nwalkers,
'nensembles': args.ensembles,
'maxsteps': args.nsteps*statevars.nwalkers*args.ensembles,
'nsteps': statevars.ncomplete,
'nburn': statevars.nburn,
'minafactor': minafactor,
'maxarchange': maxarchange,
'minTz': mintz,
'maxGR': maxgr}
save_status(statfile, 'mcmc', savestate)
statevars.reset()
def mcmc():
post = max_a_posteriori()
chains = radvel.mcmc(post, nrun=1000, ensembles=3)
return chains
def mcmc(args):
"""Perform MCMC error analysis
Args:
args (ArgumentParser): command line arguments
"""
config_file = args.setupfn
conf_base = os.path.basename(config_file).split('.')[0]
statfile = os.path.join(args.outputdir, "{}_radvel.stat".format(conf_base))
status = load_status(statfile)
if status.getboolean('fit', 'run'):
print("Loading starting positions from previous max-likelihood fit")
post = radvel.posterior.load(status.get('fit', 'postfile'))
else:
P, post = radvel.utils.initialize_posterior(config_file,
decorr=args.decorr)
msg = "Running MCMC for {}, N_walkers = {}, N_steps = {}, N_ensembles = {}, Max G-R = {}, Min Tz = {} ..."\
.format(conf_base, args.nwalkers, args.nsteps, args.ensembles, args.maxGR, args.minTz)
print(msg)
chains = radvel.mcmc(post,
nwalkers=args.nwalkers,
nrun=args.nsteps,
ensembles=args.ensembles,
burnGR=args.burnGR,
maxGR=args.maxGR,
minTz=args.minTz,
minsteps=args.minsteps,
thin=args.thin,
serial=args.serial)
mintz = statevars.mintz
maxgr = statevars.maxgr
# Convert chains into synth basis
synthchains = chains.copy()
for par in post.params.keys():
if not post.params[par].vary:
synthchains[par] = post.params[par].value
synthchains = post.params.basis.to_synth(synthchains)
synth_quantile = synthchains.quantile([0.159, 0.5, 0.841])
# Get quantiles and update posterior object to median
# values returned by MCMC chains
post_summary = chains.quantile([0.159, 0.5, 0.841])
for k in chains.keys():
if k in post.params.keys():
post.params[k].value = post_summary[k][0.5]
print("Performing post-MCMC maximum likelihood fit...")
post = radvel.fitting.maxlike_fitting(post, verbose=False)
final_logprob = post.logprob()
final_residuals = post.likelihood.residuals().std()
final_chisq = np.sum(post.likelihood.residuals()**2 /
(post.likelihood.errorbars()**2))
deg_of_freedom = len(post.likelihood.y) - len(
post.likelihood.get_vary_params())
final_chisq_reduced = final_chisq / deg_of_freedom
synthparams = post.params.basis.to_synth(post.params)
post.params.update(synthparams)
print("Calculating uncertainties...")
post.uparams = {}
post.medparams = {}
post.maxparams = {}
for par in post.params.keys():
maxlike = post.params[par].value
med = synth_quantile[par][0.5]
high = synth_quantile[par][0.841] - med
low = med - synth_quantile[par][0.159]
err = np.mean([high, low])
if maxlike == -np.inf and med == -np.inf and np.isnan(
low) and np.isnan(high):
err = 0.0
else:
err = radvel.utils.round_sig(err)
if err > 0.0:
med, err, errhigh = radvel.utils.sigfig(med, err)
maxlike, err, errhigh = radvel.utils.sigfig(maxlike, err)
post.uparams[par] = err
post.medparams[par] = med
post.maxparams[par] = maxlike
print("Final loglikelihood = %f" % final_logprob)
print("Final RMS = %f" % final_residuals)
print("Final reduced chi-square = {}".format(final_chisq_reduced))
print("Best-fit parameters:")
print(post)
print("Saving output files...")
saveto = os.path.join(args.outputdir, conf_base + '_post_summary.csv')
post_summary.to_csv(saveto, sep=',')
postfile = os.path.join(args.outputdir,
'{}_post_obj.pkl'.format(conf_base))
post.writeto(postfile)
csvfn = os.path.join(args.outputdir, conf_base + '_chains.csv.tar.bz2')
chains.to_csv(csvfn, compression='bz2')
savestate = {
'run': True,
'postfile': os.path.abspath(postfile),
'chainfile': os.path.abspath(csvfn),
'summaryfile': os.path.abspath(saveto),
'nwalkers': statevars.nwalkers,
'nensembles': args.ensembles,
'maxsteps': args.nsteps * statevars.nwalkers * args.ensembles,
'nsteps': statevars.ncomplete,
'nburn': statevars.nburn,
'minTz': mintz,
'maxGR': maxgr
}
save_status(statfile, 'mcmc', savestate)
def run_search(self,
fixed_threshold=None,
outdir=None,
mkoutdir=True,
running=True):
"""Run an iterative search for planets not given in posterior.
Args:
fixed_threshold (float): (optional) use a fixed delta BIC threshold
mkoutdir (bool): create the output directory?
"""
if outdir is None:
outdir = os.path.join(os.getcwd(), self.starname)
if mkoutdir and not os.path.exists(outdir):
os.mkdir(outdir)
if self.trend:
self.trend_test()
run = True
while run:
if self.num_planets != 0:
self.add_planet()
perioder = periodogram.Periodogram(self.post,
basebic=self.basebic,
minsearchp=self.min_per,
maxsearchp=self.max_per,
fap=self.fap,
manual_grid=self.manual_grid,
oversampling=self.oversampling,
baseline=self.baseline,
eccentric=self.eccentric,
workers=self.workers,
verbose=self.verbose)
# Run the periodogram, store arrays and threshold (if computed).
perioder.per_bic()
self.periodograms[self.num_planets] = perioder.power[self.crit]
if self.num_planets == 0 or self.pers is None:
self.pers = perioder.pers
if fixed_threshold is None:
perioder.eFAP()
self.eFAPs[self.num_planets] = perioder.fap_min
else:
perioder.bic_thresh = fixed_threshold
self.bic_threshes[self.num_planets] = perioder.bic_thresh
self.best_bics[self.num_planets] = perioder.best_bic
if self.save_outputs:
perioder.plot_per()
perioder.fig.savefig(outdir +
'/dbic{}.pdf'.format(self.num_planets +
1))
# Check whether there is a detection. If so, fit free and proceed.
if perioder.best_bic > perioder.bic_thresh:
self.num_planets += 1
for k in self.post.params.keys():
self.post.params[k].value = perioder.bestfit_params[k]
# Generalize tc reset to each new discovery.
tckey = 'tc{}'.format(self.num_planets)
if self.post.params[tckey].value < np.amin(self.data.time):
self.post.params[tckey].value = np.median(self.data.time)
for n in np.arange(1, self.num_planets + 1):
self.post.params['k{}'.format(n)].vary = False
self.post.params['per{}'.format(n)].vary = False
self.post.params['secosw{}'.format(n)].vary = False
self.post.params['secosw{}'.format(n)].vary = False
if n != self.num_planets:
self.post.params['tc{}'.format(n)].vary = False
self.post = radvel.fitting.maxlike_fitting(self.post,
verbose=False)
for n in np.arange(1, self.num_planets + 1):
self.post.params['k{}'.format(n)].vary = True
self.post.params['per{}'.format(n)].vary = True
self.post.params['secosw{}'.format(n)].vary = True
self.post.params['secosw{}'.format(n)].vary = True
self.post.params['tc{}'.format(n)].vary = True
self.fit_orbit()
self.all_params.append(self.post.params)
self.basebic = self.post.likelihood.bic()
else:
self.sub_planet()
# 8/3: Update the basebic anyway, for injections.
self.basebic = self.post.likelihood.bic()
run = False
if self.num_planets >= self.max_planets:
run = False
# If any jitter values are negative, flip them.
for key in self.post.params.keys():
if 'jit' in key:
if self.post.params[key].value < 0:
self.post.params[
key].value = -self.post.params[key].value
# Generate an orbit plot.
if self.save_outputs:
rvplot = orbit_plots.MultipanelPlot(
self.post,
saveplot=outdir +
'/orbit_plot{}.pdf'.format(self.num_planets))
multiplot_fig, ax_list = rvplot.plot_multipanel()
multiplot_fig.savefig(
outdir + '/orbit_plot{}.pdf'.format(self.num_planets))
# Generate running periodograms.
if running:
self.running_per()
# Run MCMC on final posterior, save new parameters and uncertainties.
if self.mcmc == True and (self.num_planets != 0
or self.post.params['dvdt'].vary == True):
self.post.uparams = {}
self.post.medparams = {}
self.post.maxparams = {}
# Use recommended parameters for mcmc.
nensembles = np.min([self.workers, 16])
if os.cpu_count() < nensembles:
nensembles = os.cpu_count()
# Set custom mcmc scales for e/w parameters.
for n in np.arange(1, self.num_planets + 1):
self.post.params['secosw{}'.format(n)].mcmcscale = 0.005
self.post.params['sesinw{}'.format(n)].mcmcscale = 0.005
# Sample in log-period space.
logpost = copy.deepcopy(self.post)
logparams = logpost.params.basis.to_any_basis(
logpost.params, 'logper tc secosw sesinw k')
logpost = utils.initialize_post(self.data, params=logparams)
# Run MCMC. #self.post #logpost
chains = radvel.mcmc(logpost,
nwalkers=50,
nrun=25000,
burnGR=1.03,
maxGR=1.0075,
minTz=2000,
minAfactor=15,
maxArchange=0.07,
burnAfactor=15,
minsteps=12500,
minpercent=50,
thin=5,
save=False,
ensembles=nensembles)
# Convert chains to per, e, w basis.
synthchains = logpost.params.basis.to_synth(chains)
synthquants = synthchains.quantile([0.159, 0.5, 0.841])
logpost = None
# Compress, thin, and save chains, in fitting and synthetic bases.
csvfn = outdir + '/chains.csv.tar.bz2'
synthchains.to_csv(csvfn, compression='bz2')
# Retrieve e and w medians & uncertainties from synthetic chains.
for n in np.arange(1, self.num_planets + 1):
e_key = 'e{}'.format(n)
w_key = 'w{}'.format(n)
# Add period if it's a synthetic parameter.
per_key = 'per{}'.format(n)
logper_key = 'logper{}'.format(n)
med_e = synthquants[e_key][0.5]
high_e = synthquants[e_key][0.841] - med_e
low_e = med_e - synthquants[e_key][0.159]
err_e = np.mean([high_e, low_e])
err_e = radvel.utils.round_sig(err_e)
med_e, err_e, errhigh_e = radvel.utils.sigfig(med_e, err_e)
max_e, err_e, errhigh_e = radvel.utils.sigfig(
self.post.params[e_key].value, err_e)
med_w = synthquants[w_key][0.5]
high_w = synthquants[w_key][0.841] - med_w
low_w = med_w - synthquants[w_key][0.159]
err_w = np.mean([high_w, low_w])
err_w = radvel.utils.round_sig(err_w)
med_w, err_w, errhigh_w = radvel.utils.sigfig(med_w, err_w)
max_w, err_w, errhigh_w = radvel.utils.sigfig(
self.post.params[w_key].value, err_w)
self.post.uparams[e_key] = err_e
self.post.uparams[w_key] = err_w
self.post.medparams[e_key] = med_e
self.post.medparams[w_key] = med_w
self.post.maxparams[e_key] = max_e
self.post.maxparams[w_key] = max_w
# Retrieve medians & uncertainties for the fitting basis parameters.
for par in self.post.params.keys():
if self.post.params[par].vary:
med = synthquants[par][0.5]
high = synthquants[par][0.841] - med
low = med - synthquants[par][0.159]
err = np.mean([high, low])
err = radvel.utils.round_sig(err)
med, err, errhigh = radvel.utils.sigfig(med, err)
max, err, errhigh = radvel.utils.sigfig(
self.post.params[par].value, err)
self.post.uparams[par] = err
self.post.medparams[par] = med
self.post.maxparams[par] = max
# Add uncertainties on derived parameters, if mass is provided.
if self.mstar is not None:
self.post = utils.derive(self.post, synthchains, self.mstar,
self.mstar_err)
if self.save_outputs:
# Generate a corner plot, sans nuisance parameters.
labels = []
for n in np.arange(1, self.num_planets + 1):
labels.append('per{}'.format(n))
labels.append('tc{}'.format(n))
labels.append('k{}'.format(n))
labels.append('secosw{}'.format(n))
labels.append('sesinw{}'.format(n))
if self.post.params['dvdt'].vary == True:
labels.append('dvdt')
if self.post.params['curv'].vary == True:
labels.append('curv')
texlabels = [
self.post.params.tex_labels().get(l, l) for l in labels
]
plot = corner.corner(synthchains[labels],
labels=texlabels,
label_kwargs={"fontsize": 14},
plot_datapoints=False,
bins=30,
quantiles=[0.16, 0.5, 0.84],
title_kwargs={"fontsize": 14},
show_titles=True,
smooth=True)
pl.savefig(outdir +
'/{}_corner_plot.pdf'.format(self.starname))
# Generate an orbit plot wth median parameters and uncertainties.
rvplot = orbit_plots.MultipanelPlot(
self.post,
saveplot=outdir +
'/orbit_plot_mc_{}.pdf'.format(self.starname),
uparams=self.post.uparams)
multiplot_fig, ax_list = rvplot.plot_multipanel()
multiplot_fig.savefig(
outdir + '/orbit_plot_mc_{}.pdf'.format(self.starname))
if self.save_outputs:
self.save(filename=outdir + '/post_final.pkl')
pickle_out = open(outdir + '/search.pkl', 'wb')
pickle.dump(self, pickle_out)
pickle_out.close()
periodograms_plus_pers = np.append([self.pers],
list(
self.periodograms.values()),
axis=0).T
np.savetxt(outdir + '/pers_periodograms.csv',
periodograms_plus_pers,
header='period BIC_array')
threshs_bics_faps = np.append(
[list(self.bic_threshes.values())],
[list(self.best_bics.values()),
list(self.eFAPs.values())],
axis=0).T
np.savetxt(outdir + '/thresholds_bics_faps.csv',
threshs_bics_faps,
header='threshold best_bic fap')
full_model_prior_transform.Npars,
sample='rwalk')
full_model_nested_sampler.run_nested()
full_model_nested_results = full_model_nested_sampler.results
with open(full_model_nested_sampling_results_file, "wb") as fi:
pickle.dump(full_model_nested_results, fi)
# MCMC
########
try:
full_model_mcmc_results = pd.read_pickle(full_model_mcmc_posterior_file)
print("MCMC results read from saved file.")
except FileNotFoundError:
print("No MCMC save file found.")
print("Running full model MCMC fit...")
full_model_mcmc_results = radvel.mcmc(full_model_post)
full_model_mcmc_results.to_pickle(full_model_mcmc_posterior_file)
##########################################################
#####################
# Nbody model fit #
#####################
##########################################################
if do_nbody:
print("Initializing N-body model fits...")
with open(HostStarInfoFile, "rb") as fi:
HostStarData = pickle.load(fi)
Mstar = HostStarData[system][0]
mps = system != 'HD 45364'
nbody_model_like = get_nbody_like(Observations,
Mstar,
P.stelar = dict(mstar=np.nan, mstar_err=np.nan)
if not hasattr(P, 'planet'):
planet = {}
for i in range(1, P.nplanets + 1):
planet['rp{}'.format(i)] = np.nan
for i in range(1, P.nplanets + 1):
planet['rp_err{}'.format(i)] = np.nan
P.planet = planet
if not opt.nomcmc:
msg = "Running MCMC, nwalkers = {}, nsteps = {} ...".format(
opt.nwalkers, opt.nsteps)
print msg
chains = radvel.mcmc(post,
threads=1,
nwalkers=opt.nwalkers,
nrun=opt.nsteps)
mstar = np.random.normal(loc=P.stellar['mstar'],
scale=P.stellar['mstar_err'],
size=len(chains))
# Convert chains into CPS basis
cpschains = chains.copy()
for par in post.params.keys():
if not post.vary[par]:
cpschains[par] = post.params[par]
cpschains = post.params.basis.to_cps(cpschains)
for i in np.arange(1, P.nplanets + 1, 1):
post.get_vary_params(),
method='L-BFGS-B')
# sf.plot_radvel_results(post.likelihood, t)
plt.savefig(fig_name + "%d_afterpriors.png" % err_ind, bbox_inches="tight")
print("After fitting\n")
print(post, "\n")
RVPlot = orbit_plots.MultipanelPlot(post)
RVPlot.plot_multipanel()
# plt.show()
plt.savefig(fig_name + "%d_afterpriors_multi.png" % err_ind,
bbox_inches="tight")
# plt.close(fig="all")
# df3 = radvel.mcmc(post) # amount of steps = nrun * 8 * nwalkers ?, default nrun is 10000, default nwalkers is 50?
df3 = radvel.mcmc(post, nrun=1000)
df3.to_pickle(fig_name + "%d_mcmc.pkl" % err_ind)
fig = corner.corner(df3[labels],
labels=labels,
quantiles=[0.16, 0.84],
plot_datapoints=False)
plt.savefig(fig_name + "%d_corner.png" % err_ind, bbox_inches="tight")
df2 = pd.read_pickle(fig_name + "%d_mcmc.pkl" % err_ind)
# df2 = df3.copy()
for i in range(1, 4):
df2["e%d" % i] = df2["secosw%d" % i] * df2["secosw%d" % i] + df2[
"sesinw%d" % i] * df2["sesinw%d" % i]
df2["m%d" % i] = sf.mass_from_VSA(df2["per%d" % i] / sf.days_p_year, Mstar,
