def rv_curve_model(
t_obs,
t0,
period,
f_c,
f_s,
a,
offset,
):
rv1, rv2 = ellc.rv(t_obs=t_obs,
radius_1=in_radius_1,
radius_2=in_radius_2,
sbratio=in_sbratio,
incl=in_incl,
t_zero=t0,
period=period,
q=0.21864444,
a=a,
f_c=f_c,
f_s=f_s,
grid_1='very_sparse',
grid_2='very_sparse')
#Account for instrumental offset
rv1 = rv1 - offset
return rv1
def rv_fct(params, inst, companion, xx=None):
'''
! params must be updated via update_params() before calling this function !
'''
if xx is None:
xx = config.BASEMENT.data[inst]['time']
t_exp = config.BASEMENT.settings['t_exp_'+inst]
n_int = config.BASEMENT.settings['t_exp_n_int_'+inst]
else:
t_exp = None
n_int = None
model_rv1, model_rv2 = ellc.rv(
t_obs = xx,
radius_1 = params[companion+'_radius_1'],
radius_2 = params[companion+'_radius_2'],
sbratio = params[companion+'_sbratio_'+inst],
incl = params[companion+'_incl'],
t_zero = params[companion+'_epoch'],
period = params[companion+'_period'],
a = params[companion+'_a'],
q = params[companion+'_q'],
f_c = params[companion+'_f_c'],
f_s = params[companion+'_f_s'],
ldc_1 = params['host_ldc_'+inst],
ldc_2 = params[companion+'_ldc_'+inst],
gdc_1 = params['host_gdc_'+inst],
gdc_2 = params[companion+'_gdc_'+inst],
didt = params['didt_'+inst],
domdt = params['domdt_'+inst],
rotfac_1 = params['host_rotfac_'+inst],
rotfac_2 = params[companion+'_rotfac_'+inst],
hf_1 = params['host_hf_'+inst], #1.5,
hf_2 = params[companion+'_hf_'+inst], #1.5,
bfac_1 = params['host_bfac_'+inst],
bfac_2 = params[companion+'_bfac_'+inst],
heat_1 = params['host_geom_albedo_'+inst]/2.,
heat_2 = params[companion+'_geom_albedo_'+inst]/2.,
lambda_1 = params['host_lambda_'+inst],
lambda_2 = params[companion+'_lambda_'+inst],
vsini_1 = params['host_vsini_'+inst],
vsini_2 = params[companion+'_vsini_'+inst],
t_exp = t_exp,
n_int = n_int,
grid_1 = config.BASEMENT.settings['host_grid_'+inst],
grid_2 = config.BASEMENT.settings[companion+'_grid_'+inst],
ld_1 = config.BASEMENT.settings['host_ld_law_'+inst],
ld_2 = config.BASEMENT.settings[companion+'_ld_law_'+inst],
shape_1 = config.BASEMENT.settings['host_shape_'+inst],
shape_2 = config.BASEMENT.settings[companion+'_shape_'+inst],
spots_1 = params['host_spots_'+inst],
spots_2 = params[companion+'_spots_'+inst],
#flux_weighted = config.BASEMENT.settings[companion+'_flux_weighted_'+inst],
flux_weighted = False,
verbose = False
)
return model_rv1, model_rv2
def get_rv(time):
return ellc.rv(
t_obs=time,
a=params[planet + '_a'],
incl=params[planet + '_incl'],
t_zero=params[planet + '_epoch'],
period=params[planet + '_period'],
q=params[planet + '_q'],
flux_weighted=False,
)[0]
def get_radial_velocity(x,
period,
t0,
incl,
K,
K2=None,
ecc=0,
omega=90,
sbratio=0):
try:
from ellc import rv
except ModuleNotFoundError:
print("Please install `ellc` to use this function")
sys.exit()
K *= u.m / u.s
period *= u.day
a1 = (K * period * np.sqrt(1 - ecc**2) /
(2 * np.pi * np.sin(np.deg2rad(incl)))).to(u.R_sun).value
if K2 is not None:
K2 *= u.m / u.s
q = K / K2
a2 = (K2 * period * np.sqrt(1 - ecc**2) /
(2 * np.pi * np.sin(np.deg2rad(incl)))).to(u.R_sun).value
a = a1 + a2
else:
q = 1
a = a1 * (1 + 1 / q)
fs = np.sqrt(ecc) * np.sin(np.deg2rad(omega))
fc = np.sqrt(ecc) * np.cos(np.deg2rad(omega))
model = rv(x,
period=period.value,
t_zero=t0,
incl=incl,
sbratio=0,
a=a,
q=q,
f_s=fs,
f_c=fc,
flux_weighted=False)
if K2 is None:
return model[0] * 1e3
else:
return [m * 1e3 for m in model]
def ellc_rv_short(time):
return ellc.rv(t_obs=time,
radius_1=params['R_host/a'],
radius_2=params['R_companion/a'],
sbratio=sbratio,
incl=params['incl'],
t_zero=epoch,
period=params['period'],
a=params['a'],
q=1,
f_c=params['f_c'],
f_s=params['f_s'],
ldc_1=ldc,
ldc_2=None,
gdc_1=None,
gdc_2=None,
didt=None,
domdt=None,
rotfac_1=1,
rotfac_2=1,
hf_1=1.5,
hf_2=1.5,
bfac_1=None,
bfac_2=None,
heat_1=None,
heat_2=None,
lambda_1=None,
lambda_2=None,
vsini_1=None,
vsini_2=None,
t_exp=None,
n_int=None,
grid_1='default',
grid_2='default',
ld_1=ld,
ld_2=None,
shape_1='sphere',
shape_2='sphere',
spots_1=None,
spots_2=None,
verbose=1)[0]
def rv_fct(params, inst, planet, xx=None):
'''
! params must be updated via update_params() before calling this function !
'''
if xx is None:
xx = config.BASEMENT.data[inst]['time']
model_rv1, model_rv2 = ellc.rv(
t_obs=xx,
incl=params[planet + '_incl'],
t_zero=params[planet + '_epoch'],
period=params[planet + '_period'],
a=params[planet + '_a'],
f_c=params[planet + '_f_c'],
f_s=params[planet + '_f_s'],
q=params[planet + '_q'],
flux_weighted=False,
t_exp=config.BASEMENT.settings['t_exp_' + inst],
n_int=config.BASEMENT.settings['t_exp_n_int_' + inst])
return model_rv1, model_rv2
def _model(x, fw):
return rv(x,
radius_1=r1oa,
radius_2=r2oa,
period=period.value,
t_zero=t0,
incl=incl,
sbratio=0,
a=a,
q=q,
f_s=f_s,
f_c=f_c,
ld_1=ld,
ldc_1=ustar,
flux_weighted=fw,
vsini_1=vsini,
lambda_1=ell,
t_exp=texp,
n_int=oversample,
grid_1='very_sparse',
grid_2='very_sparse')[0] * 1e3
def get_value(self, t, flux_weighted=False):
# Get r2
r2 = self.r1 * self.k
incl = 180 * np.arccos(self.b * self.r1) / np.pi
# get limb darkening coeffs
a1, a2, a3, a4, g1 = ellc.ldy.LimbGravityDarkeningCoeffs('V')(
self.T_ld, self.Logg_ld, self.M_ld)
ldc = [a1, a2, a3, a4]
# Correct for drift
tau = t - self.Pdot * (t - self.T_tr)
# Now do preliminaries
e = self.fc**2 + self.fs**2
a = 0.019771142 * self.K * np.sqrt(1 - e**2) * (
1 + 1 / self.q) * self.P / np.sin(np.pi * incl / 180)
# Then make the call
rv1, rv2 = ellc.rv(t,
radius_1=self.r1,
radius_2=r2,
sbratio=self.sbratio,
incl=incl,
q=self.q,
a=a,
ld_1='claret',
ldc_1=ldc,
ld_2='lin',
f_s=self.fs,
f_c=self.fc,
ldc_2=0.45,
t_zero=self.T_tr,
period=self.P,
flux_weighted=flux_weighted)
# now add in drift in velocity
rv1 = rv1 + self.V0 + self.dV0 * (t - self.T_tr)
return rv1
def lnlike(par,
lc_wasp,lc_nites,lc_oed,lc_byu,lc_kpno,radvel,
period, t_zero, q, ldc_white, ldc_iband, ldc_jband,
n_int_nites, n_int_kpno):
r_1, r_2, incl, f_s, f_c, sbratio_jband, K_1 = par
# For the WASP data, only need to calculate the light curve in the region of
# the transit. Phase here puts transit at phase 0.5 (for convenince).
ph_wasp = (1.5 + (((lc_wasp['HJD']-t_zero)/period) % 1)) % 1
m = np.zeros_like(lc_wasp['HJD'])
try:
m_tr = -2.5*np.log10(ellc.lc((lc_wasp['HJD'])[abs(ph_wasp-0.5) < 0.02],
radius_1=r_1, radius_2=r_2, incl=incl, sbratio=0,f_s=f_s, f_c=f_c,
ld_1='quad', ldc_1 = ldc_white, period=period, t_zero=t_zero ,
grid_1='sparse',grid_2='sparse'))
m[abs(ph_wasp-0.5) < 0.02] = m_tr
res = lc_wasp['dmag']-m
wt = 1./lc_wasp['e_dmag']**2
zp = np.sum(res*wt)/np.sum(wt)
chisq_wasp = np.sum((res-zp)**2*wt)
except:
chisq_wasp = 1e20
try:
m = -2.5*np.log10(ellc.lc(lc_nites['HJD'], radius_1=r_1, radius_2=r_2,
incl=incl, sbratio=0,f_s=f_s, f_c=f_c, ld_1='quad', ldc_1 = ldc_white,
period=period, t_zero=t_zero, n_int=n_int_nites ,
grid_1='sparse',grid_2='sparse') )
res = lc_nites['dmag']-m
wt = 1./lc_nites['e_dmag']**2
zp = np.sum(res*wt)/np.sum(wt)
chisq_nites = np.sum((res-zp)**2*wt)
except:
chisq_nites = 1e20
try:
m = -2.5*np.log10(ellc.lc(lc_oed['HJD'], radius_1=r_1, radius_2=r_2,
incl=incl, sbratio=0,f_s=f_s, f_c=f_c, ld_1='quad', ldc_1 = ldc_iband,
period=period, t_zero=t_zero , grid_1='sparse',grid_2='sparse'))
res = lc_oed['dmag']-m
wt = 1./lc_oed['e_dmag']**2
zp = np.sum(res*wt)/np.sum(wt)
chisq_oed = np.sum((res-zp)**2*wt)
except:
chisq_oed = 1e20
try:
m = -2.5*np.log10(ellc.lc(lc_byu['HJD'], radius_1=r_1, radius_2=r_2,
incl=incl, sbratio=0,f_s=f_s, f_c=f_c, ld_1='quad', ldc_1 = ldc_iband,
period=period, t_zero=t_zero, grid_1='sparse',grid_2='sparse' ))
res = lc_byu['dmag']-m
wt = 1./lc_byu['e_dmag']**2
zp = np.sum(res*wt)/np.sum(wt)
chisq_byu = np.sum((res-zp)**2*wt)
except:
chisq_byu = 1e20
# Calculate semi-major axis
ecc = f_s**2 + f_c**2
a_1 = 0.019771142 * K_1 * period * np.sqrt(1 - ecc**2)/np.sin(incl*np.pi/180)
a = (1+1/q)*a_1
# kpno secondary eclipse - include semi-major axis for light time correction
try:
m = -2.5*np.log10(ellc.lc(lc_kpno['HJD'], radius_1=r_1, radius_2=r_2,
incl=incl, sbratio=sbratio_jband,f_s=f_s, f_c=f_c, ld_2='quad', a=a,
ldc_2 = ldc_jband, period=period, t_zero=t_zero, n_int=n_int_kpno ,
grid_1='sparse',grid_2='sparse'))
res = lc_kpno['dmag']-m
wt = 1./lc_kpno['e_dmag']**2
zp = np.sum(res*wt)/np.sum(wt)
chisq_kpno = np.sum((res-zp)**2*wt)
except:
chisq_kpno = 1e20
# Radial velocity
try:
rv1,rv2 = ellc.rv(radvel['HJD'], radius_1=r_1, radius_2=r_2, incl=incl,
q=q,sbratio=0,f_s=f_s, f_c=f_c, a=a, period=period,
t_zero=t_zero, flux_weighted=False,
grid_1='very_sparse',grid_2='very_sparse')
res = radvel['RV']-rv1
wt = 1./radvel['e_RV']**2
zp = np.sum(res*wt)/np.sum(wt)
chisq_rv = np.sum((res-zp)**2*wt)
except:
chisq_rv = 1e20
chisq = (chisq_wasp + chisq_nites + chisq_byu + chisq_oed + chisq_kpno +
chisq_rv)
print(list(map(prettyfloat,[r_1, r_2, incl, f_s, f_c, sbratio_jband,
K_1,chisq])))
return -0.5*chisq
np.savetxt(os.path.join(workdir, 'Michelangelo.csv'),
X,
delimiter=',',
header=header)
#==============================================================================
#::: Donatello
#==============================================================================
planet = 'b'
inst = 'Donatello'
time_Donatello = np.sort(17. + np.random.rand(40) * 70.)
rv_Donatello = ellc.rv(
t_obs=time_Donatello,
a=params[planet + '_a'],
incl=params[planet + '_incl'],
t_zero=params[planet + '_epoch'],
period=params[planet + '_period'],
q=params[planet + '_q'],
flux_weighted=False,
)[0]
rv_Donatello += get_stellar_var(time_Donatello)
rv_Donatello += np.random.normal(0, 1e-2, size=len(rv_Donatello))
rv_err_Donatello = 6e-3 * np.ones_like(rv_Donatello)
header = 'time,flux,flux_err'
X = np.column_stack((time_Donatello, rv_Donatello, rv_err_Donatello))
np.savetxt(os.path.join(workdir, 'Donatello.csv'),
X,
delimiter=',',
header=header)
#==============================================================================
q = 0.234
ld_1 = 'quad'
ldc_1 = [0.028, 0.264]
ld_2 = 'quad'
ldc_2 = [0.272, 0.567]
shape = 'roche'
heat = [0.6, 3.5, 0.0]
dummy, rv_0 = ellc.rv(time,
t_zero=t_zero,
q=q,
heat_2=heat,
radius_1=r_1,
radius_2=r_2,
incl=incl,
sbratio=sbratio,
ld_1=ld_1,
ldc_1=ldc_1,
ld_2=ld_2,
ldc_2=ldc_2,
a=0.737,
period=period,
shape_1=shape,
shape_2=shape,
flux_weighted=False)
lc_1 = ellc.lc(time,
t_zero=0.0,
q=1 / q,
heat_1=heat,
radius_1=r_2,
radius_2=r_1,
rotfac_2=rotfac_2,
gdc_1=gdc_1,
gdc_2=gdc_2,
shape_1=shape_1,
shape_2=shape_2,
grid_1='default',
grid_2='default')
rv_ellc_2, rv_ellc_1 = ellc.rv(t,
t_zero=t_zero,
period=period,
a=a,
q=q,
radius_1=r_1,
radius_2=r_2,
incl=incl,
sbratio=sbratio,
rotfac_1=rotfac_1,
rotfac_2=rotfac_2,
gdc_1=gdc_1,
gdc_2=gdc_2,
shape_1=shape_1,
shape_2=shape_2,
grid_1='default',
grid_2='default')
fontsize = 9
fig = plt.figure(1, figsize=(8, 4))
fig = plt.figure(1)
plt.subplot(211)
plt.xlim([-0.25, 0.75])
plt.ylim([0.4, 1.1])
# Vsini = 15.0d0 !/* Vsini */
# Rp = 0.1d0 !/* radius of the planet */
vsini = 15.0
r_planet = 0.1*r_star
q = 0.0001 # Nominal mass ratio
# For calculation of period, assume M_* = 1M_sun
period = (a / 4.20944009361)**(3./2.)
t = np.arange(0.18,0.32,0.0005)
phase_1 = (t-0.25)/period + 0.25
f_1 = ellc.lc(t, radius_1 = r_star, radius_2 = r_planet, sbratio = 1e-9,
incl=incl, t_zero=0.25, period=period, a=a, q=q, ldc_1=ldc,
lambda_1=lambda_star, vsini_1=vsini, ld_1='claret',shape_1='sphere')
rv_1,dum = ellc.rv(t, radius_1 = r_star, radius_2 = r_planet, sbratio = 1e-9,
incl=incl, t_zero=0.25, period=period, a=a, q=q, ldc_1=ldc,
lambda_1=lambda_star, vsini_1=vsini, ld_1='claret',shape_1='sphere',
flux_weighted=True)
rv_orb_1,dum = ellc.rv(t, radius_1 = r_star, radius_2 = r_planet, sbratio = 1e-9,
incl=incl, t_zero=0.25, period=period, a=a, q=q, ldc_1=ldc,
lambda_1=lambda_star, vsini_1=vsini, ld_1='claret',shape_1='sphere',
flux_weighted=False)
rm_1 = rv_1 - rv_orb_1
# Light travel time correction
solar_radius = 6.957e8
c = 2.99792458e8
ltt = a*solar_radius/c/86400.0
phase_2 = (t-0.25)/period + 0.25
t_zero = 0.25 + 0.5*period + ltt
f_2 = ellc.lc(t, radius_2 = r_star, radius_1 = r_planet, sbratio = 1e9,
###############################################################################
#::: "truth" signals
###############################################################################
companion = 'b'
inst = 'Donatello'
time_Donatello = [
37.1, 38, 38.7, 38.9, 41, 42, 53, 53.4, 54.1, 54.7, 55, 56, 58
]
rv_Donatello = ellc.rv(
t_obs=time_Donatello,
a=params[companion + '_a'],
incl=params[companion + '_incl'],
t_zero=params[companion + '_epoch'],
period=params[companion + '_period'],
q=params[companion + '_q'],
f_c=params[companion + '_f_c'],
f_s=params[companion + '_f_s'],
flux_weighted=False,
)[0]
white_noise_known = 1e-2
jitter = 1e-2
print(inst, 'jitter=', jitter)
print(inst, 'ln(jitter)', np.log(jitter))
white_noise_total = np.sqrt(white_noise_known**2 + jitter**2)
rv_Donatello += np.random.normal(0, white_noise_total,
size=len(rv_Donatello)) #white noise (total)
rv_err_Donatello = white_noise_known * np.ones_like(
rv_Donatello
) #white noise (known part; jitter is the unknown part added in quadrature)
