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