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_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_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_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_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_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_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_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_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_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_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)
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_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)