PyTransit 2.7.0__tar.gz → 2.8.0__tar.gz

{pytransit-2.7.0 → pytransit-2.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyTransit
-Version: 2.7.0
+Version: 2.8.0
 Summary: Fast and painless exoplanet transit light curve modelling.
 Author-email: Hannu Parviainen <hpparvi@gmail.com>
 License: GPLv2
@@ -35,7 +35,7 @@ Requires-Dist: emcee
 Requires-Dist: pyopencl
 Requires-Dist: corner
 Requires-Dist: celerite
-Requires-Dist: meepmeep>=0.8.0
+Requires-Dist: meepmeep>=1.0.0
 Dynamic: license-file
 
 PyTransit

{pytransit-2.7.0 → pytransit-2.8.0}/PyTransit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyTransit
-Version: 2.7.0
+Version: 2.8.0
 Summary: Fast and painless exoplanet transit light curve modelling.
 Author-email: Hannu Parviainen <hpparvi@gmail.com>
 License: GPLv2
@@ -35,7 +35,7 @@ Requires-Dist: emcee
 Requires-Dist: pyopencl
 Requires-Dist: corner
 Requires-Dist: celerite
-Requires-Dist: meepmeep>=0.8.0
+Requires-Dist: meepmeep>=1.0.0
 Dynamic: license-file
 
 PyTransit

{pytransit-2.7.0 → pytransit-2.8.0}/PyTransit.egg-info/SOURCES.txt

@@ -85,7 +85,6 @@ pytransit/models/numba/ma_quadratic_nb.py
 pytransit/models/numba/ma_uniform_nb.py
 pytransit/models/numba/phasecurves.py
 pytransit/models/numba/qpower2_nb.py
-pytransit/models/numba/rrmodel.py
 pytransit/models/numba/spmodel.py
 pytransit/models/numba/udmodel.py
 pytransit/models/opencl/ma_quadratic.cl
@@ -96,7 +95,7 @@ pytransit/models/roadrunner/__init__.py
 pytransit/models/roadrunner/common.py
 pytransit/models/roadrunner/ecintersection.py
 pytransit/models/roadrunner/esmodel.py
-pytransit/models/roadrunner/model.py
+pytransit/models/roadrunner/model_eclipse.py
 pytransit/models/roadrunner/model_ecspec.py
 pytransit/models/roadrunner/model_full.py
 pytransit/models/roadrunner/model_simple.py
@@ -143,6 +142,7 @@ tests/test_limb_darkening.py
 tests/test_ma_quadratic.py
 tests/test_ma_quadratic_nb.py
 tests/test_qpower2_nb.py
+tests/test_roadrunner_eclipse.py
 tests/test_transitmodel_helpers.py
 tests/test_uniform_model.py
 tests/test_uniform_model_nb.py

{pytransit-2.7.0 → pytransit-2.8.0}/PyTransit.egg-info/requires.txt

@@ -17,4 +17,4 @@ emcee
 pyopencl
 corner
 celerite
-meepmeep>=0.8.0
+meepmeep>=1.0.0

{pytransit-2.7.0 → pytransit-2.8.0}/pyproject.toml

@@ -35,3 +35,8 @@ include-package-data = true
 [tool.setuptools.packages.find]
 include = ["pytransit"]
 namespaces = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+addopts = "-ra"

{pytransit-2.7.0 → pytransit-2.8.0}/pytransit/__init__.py

@@ -41,7 +41,7 @@ Date
 
 """
 
-__version__ = '2.7.0'
+__version__ = '2.8.0'
 
 # Generic
 # -------

{pytransit-2.7.0 → pytransit-2.8.0}/pytransit/lpf/rvlpf.py

@@ -32,8 +32,8 @@ from astropy.table import Column
 from corner import corner
 from matplotlib.pyplot import subplots, setp
 from numba import njit
-from numpy import zeros, log, pi, inf, atleast_2d, arange, arctan2, cos, squeeze, median, linspace, \
-    percentile, argsort, sum, concatenate, full, sqrt, ndarray
+from numpy import zeros, log, pi, inf, atleast_2d, arange, arctan2, cos, squeeze, median, linspace, percentile, argsort, \
+    sum, concatenate, full, sqrt, ndarray, floor
 from numpy.random.mtrand import permutation
 
 from pytransit.lpf.logposteriorfunction import LogPosteriorFunction
@@ -57,7 +57,7 @@ def lnlike_normal(o, m, e):
 
 
 class RVLPF(LogPosteriorFunction):
-    def __init__(self, name: str, nplanets: int, times, rvs, rves, rvis=None, slope_order: int = 1):
+    def __init__(self, name: str, nplanets: int, times, rvs, rves, rvis, is_transiting, slope_order: int = 1):
         super().__init__(name)
 
         def transform_input(a):
@@ -76,8 +76,8 @@ class RVLPF(LogPosteriorFunction):
         else:
             rvis = zeros(len(times), 'int')
 
-        self._tref = concatenate(times).mean()
-        self.rvm: RVModel = RVModel(self, nplanets, times, rvs, rves, rvis, slope_order=slope_order)
+        self._tref = floor(concatenate(times).min())
+        self.rvm: RVModel = RVModel(self, nplanets, times, rvs, rves, rvis, is_transiting=is_transiting, slope_order=slope_order)
 
     def model(self, pv):
         return self.rvm.rv_model(pv)
@@ -102,7 +102,7 @@ class RVModel:
     """
 
     def __init__(self, lpf: LogPosteriorFunction, nplanets: int,
-                 times, rvs: Iterable, rves: Iterable, rvis: Iterable,
+                 times, rvs: Iterable, rves: Iterable, rvis: Iterable, is_transiting,
                  tref: Optional[float] = None, slope_order: int = 1):
         self.lpf = lpf
 
@@ -110,6 +110,10 @@ class RVModel:
             assert lpf.nplanets == nplanets
         self.nplanets = nplanets
 
+        if len(is_transiting) != self.nplanets:
+            raise ValueError("The size of the is_transiting list must equal the number of planets.")
+        self.is_transiting = is_transiting
+
         if hasattr(lpf, '_tref'):
             assert tref is None
             self._tref = lpf._tref
@@ -152,12 +156,15 @@ class RVModel:
         self.ps = ps = ParameterSet([])
         pp = []
         for i in range(1, self.nplanets + 1):
-            pp.extend([
-                GParameter(f'tc_{i}', f'zero epoch {i}', 'd', NP(0.0, 0.1), (-inf, inf)),
-                GParameter(f'p_{i}', f'period {i}', 'd', NP(1.0, 1e-5), (0, inf)),
-                GParameter(f'secw_{i}', f'sqrt(e) cos(w) {i}', '', UP(-1.0, 1.0), (-1, 1)),
-                GParameter(f'sesw_{i}', f'sqrt(e) sin(w) {i}', '', UP(-1.0, 1.0), (-1, 1)),
-            ])
+            if self.is_transiting[i-1]:
+                pp.append(GParameter(f't0_{i}', f'zero epoch {i}', 'd', NP(0.0, 0.1), (-inf, inf)))
+            else:
+                pp.append(GParameter(f'm0_{i}', f'reference mean anomaly {i}', 'd', UP(0.0, 2*pi), (0, 2*pi)))
+
+            pp.extend([GParameter(f'p_{i}', f'period {i}', 'd', NP(1.0, 1e-5), (0, inf)),
+                       GParameter(f'secw_{i}', f'sqrt(e) cos(w) {i}', '', UP(-1.0, 1.0), (-1, 1)),
+                       GParameter(f'sesw_{i}', f'sqrt(e) sin(w) {i}', '', UP(-1.0, 1.0), (-1, 1)),
+                       ])
         ps.add_global_block('planets', pp)
         self._start_pl = ps.blocks[-1].start
         self._sl_pl = ps.blocks[-1].slice
@@ -190,9 +197,11 @@ class RVModel:
         self._sl_rv_slope = ps.blocks[-1].slice
         self.ps.freeze()
 
-        pnames = "rv_k_{} tc_{} p_{} secw_{} sesw_{}".split()
+        pnames_tr = "rv_k_{} t0_{} p_{} secw_{} sesw_{}".split()
+        pnames_nt = "rv_k_{} m0_{} p_{} secw_{} sesw_{}".split()
         self.pids = zeros((self.nplanets, 5), 'int')
         for ipl in range(self.nplanets):
+            pnames = pnames_tr if self.is_transiting[ipl] else pnames_nt
             for ip, p in enumerate(pnames):
                 name = p.format(ipl + 1)
                 self.pids[ipl, ip] = self.ps.names.index(name)
@@ -216,7 +225,10 @@ class RVModel:
         planets = planets if planets is not None else arange(self.nplanets)
         for ipl in planets:
             pv = pvp[:, self.pids[ipl]]
-            tc = pv[:, 1] - self._tref
+            if self.is_transiting[ipl]:
+                tc = pv[:, 1] - self._tref
+            else:
+                tc = pv[:, 1] / (2*pi) * pv[:, 2]
             p = pv[:, 2]
             e = pv[:, 3] ** 2 + pv[:, 4] ** 2
             w = arctan2(pv[:, 4], pv[:, 3])
@@ -345,7 +357,10 @@ class RVModel:
             rv_others = median(self.rv_model(pvp, planets=other_planets, add_sv=False, add_slope=False), 0)
 
         period = pv[self.ps.names.index(f'p_{planet + 1}')]
-        tc = pv[self.ps.names.index(f'tc_{planet + 1}')] - self._tref
+        if self.is_transiting[planet]:
+            tc = pv[self.ps.names.index(f't0_{planet + 1}')] - self._tref
+        else:
+            tc = pv[self.ps.names.index(f'm0_{planet + 1}')] / (2*pi) * period
 
         phase = (fold(self._timea, period, tc, 0.5) - 0.5) * period
         phase_model = (fold(rv_time, period, tc, 0.5) - 0.5) * period

{pytransit-2.7.0 → pytransit-2.8.0}/pytransit/models/eclipse_model.py

@@ -18,7 +18,7 @@ from typing import Union, Optional
 
 from numba import njit
 from numpy import ndarray, squeeze, zeros, asarray, ones
-from .numba.ma_uniform_nb import uniform_model_v, uniform_model_s, uniform_model_pv
+from .numba.ma_uniform_nb import uniform_model_v, uniform_model_s
 from .transitmodel import TransitModel
 
 __all__ = ['EclipseModel']
@@ -140,29 +140,3 @@ class EclipseModel(TransitModel):
         if fr is not None:
             flux = 1.0 + (flux - 1.0) * fr
         return squeeze(flux)
-
-    def evaluate_pv(self, pvp: ndarray, fr = None) -> ndarray:
-        """Evaluate the transit model for a 2D parameter array.
-
-         Parameters
-         ----------
-         pvp
-             Parameter array with a shape `(npv, npar)` where `npv` is the number of parameter vectors, and each row
-             contains a set of parameters `[k, t0, p, a, i, e, w]`. The radius ratios can also be given per passband,
-             in which case the row should be structured as `[k_0, k_1, k_2, ..., k_npb, t0, p, a, i, e, w]`.
-
-         Notes
-         -----
-         This version of the `evaluate` method is optimized for calculating several models in parallel, such as when
-         using *emcee* for MCMC sampling.
-
-         Returns
-         -------
-         ndarray
-             Modelled flux either as a 1D or 2D ndarray.
-         """
-        assert self.time is not None, "Need to set the data before calling the transit model."
-        flux = uniform_model_pv(self.time, pvp, self.lcids, self.pbids, self.nsamples, self.exptimes, zsign=-1.0)
-        if fr is not None:
-            flux = 1.0 + (flux - 1.0) * fr
-        return squeeze(flux)

{pytransit-2.7.0 → pytransit-2.8.0}/pytransit/models/gdmodel.py

@@ -30,8 +30,9 @@ from .numba.gdmodel import create_star_xy, create_planet_xy, map_osm, xy_taylor_
     luminosity_v2, planck, create_star_luminosity
 from ..contamination.filter import Filter, DeltaFilter
 from ..stars import read_bt_settl_table, read_husser2013_table
+from meepmeep.backends.numba.point2d import solve2d, find_contact_point
+
 from ..orbits import as_from_rhop, i_from_baew
-from ..orbits.taylor_z import vajs_from_paiew, find_contact_point
 from ..utils.octasphere import octasphere
 
 
@@ -214,15 +215,15 @@ class GravityDarkenedModel(TransitModel):
 
         # Plot the orbit
         # --------------
-        y0, vx, vy, ax_, ay, jx, jy, sx, sy = vajs_from_paiew(p, a, inc, e, w)
-        c1 = find_contact_point(k, 1, y0, vx, vy, ax_, ay, jx, jy, sx, sy)
-        c4 = find_contact_point(k, 4, y0, vx, vy, ax_, ay, jx, jy, sx, sy)
+        cf = solve2d(0.0, p, a, inc, e, w)
+        c1 = find_contact_point(k, 1, cf)
+        c4 = find_contact_point(k, 4, cf)
         time = linspace(2 * c1, 2 * c4, 100)
 
-        ox, oy = xy_taylor_vt(time, alpha, y0, vx, vy, ax_, ay, jx, jy, sx, sy)
+        ox, oy = xy_taylor_vt(time, alpha, cf)
         ax.plot(ox, oy, 'k')
 
-        pxy = xy_taylor_vt(array([0.0]), alpha, y0, vx, vy, ax_, ay, jx, jy, sx, sy)
+        pxy = xy_taylor_vt(array([0.0]), alpha, cf)
         ax.add_artist(Circle(pxy, k, zorder=10, fc='k'))
 
         # Plot the info
@@ -314,7 +315,7 @@ class GravityDarkenedModel(TransitModel):
         st, sx, sy = create_star_xy(res)
         fstar = create_star_luminosity(res, sx, sy, mstar, self.rstar, ostar, tpole, gpole, f,
                                        sphi, cphi, beta, ldc, self._flux_table, self._teff0, self._dteff, self.accurate_mu)
-        px, py = xy_taylor_vt(self.time - t0, l, *vajs_from_paiew(p, a, i, e, w))
+        px, py = xy_taylor_vt(self.time - t0, l, solve2d(0.0, p, a, i, e, w))
 
         if plot:
             fig, ax = subplots()

{pytransit-2.7.0 → pytransit-2.8.0}/pytransit/models/ma_chromosphere.py

@@ -17,7 +17,7 @@ from typing import Union
 
 from numpy import ndarray, array, squeeze, asarray, zeros, isscalar
 
-from .numba.ma_chromosphere_nb import chromosphere_model_pv, chromosphere_model_v, chromosphere_model_s
+from .numba.ma_chromosphere_nb import chromosphere_model_v, chromosphere_model_s
 from .transitmodel import TransitModel
 
 __all__ = ['ChromosphereModel']
@@ -120,27 +120,3 @@ class ChromosphereModel(TransitModel):
                                self._es, self._ms, self._tae)
         return squeeze(flux)
 
