def test_secondary_eclipse(): u1 = np.array([0.3, 0.2]) lc1 = LimbDarkLightCurve(u1) u2 = np.array([0.4, 0.1]) lc2 = LimbDarkLightCurve(u1) s = 0.3 ror = 0.08 f = ror**2 * s lc = SecondaryEclipseLightCurve(u1, u2, s) t = np.linspace(-6.435, 10.4934, 5000) orbit1 = KeplerianOrbit(period=1.543, t0=-0.123) orbit2 = KeplerianOrbit( period=orbit1.period, t0=orbit1.t0 + 0.5 * orbit1.period, r_star=ror, m_star=1.0, ) y1 = lc1.get_light_curve(orbit=orbit1, r=ror, t=t).eval() y2 = lc2.get_light_curve(orbit=orbit2, r=1.0, t=t).eval() y = lc.get_light_curve(orbit=orbit1, r=ror, t=t).eval() y_expect = (y1 + f * y2) / (1 + f) assert np.allclose(y_expect, y, atol=5e-6)
def test_contact_bug(): orbit = KeplerianOrbit(period=3.456, ecc=0.6, omega=-1.5) t = np.linspace(-0.1, 0.1, 1000) u = [0.3, 0.2] y1 = (LimbDarkLightCurve(u[0], u[1]).get_light_curve(orbit=orbit, r=0.1, t=t, texp=0.02).eval()) y2 = (LimbDarkLightCurve(u[0], u[1]).get_light_curve( orbit=orbit, r=0.1, t=t, texp=0.02, use_in_transit=False).eval()) assert np.allclose(y1, y2)
def test_in_transit(): t = np.linspace(-20, 20, 1000) m_planet = np.array([0.3, 0.5]) m_star = 1.45 orbit = KeplerianOrbit( m_star=m_star, r_star=1.5, t0=np.array([0.5, 17.4]), period=np.array([10.0, 5.3]), ecc=np.array([0.1, 0.8]), omega=np.array([0.5, 1.3]), m_planet=m_planet, ) u = np.array([0.2, 0.3, 0.1, 0.5]) r = np.array([0.1, 0.01]) lc = LimbDarkLightCurve(u) model1 = lc.get_light_curve(r=r, orbit=orbit, t=t) model2 = lc.get_light_curve(r=r, orbit=orbit, t=t, use_in_transit=False) vals = theano.function([], [model1, model2])() utt.assert_allclose(*vals) model1 = lc.get_light_curve(r=r, orbit=orbit, t=t, texp=0.1) model2 = lc.get_light_curve(r=r, orbit=orbit, t=t, texp=0.1, use_in_transit=False) vals = theano.function([], [model1, model2])() utt.assert_allclose(*vals)
def test_singular_points(): u = tt.vector() b = tt.vector() r = tt.vector() lc = LimbDarkLightCurve(u) f = lc._compute_light_curve(b, r) func = theano.function([u, b, r], f) u_val = np.array([0.2, 0.3, 0.1, 0.5]) def compare(b_val, r_val, b_eps, r_eps): """ Compare the flux at a singular point to the flux at neighboring points. """ b_val = [b_val - b_eps, b_val + b_eps, b_val] r_val = [r_val - r_eps, r_val + r_eps, r_val] flux = func(u_val, b_val, r_val) assert np.allclose(np.mean(flux[:2]), flux[2]) # Test the b = 1 - r singular point compare(0.1, 0.9, 1e-8, 0.0) # Test the b = r = 0.5 singular point compare(0.5, 0.5, 1e-8, 0.0) # Test the b = 0 singular point compare(0.0, 0.1, 1e-8, 0.0) # Test the b = 0, r = 1 singular point compare(0.0, 1.0, 0.0, 1e-8) # Test the b = 1 + r singular point compare(1.1, 0.1, 1e-8, 0.0)
def test_simple_light_curve_compare_kepler(): t = np.linspace(0.0, 1, 1000) # We use a long period, because at short periods there is a big difference # between a circular orbit and an object moving on a straight line. period = 1000 t0 = 0.5 r = 0.01 r_star = 1 b = 1 - r / r_star * 3 star = LimbDarkLightCurve(0.2, 0.3) orbit_keplerian = KeplerianOrbit(period=period, t0=t0, b=b, r_star=r_star, m_star=1) duration = (period / np.pi) * np.arcsin( ((r_star + r)**2 - (b * r_star)**2)**0.5 / orbit_keplerian.a).eval() lc_keplerian = star.get_light_curve(orbit=orbit_keplerian, r=r, t=t) orbit_simple1 = SimpleTransitOrbit( period=period, t0=t0, b=b, duration=duration, r_star=r_star, ror=r / r_star, ) lc_simple1 = star.get_light_curve(orbit=orbit_simple1, r=r, t=t) # Should look similar to Keplerian orbit assert np.allclose(lc_keplerian.eval(), lc_simple1.eval(), rtol=0.001)
def test_vector_params(): u = tt.vector() u.tag.test_value = u_val = np.array([0.3, 0.2]) b = np.linspace(-1.5, 1.5, 20) r = 0.1 + np.zeros_like(b) with pytest.warns(DeprecationWarning, match=r"vector of limb darkening"): lc1 = theano.function([u], LimbDarkLightCurve(u)._compute_light_curve( b, r))(u_val) lc2 = theano.function([u], LimbDarkLightCurve(u[0], u[1])._compute_light_curve( b, r))(u_val) np.testing.assert_allclose(lc1, lc2) with pytest.raises(AssertionError): theano.function([], LimbDarkLightCurve([0.3])._compute_light_curve(b, r))()
def test_light_curve_grad(caplog): u_val = np.array([0.2, 0.3, 0.1, 0.5]) b_val = np.linspace(-1.5, 1.5, 20) r_val = 0.1 + np.zeros_like(b_val) lc = lambda u, b, r: LimbDarkLightCurve(u)._compute_light_curve( # NOQA b, r) with caplog.at_level(logging.DEBUG, logger="theano.gof.cmodule"): utt.verify_grad(lc, [u_val, b_val, r_val])
def test_light_curve_grad(caplog): u_val = np.array([0.2, 0.3]) b_val = np.linspace(-1.5, 1.5, 20) r_val = 0.1 + np.zeros_like(b_val) lc = lambda u, b, r: LimbDarkLightCurve( # NOQA u[0], u[1])._compute_light_curve(b, r) with theano.configparser.change_flags(compute_test_value="off"): with caplog.at_level(logging.DEBUG, logger="theano.gof.cmodule"): theano.gradient.verify_grad(lc, [u_val, b_val, r_val], rng=np.random)
def test_approx_transit_depth(): u = np.array([0.3, 0.2]) lc = LimbDarkLightCurve(u) for b, delta in [ (np.float64(0.5), np.float64(0.01)), (np.array([0.1, 0.9]), np.array([0.1, 0.5])), (np.array([0.1, 0.9, 0.3]), np.array([0.1, 0.5, 0.0234])), ]: dv = tt.as_tensor_variable(delta) ror, jac = lc.get_ror_from_approx_transit_depth(dv, b, jac=True) _check_quad(u, b, delta, ror.eval()) assert np.allclose(theano.grad(tt.sum(ror), dv).eval(), jac.eval())
def test_small_star(): pytest.importorskip("batman.transitmodel") from batman.transitmodel import TransitModel, TransitParams u_star = [0.2, 0.1] r = 0.04221468 m_star = 0.151 r_star = 0.189 period = 0.4626413 t0 = 0.2 b = 0.5 ecc = 0.1 omega = 0.1 t = np.linspace(0, period, 500) r_pl = r * r_star orbit = KeplerianOrbit( r_star=r_star, m_star=m_star, period=period, t0=t0, b=b, ecc=ecc, omega=omega, ) a = orbit.a.eval() incl = orbit.incl.eval() lc = LimbDarkLightCurve(u_star[0], u_star[1]) model1 = lc.get_light_curve(r=r_pl, orbit=orbit, t=t) model2 = lc.get_light_curve(r=r_pl, orbit=orbit, t=t, use_in_transit=False) vals = theano.function([], [model1, model2])() assert np.allclose(*vals) params = TransitParams() params.t0 = t0 params.per = period params.rp = r params.a = a / r_star params.inc = np.degrees(incl) params.ecc = ecc params.w = np.degrees(omega) params.u = u_star params.limb_dark = "quadratic" model = TransitModel(params, t) flux = model.light_curve(params) assert np.allclose(vals[0][:, 0], flux - 1)
def test_basic(): with pm.Model() as model: txt, bib = get_citations_for_model() assert txt == "" assert bib == "" with pm.Model() as model: LimbDarkLightCurve([0.5, 0.2]) txt, bib = get_citations_for_model() for k in ["exoplanet", "theano", "pymc3", "starry"]: assert all(v in bib for v in CITATIONS[k][0]) assert CITATIONS[k][1] in bib txt1, bib1 = get_citations_for_model(model=model) assert txt == txt1 assert bib == bib1
def test_light_curve(): u_val = np.array([0.2, 0.3]) b_val = np.linspace(-1.5, 1.5, 100) r_val = 0.1 + np.zeros_like(b_val) lc = LimbDarkLightCurve(u_val[0], u_val[1]) evaluated = lc._compute_light_curve(b_val, r_val).eval() if version.parse(starry.__version__) < version.parse("0.9.9"): m = starry.Map(lmax=len(u_val)) m[:] = u_val expect = m.flux(xo=b_val, ro=r_val) - 1 else: m = starry.Map(udeg=len(u_val)) m[1:] = u_val expect = m.flux(xo=b_val, ro=r_val[0]).eval() - 1 assert np.allclose(expect, evaluated)
def test_variable_texp(): t = np.linspace(-20, 20, 1000) m_planet = np.array([0.3, 0.5]) m_star = 1.45 orbit = KeplerianOrbit( m_star=m_star, r_star=1.5, t0=np.array([0.5, 17.4]), period=np.array([10.0, 5.3]), ecc=np.array([0.1, 0.8]), omega=np.array([0.5, 1.3]), m_planet=m_planet, ) u = np.array([0.2, 0.3]) r = np.array([0.1, 0.01]) texp0 = 0.1 lc = LimbDarkLightCurve(u[0], u[1]) model1 = lc.get_light_curve(r=r, orbit=orbit, t=t, texp=texp0, use_in_transit=False) model2 = lc.get_light_curve( r=r, orbit=orbit, t=t, use_in_transit=False, texp=texp0 + np.zeros_like(t), ) vals = theano.function([], [model1, model2])() assert np.allclose(*vals) model1 = lc.get_light_curve(r=r, orbit=orbit, t=t, texp=texp0) model2 = lc.get_light_curve( r=r, orbit=orbit, t=t, texp=texp0 + np.zeros_like(t), use_in_transit=False, ) vals = theano.function([], [model1, model2])() assert np.allclose(*vals)
def test_keplerian_light_curve(): t = np.linspace(50, 1000, 1045) r = np.array([0.04, 0.02]) args = dict( period=[50.0, 87.5], t0=[1.55, 10.6], ecc=[0.28, 0.01], omega=[-4.56, 1.5], m_planet=[0.0, 0.0], b=[0.51, 0.21], m_star=1.51, r_star=1.0, ) orbit0 = KeplerianOrbit(**args) orbit = ReboundOrbit(**args) ld = LimbDarkLightCurve([0.2, 0.3]) lc0 = ld.get_light_curve(orbit=orbit0, r=r, t=t).eval() lc = ld.get_light_curve(orbit=orbit, r=r, t=t).eval() assert np.allclose(lc0, lc)
def test_light_curve(): u = tt.vector() b = tt.vector() r = tt.vector() lc = LimbDarkLightCurve(u) f = lc._compute_light_curve(b, r) func = theano.function([u, b, r], f) u_val = np.array([0.2, 0.3, 0.1, 0.5]) b_val = np.linspace(-1.5, 1.5, 100) r_val = 0.1 + np.zeros_like(b_val) if version.parse(starry.__version__) < version.parse("0.9.9"): m = starry.Map(lmax=len(u_val)) m[:] = u_val expect = m.flux(xo=b_val, ro=r_val) - 1 else: m = starry.Map(udeg=len(u_val)) m[1:] = u_val expect = m.flux(xo=b_val, ro=r_val[0]).eval() - 1 evaluated = func(u_val, b_val, r_val) utt.assert_allclose(expect, evaluated)