def __make_model(self, time, flux, flux_err, rstar, mstar, epoch, period, rplanet, exposure_time): P1 = period * u.day a = np.cbrt((ac.G * mstar * P1**2) / (4 * np.pi**2)).to(u.au) texpo = exposure_time / 60. / 60. / 24. model = ellc.lc( t_obs=time, radius_1=rstar.to(u.au) / a, # star radius convert from AU to in units of a radius_2=rplanet.to(u.au) / a, # convert from Rearth (equatorial) into AU and then into units of a sbratio=0, incl=90, light_3=0, t_zero=epoch, period=period, a=None, q=1e-6, f_c=None, f_s=None, ldc_1=self.ab, 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=texpo, n_int=None, grid_1='default', grid_2='default', ld_1='quad', ld_2=None, shape_1='sphere', shape_2='sphere', spots_1=None, spots_2=None, exact_grav=False, verbose=1) if model[0] > 0: flux_t = flux + model - 1. result_flux = flux_t result_flux_err = flux_err result_time = time else: result_flux = [] result_time = [] result_flux_err = [] return result_time, result_flux, result_flux_err
def basic_model(t, pars, grid='default'): try: m = ellc.lc(t_obs=t, radius_1=pars[0], radius_2=pars[1], sbratio=pars[2], incl=pars[3], t_zero=58664.0, q=pars[4], period=pars[6] / 86400.0, shape_1='roche', shape_2='roche', t_exp=30 / 86400.0, grid_1=grid, grid_2=grid, heat_2=pars[5], exact_grav=False) m *= 1.0 except: print("Failed with parameters:", pars) return t * 10**99 return m
def flux_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_flux = ellc.lc( t_obs=xx, radius_1=params[planet + '_radius_1'], radius_2=params[planet + '_radius_2'], sbratio=params[planet + '_sbratio_' + inst], incl=params[planet + '_incl'], light_3=params['light_3_' + inst], t_zero=params[planet + '_epoch'], period=params[planet + '_period'], f_c=params[planet + '_f_c'], f_s=params[planet + '_f_s'], ldc_1=params['ldc_1_' + inst], # ldc_2 = ldc_2, ld_1=config.BASEMENT.settings['ld_law_' + inst], # ld_2 = 'quad', heat_2=params[planet + '_heat_2_' + inst], t_exp=config.BASEMENT.settings['t_exp_' + inst], n_int=config.BASEMENT.settings['t_exp_n_int_' + inst]) return model_flux
def subtract_planet_transit(self, ab, star_radius, star_mass, time, flux, planet_radius, planet_t0, planet_period, planet_inc=90): P1 = planet_period * u.day a = np.cbrt( (ac.G * star_mass * u.M_sun * P1**2) / (4 * np.pi**2)).to(u.au) model = ellc.lc( t_obs=time, radius_1=(star_radius * u.R_sun).to(u.au) / a, # star radius convert from AU to in units of a radius_2=(planet_radius * u.R_earth).to(u.au) / a, # convert from Rearth (equatorial) into AU and then into units of a sbratio=0, incl=planet_inc, light_3=0, t_zero=planet_t0, period=planet_period, a=None, q=1e-6, f_c=None, f_s=None, ldc_1=ab, 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='quad', ld_2=None, shape_1='sphere', shape_2='sphere', spots_1=None, spots_2=None, exact_grav=False, verbose=1) return flux - model + 1
def test_EB(p=1.0, maxNterms=10): """ using ellc, make an eclipsing binary LC and fit using fourier components input: p: float the period Nterms number of fourier terms to be used for fitting output: 0 """ import ellc # make testdata t = 100. * np.random.rand(1000) t.sort() y = ellc.lc(t, 0.05, 0.25, 0.12, 85., t_zero=0.32321, period=p, q=0.23, shape_2='roche') y += 0.0000001 * (t - np.min(t)) dy = 0.01 * np.ones_like(t) y += dy * np.random.randn(np.size(t)) # fit data LC = np.c_[t, y, dy] output1 = fit_best(LC, p, maxNterms=maxNterms, output='full') output2 = fit(LC, p, Nterms=5, output='full') plt.plot(AB2AmpPhi(copy.deepcopy(output1[4:]).reshape(maxNterms, 2)), 'ro') plt.plot(AB2AmpPhi(copy.deepcopy(output2[4:]).reshape(Nterms, 2)), 'bo') plt.show() # show result f = make_f(p=p) model1 = f(t, *output1[2:]) model2 = f(t, *output2[2:]) #plt.errorbar(t,y,dy,fmt='k,') #plt.plot(t,model,'r.') #plt.show() # fold plt.errorbar(t / p % 1, y, dy, fmt='k,') plt.plot(t / p % 1, model1, 'r.') plt.plot(t / p % 1, model2, 'b.') plt.show() return 0
def ellc_WDWD(pars, x, logpars=False): # set values p, t0, r1, r2, incl, q, M1, scale, sbratio, heat = pars if logpars: sbratio = 10**sbratio # check parameter values if np.min(pars) < 0: return -np.inf #print(p,t0,r1,r2,incl,q,sbratio,heat) if (r2 > 0.99 * get_REg(q) or r1 > 0.99 * get_REg(q**-1) or incl >= 90 or np.min([r1, r2, incl, q, scale, sbratio, heat]) <= 0): return -np.inf # calculate binary parameters K1, K2, a = kepler_calc_RV(M1, q * M1, p, incl) # lower limit to WD radius if M1 > 1.44 or r1 * a < WD_MR(M1): print('WD mass/radius out of range') return -np.inf if M2 > 1.44 or r2 * a < WD_MR(M2): print('WD mass/radius out of range') return -np.inf try: m = scale * ellc.lc( x, radius_1=r1, radius_2=r2, sbratio=sbratio, incl=incl, q=q, period=p, t_zero=t0, shape_2='roche', exact_grav=False, #WARNING TURN THIS ON IN PRODUCTION!!! ldc_1=0.6, ldc_2=0.6, gdc_2=0.08, heat_2=heat, grid_1='default', grid_2='default', t_exp=30. / 3600 / 24, n_int=3) #print('succes') return m except Exception as e: print('ellc failed:') print(e) return -np.inf
def calcFLUX(curvas,pontos): startTime = datetime.now() time = linspace(0,curvas,pontos) flux = ellc.lc(time,t_zero=t_zero, period=period, radius_1=r_1, radius_2=r_2,incl=90,sbratio=0, rotfac_1 = rotfac_1, ld_1=ld_1, ldc_1=ldc_1,shape_1='sphere',shape_2='sphere', grid_1='sparse',grid_2='sparse',spots_1=spots_1) endTime = datetime.now() duracao = endTime - startTime registraExecucao(curvas, pontos, duracao, 1) return flux
def get_light_curve(x, period, t0, aor, ror, incl, ustar=None, ld=None, ecc=0, omega=90, sbratio=0, oversample=1, texp=None, **kwargs): try: from ellc import lc except ModuleNotFoundError: print("Please install `ellc` to use this function") sys.exit() if not isinstance(x, np.ndarray): x = np.array([x]) r1oa = 1 / aor r2oa = r1oa * ror f_s = np.sqrt(ecc) * np.sin(np.deg2rad(omega)) f_c = np.sqrt(ecc) * np.cos(np.deg2rad(omega)) model = lc(x, radius_1=r1oa, radius_2=r2oa, incl=incl, sbratio=sbratio, period=period, t_zero=t0, f_s=f_s, f_c=f_c, light_3=0, ld_1=ld, ldc_1=ustar, t_exp=texp, n_int=oversample, **kwargs) # grid_1='very_sparse', # grid_2='v) return model
def func(c, t, r_1, k, incl, grid_size, lc_mugrid): h1, h2 = q1q2_to_h1h2(c[0], c[1]) c2, a2 = h1h2_to_ca(h1, h2) ldc_1 = [c2, a2] try: lc_fit = lc(t, radius_1=r_1, radius_2=r_1 * k, sbratio=0, incl=incl, ld_1='power-2', ldc_1=ldc_1, grid_1=grid_size, grid_2=grid_size) except: lc_fit = zero_like(t) return (lc_fit - lc_mugrid).std()
def basic_model(t, pars, grid='default'): """ a function which returns model values at times t for parameters pars input: t a 1D array with times pars a 1D array with parameter values; r1,r2,J,i,t0,p output: m a 1D array with model values at times t """ try: m = ellc.lc(t_obs=t, radius_1=pars[0], radius_2=pars[1], sbratio=pars[2], incl=pars[3], t_zero=pars[4], q=pars[6], period=p, shape_1='sphere', shape_2='roche', ld_1="claret", ldc_1=[0.9361, -1.0310, 0.8933, -0.3117], ld_2="claret", ldc_2=[0.7593, -0.2638, 0.1634, -0.0651], gdc_1=0.4712, gdc_2=0.4102, f_c=0, f_s=0, t_exp=t_exp, grid_1=grid, grid_2=grid, heat_2=1.0, exact_grav=True, verbose=0) m *= pars[5] except: print("Failed with parameters:", pars) return t * 10**99 return m
def ellc_lc_short(time): return ellc.lc(t_obs=time, radius_1=params['R_host/a'], radius_2=params['R_companion/a'], sbratio=sbratio, incl=params['incl'], light_3=dil, t_zero=params['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, exact_grav=False, verbose=1)
def basic_model(t, radius_1, radius_2, sbratio, incl, t_zero, q, period, heat_2, scale_factor): """ A function which returns model values at times t for parameters pars input: t a 1D array with times pars a 1D array with parameter values; r1,r2,J,i,t0,p output: m a 1D array with model values at times t """ grid = "very_sparse" try: m = ellc.lc(t_obs=t, radius_1=radius_1, radius_2=radius_2, sbratio=sbratio, incl=incl, t_zero=t_zero, q=q, period=period, shape_1='sphere', shape_2='roche', ldc_1=0.2, ldc_2=0.4548, gdc_2=0.61, f_c=0, f_s=0, t_exp=3.0 / 86400, grid_1=grid, grid_2=grid, heat_2=heat_2, exact_grav=False, verbose=0) m *= scale_factor except: return t * 10**99 return m
def basic_model(t, pars, grid='default'): """ a function which returns model values at times t for parameters pars input: t a 1D array with times pars a 1D array with parameter values; r1,r2,J,i,t0,p output: m a 1D array with model values at times t """ try: m = ellc.lc(t_obs=t, radius_1=pars[0], radius_2=pars[1], sbratio=pars[2], incl=pars[3], t_zero=pars[4], q=pars[7], period=pars[8], shape_1='sphere', shape_2='roche', ldc_1=0.2, ldc_2=0.4548, gdc_2=0.61, f_c=0, f_s=0, t_exp=3.0 / 86400, grid_1=grid, grid_2=grid, heat_2=pars[6], exact_grav=True, verbose=0) m *= pars[5] except: print("Failed with parameters:", pars) return t * 10**99 return m
def _f(self, c, k, incl, law): if law in ("power-2"): h1, h2 = q1q2_to_h1h2(c[0], c[1]) c2, a2 = h1h2_to_ca(h1, h2) ldc_1 = [c2, a2] else: ldc_1 = c try: lc_fit = lc(self._t, radius_1=0.1, radius_2=0.1 * k, sbratio=0, incl=incl, ld_1=law, ldc_1=ldc_1, grid_1=self._gridsize, grid_2=self._gridsize) except: lc_fit = zero_like(self._t) rms = np.sqrt(np.mean((lc_fit - self._lc_mugrid)**2)) return rms
def light_curve_model(t_obs, t0, period, radius_1, radius_2, sbratio, incl, f_c, f_s, ldc_1): lc_model = ellc.lc(t_obs=t_obs, radius_1=radius_1, radius_2=radius_2, sbratio=sbratio, incl=incl, t_zero=t0, period=period, q=0.21864444, a=14.6, t_exp=0.02044, n_int=5, f_c=f_c, f_s=f_s, ldc_1=ldc_1, ldc_2=0.6, ld_1='lin', ld_2='lin', grid_1='very_sparse', grid_2='very_sparse') return lc_model
def transit_model(time, rr=0.1, rsuma=0.1, cosi=0, epoch=0, period=1, ldc=[0.5, 0.5]): params = { 'b_rr': rr, 'b_rsuma': rsuma, 'b_cosi': cosi, 'b_epoch': epoch, 'b_period': period, } companion = 'b' params[companion + '_radius_1'] = params[companion + '_rsuma'] / (1. + params[companion + '_rr']) params[companion + '_radius_2'] = params[companion + '_radius_1'] * params[companion + '_rr'] params[companion + '_incl'] = np.arccos(params[companion + '_cosi']) / np.pi * 180. model_flux = ellc.lc(t_obs=time, radius_1=params[companion + '_radius_1'], radius_2=params[companion + '_radius_2'], sbratio=0., incl=params[companion + '_incl'], t_zero=params[companion + '_epoch'], period=params[companion + '_period'], ldc_1=ldc, ld_1='quad', verbose=False) return model_flux
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, incl=incl, sbratio=1. / sbratio, a=0.737, period=period, ld_1=ld_2, ldc_1=ldc_2, ld_2=ld_1, ldc_2=ldc_1, shape_1=shape, shape_2=shape) lc_1 = lc_1 / np.min(lc_1) rv_1, dummy = ellc.rv(time, t_zero=0.0, q=1 / q, heat_1=heat, radius_1=r_2, radius_2=r_1, incl=incl,
ld_2 = 'claret' ldc_2 = [a1, a2, a3, a4] print('y_1 = ', y_1) print('y_2 = ', y_2) alpha = 0.5 lc_1 = lc(phase, t_zero=0.5, q=q, radius_1=r_1, radius_2=r_2, incl=incl, sbratio=sbratio, ld_1=ld_2, ldc_1=ldc_1, gdc_1=y_1, ld_2=ld_2, ldc_2=ldc_2, gdc_2=y_2, heat_1=alpha, heat_2=alpha, shape_1=shape_1, shape_2=shape_2, exact_grav=False, verbose=3) heat_1 = [0.35, 1.0, np.sum(ldc_1)] heat_2 = [0.35, 1.0, np.sum(ldc_2)] lc_2 = lc(phase, t_zero=0.5, q=q,
def ellc(t_obs, radius_1=r1 / a, radius_2=r2 / a, sbratio=0.5, incl=80, light_3=0, t_zero=0, period=P0, a=a, q=m1 / m2, f_c=None, f_s=None, ldc_1=None, 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=None, ld_2=None, shape_1='sphere', shape_2='sphere', spots_1=None, spots_2=None, exact_grav=False, verbose=1): """ Uses ellc binary star model [1] to create light curve of binary star system See lc.py for documentation of all params and defaults INPUT: t = time array from time() function Default: n=100, mean_dt=3, sig_t=2 r1, r2 = radii of the objects Default: r1 = 1.5e-2 rsun, r2 = 3e-2 rsun a = semi-major axis of binary system Default: 10e-2 rsun sbratio = surface brightness ratio Default: 0.5 incl = inclination of orbit Default: 80 deg period = period of orbit (assumes p dot = 0) Default: 0.005 days (432 s) m1, m2 = masses of objects Default: m1 = 0.5 msun, m2 = 0.25 msun (for other params, see ellc/lc.py documentation) OUTPUT: flux = flux array for binary system ------------ References: [1] Maxted, P.F.L. 2016. A fast, flexible light curve model for detached eclipsing binary stars and transiting exoplanets. A&A 591, A111, 2016. """ flux = lc(t_obs=t_obs, radius_1=radius_1, radius_2=radius_2, sbratio=sbratio, incl=incl, period=period, q=q, a=a, light_3=light_3, t_zero=t_zero, f_c=f_c, f_s=f_s, ldc_1=ldc_1, ldc_2=ldc_2, gdc_1=gdc_1, gdc_2=gdc_2, didt=didt, domdt=domdt, rotfac_1=rotfac_1, rotfac_2=rotfac_2, hf_1=hf_1, hf_2=hf_2, bfac_1=bfac_1, bfac_2=bfac_2, heat_1=heat_1, heat_2=heat_2, lambda_1=lambda_1, lambda_2=lambda_2, vsini_1=vsini_1, vsini_2=vsini_2, t_exp=t_exp, n_int=n_int, grid_1=grid_1, grid_2=grid_2, ld_1=ld_1, ld_2=ld_2, shape_1=shape_1, shape_2=shape_2, spots_1=spots_1, spots_2=spots_2, exact_grav=exact_grav, verbose=verbose) return np.array(flux)
def main(): parser = argparse.ArgumentParser( description='Optimize limb-darkening coefficients', formatter_class=argparse.RawDescriptionHelpFormatter, epilog=textwrap.dedent('''\ Optimize limb-darkening coefficients by fitting a transit light curve Input files containing centre-to-limb intensity profile must have three columns with mu in the _2nd_ column and intensity in the _3rd_column. N.B. input data must be in ascending order of mu. Currently only implements power-2 law - others to be added. The output is a single line with the parameters in the following order profile c alpha h_1 h_2 q_1 q_2 rms rms is the root-mean-square residual of the fit to the transit light curve in ppm. Notes ~~~~~ - If repeated intensity values with mu=0 are present at the start of the data file then only the last one in the list is used. - If the data file does not contain data at mu=0, I(0)=0 will be used. - If the data file does not contain data at mu=1, I(1)=1 will be used. -- ''')) parser.add_argument( 'profile', nargs='+', help='File with intensity profile, mu in col. 2, I(mu) in col. 3') parser.add_argument('-r', '--resample', default=101, type=int, help='''Re-sample input data Input data are interpolated onto regular grid with specifed number of points. Set this value to 0 to avoid re-sampling if the input data are already on a regular grid of mu values. (default: %(default)d) ''') parser.add_argument('-n', '--n_lc', default=64, type=int, help='''Number of points in the simulated light curve. (default: %(default)d) ''') parser.add_argument('-b', '--impact', default=0.0, type=float, help='''Impact parameter for simulated light curve (default: %(default)f) ''') parser.add_argument( '-k', '--ratio', default=0.1, type=float, help='''Planet-star radius ratio for simulated light curve (default: %(default)f) ''') parser.add_argument('-g', '--grid', default='sparse', type=str, help='''Density of numerical grid for simulation Options are 'very_sparse', 'sparse', 'default', 'fine' and 'very_fine' (default: %(default)s) ''') args = parser.parse_args() # Fixed parameters, might change these to input options later, idk r_1 = 0.1 # star radius/a w = 0.5 * transit_width(r_1, args.ratio, args.impact) t = np.linspace(0, w, args.n_lc, endpoint=False) for profile in args.profile: mu, I_mu = np.loadtxt(profile, unpack=True, usecols=[1, 2]) # Deal with repeated data at mu=0 if sum(mu == 0) > 1: j = np.arange(len(mu))[mu == 0].max() mu = mu[j:] I_mu = I_mu[j:] elif sum(mu == 0) == 0: mu = np.array([0, *mu]) I_mu = np.array([0, *I_mu]) if sum(mu == 1) == 0: mu = np.array([*mu, 1]) I_mu = np.array([*I_mu, 1]) if args.resample > 0: mu_1 = np.linspace(0, 1, args.resample) ldc_1 = pchip_interpolate(mu, I_mu, mu_1) else: ldc_1 = mu incl = 180 * np.arccos(r_1 * args.impact) / np.pi lc_mugrid = lc(t, radius_1=r_1, radius_2=r_1 * args.ratio, sbratio=0, incl=incl, ld_1='mugrid', ldc_1=ldc_1, grid_1=args.grid, grid_2=args.grid) c = np.array([0.3, 0.45]) # q1, q2 smol = np.sqrt(np.finfo(float).eps) soln = minimize(func, c, args=(t, r_1, args.ratio, incl, args.grid, lc_mugrid), method='L-BFGS-B', bounds=((smol, 1 - smol), (smol, 1 - smol))) q1, q2 = soln.x h1, h2 = q1q2_to_h1h2(q1, q2) c2, a2 = h1h2_to_ca(h1, h2) print( f"{profile} {c2:0.5f} {a2:0.5f} {h1:0.5f} {h2:0.5f} {q1:0.5f} {q2:0.5f} {soln.fun*1e6:5.2f}" )
om = 90 f_c = np.sqrt(ecc) * np.cos(om * np.pi / 180.) f_s = np.sqrt(ecc) * np.sin(om * np.pi / 180.) t = phase * period lc = ellc.lc(t, t_zero=t_zero, period=period, a=a, q=q, ld_1=ld_1, ldc_1=ldc_1, ld_2=ld_2, ldc_2=ldc_2, 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') rv_ellc_2, rv_ellc_1 = ellc.rv(t, t_zero=t_zero, period=period, a=a, q=q,
ldc_1 = [0.1, 0.3] ld_1 = 'quad' sbratio = 0 e = 0.1 om = 60 f_s = np.sqrt(e) * np.sin(om * np.pi / 180.) f_c = np.sqrt(e) * np.cos(om * np.pi / 180.) q = 0.001 flux_0 = ellc.lc(t, radius_1=r_1, radius_2=r_2, incl=incl, sbratio=sbratio, ld_1=ld_1, ldc_1=ldc_1, shape_1='sphere', shape_2='sphere', grid_1='default', grid_2='default', f_s=f_s, f_c=f_c) flux_2 = ellc.lc(t, radius_1=r_1, radius_2=r_2, incl=incl, sbratio=sbratio, ld_1=ld_1, ldc_1=ldc_1, shape_1='sphere',
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
print('Median acceptance fraction =',np.median(af)) print('Range of acceptance fraction =',np.min(af),' to ', np.max(af)) # Plot fit to lightcurves fig=plt.figure(2,figsize=(5,7)) ph_mod = np.arange(-0.024,0.025,0.001) offstep = 0.08 offset = 0 ph_wasp = (1 + (((lc_wasp['HJD']-t_zero)/period) % 1)) % 1 plt.scatter(ph_wasp ,lc_wasp['dmag'],s=1) plt.scatter(ph_wasp-1,lc_wasp['dmag'],s=1) plt.xlim([-0.024,0.024]) plt.ylim([0.35,-0.03]) m = -2.5*np.log10(ellc.lc(ph_mod*period+t_zero, 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' )) plt.plot(ph_mod,m) plt.text(-0.023,-0.019,'WASP') offset += offstep ph_nites = (1 + (((lc_nites['HJD']-t_zero)/period) % 1)) % 1 plt.scatter(ph_nites ,lc_nites['dmag']+offset,s=1) plt.scatter(ph_nites-1,lc_nites['dmag']+offset,s=1) m = -2.5*np.log10(ellc.lc(ph_mod*period+t_zero, 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')) plt.plot(ph_mod,m+offset) plt.text(-0.023,offset-0.019,'NITES') offset += offstep
def __call__(self, T_eff, log_g, Fe_H, k=0.1, b=0.0, law='power-2', precision='low'): """ :parameter T_eff: effective temperature in Kelvin :parameter log_g: log of the surface gravity in cgs units :parameter Fe/H: [Fe/H] in dex :parameter k: Radius ratio R_pl/R_star :parameter b: Impact parameter (R_star/a)cos(incl) :parameter law: Limb darkening law :param precision: 'low', 'medium' or 'high' :returns: array of coefficients """ self._mu_default = np.array( [0, 0.01, 0.05, 0.1, 0.2, 0.3, 0.5, 0.7, 0.8, 0.9, 1.0]) precision_to_gridsize = { "low": "very_sparse", "medium": "sparse", "high": "default" } self._gridsize = precision_to_gridsize.get(precision, None) if self._gridsize is None: raise ValueError("Invalid precision value", precision) # Fixed parameters n_mu = 51 n_grid = 32 mu = np.linspace(0, 1, n_mu) I_mu = self._interpolator(T_eff, log_g, Fe_H) ldc_1 = pchip_interpolate(self._mu_default, I_mu, mu) w = 0.5 * transit_width(0.1, k, b) # Avoid last contact point - occasional numerical problems self._t = np.linspace(0, w, n_grid, endpoint=False) incl = 180 * np.arccos(0.1 * b) / np.pi self._lc_mugrid = lc(self._t, radius_1=0.1, radius_2=0.1 * k, sbratio=0, incl=incl, ld_1='mugrid', ldc_1=ldc_1, grid_1=self._gridsize, grid_2=self._gridsize) if law in ("lin"): c = np.full(1, 0.5) elif law in ("quad", "log", "sqrt", "exp"): c = np.full(2, 0.5) elif law in ("power-2"): c = np.array([0.3, 0.45]) # q1, q2 elif law in ("sing"): c = np.full(3, 0.5) elif law in ("claret"): c = np.full(4, 0.5) else: raise Exception("Invalid limb darkening law") if law in ("power-2"): smol = np.sqrt(np.finfo(float).eps) soln = minimize(self._f, c, args=(k, incl, law), method='L-BFGS-B', bounds=((smol, 1 - smol), (smol, 1 - smol))) h1, h2 = q1q2_to_h1h2(soln.x[0], soln.x[1]) c2, a2 = h1h2_to_ca(h1, h2) c = np.array([c2, a2]) else: soln = minimize(self._f, c, args=(k, incl, law)) c = soln.x self._rms = soln.fun self._lc_fit = lc(self._t, radius_1=0.1, radius_2=0.1 * k, sbratio=0, incl=incl, ld_1=law, ldc_1=c, grid_1=self._gridsize, grid_2=self._gridsize) return c
incl = 29.3 q = 0.234 ld_1 = 'quad' ldc_1 = [0.028, 0.264] ld_2 = 'quad' ldc_2 = [0.272, 0.567] shape_1 = 'roche' shape_2 = 'roche' heat_2 = [0.6, 3.5, 0.0] lc_1 = ellc.lc(phase, t_zero=t_zero, q=q, heat_2=heat_2, 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, shape_1=shape_1, shape_2=shape_2) heat_2 = [1.0, 1.5, 0.0] lc_2 = ellc.lc(phase, t_zero=t_zero, q=q, heat_2=heat_2, radius_1=r_1, radius_2=r_2, incl=incl, sbratio=sbratio,
def flux_fct(params, inst, companion, xx=None): ''' ! params must be updated via update_params() before calling this function ! if phased, pass e.g. xx=np.linspace(-0.25,0.75,1000) amd t_exp_scalefactor=1./params[companion+'_period'] ''' if xx is None: xx = config.BASEMENT.data[inst]['time'] + params['ttv_'+inst] 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 # try: #::: planet and EB transit lightcurve model if params[companion+'_rr'] > 0: model_flux = ellc.lc( t_obs = xx, radius_1 = params[companion+'_radius_1'], radius_2 = params[companion+'_radius_2'], sbratio = params[companion+'_sbratio_'+inst], incl = params[companion+'_incl'], light_3 = params['dil_'+inst], 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], verbose = False ) else: model_flux = np.ones_like(xx) #::: flare lightcurve model if config.BASEMENT.settings['N_flares'] > 0: for i in range(1,config.BASEMENT.settings['N_flares']+1): # print(params['flare_tpeak_'+str(i)]) model_flux += aflare1(xx, params['flare_tpeak_'+str(i)], params['flare_fwhm_'+str(i)], params['flare_ampl_'+str(i)], upsample=True, uptime=10) # # print(xx) # print(model_flux) # import matplotlib.pyplot as plt # plt.figure(xx, model_flux, 'r-') # err # except: # for key in params: # print(key, '\t', params[key]) # raise ValueError('flux_fct crashed for the parameters given above.') return model_flux
params['flare_tpeak_2'] = 0.5 params['flare_fwhm_2'] = 0.05 params['flare_ampl_2'] = 0.004 params['flare_tpeak_3'] = 1.4 params['flare_fwhm_3'] = 0.2 params['flare_ampl_3'] = 0.007 ############################################################################### #::: "truth" signal ############################################################################### time = np.linspace(0, 3, 1000) flux_ellc = ellc.lc(t_obs=time, radius_1=params[planet + '_radius_1'], radius_2=params[planet + '_radius_2'], sbratio=0, incl=params[planet + '_incl'], t_zero=params[planet + '_epoch'], period=params[planet + '_period']) flux_flares = np.zeros_like(time) for i in range(1, N_flares + 1): flux_flares += aflare1(time, params['flare_tpeak_' + str(i)], params['flare_fwhm_' + str(i)], params['flare_ampl_' + str(i)], upsample=False, uptime=10) flux = flux_ellc + flux_flares flux += 1e-3 * np.random.randn(len(time))
############################################################################### #::: "truth" signals ############################################################################### #============================================================================== #::: Leonardo #============================================================================== planet = 'b' inst = 'Leonardo' time_Leonardo = np.arange(0, 16, 5. / 60. / 24.)[::5] time_Leonardo = time_Leonardo[(time_Leonardo < 2) | (time_Leonardo > 4)] flux_Leonardo = ellc.lc(t_obs=time_Leonardo, radius_1=params[planet + '_radius_1'], radius_2=params[planet + '_radius_2'], sbratio=params[planet + '_sbratio'], incl=params[planet + '_incl'], t_zero=params[planet + '_epoch'], period=params[planet + '_period'], ld_1=params['ld_1_' + inst], ldc_1=params['ldc_1_' + inst]) flux_Leonardo += np.random.normal(0, 2e-3, size=len(flux_Leonardo)) flux_Leonardo += 1e-3 * np.exp(time_Leonardo / 4.7) * np.sin( time_Leonardo / 2.7) flux_err_Leonardo = 2e-3 * np.ones_like(flux_Leonardo) header = 'time,flux,flux_err' X = np.column_stack((time_Leonardo, flux_Leonardo, flux_err_Leonardo)) np.savetxt(os.path.join(workdir, 'Leonardo.csv'), X, delimiter=',', header=header)
def _lnlike(varpar_v, lcdata, varpar_l, fixpar_d, priors, ldy_, n_spot_1, n_spot_2, grid_size, return_fit=False): try: r_1 = varpar_v[(([i for i, s in enumerate(varpar_l) if s == 'r_1'])[0])] except: r_1 = fixpar_d['r_1'] if (r_1 <= 0) or (r_1 > 1): return -np.inf try: r_2 = varpar_v[(([i for i, s in enumerate(varpar_l) if s == 'r_2'])[0])] except: r_2 = fixpar_d['r_2'] if (r_2 <= 0) or (r_2 > 1): return -np.inf try: sb2 = varpar_v[(([i for i, s in enumerate(varpar_l) if s == 'sb2'])[0])] except: sb2 = fixpar_d['sb2'] if sb2 < 0: return -np.inf try: incl = varpar_v[(([i for i, s in enumerate(varpar_l) if s == 'incl'])[0])] except: incl = fixpar_d['incl'] if (incl <= 0) or (incl > 90): return -np.inf try: l_3 = varpar_v[(([i for i, s in enumerate(varpar_l) if s == 'l_3'])[0])] except: l_3 = fixpar_d['l_3'] try: t0 = varpar_v[(([i for i, s in enumerate(varpar_l) if s == 'T_0'])[0])] except: t0 = fixpar_d['T_0'] try: period = varpar_v[(([i for i, s in enumerate(varpar_l) if s == 'P'])[0])] except: period = fixpar_d['P'] try: f_c = varpar_v[(([i for i, s in enumerate(varpar_l) if s == 'f_c'])[0])] except: f_c = fixpar_d['f_c'] if (f_c <= -1) or (f_c >= 1): return -np.inf try: f_s = varpar_v[(([i for i, s in enumerate(varpar_l) if s == 'f_s'])[0])] except: f_s = fixpar_d['f_s'] if (f_s <= -1) or (f_s >= 1): return -np.inf try: domdt = varpar_v[(([i for i, s in enumerate(varpar_l) if s == 'domdt'])[0])] except: domdt = fixpar_d['domdt'] if (domdt <= -1) or (domdt >= 1): return -np.inf try: frot1 = varpar_v[(([i for i, s in enumerate(varpar_l) if s == 'F_1'])[0])] except: frot1 = fixpar_d['F_1'] try: frot2 = varpar_v[(([i for i, s in enumerate(varpar_l) if s == 'F_2'])[0])] except: frot2 = fixpar_d['F_2'] try: t1 = varpar_v[(([i for i, s in enumerate(varpar_l) if s == 'Teff1'])[0])] except: t1 = fixpar_d['Teff1'] try: g1 = varpar_v[(([i for i, s in enumerate(varpar_l) if s == 'logg1'])[0])] except: g1 = fixpar_d['logg1'] try: t2 = varpar_v[(([i for i, s in enumerate(varpar_l) if s == 'Teff2'])[0])] except: t2 = fixpar_d['Teff2'] try: g2 = varpar_v[(([i for i, s in enumerate(varpar_l) if s == 'logg2'])[0])] except: g2 = fixpar_d['logg2'] try: m = varpar_v[(([i for i, s in enumerate(varpar_l) if s == '[M/H]'])[0])] except: m = fixpar_d['[M/H]'] try: A_1 = varpar_v[(([i for i, s in enumerate(varpar_l) if s == 'A_1'])[0])] except: A_1 = fixpar_d['A_1'] if A_1 < 0: return -np.inf try: A_2 = varpar_v[(([i for i, s in enumerate(varpar_l) if s == 'A_2'])[0])] except: A_2 = fixpar_d['A_2'] if A_2 < 0: return -np.inf try: tilt = varpar_v[(([i for i, s in enumerate(varpar_l) if s == 'tilt'])[0])] except: tilt = fixpar_d['tilt'] if tilt < 0: return -np.inf spots_1 = None if n_spot_1 > 0: try: s_1_1 = varpar_v[(([ i for i, s in enumerate(varpar_l) if s == 's_1_1' ])[0])] except: s_1_1 = fixpar_d['s_1_1'] if s_1_1 < 0: return -np.inf try: l_1_1 = varpar_v[(([ i for i, s in enumerate(varpar_l) if s == 'l_1_1' ])[0])] except: l_1_1 = fixpar_d['l_1_1'] try: b_1_1 = varpar_v[(([ i for i, s in enumerate(varpar_l) if s == 'b_1_1' ])[0])] except: b_1_1 = fixpar_d['b_1_1'] try: f_1_1 = varpar_v[(([ i for i, s in enumerate(varpar_l) if s == 'f_1_1' ])[0])] except: f_1_1 = fixpar_d['f_1_1'] if f_1_1 < 0: return -np.inf spots_1 = [[l_1_1], [b_1_1], [s_1_1], [f_1_1]] if n_spot_1 > 1: try: s_2_1 = varpar_v[(([ i for i, s in enumerate(varpar_l) if s == 's_2_1' ])[0])] except: s_2_1 = fixpar_d['s_2_1'] if s_2_1 < 0: return -np.inf try: l_2_1 = varpar_v[(([ i for i, s in enumerate(varpar_l) if s == 'l_2_1' ])[0])] except: l_2_1 = fixpar_d['l_2_1'] try: b_2_1 = varpar_v[(([ i for i, s in enumerate(varpar_l) if s == 'b_2_1' ])[0])] except: b_2_1 = fixpar_d['b_2_1'] try: f_2_1 = varpar_v[(([ i for i, s in enumerate(varpar_l) if s == 'f_2_1' ])[0])] except: f_2_1 = fixpar_d['f_2_1'] if f_2_1 < 0: return -np.inf spots_1 = [[l_1_1, l_2_1], [b_1_1, b_2_1], [s_1_1, s_2_1], [f_1_1, f_2_1]] spots_2 = None if n_spot_2 > 0: try: s_1_2 = varpar_v[(([ i for i, s in enumerate(varpar_l) if s == 's_1_2' ])[0])] except: s_1_2 = fixpar_d['s_1_2'] if s_1_2 < 0: return -np.inf try: l_1_2 = varpar_v[(([ i for i, s in enumerate(varpar_l) if s == 'l_1_2' ])[0])] except: l_1_2 = fixpar_d['l_1_2'] try: b_1_2 = varpar_v[(([ i for i, s in enumerate(varpar_l) if s == 'b_1_2' ])[0])] except: b_1_2 = fixpar_d['b_1_2'] try: f_1_2 = varpar_v[(([ i for i, s in enumerate(varpar_l) if s == 'f_1_2' ])[0])] except: f_1_2 = fixpar_d['f_1_2'] if f_1_2 < 0: return -np.inf spots_2 = [[l_1_2], [b_1_2], [s_1_2], [f_1_2]] if n_spot_2 > 1: try: s_2_2 = varpar_v[(([ i for i, s in enumerate(varpar_l) if s == 's_2_2' ])[0])] except: s_2_2 = fixpar_d['s_2_2'] if s_2_2 < 0: return -np.inf try: l_2_2 = varpar_v[(([ i for i, s in enumerate(varpar_l) if s == 'l_2_2' ])[0])] except: l_2_2 = fixpar_d['l_2_2'] try: b_2_2 = varpar_v[(([ i for i, s in enumerate(varpar_l) if s == 'b_2_2' ])[0])] except: b_2_2 = fixpar_d['b_2_2'] try: f_2_2 = varpar_v[(([ i for i, s in enumerate(varpar_l) if s == 'f_2_2' ])[0])] except: f_2_2 = fixpar_d['f_2_2'] if f_2_2 < 0: return -np.inf spots_2 = [[l_1_2, l_2_2], [b_1_2, b_2_2], [s_1_2, s_2_2], [f_1_2, f_2_2]] a1, a2, a3, a4, y1 = ldy_(t1, g1, m) if np.isnan(y1): return -np.inf ldc_1 = [a1, a2, a3, a4] a1, a2, a3, a4, y2 = ldy_(t2, g2, m) if np.isnan(y2): return -np.inf ldc_2 = [a1, a2, a3, a4] heat_1 = A_1 heat_2 = A_2 q = fixpar_d['q'] t_exp = fixpar_d['t_exp'] if (t_exp <= 0) or (np.max(lcdata['flag']) < 2): t_exp = None if return_fit: n_int = np.array(lcdata['flag']) n_int[n_int < 0] = 1 t = lcdata['time'] f = lc(t, radius_1=r_1, radius_2=r_2, sbratio=sb2, incl=incl, light_3=l_3, t_zero=t0, period=period, q=q, f_c=f_c, f_s=f_s, domdt=domdt, rotfac_1=frot1, rotfac_2=frot2, heat_1=heat_1, heat_2=heat_2, n_int=n_int, ld_1='claret', ldc_1=ldc_1, ld_2='claret', ldc_2=ldc_2, gdc_1=y1, gdc_2=y2, t_exp=t_exp, grid_1=grid_size, grid_2=grid_size, shape_1='roche', shape_2='roche', spots_1=spots_1, spots_2=spots_2) m = tilt * (t - np.min(t)) - 2.5 * np.log10(f) m_mod = m[lcdata['flag'] >= 0] m_fit = (lcdata[lcdata['flag'] >= 0])['mag'] e_fit = (lcdata[lcdata['flag'] >= 0])['e_mag'] wt = 1.0 / e_fit**2 zp = np.average((m_fit - m_mod), weights=wt) return m + zp # Check for input value outside range set by priors for p in priors: if p['p_type'] == 'U': if p['p_var'] in varpar_l: v = varpar_v[(([ i for i, s in enumerate(varpar_l) if s == p['p_var'] ])[0])] elif p['p_var'] == 'e': v = f_c**2 + f_s**2 elif p['p_var'] == 'om': v = np.arctan2(f_s, f_c) elif p['p_var'] == 'rsum': v = r_1 + r_2 elif p['p_var'] == 'lrat': v = sb2 * (r_2 / r_1)**2 elif p['p_var'] == 'k': v = r_2 / r_1 else: raise Exception('No such prior variable') if (v < p['p_par1']) or (v > p['p_par2']): return -np.inf t_fit = (lcdata[lcdata['flag'] >= 0])['time'] n_int = (lcdata[lcdata['flag'] >= 0])['flag'] f = lc(t_fit, radius_1=r_1, radius_2=r_2, sbratio=sb2, incl=incl, light_3=l_3, t_zero=t0, period=period, q=q, f_c=f_c, f_s=f_s, domdt=domdt, rotfac_1=frot1, rotfac_2=frot2, heat_1=heat_1, heat_2=heat_2, n_int=n_int, ld_1='claret', ldc_1=ldc_1, ld_2='claret', ldc_2=ldc_2, gdc_1=y1, gdc_2=y2, t_exp=t_exp, grid_1=grid_size, grid_2=grid_size, shape_1='roche', shape_2='roche', spots_1=spots_1, spots_2=spots_2) if (True in np.isnan(f)) or np.min(f) <= 0: return -np.inf mod_fit = tilt * (t_fit - np.min(t_fit)) - 2.5 * np.log10(f) mag_fit = (lcdata[lcdata['flag'] >= 0])['mag'] err_fit = (lcdata[lcdata['flag'] >= 0])['e_mag'] wt = 1.0 / err_fit**2 zp = np.average((mag_fit - mod_fit), weights=wt) mod_fit = mod_fit + zp lnlike = -0.5 * np.sum(wt * (mod_fit - mag_fit)**2) for p in priors: if p['p_type'] == 'G': if p['p_var'] in varpar_l: v = varpar_v[(([ i for i, s in enumerate(varpar_l) if s == p['p_var'] ])[0])] elif p['p_var'] == 'e': v = f_c**2 + f_s**2 elif p['p_var'] == 'om': v = np.arctan2(f_s, f_c) elif p['p_var'] == 'rsum': v = r_1 + r_2 elif p['p_var'] == 'lrat': v = sb2 * (r_2 / r_1)**2 elif p['p_var'] == 'k': v = r_2 / r_1 else: raise Exception('No such prior variable') lnlike = lnlike - 0.5 * ((v - p['p_par1']) / (p['p_par2']))**2 return lnlike