-    def evaluate_pv(self, pvp: ndarray) -> ndarray:
-        """Evaluate the transit model for a 2D parameter array.
-
-         Parameters
-         ----------
-         pvp
-             Parameter array with a shape `(npv, npar)` where `npv` is the number of parameter vectors, and each row
-             contains a set of parameters `[k, t0, p, a, i, e, w]`. The radius ratios can also be given per passband,
-             in which case the row should be structured as `[k_0, k_1, k_2, ..., k_npb, t0, p, a, i, e, w]`.
-
-         Notes
-         -----
-         This version of the `evaluate` method is optimized for calculating several models in parallel, such as when
-         using *emcee* for MCMC sampling.
-
-         Returns
-         -------
-         ndarray
-             Modelled flux either as a 1D or 2D ndarray.
-         """
-        assert self.time is not None, "Need to set the data before calling the transit model."
-        flux = chromosphere_model_pv(self.time, pvp, self.lcids, self.pbids, self.nsamples, self.exptimes, self._es,
-                                self._ms, self._tae)
-        return squeeze(flux)

{pytransit-2.7.0 → pytransit-2.8.0}/pytransit/models/ma_quadratic.py

@@ -30,7 +30,7 @@ from typing import Union, Optional, List
 
 from numpy import ndarray, array, squeeze, atleast_2d, atleast_1d, zeros, asarray, inf, isscalar
 
