def residuals_three_param(params, x, y):
c = LDC3.forward([params['q1'].value,params['q2'].value, params['q3'].value])
if LDC3.criteriatest(0,c) == 0:
c = [guess_coeff1, guess_coeff2, guess_coeff3]
batman_params.rp = params['p'].value
batman_params.a = params['a'].value
batman_params.inc = params['i'].value
batman_params.u = [0.,c[0],c[1],c[2]]
return y - batman_m.light_curve(batman_params)
def residuals_three_param(params, x, y):
c = LDC3.forward(
[params['q1'].value, params['q2'].value, params['q3'].value])
if LDC3.criteriatest(0, c) == 0:
c = [guess_coeff1, guess_coeff2, guess_coeff3]
batman_params.rp = params['p'].value
batman_params.a = params['a'].value
batman_params.inc = params['i'].value
batman_params.u = [0., c[0], c[1], c[2]]
return y - batman_m.light_curve(batman_params)
import random import LDC3 # Generate random alpha values alphas=[0 for i in range(3)] alphas=[random.uniform(0.0,1.0) for i in range(3)] print ' ' print 'Generating random alpha vector:' print 'alpha_h = ',alphas[0] print 'alpha_r = ',alphas[1] print 'alpha_t = ',alphas[2] print ' ' # Calculate the corresponding LDCs c=LDC3.forward(alphas) print 'Converting alpha vector -> LDCs vector:' print 'c_2 = ',c[0] print 'c_3 = ',c[1] print 'c_4 = ',c[2] # Test if the LDCs satisfy the seven analytic criteria passed=LDC3.criteriatest(0,c) if passed == 1: print 'LDCs satisfy the 7 analytic criteria => physically valid' print ' ' else: print 'LDCs violate one or more of the 7 analytic criteria' print ' ' # Invert LDCs back to alphas alphas_inv=LDC3.inverse(c)
def fit_transit_floating_lds(x, y, guess_p, guess_coeff1, guess_coeff2, guess_i, guess_a, P, t0, ld_law, guess_coeff3 = None):
"""
This function fits transit lightcurves with floating limb-darkening coefficients. Inputs are:
x: Times of observation.
y: Normalized fluxes
guess_p: Guess for the planet-to-star radius ratio (R_p/R_*)
guess_coeff1: Guess for the first limb-darkening coefficient.
guess_coeff2: Same for the second coefficient (not used if law is linear).
guess_coeff3: Same for third coefficient (if non-linear law is used)
guess_i: Guess on the inclination.
guess_a: Guess on the scaled semi-major axis (a/R_*)
P: Period of the orbit (not fitted).
t0: Time of transit center of the orbit (not fitted).
ld_law: Limb-darkening law to use for the fit.
The function returns the fitted values of p,i,a and the coefficients of the chosen LD law.
"""
# First, initialize the batman transit modeller with guess parameters:
if ld_law == 'linear':
batman_params,batman_m = init_batman(x, P, guess_i, guess_a, guess_p, t0, \
[guess_coeff1], ld_law = ld_law)
elif ld_law == 'three-param':
batman_params,batman_m = init_batman(x, P, guess_i, guess_a, guess_p, t0, \
[guess_coeff1, guess_coeff2,guess_coeff3], ld_law = ld_law)
else:
batman_params,batman_m = init_batman(x, P, guess_i, guess_a, guess_p, t0, \
[guess_coeff1, guess_coeff2], ld_law = ld_law)
# Define the residual functions depending on the LD law used:
def residuals_linear(params, x, y):
batman_params.rp = params['p'].value
batman_params.a = params['a'].value
batman_params.inc = params['i'].value
batman_params.u = [params['q1'].value]
return y - batman_m.light_curve(batman_params)
def residuals_quadratic(params, x, y):
coeff1 = 2.*np.sqrt(params['q1'].value)*params['q2'].value
coeff2 = np.sqrt(params['q1'].value)*(1.-2.*params['q2'].value)
batman_params.rp = params['p'].value
batman_params.a = params['a'].value
batman_params.inc = params['i'].value
batman_params.u = [coeff1,coeff2]
return y - batman_m.light_curve(batman_params)
def residuals_sqroot(params, x, y):
coeff1 = np.sqrt(params['q1'].value)*(1.-2.*params['q2'].value)
coeff2 = 2.*np.sqrt(params['q1'].value)*params['q2'].value
batman_params.rp = params['p'].value
batman_params.a = params['a'].value
batman_params.inc = params['i'].value
batman_params.u = [coeff1,coeff2]
return y - batman_m.light_curve(batman_params)
def residuals_logarithmic(params, x, y):
coeff1 = 1.-np.sqrt(params['q1'].value)*params['q2'].value
coeff2 = 1.-np.sqrt(params['q1'].value)
batman_params.rp = params['p'].value
batman_params.a = params['a'].value
batman_params.inc = params['i'].value
batman_params.u = [coeff1,coeff2]
return y - batman_m.light_curve(batman_params)
def residuals_three_param(params, x, y):
c = LDC3.forward([params['q1'].value,params['q2'].value, params['q3'].value])
if LDC3.criteriatest(0,c) == 0:
c = [guess_coeff1, guess_coeff2, guess_coeff3]
batman_params.rp = params['p'].value
batman_params.a = params['a'].value
batman_params.inc = params['i'].value
batman_params.u = [0.,c[0],c[1],c[2]]
return y - batman_m.light_curve(batman_params)
# Define the initial values of the q_i parameters with
# the initial guesses of the coefficients:
if ld_law == 'linear':
guess_q1 = guess_coeff1
elif ld_law == 'quadratic':
guess_q1 = (guess_coeff1 + guess_coeff2)**2
guess_q2 = (guess_coeff1)/(2.*(guess_coeff1+guess_coeff2))
elif ld_law == 'squareroot':
guess_q1 = (guess_coeff1 + guess_coeff2)**2
guess_q2 = (guess_coeff2)/(2.*(guess_coeff1+guess_coeff2))
elif ld_law == 'logarithmic':
guess_q1 = (1.-guess_coeff2)**2
guess_q2 = (1.-guess_coeff1)/(1.-guess_coeff2)
elif ld_law == 'three-param':
guess_q1,guess_q2,guess_q3 = LDC3.inverse([guess_coeff1,guess_coeff2,guess_coeff3])
# Init lmfit
prms = lmfit.Parameters()
prms.add('p', value = guess_p, min = 0, vary = True)
prms.add('q1', value = guess_q1, min = 0, max = 1, vary = True)
if ld_law != 'linear':
prms.add('q2', value = guess_q2, min = 0, max = 1, vary = True)
if ld_law == 'three-param':
prms.add('q3', value = guess_q2, min = 0, max = 1, vary = True)
prms.add('i', value = guess_i, min = 0, max = 90, vary = True)
if guess_i == 90.0:
prms.add('a', value = guess_a, min = 0, vary = True)
else:
prms.add('b', value = np.cos(guess_i*np.pi/180.0)*guess_a, min = 0, max = 1, vary = True)
prms.add('a', expr = 'b/cos(i * pi/180.0)')
# Run lmfit for the corresponding ld-law:
if ld_law == 'linear':
result = lmfit.minimize(residuals_linear, prms, args=(x,y))
coeff1out = result.params['q1'].value
elif ld_law == 'quadratic':
result = lmfit.minimize(residuals_quadratic, prms, args=(x,y))
coeff1out = 2.*np.sqrt(result.params['q1'].value)*result.params['q2'].value
coeff2out = np.sqrt(result.params['q1'].value)*(1.-2.*result.params['q2'].value)
elif ld_law == 'squareroot':
result = lmfit.minimize(residuals_sqroot, prms, args=(x,y))
coeff1out = np.sqrt(result.params['q1'].value)*(1.-2.*result.params['q2'].value)
coeff2out = 2.*np.sqrt(result.params['q1'].value)*result.params['q2'].value
elif ld_law == 'logarithmic':
result = lmfit.minimize(residuals_logarithmic, prms, args=(x,y))
coeff1out = 1.-np.sqrt(result.params['q1'].value)*result.params['q2'].value
coeff2out = 1.-np.sqrt(result.params['q1'].value)
elif ld_law == 'three-param':
result = lmfit.minimize(residuals_three_param, prms, args=(x,y))
coeff1out, coeff2out, coeff3out = LDC3.forward([result.params['q1'].value,\
result.params['q2'].value,result.params['q3'].value])
# If the fit is successful, return fitted parameters. If not, raise an
# message and end the program:
if result.success:
if ld_law == 'linear':
return result.params['p'].value, coeff1out, result.params['i'].value, result.params['a'].value
elif ld_law == 'three-param':
return result.params['p'].value, coeff1out, coeff2out, coeff3out, result.params['i'].value, result.params['a'].value
else:
return result.params['p'].value, coeff1out, coeff2out, result.params['i'].value, result.params['a'].value
else:
print 'Unsuccessful fit for LD law',ld_law
if ld_law == 'linear':
return guess_p, guess_coeff1, guess_i, guess_a
elif ld_law == 'three-param':
return guess_p, guess_coeff1, guess_coeff2, guess_coeff3, guess_i, guess_a
else:
return guess_p, guess_coeff1, guess_coeff2, guess_i, guess_a
def fit_transit_floating_lds(x,
y,
guess_p,
guess_coeff1,
guess_coeff2,
guess_i,
guess_a,
P,
t0,
ld_law,
guess_coeff3=None):
"""
This function fits transit lightcurves with floating limb-darkening coefficients. Inputs are:
x: Times of observation.
y: Normalized fluxes
guess_p: Guess for the planet-to-star radius ratio (R_p/R_*)
guess_coeff1: Guess for the first limb-darkening coefficient.
guess_coeff2: Same for the second coefficient (not used if law is linear).
guess_coeff3: Same for third coefficient (if non-linear law is used)
guess_i: Guess on the inclination.
guess_a: Guess on the scaled semi-major axis (a/R_*)
P: Period of the orbit (not fitted).
t0: Time of transit center of the orbit (not fitted).
ld_law: Limb-darkening law to use for the fit.
The function returns the fitted values of p,i,a and the coefficients of the chosen LD law.
"""
# First, initialize the batman transit modeller with guess parameters:
if ld_law == 'linear':
batman_params,batman_m = init_batman(x, P, guess_i, guess_a, guess_p, t0, \
[guess_coeff1], ld_law = ld_law)
elif ld_law == 'three-param':
batman_params,batman_m = init_batman(x, P, guess_i, guess_a, guess_p, t0, \
[guess_coeff1, guess_coeff2,guess_coeff3], ld_law = ld_law)
else:
batman_params,batman_m = init_batman(x, P, guess_i, guess_a, guess_p, t0, \
[guess_coeff1, guess_coeff2], ld_law = ld_law)
# Define the residual functions depending on the LD law used:
def residuals_linear(params, x, y):
batman_params.rp = params['p'].value
batman_params.a = params['a'].value
batman_params.inc = params['i'].value
batman_params.u = [params['q1'].value]
return y - batman_m.light_curve(batman_params)
def residuals_quadratic(params, x, y):
coeff1 = 2. * np.sqrt(params['q1'].value) * params['q2'].value
coeff2 = np.sqrt(params['q1'].value) * (1. - 2. * params['q2'].value)
batman_params.rp = params['p'].value
batman_params.a = params['a'].value
batman_params.inc = params['i'].value
batman_params.u = [coeff1, coeff2]
return y - batman_m.light_curve(batman_params)
def residuals_sqroot(params, x, y):
coeff1 = np.sqrt(params['q1'].value) * (1. - 2. * params['q2'].value)
coeff2 = 2. * np.sqrt(params['q1'].value) * params['q2'].value
batman_params.rp = params['p'].value
batman_params.a = params['a'].value
batman_params.inc = params['i'].value
batman_params.u = [coeff1, coeff2]
return y - batman_m.light_curve(batman_params)
def residuals_logarithmic(params, x, y):
coeff1 = 1. - np.sqrt(params['q1'].value) * params['q2'].value
coeff2 = 1. - np.sqrt(params['q1'].value)
batman_params.rp = params['p'].value
batman_params.a = params['a'].value
batman_params.inc = params['i'].value
batman_params.u = [coeff1, coeff2]
return y - batman_m.light_curve(batman_params)
def residuals_three_param(params, x, y):
c = LDC3.forward(
[params['q1'].value, params['q2'].value, params['q3'].value])
if LDC3.criteriatest(0, c) == 0:
c = [guess_coeff1, guess_coeff2, guess_coeff3]
batman_params.rp = params['p'].value
batman_params.a = params['a'].value
batman_params.inc = params['i'].value
batman_params.u = [0., c[0], c[1], c[2]]
return y - batman_m.light_curve(batman_params)
# Define the initial values of the q_i parameters with
# the initial guesses of the coefficients:
if ld_law == 'linear':
guess_q1 = guess_coeff1
elif ld_law == 'quadratic':
guess_q1 = (guess_coeff1 + guess_coeff2)**2
guess_q2 = (guess_coeff1) / (2. * (guess_coeff1 + guess_coeff2))
elif ld_law == 'squareroot':
guess_q1 = (guess_coeff1 + guess_coeff2)**2
guess_q2 = (guess_coeff2) / (2. * (guess_coeff1 + guess_coeff2))
elif ld_law == 'logarithmic':
guess_q1 = (1. - guess_coeff2)**2
guess_q2 = (1. - guess_coeff1) / (1. - guess_coeff2)
elif ld_law == 'three-param':
guess_q1, guess_q2, guess_q3 = LDC3.inverse(
[guess_coeff1, guess_coeff2, guess_coeff3])
# Init lmfit
prms = lmfit.Parameters()
prms.add('p', value=guess_p, min=0, vary=True)
prms.add('q1', value=guess_q1, min=0, max=1, vary=True)
if ld_law != 'linear':
prms.add('q2', value=guess_q2, min=0, max=1, vary=True)
if ld_law == 'three-param':
prms.add('q3', value=guess_q2, min=0, max=1, vary=True)
prms.add('i', value=guess_i, min=0, max=90, vary=True)
if guess_i == 90.0:
prms.add('a', value=guess_a, min=0, vary=True)
else:
prms.add('b',
value=np.cos(guess_i * np.pi / 180.0) * guess_a,
min=0,
max=1,
vary=True)
prms.add('a', expr='b/cos(i * pi/180.0)')
# Run lmfit for the corresponding ld-law:
if ld_law == 'linear':
result = lmfit.minimize(residuals_linear, prms, args=(x, y))
coeff1out = result.params['q1'].value
elif ld_law == 'quadratic':
result = lmfit.minimize(residuals_quadratic, prms, args=(x, y))
coeff1out = 2. * np.sqrt(
result.params['q1'].value) * result.params['q2'].value
coeff2out = np.sqrt(
result.params['q1'].value) * (1. - 2. * result.params['q2'].value)
elif ld_law == 'squareroot':
result = lmfit.minimize(residuals_sqroot, prms, args=(x, y))
coeff1out = np.sqrt(
result.params['q1'].value) * (1. - 2. * result.params['q2'].value)
coeff2out = 2. * np.sqrt(
result.params['q1'].value) * result.params['q2'].value
elif ld_law == 'logarithmic':
result = lmfit.minimize(residuals_logarithmic, prms, args=(x, y))
coeff1out = 1. - np.sqrt(
result.params['q1'].value) * result.params['q2'].value
coeff2out = 1. - np.sqrt(result.params['q1'].value)
elif ld_law == 'three-param':
result = lmfit.minimize(residuals_three_param, prms, args=(x, y))
coeff1out, coeff2out, coeff3out = LDC3.forward([result.params['q1'].value,\
result.params['q2'].value,result.params['q3'].value])
# If the fit is successful, return fitted parameters. If not, raise an
# message and end the program:
if result.success:
if ld_law == 'linear':
return result.params['p'].value, coeff1out, result.params[
'i'].value, result.params['a'].value
elif ld_law == 'three-param':
return result.params[
'p'].value, coeff1out, coeff2out, coeff3out, result.params[
'i'].value, result.params['a'].value
else:
return result.params[
'p'].value, coeff1out, coeff2out, result.params[
'i'].value, result.params['a'].value
else:
print 'Unsuccessful fit for LD law', ld_law
if ld_law == 'linear':
return guess_p, guess_coeff1, guess_i, guess_a
elif ld_law == 'three-param':
return guess_p, guess_coeff1, guess_coeff2, guess_coeff3, guess_i, guess_a
else:
return guess_p, guess_coeff1, guess_coeff2, guess_i, guess_a
