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,