-from .numba.ma_quadratic_nb import quadratic_model_pv, calculate_interpolation_tables, quadratic_model_v, quadratic_model_s
+from .numba.ma_quadratic_nb import calculate_interpolation_tables, quadratic_model_v, quadratic_model_s
 from .transitmodel import TransitModel
 
 __all__ = ['QuadraticModel']
@@ -191,39 +191,6 @@ class QuadraticModel(TransitModel):
                                  self.ed, self.ld, self.le, self.kt, self.zt, self.interpolate)
         return squeeze(flux)
 
-    def evaluate_pv(self, pvp: ndarray, ldc: ndarray, copy: bool = True) -> ndarray:
-        """Evaluate the transit model for a 2D parameter array.
-
-        Parameters
-        ----------
-        pvp: ndarray
-            Parameter array with a shape `(npv, npar)` where `npv` is the number of parameter vectors, and each row
-            contains a set of parameters `[k, t0, p, a, i, e, w]`. The radius ratios can also be given per passband,
-            in which case the row should be structured as `[k_0, k_1, k_2, ..., k_npb, t0, p, a, b, e, w]`.
-        ldc: ndarray
-            Limb darkening coefficient array with shape `(npv, 2*npb)`, where `npv` is the number of parameter vectors
-            and `npb` is the number of passbands.
-
-        Notes
-        -----
-        This version of the `evaluate` method is optimized for calculating several models in parallel, such as when
-        using *emcee* for MCMC sampling.
-
-        Returns
-        -------
-        ndarray
-            Modelled flux either as a 1D or 2D ndarray.
-        """
-
-        ldc = asarray(ldc)
-        pvp = asarray(pvp)
-
-        if self.time is None:
-            raise ValueError("Need to set the data before calling the transit model.")
-
-        flux = quadratic_model_pv(self.time, pvp, ldc, self.lcids, self.pbids, self.nsamples, self.exptimes,
-                                  self.npb, self.ed, self.ld, self.le, self.kt, self.zt, self.interpolate)
-        return squeeze(flux)
 
     def to_opencl(self):
         """Creates an OpenCL clone (`QuadraticModelCL`) of the transit model.

{pytransit-2.7.0 → pytransit-2.8.0}/pytransit/models/ma_uniform.py

@@ -16,7 +16,7 @@
 
 from typing import Union
 from numpy import ndarray, squeeze, zeros, asarray, isscalar
-from .numba.ma_uniform_nb import uniform_model_v, uniform_model_s, uniform_model_pv
+from .numba.ma_uniform_nb import uniform_model_v, uniform_model_s
 from .transitmodel import TransitModel
 
 __all__ = ['UniformModel']
@@ -122,27 +122,3 @@ class UniformModel(TransitModel):
         k = asarray(k)
         flux = uniform_model_s(self.time, k, t0, p, a, i, e, w, self.lcids, self.pbids, self.nsamples, self.exptimes, zsign=self._zsign)
         return squeeze(flux)
-
-    def evaluate_pv(self, pvp: ndarray) -> ndarray:
-        """Evaluate the transit model for a 2D parameter array.
-
-         Parameters
-         ----------
-         pvp
-             Parameter array with a shape `(npv, npar)` where `npv` is the number of parameter vectors, and each row
-             contains a set of parameters `[k, t0, p, a, i, e, w]`. The radius ratios can also be given per passband,
-             in which case the row should be structured as `[k_0, k_1, k_2, ..., k_npb, t0, p, a, i, e, w]`.
-
-         Notes
-         -----
-         This version of the `evaluate` method is optimized for calculating several models in parallel, such as when
-         using *emcee* for MCMC sampling.
-
-         Returns
-         -------
-         ndarray
-             Modelled flux either as a 1D or 2D ndarray.
-         """
-        assert self.time is not None, "Need to set the data before calling the transit model."
-        flux = uniform_model_pv(self.time, pvp, self.lcids, self.pbids, self.nsamples, self.exptimes, zsign=self._zsign)
-        return squeeze(flux)

{pytransit-2.7.0 → pytransit-2.8.0}/pytransit/models/numba/gdmodel.py

@@ -19,8 +19,9 @@ from scipy.constants import G, k, h, c
 from numpy import exp, pi, sqrt, zeros, sin, cos, nan, inf, linspace, meshgrid, floor, isfinite, fmax, isnan, nanmean, \
     arange, zeros_like, atleast_2d, array, cross, sign
 
+from meepmeep.backends.numba.point2d import solve2d, find_contact_point, bounding_box
+
 from ..roadrunner.common import circle_circle_intersection_area
-from ...orbits.taylor_z import vajs_from_paiew, find_contact_point, t14
 
 d2sec = 24.*60.*60.
 
@@ -397,18 +398,18 @@ def mean_luminosity_under_planet(x, y, mstar, rstar, ostar, tpole, gpole, f, sph
 
 
 @njit
-def calculate_luminosity_interpolation_table(res, k, xp, yp, sa, ca, y0, vx, vy, ax, ay, jx, jy, sx, sy,
+def calculate_luminosity_interpolation_table(res, k, xp, yp, sa, ca, c,
                                              mstar, rstar, ostar, tpole, gpole, f, sphi, cphi, beta, ldc,
                                              ftable, t0, dt, accurate_mu):
-    t1 = find_contact_point(k, 1, y0, vx, vy, ax, ay, jx, jy, sx, sy)
-    t4 = find_contact_point(k, 4, y0, vx, vy, ax, ay, jx, jy, sx, sy)
+    t1 = find_contact_point(k, 1, c)
+    t4 = find_contact_point(k, 4, c)
     times = linspace(t1, t4, res)
 
     npb = ftable.shape[0]
     lt = zeros((npb, res))
     for ipb in range(npb):
         for i in range(lt.shape[1]):
-            x, y = xy_taylor_st(times[i], sa, ca, y0, vx, vy, ax, ay, jx, jy, sx, sy)
+            x, y = xy_taylor_st(times[i], sa, ca, c)
             xs = x + k * xp
             ys = y + k * yp
             lt[ipb, i] = mean_luminosity_under_planet(xs, ys, mstar, rstar, ostar, tpole, gpole, f, sphi, cphi, beta, ldc,
@@ -436,12 +437,9 @@ def calculate_luminosity_interpolation_table(res, k, xp, yp, sa, ca, y0, vx, vy,
 
 
 @njit(fastmath=True)
-def xy_taylor_st(t, sa, ca, y0, vx, vy, ax, ay, jx, jy, sx, sy):
-    t2 = t*t
-    t3 = t2*t
-    t4 = t3*t
-    px =      vx*t + 0.5*ax*t2 + jx*t3/6.0 + sx*t4/24.
-    py = y0 + vy*t + 0.5*ay*t2 + jy*t3/6.0 + sy*t4/24.
+def xy_taylor_st(t, sa, ca, c):
+    px = c[0, 0] + t*(c[0, 1] + t*(c[0, 2] + t*(c[0, 3] + t*c[0, 4])))
+    py = c[1, 0] + t*(c[1, 1] + t*(c[1, 2] + t*(c[1, 3] + t*c[1, 4])))
 
     x = ca*px - sa*py
     y = ca*py + sa*px
@@ -450,18 +448,15 @@ def xy_taylor_st(t, sa, ca, y0, vx, vy, ax, ay, jx, jy, sx, sy):
 
 
 @njit(fastmath=True)
-def xy_taylor_vt(ts, a, y0, vx, vy, ax, ay, jx, jy, sx, sy):
+def xy_taylor_vt(ts, a, c):
     npt = ts.size
     x, y = zeros(npt), zeros(npt)
     ca, sa = cos(a), sin(a)
 
     for i in range(npt):
         t = ts[i]
-        t2 = t*t
-        t3 = t2*t
-        t4 = t3*t
-        px =      vx*t + 0.5*ax*t2 + jx*t3/6.0 + sx*t4/24.
-        py = y0 + vy*t + 0.5*ay*t2 + jy*t3/6.0 + sy*t4/24.
+        px = c[0, 0] + t*(c[0, 1] + t*(c[0, 2] + t*(c[0, 3] + t*c[0, 4])))
+        py = c[1, 0] + t*(c[1, 1] + t*(c[1, 2] + t*(c[1, 3] + t*c[1, 4])))
 
         x[i] = ca*px - sa*py
         y[i] = ca*py + sa*px
@@ -470,7 +465,7 @@ def xy_taylor_vt(ts, a, y0, vx, vy, ax, ay, jx, jy, sx, sy):
 
 
 @njit
-def find_contact_point_2d(k: float, point: int, az, feff, y0, vx, vy, ax, ay, jx, jy, sx, sy):
+def find_contact_point_2d(k: float, point: int, az, feff, c):
     if point == 1 or point == 2 or point == 12:
         s = -1.0
     else:
@@ -483,14 +478,16 @@ def find_contact_point_2d(k: float, point: int, az, feff, y0, vx, vy, ax, ay, jx
     else:
         zt = 1.0
 
+    vx = c[0, 1]
+
     t0 = 0.0
     t2 = s * 2.0 / vx
     t1 = 0.5 * t2
 
     sa, ca = sin(az), cos(az)
 
-    x0, y0 = xy_taylor_st(t0, sa, ca, y0, vx, vy, ax, ay, jx, jy, sx, sy)
-    x1, y1 = xy_taylor_st(t1, sa, ca, y0, vx, vy, ax, ay, jx, jy, sx, sy)
+    x0, y0 = xy_taylor_st(t0, sa, ca, c)
+    x1, y1 = xy_taylor_st(t1, sa, ca, c)
     z0 = sqrt(x0 ** 2 + (y0 / (1 - feff)) ** 2) - zt
     z1 = sqrt(x1 ** 2 + (y1 / (1 - feff)) ** 2) - zt
 
@@ -499,12 +496,12 @@ def find_contact_point_2d(k: float, point: int, az, feff, y0, vx, vy, ax, ay, jx
         if z0 * z1 < 0.0:
             t1, t2 = 0.5 * (t0 + t1), t1
             z2 = z1
-            x1, y1 = xy_taylor_st(t1, sa, ca, y0, vx, vy, ax, ay, jx, jy, sx, sy)
+            x1, y1 = xy_taylor_st(t1, sa, ca, c)
             z1 = sqrt(x1 ** 2 + (y1 / (1 - feff)) ** 2) - zt
         else:
             t0, t1 = t1, 0.5 * (t1 + t2)
             z0 = z1
-            x1, y1 = xy_taylor_st(t1, sa, ca, y0, vx, vy, ax, ay, jx, jy, sx, sy)
+            x1, y1 = xy_taylor_st(t1, sa, ca, c)
             z1 = sqrt(x1 ** 2 + (y1 / (1 - feff)) ** 2) - zt
         i += 1
     return t1
@@ -516,16 +513,17 @@ def oblate_model_s(t, k, t0, p, a, aa, i, e, w, ldc,
                    f, feff, sphi, cphi, beta, ftable, teff0, dteff,
                    tres, ts, xs, ys, xp, yp,
                    lcids, pbids, nsamples, exptimes, npb, accurate_mu):
-    y0, vx, vy, ax, ay, jx, jy, sx, sy = vajs_from_paiew(p, a, i, e, w)
+    c = solve2d(0.0, p, a, i, e, w)
     ldc = atleast_2d(ldc)
 
     sa, ca = sin(aa), cos(aa)
-    half_window_width = 0.025 + 0.5 * t14(k[0], y0, vx, vy, ax, ay, jx, jy, sx, sy)
+    bt1, bt4 = bounding_box(k[0], c)
+    bt1 -= 0.025
+    bt4 += 0.025
 
     npt = t.size
     flux = zeros(npt)
-    tp, lp = calculate_luminosity_interpolation_table(tres, k[0], xp, yp, sa, ca,
-                                                      y0, vx, vy, ax, ay, jx, jy, sx, sy,
+    tp, lp = calculate_luminosity_interpolation_table(tres, k[0], xp, yp, sa, ca, c,
                                                       mstar, rstar, ostar, tpole, gpole, f,
                                                       sphi, cphi, beta, ldc, ftable, teff0, dteff, accurate_mu)
     dtp = tp[1] - tp[0]
@@ -541,7 +539,7 @@ def oblate_model_s(t, k, t0, p, a, aa, i, e, w, ldc,
     for j in range(npt):
         epoch = floor((t[j] - t0 + 0.5*p)/p)
         tc = t[j] - (t0 + epoch*p)
-        if abs(tc) > half_window_width:
+        if not (bt1 <= tc <= bt4):
             flux[j] = 1.0
         else:
             ilc = lcids[j]
@@ -570,7 +568,7 @@ def oblate_model_s(t, k, t0, p, a, aa, i, e, w, ldc,
                         at = (to - tp[it]) / dtp
                     ml = (1.0 - at) * lp[ipb, it] + at * lp[ipb, it + 1]
 
-                    x, y = xy_taylor_st(to, sa, ca, y0, vx, vy, ax, ay, jx, jy, sx, sy)
+                    x, y = xy_taylor_st(to, sa, ca, c)
 
                     b = sqrt(x**2 + (y / (1. - feff))**2)
                     ia = circle_circle_intersection_area(1., _k, b)

{pytransit-2.7.0 → pytransit-2.8.0}/pytransit/models/numba/ma_chromosphere_nb.py

@@ -213,35 +213,3 @@ def chromosphere_model_s(t, k, t0, p, a, i, e, w, lcids, pbids, nsamples, exptim
                 flux[j] += chromosphere_z_s(z, _k)
         flux[j] /= nsamples[ilc]
     return flux
-
-@njit(parallel=True, fastmath=True)
-def chromosphere_model_pv(t, pvp, lcids, pbids, nsamples, exptimes, es, ms, tae):
-    pvp = atleast_2d(pvp)
-    npv = pvp.shape[0]
-    npt = t.size
-    nk = pvp.shape[1] - 6
-
-    flux = zeros((npv, npt))
-    for j in prange(npt):
-        for ipv in range(npv):
-            t0, p, a, i, e, w = pvp[ipv,nk:]
-            ilc = lcids[j]
-            ipb = pbids[ilc]
-
-            if nk == 1:
-                k = pvp[ipv, 0]
-            else:
-                if ipb < nk:
-                    k = pvp[ipv, ipb]
-                else:
-                    k = nan
-
-            for isample in range(1,nsamples[ilc]+1):
-                time_offset = exptimes[ilc] * ((isample - 0.5) / nsamples[ilc] - 0.5)
-                z = z_ip_s(t[j]+time_offset, t0, p, a, i, e, w, es, ms, tae)
-                if z > 1.0+k:
-                    flux[ipv, j] += 1.
-                else:
-                    flux[ipv, j] += chromosphere_z_s(z, k)
-            flux[ipv, j] /= nsamples[ilc]
-    return flux