def make_like(mod, invels, planets, addextra=False):
like = radvel.likelihood.RVLikelihood(mod, invels['time'], invels['mnvel'],
invels['errvel'])
gamma_guess = (invels['mnvel'].max() + invels['mnvel'].min()) / 2.
like.params['gamma'] = radvel.Parameter(value=0.01)
like.params['jit'] = radvel.Parameter(value=3.)
np = like.params.num_planets
if addextra:
np = np + 1
for n in range(1, np + 1):
like.params['w%d' % (n)].vary = True
like.params['e%d' % (n)].vary = False
like.params['per%d' % (n)].vary = False
like.params['tp%d' % (n)].vary = False
# like.params['secosw%d' % (n)].vary = False
# like.params['sesinw%d'% (n)].vary = False
# like.params['per%d' % (n)].vary = False
# like.params['tc%d' % (n)].vary = True
like.params['curv'].vary = False
like.params['jit'].vary = True
like.params['gamma'].vary = True
like.params['dvdt'].vary = False
return like
def initialize_instparams(tel_suffix):
indices = telgrps[tel_suffix]
params['gamma_' +
tel_suffix] = radvel.Parameter(value=np.mean(vel[indices]))
params['jit_' +
tel_suffix] = radvel.Parameter(value=jit_guesses[tel_suffix])
def test_priors():
"""
Test basic functionality of all Priors
"""
params = radvel.Parameters(1, 'per tc secosw sesinw logk')
params['per1'] = radvel.Parameter(10.0)
params['tc1'] = radvel.Parameter(0.0)
params['secosw1'] = radvel.Parameter(0.0)
params['sesinw1'] = radvel.Parameter(0.0)
params['logk1'] = radvel.Parameter(1.5)
vector = radvel.Vector(params)
testTex = r'Delta Function Prior on $\sqrt{e}\cos{\omega}_{b}$'
def userdef_prior_func(inp_list):
if inp_list[0] >= 0. and inp_list[0] < 1.:
return 0.
else:
return -np.inf
prior_tests = {
radvel.prior.EccentricityPrior(1):
1 / .99,
radvel.prior.EccentricityPrior([1]):
1 / .99,
radvel.prior.PositiveKPrior(1):
1.0,
radvel.prior.Gaussian('per1', 9.9, 0.1):
scipy.stats.norm(9.9, 0.1).pdf(10.),
radvel.prior.HardBounds('per1', 1.0, 9.0):
0.,
radvel.prior.HardBounds('per1', 1.0, 11.0):
1. / 10.,
radvel.prior.Jeffreys('per1', 0.1, 100.0):
(1. / 10.) / np.log(100. / 0.1),
radvel.prior.ModifiedJeffreys('per1', 0.1, 100.0, 0.):
(1. / 10.) / np.log(100. / 0.1),
radvel.prior.ModifiedJeffreys('per1', 2., 100.0, 1.):
(1. / 9.) / np.log(99.),
radvel.prior.SecondaryEclipsePrior(1, 5.0, 10.0):
1. / np.sqrt(2. * np.pi),
radvel.prior.NumericalPrior(['sesinw1'], np.random.randn(1, 5000000)):
scipy.stats.norm(0, 1).pdf(0.),
radvel.prior.UserDefinedPrior(['secosw1'], userdef_prior_func, testTex):
1.0,
radvel.prior.InformativeBaselinePrior('per1', 5.0, duration=1.0):
6. / 10.
}
for prior, val in prior_tests.items():
print(prior.__repr__())
print(prior.__str__())
tolerance = .01
print(abs(np.exp(prior(params, vector))))
print(val)
assert abs(np.exp(prior(params, vector)) - val) < tolerance, \
"Prior output does not match expectation"
def limit_plots(args):
"""
Generate plots
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)
assert status.getboolean('fit', 'run'), \
"Must perform max-liklihood fit before plotting"
postpath = status.get('fit', 'postfile')
postpath = os.path.join(args.outputdir, os.path.basename(postpath))
if not os.path.exists(postpath):
raise FileNotFoundError(f'expected posterior file to exist, {post}')
post = radvel.posterior.load(postpath)
# from timmy.driver.soneoff_drivers, 99.7th percetile
logk1_limit = 4.68726682
post.params['logk1'] = radvel.Parameter(value=logk1_limit)
post.params['k1'] = radvel.Parameter(value=np.exp(logk1_limit))
for ptype in args.type:
print("Creating {} plot for {}".format(ptype, conf_base))
if ptype == 'rv':
args.plotkw['uparams'] = post.uparams
saveto = os.path.join(args.outputdir,
conf_base + '_rvlimit_multipanel.pdf')
P, _ = radvel.utils.initialize_posterior(config_file)
if hasattr(P, 'bjd0'):
args.plotkw['epoch'] = P.bjd0
# import IPython; IPython.embed()
# P.params (set logk1 to whatever...)
# assert 0
RVPlot = MultipanelPlot(post, saveplot=saveto, **args.plotkw)
RVPlot.plot_multipanel()
savestate = {'{}_plot'.format(ptype): os.path.relpath(saveto)}
save_status(statfile, 'plot', savestate)
def test_priors():
"""
Test basic functionality of all Priors
"""
params = radvel.Parameters(1)
params['per1'] = radvel.Parameter(10.0)
params['tc1'] = radvel.Parameter(0.0)
params['secosw1'] = radvel.Parameter(0.0)
params['sesinw1'] = radvel.Parameter(0.0)
params['logk1'] = radvel.Parameter(1.5)
testTex = 'Delta Function Prior on $\sqrt{e}\cos{\omega}_{b}$'
def userdef_prior_func(inp_list):
if inp_list == [0.]:
return 0.
else:
return -np.inf
prior_tests = {
radvel.prior.EccentricityPrior(1):
0.0,
radvel.prior.PositiveKPrior(1):
0.0,
radvel.prior.Gaussian('per1', 10.0, 0.1):
0.0,
radvel.prior.HardBounds('per1', 1.0, 9.0):
-np.inf,
radvel.prior.Jeffreys('per1', 0.1, 100.0):
-np.log(params['per1'].value),
radvel.prior.ModifiedJeffreys('per1', 0.1, 100.0):
-np.log(params['per1'].value + 0.1),
radvel.prior.SecondaryEclipsePrior(1, 5.0, 1.0):
0.0,
radvel.prior.NumericalPrior(['sesinw1'], np.random.randn(1, 5000000)):
scipy.stats.norm(0, 1).pdf(0),
radvel.prior.UserDefinedPrior(['secosw1'], userdef_prior_func, testTex):
0.0
}
for prior, val in prior_tests.items():
print(prior.__repr__())
print(prior.__str__())
tolerance = .01
assert prior(params) == val or abs(prior(params) - val) < tolerance, \
"Prior output does not match expectation"
def __init__(self,
Nplanets,
Mstar=1.0,
time_base=0,
meters_per_second=True):
params = radvel.Parameters(Nplanets, basis='per tc secosw sesinw k')
self.num_planets = params.num_planets
self.meters_per_second = meters_per_second
for i in range(1, Nplanets + 1):
params.pop("k{}".format(i))
params.pop("tc{}".format(i))
params.update({"m{}".format(i): radvel.Parameter()})
params.update({"M{}".format(i): radvel.Parameter()})
params.update({"Mstar": radvel.Parameter(value=Mstar, vary=False)})
super(NbodyModel, self).__init__(params, _nb_rv_calc, time_base)
def initialize_params():
# Sarah's period guess: 21860.
params = radvel.Parameters(1, basis='per tc secosw sesinw k')
# Guess #2
params['per1'] = radvel.Parameter(value=21843.2) #21860.)
params['tc1'] = radvel.Parameter(value=2458936.) #2458975.79)
params['secosw1'] = radvel.Parameter(value=0.849)
params['sesinw1'] = radvel.Parameter(value=-0.313)
params['k1'] = radvel.Parameter(value=37.86)
params['dvdt'] = radvel.Parameter(value=0, vary=vary_dvdt)
params['curv'] = radvel.Parameter(value=0, vary=False)
'''
# Sarah's parameters
params = radvel.Parameters(1,basis='per tp e w k')
params['per1'] = radvel.Parameter(value=21860.)
params['tp1'] = radvel.Parameter(value=2458104.64)#18134.)
params['e1'] = radvel.Parameter(value=0.84)
params['w1'] = radvel.Parameter(value=-0.26)
params['k1'] = radvel.Parameter(value=38.)
params['dvdt'] = radvel.Parameter(value=0, vary=vary_dvdt)
params['curv'] = radvel.Parameter(value=0, vary=False)
# Convert input orbital parameters into the fitting basis
params = params.basis.to_any_basis(params,fitting_basis)
'''
return params
def keplerian_analysis(self, periods, numplanets):
"""
Analyze the given parameters from initializing the model and update the posteriors, as in the tutorial
described by Fulton et al. (2018).
:param periods: the periods in the system.
:param numplanets: The number of planets in the system.
"""
# Initialize model
mod = KeplerianAnalysis(self.df,
self.lsdf,
self.gamma,
self.jit,
stellar_mass=self.smass,
starname=self.name,
directory=self.dir).initialize_model(
periods, numplanets)
like = radvel.likelihood.RVLikelihood(mod, self.t, self.y, self.err)
like.params['gamma'] = radvel.Parameter(
value=self.gamma, vary=False,
linear=True) # Measurement uncertainty
like.params['jit'] = radvel.Parameter(
value=self.jit) # Stellar Activity noise
for i in range(1, numplanets + 1):
like.params['per' + str(i)].vary = True
like.params['tc' + str(i)].vary = True
like.params['secosw' + str(i)].vary = False
like.params['sesinw' + str(i)].vary = False
print(like)
# Update posteriors
post = radvel.posterior.Posterior(like)
res = optimize.minimize(post.neglogprob_array,
post.get_vary_params(),
method='Powell')
# Update the class's properties to match.
self.like = like
self.mod = mod
self.res = res
self.post = post
print(post)
print('\n')
def main(hack_radvel_plots=0, make_my_plot=1):
# initialization script used to make the fix_gammadot fits
basedir = "/home/luke/Dropbox/proj/WASP-4b_decay/"
setupfn = os.path.join(basedir, "src/WASP4.py")
outputdir = os.path.join(basedir,
"results/rv_fitting/fix_gammaddot_for_paper")
args = args_object(setupfn, outputdir)
args.inputdir = os.path.join(
basedir, "results/rv_fitting/t10onlytwo_LGB_20190228_fix_gammaddot")
# radvel plot -t rv -s $basepath
args.type = ['rv']
if hack_radvel_plots:
_hack_radvel_plots(args)
# get residuals, RVs, error bars, etc.
config_file = args.setupfn
conf_base = os.path.basename(config_file).split('.')[0]
statfile = os.path.join(args.inputdir, "{}_radvel.stat".format(conf_base))
status = load_status(statfile)
assert status.getboolean('fit', 'run'), \
"Must perform max-liklihood fit before plotting"
# initialize posterior object from the statfile that is passed.
post = radvel.posterior.load(status.get('fit', 'postfile'))
# update the posterior to match the median best-fit parameters.
summarycsv = "../results/rv_fitting/t10onlytwo_LGB_20190228_fix_gammaddot/WASP4_post_summary.csv"
sdf = pd.read_csv(summarycsv)
for param in [c for c in sdf.columns if 'Unnamed' not in c]:
post.params[param] = radvel.Parameter(value=sdf.ix[1][param])
P, _ = radvel.utils.initialize_posterior(config_file)
if hasattr(P, 'bjd0'):
args.plotkw['epoch'] = P.bjd0
model = post.likelihood.model
rvtimes = post.likelihood.x
rvs = post.likelihood.y
rverrs = post.likelihood.errorbars()
num_planets = model.num_planets
telvec = post.likelihood.telvec
dvdt_merr = sdf['dvdt'].iloc[0]
dvdt_perr = sdf['dvdt'].iloc[2]
rawresid = post.likelihood.residuals()
resid = (rawresid + post.params['dvdt'].value *
(rvtimes - model.time_base) + post.params['curv'].value *
(rvtimes - model.time_base)**2)
plot_rvs(rvtimes, rvs, rverrs, resid, telvec, post.params['dvdt'].value,
post.params['curv'].value, dvdt_merr, dvdt_perr, model.time_base)
def _get_fit_results(setupfn, outputdir):
args = args_object(setupfn, outputdir)
args.inputdir = outputdir
# radvel plot -t rv -s $basepath
args.type = ['rv']
# get residuals, RVs, error bars, etc from the fit that has been run..
config_file = args.setupfn
conf_base = os.path.basename(config_file).split('.')[0]
statfile = os.path.join(args.inputdir, "{}_radvel.stat".format(conf_base))
status = load_status(statfile)
if not status.getboolean('fit', 'run'):
raise AssertionError("Must perform max-liklihood fit before plotting")
# initialize posterior object from the statfile that is passed.
post = radvel.posterior.load(status.get('fit', 'postfile'))
# update the posterior to match the median best-fit parameters.
summarycsv = os.path.join(outputdir, "WASP4_post_summary.csv")
sdf = pd.read_csv(summarycsv)
for param in [c for c in sdf.columns if 'Unnamed' not in c]:
post.params[param] = radvel.Parameter(value=sdf.ix[1][param])
P, _ = radvel.utils.initialize_posterior(config_file)
if hasattr(P, 'bjd0'):
args.plotkw['epoch'] = P.bjd0
model = post.likelihood.model
rvtimes = post.likelihood.x
rvs = post.likelihood.y
rverrs = post.likelihood.errorbars()
num_planets = model.num_planets
telvec = post.likelihood.telvec
dvdt_merr = sdf['dvdt'].iloc[0]
dvdt_perr = sdf['dvdt'].iloc[2]
rawresid = post.likelihood.residuals()
resid = (
rawresid + post.params['dvdt'].value*(rvtimes-model.time_base)
+ post.params['curv'].value*(rvtimes-model.time_base)**2
)
rvtimes, rvs, rverrs, resid, telvec = rvtimes, rvs, rverrs, resid, telvec
dvdt, curv = post.params['dvdt'].value, post.params['curv'].value
dvdt_merr, dvdt_perr = dvdt_merr, dvdt_perr
time_base = model.time_base
return (rvtimes, rvs, rverrs, resid, telvec, dvdt, curv, dvdt_merr,
dvdt_perr, time_base)
def test_basis():
"""
Test basis conversions
"""
basis_list = radvel.basis.BASIS_NAMES
default_basis = 'per tc e w k'
anybasis_params = radvel.Parameters(1, basis=default_basis)
anybasis_params['per1'] = radvel.Parameter(value=20.885258)
anybasis_params['tc1'] = radvel.Parameter(value=2072.79438)
anybasis_params['e1'] = radvel.Parameter(value=0.01)
anybasis_params['w1'] = radvel.Parameter(value=1.6)
anybasis_params['k1'] = radvel.Parameter(value=10.0)
anybasis_params['dvdt'] = radvel.Parameter(value=0.0)
anybasis_params['curv'] = radvel.Parameter(value=0.0)
anybasis_params['gamma_j'] = radvel.Parameter(1.0)
anybasis_params['jit_j'] = radvel.Parameter(value=2.6)
for new_basis in basis_list:
iparams = radvel.basis._copy_params(anybasis_params)
ivector = radvel.Vector(iparams)
if new_basis != default_basis:
new_vector = iparams.basis.v_to_any_basis(ivector, new_basis)
new_params = iparams.basis.to_any_basis(iparams, new_basis)
tmpv = new_vector.copy()
tmp = radvel.basis._copy_params(new_params)
old_vector = tmp.basis.v_to_any_basis(tmpv, default_basis)
old_params = tmp.basis.to_any_basis(tmp, default_basis)
for par in iparams:
before = iparams[par].value
after = old_params[par].value
assert (before - after) <= 1e-5,\
"Parameters do not match after basis conversion: \
{}, {} != {}" .format(par, before, after)
for i in range(ivector.vector.shape[0]):
before = ivector.vector[i][0]
after = old_vector[i][0]
assert (before - after) <= 1e-5, \
"Vectors do not match after basis conversion: \
{} row, {} != {}" .format(i, before, after)
def draw_models(setupfn, outputdir, chaindf, times, n_samples=None):
# return n_samples x n_rvs RV models, and the parameters they were drawn
# from.
chain_samples = chaindf.sample(n=n_samples).drop('Unnamed: 0', axis=1)
chain_sample_params = chain_samples.drop('lnprobability', axis=1)
# get residuals, RVs, error bars, etc from the fit that has been run..
args = args_object(setupfn, outputdir)
args.inputdir = outputdir
args.type = ['rv']
config_file = args.setupfn
conf_base = os.path.basename(config_file).split('.')[0]
statfile = os.path.join(args.inputdir, "{}_radvel.stat".format(conf_base))
status = load_status(statfile)
# initialize posterior object from the statfile that is passed.
post = radvel.posterior.load(status.get('fit', 'postfile'))
rvmodel = deepcopy(post.likelihood.model)
rvmodel.params['curv'] = radvel.Parameter(0, vary=False)
# set the RV model parameters use the sample parameters from the chain.
# then calculate the model and append it.
model_rvs = []
for ix, sample_row in chain_sample_params.iterrows():
for key in sample_row.index:
rvmodel.params[key] = radvel.Parameter(sample_row[key], vary=True)
model_rvs.append( rvmodel(times) )
model_rvs = np.vstack(model_rvs)
return model_rvs, chain_sample_params
def test_kernels():
"""
Test basic functionality of all standard GP kernels
"""
kernel_list = radvel.gp.KERNELS
for kernel in kernel_list:
hnames = kernel_list[
kernel] # gets list of hyperparameter name strings
hyperparams = {k: radvel.Parameter(value=1.) for k in hnames}
kernel_call = getattr(radvel.gp, kernel + "Kernel")
test_kernel = kernel_call(hyperparams)
x = np.array([1., 2., 3.])
test_kernel.compute_distances(x, x)
test_kernel.compute_covmatrix(x.T)
print("Testing {}".format(kernel_call(hyperparams)))
sys.stdout.write(
"Testing error catching with dummy hyperparameters... \n")
fakeparams1 = {}
fakeparams1['dummy'] = radvel.Parameter(value=1.0)
try:
kernel_call(fakeparams1)
raise Exception('Test #1 failed for {}'.format(kernel))
except AssertionError:
sys.stdout.write("passed #1\n")
fakeparams2 = copy.deepcopy(hyperparams)
fakeparams2[hnames[0]] = 1.
try:
kernel_call(fakeparams2)
raise Exception('Test #2 failed for {}'.format(kernel))
except AttributeError:
sys.stdout.write("passed #2\n")
def initialize_model(e):
time_base = 0.0
params = radvel.Parameters(1, basis='per tp e w k')
params['per1'] = radvel.Parameter(value=6)
params['tp1'] = radvel.Parameter(value=2)
params['e1'] = radvel.Parameter(value=e)
params['w1'] = radvel.Parameter(value=0.0)
params['k1'] = radvel.Parameter(value=10.1)
mod = radvel.RVModel(params, time_base=time_base)
mod.params['dvdt'] = radvel.Parameter(value=-0.0)
mod.params['curv'] = radvel.Parameter(value=0.0)
return mod
def make_like(mod, invels, planets, addextra=False):
like = radvel.likelihood.RVLikelihood(mod, invels['time'], invels['mnvel'],
invels['errvel'])
like.params['gamma'] = radvel.Parameter(value=0.01)
like.params['jit'] = radvel.Parameter(value=3.)
for n in range(1, like.params.num_planets + 1):
like.params['w%d' % (n)].vary = True
like.params['e%d' % (n)].vary = False
like.params['per%d' % (n)].vary = False
like.params['tp%d' % (n)].vary = False
if addextra:
n = like.params.num_planets
like.params['e%d' % (n)].vary = True
like.params['per%d' % (n)].vary = True
like.params['tp%d' % (n)].vary = True
like.params['curv'].vary = False
like.params['jit'].vary = True
like.params['gamma'].vary = True
like.params['dvdt'].vary = False
return like
def initialize_params():
params = radvel.Parameters(1, basis='per tp e w k')
params['per1'] = radvel.Parameter(value=12525.0)
params['tp1'] = radvel.Parameter(value=2450593.5)
params['k1'] = radvel.Parameter(value=725.3)
params['e1'] = radvel.Parameter(value=0.74)
params['w1'] = radvel.Parameter(value=4.6967)
params['dvdt'] = radvel.Parameter(value=0, vary=vary_dvdt)
params['curv'] = radvel.Parameter(value=0, vary=False)
# Convert input orbital parameters into the fitting basis
params = params.basis.to_any_basis(params, fitting_basis)
return params
def initialize_params():
params = radvel.Parameters(1,basis='per tc e w k')
params['per1'] = radvel.Parameter(value=16469.7)
params['tc1'] = radvel.Parameter(value=2457211.2)
params['k1'] = radvel.Parameter(value=786.5)
params['e1'] = radvel.Parameter(value=0.645)
params['w1'] = radvel.Parameter(value=-2.48)
params['dvdt'] = radvel.Parameter(value=0, vary=vary_dvdt)
params['curv'] = radvel.Parameter(value=0, vary=False)
# Convert input orbital parameters into the fitting basis
params = params.basis.to_any_basis(params,fitting_basis)
return params
def initialize_params():
params = radvel.Parameters(1, basis='per tp e w k')
params['per1'] = radvel.Parameter(value=71.4808)
params['tp1'] = radvel.Parameter(value=2450300.608)
params['k1'] = radvel.Parameter(value=343.232)
params['e1'] = radvel.Parameter(value=0.11316)
params['w1'] = radvel.Parameter(value=2.89598)
params['dvdt'] = radvel.Parameter(value=0, vary=False)
params['curv'] = radvel.Parameter(value=0, vary=False)
# Convert input orbital parameters into the fitting basis
params = params.basis.to_any_basis(params, fitting_basis)
return params
def initialize_params():
params = radvel.Parameters(1, basis='per tc e w k')
params['per1'] = radvel.Parameter(value=323.33)
params['tc1'] = radvel.Parameter(value=2450305.3)
params['k1'] = radvel.Parameter(value=27019.0)
params['e1'] = radvel.Parameter(value=0.832)
params['w1'] = radvel.Parameter(value=2.2)
params['dvdt'] = radvel.Parameter(value=4.07, vary=vary_dvdt)
params['curv'] = radvel.Parameter(value=0, vary=False)
# Convert input orbital parameters into the fitting basis
params = params.basis.to_any_basis(params, fitting_basis)
return params
def initialize_params():
params = radvel.Parameters(1, basis='per tc e w k')
params['per1'] = radvel.Parameter(value=4433.0)
params['tc1'] = radvel.Parameter(value=2451281.0)
params['k1'] = radvel.Parameter(value=612.2)
params['e1'] = radvel.Parameter(value=0.34)
params['w1'] = radvel.Parameter(value=-2.36)
params['dvdt'] = radvel.Parameter(value=0, vary=vary_dvdt)
params['curv'] = radvel.Parameter(value=0, vary=False)
# Convert input orbital parameters into the fitting basis
params = params.basis.to_any_basis(params, fitting_basis)
return params
def initialize_params():
params = radvel.Parameters(1, basis='per tc e w k')
params['per1'] = radvel.Parameter(value=8443.5) #8585.24)
params['tc1'] = radvel.Parameter(value=2458314.1) #8341.5)
params['k1'] = radvel.Parameter(value=2908.0) #2958.5)
params['e1'] = radvel.Parameter(value=0.678) #0.685)
params['w1'] = radvel.Parameter(value=1.129) #1.134)
params['dvdt'] = radvel.Parameter(value=0, vary=False)
params['curv'] = radvel.Parameter(value=0, vary=False)
# Convert input orbital parameters into the fitting basis
params = params.basis.to_any_basis(params, fitting_basis)
return params
def initialize_params():
params = radvel.Parameters(1,basis='per tc e w k')
params['per1'] = radvel.Parameter(value=80686)
params['tc1'] = radvel.Parameter(value=2455110.7)
params['k1'] = radvel.Parameter(value=2730.3)
params['e1'] = radvel.Parameter(value=0.66)
params['w1'] = radvel.Parameter(value=0.76)
params['dvdt'] = radvel.Parameter(value=0, vary=vary_dvdt)
params['curv'] = radvel.Parameter(value=0, vary=False)
# Convert input orbital parameters into the fitting basis
params = params.basis.to_any_basis(params,fitting_basis)
return params
def initialize_params():
params = radvel.Parameters(1, basis='per tc e w k')
params['per1'] = radvel.Parameter(value=26905)
params['tc1'] = radvel.Parameter(value=7604.22 + bjd0)
params['k1'] = radvel.Parameter(value=711.0)
params['e1'] = radvel.Parameter(value=0.637)
params['w1'] = radvel.Parameter(value=2.358)
params['dvdt'] = radvel.Parameter(value=0, vary=vary_dvdt)
params['curv'] = radvel.Parameter(value=0, vary=False)
# Convert input orbital parameters into the fitting basis
params = params.basis.to_any_basis(params, fitting_basis)
return params
def initialize_params():
params = radvel.Parameters(1, basis='per tp e w k')
params['per1'] = radvel.Parameter(value=25962.)
params['tp1'] = radvel.Parameter(value=18134.)
params['e1'] = radvel.Parameter(value=0.84)
params['w1'] = radvel.Parameter(value=-0.26)
params['k1'] = radvel.Parameter(value=38.)
params['dvdt'] = radvel.Parameter(value=0, vary=vary_dvdt)
params['curv'] = radvel.Parameter(value=0, vary=False)
# Convert input orbital parameters into the fitting basis
params = params.basis.to_any_basis(params, fitting_basis)
return params
def initialize_params():
params = radvel.Parameters(1,basis='per tc e w k')
params['per1'] = radvel.Parameter(value=44495.8)
params['tc1'] = radvel.Parameter(value=2441100.06)
params['k1'] = radvel.Parameter(value=578.2)
params['e1'] = radvel.Parameter(value=0.63)
params['w1'] = radvel.Parameter(value=-1.85)
params['dvdt'] = radvel.Parameter(value=0, vary=vary_dvdt)
params['curv'] = radvel.Parameter(value=0, vary=False)
# Convert input orbital parameters into the fitting basis
params = params.basis.to_any_basis(params,fitting_basis)
return params
def initialize_params():
params = radvel.Parameters(1, basis='per tc e w k')
params['per1'] = radvel.Parameter(value=10084.5)
params['tc1'] = radvel.Parameter(value=2455548.8)
params['k1'] = radvel.Parameter(value=900.3)
params['e1'] = radvel.Parameter(value=0.52)
params['w1'] = radvel.Parameter(value=-0.83)
params['dvdt'] = radvel.Parameter(value=0, vary=vary_dvdt)
params['curv'] = radvel.Parameter(value=0, vary=False)
# Convert input orbital parameters into the fitting basis
params = params.basis.to_any_basis(params, fitting_basis)
return params
def initialize_params():
params = radvel.Parameters(1, basis='per tc e w k')
params['per1'] = radvel.Parameter(value=709.54)
params['tc1'] = radvel.Parameter(value=2457758.54) #2454920.0)
params['k1'] = radvel.Parameter(value=5672.0)
params['e1'] = radvel.Parameter(value=0.32)
params['w1'] = radvel.Parameter(value=1.11)
params['dvdt'] = radvel.Parameter(value=0, vary=vary_dvdt)
params['curv'] = radvel.Parameter(value=0, vary=False)
# Convert input orbital parameters into the fitting basis
params = params.basis.to_any_basis(params, fitting_basis)
return params
def initialize_params():
params = radvel.Parameters(1, basis='per tc secosw sesinw k')
params['per1'] = radvel.Parameter(value=30477.33)
params['tc1'] = radvel.Parameter(value=2451703.3)
params['k1'] = radvel.Parameter(value=4252.6)
params['secosw1'] = radvel.Parameter(value=0.23)
params['sesinw1'] = radvel.Parameter(value=0.65)
params['dvdt'] = radvel.Parameter(value=0, vary=vary_dvdt)
params['curv'] = radvel.Parameter(value=0, vary=False)
# Convert input orbital parameters into the fitting basis
params = params.basis.to_any_basis(params, fitting_basis)
return params
def initialize_params():
params = radvel.Parameters(1, basis='per tc e w k')
params['per1'] = radvel.Parameter(value=6829)
params['tc1'] = radvel.Parameter(value=2458538.0)
params['k1'] = radvel.Parameter(value=3530)
params['e1'] = radvel.Parameter(value=0.87)
params['w1'] = radvel.Parameter(value=2.97)
params['dvdt'] = radvel.Parameter(value=0, vary=vary_dvdt)
params['curv'] = radvel.Parameter(value=0, vary=False)
# Convert input orbital parameters into the fitting basis
params = params.basis.to_any_basis(params, fitting_basis)
return params
def initialize_params():
params = radvel.Parameters(1, basis='per tc e w k')
#From Halbwachs et al. 2018
params['per1'] = radvel.Parameter(value=5554.71)
params['tc1'] = radvel.Parameter(value=2453540.68) #2448024.2)
params['k1'] = radvel.Parameter(value=2812.17)
params['e1'] = radvel.Parameter(value=0.656)
params['w1'] = radvel.Parameter(value=1.987)
params['dvdt'] = radvel.Parameter(value=0, vary=vary_dvdt)
params['curv'] = radvel.Parameter(value=0, vary=False)
# Convert input orbital parameters into the fitting basis
params = params.basis.to_any_basis(params, fitting_basis)
return params
