def DoubleTransitModel(theta, x, y, yerr):
p1, t01, rp1, w1, u1, p2, t02, rp2, w2, u2, V, C = theta
params1 = batman.TransitParams()
#params1.t0=t01
params1.t0 = 57512.3834
params1.per = 1.6377
params1.rp = rp1
params1.a = 19.5
params1.inc = 90
params1.ecc = 0
params1.w = w1
params1.u = [u1]
params1.limb_dark = "linear"
m1 = batman.TransitModel(params1, x)
model1 = m1.light_curve(params1)
params2 = batman.TransitParams()
params2.t0 = 57512.3897
params2.per = 2.0198
params2.rp = rp2
params2.a = 26.7
params2.inc = 90
params2.ecc = 0
params2.w = w2
params2.u = [u2]
params2.limb_dark = "linear"
m2 = batman.TransitModel(params2, x)
model2 = m2.light_curve(params2)
model3 = V * (x - x[0]) + C
#model3=-1167273.5778*(x-x[0])+59856592.8761
#model=(model1+model2-1)*model3
model = model1 + model2 - 1
#model=model1
return model
def fit_db(X0, p1, f1, e1, p2, f2, e2):
pm1 = bm.TransitParams()
pm2 = bm.TransitParams()
t01, t02 = X0[0], X0[1]
rp1 = X0[2]
rp2 = 1 / rp1
fp1 = X0[3]
fp2 = 1 / fp1
a1, a2 = X0[4], X0[5]
inc = X0[6]
ecc = X0[7]
w1 = X0[8]
w2 = w1 + 180
u1, u2 = X0[9], X0[10]
u3, u4 = X0[11], X0[12]
pm1.t0 = t01
pm1.per = 1.
pm1.rp = rp1
pm1.a = a1
pm1.inc = inc
pm1.ecc = ecc
pm1.w = w1
pm1.u = [u1, u2]
pm1.limb_dark = "quadratic"
pm2.t0 = t02
pm2.per = 1.
pm2.rp = rp2
pm2.a = a2
pm2.inc = inc
pm2.ecc = ecc
pm2.w = w2
pm2.u = [u3, u4]
pm2.limb_dark = "quadratic"
m1 = bm.TransitModel(pm1, p1)
m2 = bm.TransitModel(pm2, p2)
F1 = (m1.light_curve(pm1) + fp1) / (1 + fp1)
F2 = (m2.light_curve(pm2) + fp2) / (1 + fp2)
fit_vals1 = np.sqrt((f1 - F1)**2 / e1**2)
fit_vals2 = np.sqrt((f2 - F2)**2 / e2**2)
fit_val = (np.sum(fit_vals1) + np.sum(fit_vals2)) / (len(fit_vals1) +
len(fit_vals2) - 1)
return fit_val
def lnlike(theta,
t_kep,
f_kep,
t_spit,
f_spit,
u1_kep=u1_KEP,
u2_kep=u2_KEP,
u1_spit=u1_SPIT,
u2_spit=u2_SPIT):
t0, per, a, b, rpKEP, rpSPIT, sigmaKEP, sigmaSPIT, offsetKEP, offsetSPIT = theta
# Set up K2 transit parameters.
kep_params = batman.TransitParams()
kep_params.t0 = t0
kep_params.per = per
kep_params.rp = rpKEP
kep_params.a = a
kep_params.inc = np.arccos(b / a) * (180. / np.pi)
kep_params.ecc = 0.
kep_params.w = 0.
kep_params.u = [u1_kep, u2_kep]
kep_params.limb_dark = 'quadratic'
# Initialize the K2 transit model.
kep_init = batman.TransitModel(kep_params, t_kep)
kep_model = kep_init.light_curve(kep_params) + offsetKEP
# Calculate likelihood of K2 model
like_kep = -0.5 * (np.sum((f_kep - kep_model)**2 *
(1 / sigmaKEP**2) - np.log(2 * np.pi *
(1 / sigmaKEP**2))))
# Set up Spitzer transit parameters.
spit_params = batman.TransitParams()
spit_params.t0 = t0
spit_params.per = per
spit_params.rp = rpSPIT
spit_params.a = a
spit_params.inc = np.arccos(b / a) * (180. / np.pi)
spit_params.ecc = 0.
spit_params.w = 0.
spit_params.u = [u1_spit, u2_spit]
spit_params.limb_dark = 'quadratic'
# Initialize the Spitzer transit model.
spit_init = batman.TransitModel(spit_params, t_spit)
spit_model = spit_init.light_curve(spit_params) + offsetSPIT
# Calculate likelihood of Spitzer model
like_spit = -0.5 * (np.sum((f_spit - spit_model)**2 * (1 / sigmaSPIT**2) -
np.log(2 * np.pi * (1 / sigmaSPIT**2))))
return like_kep + like_spit
def __init__(self, lightcurves, priors):
lightcurves = deepcopy(lightcurves)
self.lightcurves = np.array(lightcurves, dtype=object)
self.n_telescopes = self.lightcurves.shape[0]
self.n_filters = self.lightcurves.shape[1]
self.n_epochs = self.lightcurves.shape[2]
self.num_light_curves = len(np.where(self.lightcurves.flatten() != None)[0])
self.priors = priors
# We need to make a separate TransitParams and TransitModels for each
# light curve.
# Initialise them:
self.batman_params = ParamArray('batman_params', (self.n_telescopes, self.n_filters, self.n_epochs), True, True, True, lightcurves=self.lightcurves)
self.batman_models = ParamArray('batman_models', (self.n_telescopes, self.n_filters, self.n_epochs), True, True, True, lightcurves=self.lightcurves)
for i in np.ndindex(self.lightcurves.shape):
tidx, fidx, eidx = i
if self.lightcurves[i] is not None:
# Set up the params
self.batman_params.set_value(batman.TransitParams(), tidx, fidx, eidx)
# Set up the TransitModels
# Make some realistic parameters to setup the models with
default_params = batman.TransitParams()
if self.priors.fit_ttv:
default_params.t0 = priors.priors['t0'].default_value
else:
default_params.t0 = priors.priors['t0'].default_value
default_params.per = priors.priors['P'].default_value
default_params.rp = priors.priors['rp'].default_value
default_params.a = priors.priors['a'].default_value
default_params.inc = priors.priors['inc'].default_value
default_params.ecc = priors.priors['ecc'].default_value
default_params.w = priors.priors['w'].default_value
default_params.limb_dark = priors.limb_dark
# Note that technically this is q, not u, but it doesn't matter
# as we are only initialising here
default_params.u = [priors.priors[qX].default_value for qX in priors.limb_dark_coeffs]
# Now make the models
model = batman.TransitModel(default_params, self.lightcurves[i].times)
self.batman_models.set_value(model, tidx, fidx, eidx)
def mini_transit(lc_params, time, fsigns, free_params, ld, *theta_j):
#P, t0, radius, dist, inc = theta
nfp = len(free_params)
params = batman.TransitParams()
if theta_j:
params.per = theta_j[0] #orbital period in days
params.w = theta_j[1] #longitude of periastron (in degrees)
params.ecc = theta_j[2] #eccentricity
else:
params.per = nfplc_params[nfp + ld] #orbital period in days
params.w = nfplc_params[nfp + ld +
1] #longitude of periastron (in degrees)
params.ecc = nfplc_params[nfp + ld + 2] #eccentricity
params.t0 = nfplc_params[0] #time of inferior conjunction
params.rp = nfplc_params[1] #planet radius (in units of stellar radii)
params.a = nfplc_params[2] #semi-major axis (in units of stellar radii)
params.inc = nfplc_params[3] #orbital inclination (in degrees)
u = []
for i in range(ld):
u.append(nfplc_params[nfp + i])
params.u = u #limb darkening coefficients [u1, u2]
params.limb_dark = "quadratic" #limb darkening model
m = batman.TransitModel(params, time) #initializes model
flux = m.light_curve(params) #calculates light curve
return (flux)
def init_catwoman(t, ld_law, nresampling=None, etresampling=None):
"""
This function initializes the catwoman code.
"""
params = batman.TransitParams()
params.t0 = 0.
params.per = 1.
params.rp = 0.1
params.rp2 = 0.1
params.a = 15.
params.inc = 87.
params.ecc = 0.
params.w = 90.
params.phi = 90.
if ld_law == 'linear':
params.u = [0.5]
else:
params.u = [0.1, 0.3]
params.limb_dark = ld_law
if nresampling is None or etresampling is None:
m = catwoman.TransitModel(params, t)
else:
m = catwoman.TransitModel(params,
t,
supersample_factor=nresampling,
exp_time=etresampling)
return params, m
def lc_min(params, phase, flux, err):
'''
Function which calculates Chi2 value for a given set of input parameters.
Function to be minimized to find best fit parameters
'''
#Define the system parameters for the batman LC model
pm = bm.TransitParams()
pm.t0 = 0. #Time of transit centre
pm.per = 1. #Orbital period = 1 as phase folded
pm.rp = params[0] #Ratio of planet to stellar radius
pm.a = params[1] #Semi-major axis (units of stellar radius)
pm.inc = params[2] #Orbital Inclination [deg]
pm.ecc = 0. #Orbital eccentricity (fix circular orbits)
pm.w = 90. #Longitude of periastron [deg] (unimportant as circular orbits)
pm.u = [0.1, 0.3] #Stellar LD coefficients
pm.limb_dark = "quadratic" #LD model
#Initialize the batman LC model and compute model LC
m = bm.TransitModel(pm, phase)
f_model = m.light_curve(pm)
fit_vals = np.sqrt((flux - f_model)**2 / err**2)
fit_val = np.sum(fit_vals) / (len(fit_vals) - 4)
return fit_val
def transit_model_1_plot(period):
"""
Function for interactive transit modeling
"""
# Parameters of planet model
params = batman.TransitParams()
params.t0 = 0. # time of inferior conjunction
params.per = period # orbital period (days)
params.rp = (
(1.0 * u.Rjup) /
(1.203 * u.Rsun)).si.value # planet radius (in units of stellar radii)
params.a = 15. # semi-major axis (in units of stellar radii)
params.inc = 87. # orbital inclination (in degrees)
params.ecc = 0. # eccentricity
params.w = 90. # longitude of periastron (in degrees)
params.u = [0.1, 0.1] # limb darkening coefficients [u1, u2]
params.limb_dark = "quadratic" # limb darkening model
# Defining the timeframe and calculating flux
time = np.linspace(-1, 1, 10000) * 6 # Creates an array of 10000 points
# over a roughly 12-day period
model = batman.TransitModel(params, time)
flux_model = model.light_curve(params)
# Plotting results
plt.figure(figsize=(14, 5))
plt.plot(time - time[0], flux_model, 'r-')
plt.title(
"Figure 3: Multiple Transits of a Hot Jupiter with a {:0.1f}-day Period"
.format(params.per))
plt.xlabel("Time (days)")
plt.ylabel("Star brightness")
return
def __init__(self, planet_row):
self.planet_row = planet_row
# Initialize transit model
self.params = batman.TransitParams()
self.params.t0 = planet_row['TT'][0]
self.params.inc = planet_row['I'][0].value
self.params.a = planet_row['AR'][0].value
self.params.rp = planet_row['DEPTH'][
0].value**0.5 #planet_row['RR'][0].value
self.params.ecc = planet_row['ECC'][0].value
self.params.w = planet_row['OM'][0].value
self.params.u = [0.0]
self.params.limb_dark = 'linear'
self.params.per = planet_row['PER'][0].value
self.b = planet_row['B'][0]
self.transit_duration = duration_14(self.params.per, self.params.rp,
self.params.a, self.b,
np.radians(self.params.inc),
self.params.ecc,
np.radians(self.params.w))
# Initialize some attributes to fill later
self.transit_model = None
self.phase = None
def init_batman(t, ld_law, nresampling=None, etresampling=None):
"""
This function initializes the batman code.
"""
params = batman.TransitParams()
params.t0 = 0.
params.per = 1.
params.rp = 0.1
params.a = 15.
params.inc = 87.
params.ecc = 0.
params.w = 90.
if ld_law == 'linear':
params.u = [0.5]
else:
params.u = [0.1,0.3]
if ld_law == 'none':
params.limb_dark = 'quadratic'
else:
params.limb_dark = ld_law
params.ac = 0.001
params.fp = 0.001
params.t_secondary = params.t0 + (params.per/2) + params.ac
if nresampling is None or etresampling is None:
m = [batman.TransitModel(params, t), batman.TransitModel(params, t, transittype='secondary')]
else:
m = [batman.TransitModel(params, t, supersample_factor=nresampling, exp_time=etresampling),\
batman.TransitModel(params, t, transittype='secondary', supersample_factor=nresampling, exp_time=etresampling)]
return params,m
def BatmanModel(t0=0.0,
P=1.0,
rad_pl=0.01602,
a=15.0,
i=87.0,
e=0.0,
w=90.0,
coeff=[0.5, 0.1],
plot=False):
# Initialize the model
params = batman.TransitParams() #object to store transit parameters
params.t0 = t0 #76.6764 #time of inferior conjunction
params.per = P #13.17562 #orbital period
params.rp = rad_pl #0.01602 #planet radius (in units of stellar radii)
params.a = a #13.8 #semi-major axis (in units of stellar radii)
params.inc = i #88.19 #orbital inclination (in degrees)
params.ecc = e #0.0 #eccentricity
params.w = w #90. #longitude of periastron (in degrees)
params.limb_dark = "quadratic" #limb darkening model
params.u = coeff #[0.4899, 0.1809] #limb darkening coefficients [u1, u2]
t = np.linspace(-.25, .25, 1000) #times at which to calculate light curve
t_new = np.interp(t, (t.min(), t.max()), (0, 0.2))
m = batman.TransitModel(params, t) #initializes model
flux = m.light_curve(params) #calculates light curve
if plot == True:
fig, ax = plt.subplots()
ax.get_yaxis().get_major_formatter().set_useOffset(False)
ax.plot(t_new, flux)
return (t_new, flux, rad_pl)
def test_run_with_planet(self):
"""A test of simulate() with a planet"""
# Make the TSO object
tso = TSO(ngrps=2, nints=2, star=self.star)
# Make orbital params
params = batman.TransitParams()
params.t0 = 0.
params.per = 5.7214742
params.a = 0.0558*q.AU.to(ac.R_sun)*0.66
params.inc = 89.8
params.ecc = 0.
params.w = 90.
params.limb_dark = 'quadratic'
params.u = [0.1, 0.1]
params.rp = 0.
tmodel = batman.TransitModel(params, tso.time)
tmodel.teff = 3500
tmodel.logg = 5
tmodel.feh = 0
# Run the simulation
tso.simulate(planet=self.planet, tmodel=tmodel)
tso.subarray = 'SUBSTRIP96'
tso.simulate(planet=self.planet, tmodel=tmodel)
tso.subarray = 'FULL'
tso.simulate(planet=self.planet, tmodel=tmodel)
def reference_transit(self, period_grid, duration_grid, samples, per, rp, a, inc, ecc, w, u, limb_dark):
f = numpy.ones(tls_constants.SUPERSAMPLE_SIZE)
duration = 1 # transit duration in days. Increase for exotic cases
t = numpy.linspace(-duration * 0.5, duration * 0.5, tls_constants.SUPERSAMPLE_SIZE)
ma = batman.TransitParams()
ma.t0 = 0 # time of inferior conjunction
ma.per = per # orbital period, use Earth as a reference
ma.rp = rp # planet radius (in units of stellar radii)
ma.a = a # semi-major axis (in units of stellar radii)
ma.inc = inc # orbital inclination (in degrees)
ma.ecc = ecc # eccentricity
ma.w = w # longitude of periastron (in degrees)
ma.u = u # limb darkening coefficients
ma.limb_dark = limb_dark # limb darkening model
m = batman.TransitModel(ma, t) # initializes model
flux = m.light_curve(ma) # calculates light curve
# Determine start of transit (first value < 1)
idx_first = numpy.argmax(flux < 1)
intransit_time = t[idx_first: -idx_first + 1]
intransit_flux = flux[idx_first: -idx_first + 1]
# Downsample (bin) to target sample size
x_new = numpy.linspace(t[idx_first], t[-idx_first - 1], samples, per)
f = interp1d(x_new, intransit_time)
downsampled_intransit_flux = f(intransit_flux)
# Rescale to height [0..1]
rescaled = (numpy.min(downsampled_intransit_flux) - downsampled_intransit_flux) / (
numpy.min(downsampled_intransit_flux) - 1
)
return rescaled
def gentransit(t,
t0=0.0,
Porb=14.0,
Rp=1.0,
Mp=1.0,
Rs=0.2,
Ms=0.15,
ideg=90.0,
w=90.0,
e=0.0,
u1=0.1,
u2=0.3):
#Rp Earth radius
params = batman.TransitParams()
params.t0 = t0 # time of inferior conjunction
params.rp = Rp * R_earth / (Rs * R_sun
) # planet radius (in units of stellar radii)
# calculate semi-major axis from orbital period value
params.inc = ideg # orbital inclination (in degrees)
params.ecc = e # eccentricity
params.w = w # longitude of periastron (in degrees), 90 for circular
params.u = [u1, u2] # limb darkening coefficients
params.limb_dark = "quadratic" # limb darkening model
#period update
params.per = Porb # orbital period (days)
a = (((params.per * u.day)**2 * G * (Ms * M_sun + Mp * M_earth) /
(4 * np.pi**2))**(1. / 3)).to(R_sun).value / Rs
params.a = a # semi-major axis (in units of stellar radii)
b = a * np.cos(ideg / 180.0 * np.pi)
m = batman.TransitModel(params, t) # initializes the model
injlc = np.array(m.light_curve(params))
return injlc, b
def transit_model_func(model_params, times, ldtype='quadratic', transitType='primary'):
# Transit Parameters
u1 = model_params['u1'].value
u2 = model_params['u2'].value
if 'edepth' in model_params.keys() and model_params['edepth'] > 0:
if 'ecc' in model_params.keys() and 'omega' in model_params.keys() and model_params['ecc'] > 0:
delta_phase = deltaphase_eclipse(model_params['ecc'], model_params['omega'])
else:
delta_phase = 0.5
t_secondary = model_params['tCenter'] + model_params['period']*delta_phase
else:
model_params.add('edepth', 0.0, False)
rprs = np.sqrt(model_params['tdepth'].value)
bm_params = batman.TransitParams() # object to store transit parameters
bm_params.per = model_params['period'].value # orbital period
bm_params.t0 = model_params['tCenter'].value # time of inferior conjunction
bm_params.inc = model_params['inc'].value # inclunaition in degrees
bm_params.a = model_params['aprs'].value # semi-major axis (in units of stellar radii)
bm_params.rp = rprs # planet radius (in units of stellar radii)
bm_params.fp = model_params['edepth'].value # planet radius (in units of stellar radii)
bm_params.ecc = model_params['ecc'].value # eccentricity
bm_params.w = model_params['omega'].value # longitude of periastron (in degrees)
bm_params.limb_dark = ldtype # limb darkening model # NEED TO FIX THIS
bm_params.u = [u1, u2] # limb darkening coefficients # NEED TO FIX THIS
m_eclipse = batman.TransitModel(bm_params, times, transittype=transitType)# initializes model
return m_eclipse.light_curve(bm_params)
def lc_min(params, time, flux, err):
'''
Function which calculates Chi2 value for a given set of input parameters.
Function to be minimized to find best fit parameters
'''
phase = ((time - params['t0'].value) / params['per'].value) % 1
#Define the system parameters for the batman LC model
pm = bm.TransitParams()
pm.t_secondary = 0 #Time of transit centre
pm.per = 1. #Orbital period = 1 as phase folded
pm.rp = params['rp'].value #Ratio of planet to stellar radius
pm.a = params['a'].value #Semi-major axis (units of stellar radius)
pm.inc = 90 #Orbital Inclination [deg]
pm.fp = params['fp'].value
pm.ecc = args.ecc #Orbital eccentricity (fix circular orbits)
pm.w = args.w #Longitude of periastron [deg] (unimportant as circular orbits)
if not args.ld == "uniform":
pm.u = [args.u1, args.u2] #Stellar LD coefficients
else:
pm.u = []
pm.limb_dark = args.ld #LD model
#Initialize the batman LC model and compute model LC
m = bm.TransitModel(pm, phase, transittype="secondary")
f_model = m.light_curve(pm) - params['base'].value
residuals = (flux - f_model)**2 / err**2
return residuals
def eval(self, **kwargs):
"""Evaluate the function with the given values"""
# Get the time
if self.time is None:
self.time = kwargs.get('time')
# Generate with batman
bm_params = batman.TransitParams()
# Set all parameters
for p in self.parameters.list:
setattr(bm_params, p[0], p[1])
# Combine limb darkening coeffs
bm_params.u = [getattr(self.parameters, u).value for u in self.coeffs]
# Use batman ld_profile name
if self.parameters.limb_dark.value == '4-parameter':
bm_params.limb_dark = 'nonlinear'
# Make the eclipse
tt = self.parameters.transittype.value
m_eclipse = batman.TransitModel(bm_params, self.time, transittype=tt)
# Evaluate the light curve
return m_eclipse.light_curve(bm_params)
def fit_secondary(X0, p, f, e):
pm = bm.TransitParams()
pm.t0 = t0
pm.per = 1.
pm.rp = rp
pm.a = X0[0]
pm.inc = X0[1]
pm.ecc = X0[2]
pm.w = w
pm.u = [0.3, 0.2]
pm.limb_dark = "quadratic"
pm.fp = fp
m = bm.TransitModel(pm, p)
pm.t_secondary = m.get_t_secondary(pm)
m2 = bm.TransitModel(pm, p, transittype="secondary")
f1 = (m.light_curve(pm) + 1) / 2
f2 = m2.light_curve(pm) / 2
F = f1 * f2
vals = np.sqrt((f - F)**2 / e**2)
fit_val = np.sum(vals) / (len(vals) - 1)
return fit_val
def transit(idx, data, params):
t = data.time[idx]
p = batman.TransitParams()
t0, per, rp, a, inc, ecc, w, u1, u2, limb_dark = params
#FIXME
if limb_dark == 2: p.limb_dark = "quadratic"
else:
print "unsupported limb darkening parameter"
return 0
p.t0 = t0
p.per = per
p.rp = rp
p.a = a
p.inc = inc
p.ecc = ecc
p.w = w
p.u = [u1, u2]
m = batman.TransitModel(p,
t,
supersample_factor=3,
exp_time=data.exp_time / 24. / 60. / 60.)
return m.light_curve(p)
def transitmodel(target, time=None):
'''Some day soon this will be starry'''
if time is None:
time = target.time
planets_dictionary = find_planet_parameters(target)
mlc_flux = np.ones(len(time))
for idx, planet in planets_dictionary.items():
params = batman.TransitParams()
params.limb_dark = "linear" # limb darkening model
params.u = [0.5] # limb darkening coefficients [u1, u2]
params.w = 90. # longitude of periastron (in degrees)
params.t0 = planet['tranmid'] # time of inferior conjunction
params.per = planet['period'] # orbital period
params.ecc = planet['ecc'] # eccentricity
params.a = planet['orbsmax'] / planet[
'st_rad'] # semi-major axis (in units of stellar radii)
params.rp = planet['radj'] / planet[
'st_rad'] # planet radius (in units of stellar radii)
params.inc = planet['incl'] # orbital inclination (in degrees)
m = batman.TransitModel(params, time) # initializes model
mlc_flux += (m.light_curve(params) - 1)
return mlc_flux / np.median(mlc_flux)
def light_curve_model(t, rp, a, t0 = 0., per = 1., inc = 90., ecc = 0., w = 90., limb_dark = "quadratic", u = [0.1, 0.3]): '''Python Function to use the batman package to produce a model lightcurve using the following input parameters: t: numpy array containing the time values at which to calculate the model LC rp: radius of the planet, in units of stellar radii a semi-major axis of the planet's orbit, in units of stellar radii t0 = 0. time of the transit centre per = 1. orbital period inc = 90. orbital inclination [degrees] ecc = 0. orbital eccentricity w = 90. longitude of periastron [degrees] limb_dark = "uniform" limb darkening mechanism u = [] limb darkening coefficients NOTE: Units of t, t0, and per are not set to be a specific unit but must all be consistent OUTPUT: flux_model : a numpy array of the same dimensions as t, containing the relative for the model LC at each time point in t''' params = batman.TransitParams() params.t0 = t0 params.per = per params.rp = rp params.a = a params.inc = inc params.ecc = ecc params.w = w params.u = u params.limb_dark = limb_dark m = batman.TransitModel(params, t) flux_model = m.light_curve(params) return flux_model
def set_params_batman(params_lm, names, limb_type="quadratic"):
params = batman.TransitParams() #object to store transit parameters
params.limb_dark = limb_type #limb darkening model
q_arr = np.zeros(2)
for i in range(len(names)):
value = params_lm[names[i]]
name = names[i]
if name == "t0":
params.t0 = value
if name == "per":
params.per = value
if name == "rp":
params.rp = value
if name == "a":
params.a = value
#if name=="inc":
#params.inc = value
if name == "b":
params.inc = np.degrees(np.arccos(value / params.a))
if name == "ecc":
params.ecc = value
if name == "w":
params.w = value
if name == "q1":
q_arr[0] = value
if name == "q2":
q_arr[1] = value
u_arr = q_to_u_limb(q_arr)
params.u = u_arr
return params
def make_lightcurve(r, i, width, u_type, u_param, t):
'''
r: planet radius (in stellar radii)
i: inclination (in degrees)
width: "width parameter" a**3/p**2
u_type: type of limb darkening
u_param: list of parameters for limb darkening
t: timesteps that you want the fluxes at
assume circular orbit
'''
params = batman.TransitParams()
params.rp = r #planet radius (in units of stellar radii)
params.inc = i #orbital inclination (in degrees)
params.w = 0 #longitude of periastron (in degrees)
params.ecc = 0 #eccentricity
params.per = 100 #orbital period
params.t0 = 0 #time of inferior conjunction
params.a = (width * 100**2)**(
1 / 3) #semi-major axis (in units of stellar radii)
params.u = u_param #limb darkening coefficients [u1, u2]
params.limb_dark = u_type #limb darkening model
m = batman.TransitModel(params, t) #initializes model
flux = m.light_curve(params) #calculates light curve
return flux
def __init__(self,
epoch=0.0,
period=1.0,
rp_over_rs=0.1,
a_over_rs=15.0,
impact_parameter=0.5,
eccentricity=0.0,
omega=90.0,
limb_coef=[0.1, 0.3],
limb_type="quadratic"):
'''
Initialize a transit object and set its parameters.
'''
import batman
self.batman = batman
self.params = batman.TransitParams()
self.params.t0 = epoch
self.params.per = period
self.params.rp = rp_over_rs
self.params.a = a_over_rs
inclination = np.arccos(impact_parameter / a_over_rs) * 180.0 / np.pi
self.params.inc = inclination
self.params.ecc = eccentricity
self.params.w = omega
self.params.u = limb_coef
self.params.limb_dark = limb_type
def lc_min(params, time, flux, err, spl):
'''
Function which calculates Chi2 value for a given set of input parameters.
Function to be minimized to find best fit parameters
Uses a spline to model any Out-of-Transit variability
'''
phase = ((time - (params['t0'].value)) / params['per'].value) % 1
#Produce binned data set for caclulating the spline
variability_model = spl(phase)
#Define the system parameters for the batman LC model
pm = bm.TransitParams()
pm.t0 = 0 #Time of transit centre
pm.per = 1. #Orbital period = 1 as phase folded
pm.rp = params['rp'].value #Ratio of planet to stellar radius
pm.a = params['a'].value #Semi-major axis (units of stellar radius)
pm.inc = params['inc'].value #Orbital Inclination [deg]
pm.ecc = args.ecc #Orbital eccentricity (fix circular orbits)
pm.w = args.w #Longitude of periastron [deg] (unimportant as circular orbits)
if not args.ld == "uniform":
pm.u = [args.u1, args.u2] #Stellar LD coefficients
else:
pm.u = []
pm.limb_dark = args.ld #LD model
#Initialize the batman LC model and compute model LC
m = bm.TransitModel(pm, phase)
f_model = m.light_curve(pm)
model_total = f_model * variability_model
residuals = (flux - model_total)**2 / err**2
return residuals
def make_lightcurve(T0, RP, INC, PER, width, u_type, u_param, t):
'''
r: planet radius
i: inclination
per = orbital period
width: "width parameter" a ** 3/per ** 2
u_type: type of limb darkening
u_param: list of parameters for limb darkening
assume circular orbit
'''
params = batman.TransitParams()
params.w = 0 #longitude of periastron (in degrees)
params.ecc = 0 #eccentricity
params.t0 = T0 #time of inferior conjunction
params.rp = RP #planet radius (in units of stellar radii)
params.inc = INC #orbital inclination (in degrees)
params.per = PER #orbital period
params.a = (width * PER**2)**(
1 / 3) #semi-major axis (in units of stellar radii)
params.u = u_param #limb darkening coefficients [u1, u2]
params.limb_dark = u_type #limb darkening model
m = batman.TransitModel(params, t) #initializes model
flux = m.light_curve(params) #calculates light curve
return flux
def transit_model(self, pv, time):
"""
Define the transit model for a given pv vector
INPUT:
pv[0] - period
pv[1] - epoch (0)
pv[2] - Rp/Rs (sqrt(depth))
pv[3] - a/Rs (estimate from stellar density)
pv[4] - impact param
"""
p,t0,RpRs,aRs,dur = pv
ii = mt.acos(pv[4]/pv[3])*(180./np.pi) # inclination in degrees
params = batman.TransitParams()
params.t0 = t0
params.per = p
params.inc = ii
params.rp = RpRs
params.a = aRs
params.ecc = 0.
params.w = 0.
params.u = self.limbdark
params.limb_dark = "quadratic"
params.fp = 0.001
# supersample for K2 cadence
transitmodel = batman.TransitModel(params, time, transittype='primary',supersample_factor=7,exp_time=0.020431801470066003)
lc = transitmodel.light_curve(params)
return lc
def batman_model(time, p):
"""
Creates a batman transit model to inject into the data
as not-a-flare noise.
Parameters
----------
time : np.ndarray
params : parameters for the batman model. params is an
array of [t0, period, rp/r_star, a/r_star].
Returns
----------
flux : batman modeled flux with transit injected.
"""
params = batman.TransitParams()
params.t0 = p[0]
params.per = p[1]
params.rp = p[2]
params.a = p[3]
params.inc = 90.
params.ecc = 0.
params.w = 90.
params.u = [0.1, 0.3]
params.limb_dark = "quadratic"
m = batman.TransitModel(params, time)
flux = m.light_curve(params)
return flux
def make_lightcurve(t0, r, i, p, width, u_type, u_param, t):
"""
Generate a batman lightcurve with the given parameters.
Parameters
----------
t0 (num): time of inferior conjunction
r (num): planet radius (in stellar radii)
i (num): orbital inclination (in degrees)
p (num): orbital period
width (num): width parameter (defined as a**3/p**2)
u_type (str): limb darkening model
u_param (list): parameters for limb darkening
t: timesteps that you want the fluxes at
assume circular orbit
"""
# Init batman model
params = batman.TransitParams()
params.rp = r
params.inc = i
params.w = 0 # longitude of periastron (degenerate with width)
params.ecc = 0 # eccentricity (0 for circular orbits)
params.per = p # orbital period
params.t0 = t0
params.a = (width * p**2)**(1 / 3) # semi-major axis (stellar radii)
params.limb_dark = u_type
params.u = u_param
model = batman.TransitModel(params, t)
# Generate curve
flux = model.light_curve(params) # compute light curve
return flux
def __init__(self, time, flux, uncertainty, parameter_dict):
'''
This is a TransitCurve - the flux, uncertainty and times, plus all the
parameter information you might need. You can also use this object to
add systematics.
'''
self.time = time
self.flux = flux
self.uncertainty = uncertainty
self.parameters = {}
self.parameters['Rp'] = parameter_dict['Rp']
self.parameters['P'] = parameter_dict['P']
self.parameters['t0'] = parameter_dict['t0']
self.parameters['a'] = parameter_dict['a']
self.parameters['inc'] = parameter_dict['inc']
self.parameters['limb_darkening_model'] = parameter_dict[
'limb_darkening_model']
self.parameters['limb_darkening_params'] = parameter_dict[
'limb_darkening_params']
self.parameters['w'] = parameter_dict['w']
self.parameters['ecc'] = parameter_dict['ecc']
# batman.TransitParams which can be used to generate the curve again
self.batman_params = batman.TransitParams()
self.batman_params.t0 = self.parameters['t0']
self.batman_params.rp = self.parameters['Rp']
self.batman_params.per = self.parameters['P']
self.batman_params.a = self.parameters['a']
self.batman_params.limb_dark = self.parameters['limb_darkening_model']
self.batman_params.u = self.parameters['limb_darkening_params']
self.batman_params.inc = self.parameters['inc']
self.batman_params.w = self.parameters['w']
self.batman_params.ecc = self.parameters['ecc']
