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