PyTransit 2.7.1__tar.gz → 2.8.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyTransit
-Version: 2.7.1
+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.1 → pytransit-2.8.0}/PyTransit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyTransit
-Version: 2.7.1
+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.1 → 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,6 @@ 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-2.7.1 → 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.1 → 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.1 → pytransit-2.8.0}/pytransit/__init__.py

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

{pytransit-2.7.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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

{pytransit-2.7.1 → pytransit-2.8.0}/pytransit/models/numba/ma_quadratic_nb.py

@@ -45,7 +45,7 @@ from numba import njit, prange
 from numpy import pi, sqrt, arccos, abs, log, zeros, linspace, array, atleast_2d, floor, inf, isnan, atleast_1d, ndarray, nan, copysign, \
     fmax, any
 
-from ...orbits.taylor_z import vajs_from_paiew, z_taylor_st, t14
+from meepmeep.backends.numba.point2d import solve2d, sep_c, bounding_box
 
 HALF_PI = 0.5 * pi
 FOUR_PI = 4.0 * pi
@@ -555,8 +555,10 @@ def quadratic_model_v(t, k, t0, p, a, i, e, w, ldc, lcids, pbids, epids, nsample
             flux[ipv, :] = inf
             continue
 
-        y0, vx, vy, ax, ay, jx, jy, sx, sy = vajs_from_paiew(p[ipv], a[ipv], i[ipv], e[ipv], w[ipv])
-        half_window_width = 0.025 + 0.5 * t14(k[ipv,0], y0, vx, vy, ax, ay, jx, jy, sx, sy)
+        c = solve2d(0.0, p[ipv], a[ipv], i[ipv], e[ipv], w[ipv])
+        bt1, bt4 = bounding_box(k[ipv, 0], c)
+        bt1 -= 0.025
+        bt4 += 0.025
 
         for j in range(npt):
             ilc = lcids[j]
@@ -565,7 +567,7 @@ def quadratic_model_v(t, k, t0, p, a, i, e, w, ldc, lcids, pbids, epids, nsample
             epoch = floor((t[j] - t0[ipv, iep] + 0.5 * p[ipv]) / p[ipv])
             tc = t[j] - (t0[ipv, iep] + epoch * p[ipv])
 
-            if abs(tc) > half_window_width:
+            if not (bt1 <= tc <= bt4):
                 flux[ipv, j] = 1.0
             else:
                 ipb = pbids[ilc]
@@ -581,7 +583,7 @@ def quadratic_model_v(t, k, t0, p, a, i, e, w, ldc, lcids, pbids, epids, nsample
                 else:
                     for isample in range(1, nsamples[ilc] + 1):
                         time_offset = exptimes[ilc] * ((isample - 0.5) / nsamples[ilc] - 0.5)
-                        z = z_taylor_st(tc + time_offset, y0, vx, vy, ax, ay, jx, jy, sx, sy)
+                        z = sep_c(tc + time_offset, c)
                         if z > 1.0 + _k:
                             flux[ipv, j] += 1.
                         else:
@@ -607,8 +609,10 @@ def quadratic_model_s(t, k, t0, p, a, i, e, w, ldc, lcids, pbids, epids, nsample
     if epids.max() != t0.size - 1:
         raise ValueError("The number of transit centers must equal to the number of individual epoch IDs.")
 
-    y0, vx, vy, ax, ay, jx, jy, sx, sy = vajs_from_paiew(p, a, i, e, w)
-    half_window_width = 0.025 + 0.5 * t14(k[0], y0, vx, vy, ax, ay, jx, jy, sx, sy)
+    c = solve2d(0.0, p, a, i, e, w)
+    bt1, bt4 = bounding_box(k[0], c)
+    bt1 -= 0.025
+    bt4 += 0.025
 
     npt = t.size
     flux = zeros(npt)
@@ -623,7 +627,7 @@ def quadratic_model_s(t, k, t0, p, a, i, e, w, ldc, lcids, pbids, epids, nsample
 
         epoch = floor((t[j] - t0[iep] + 0.5 * p) / p)
         tc = t[j] - (t0[iep] + epoch * p)
-        if abs(tc) > half_window_width:
+        if not (bt1 <= tc <= bt4):
             flux[j] = 1.0
         else:
             ipb = pbids[ilc]
@@ -640,7 +644,7 @@ def quadratic_model_s(t, k, t0, p, a, i, e, w, ldc, lcids, pbids, epids, nsample
             else:
                 for isample in range(1, nsamples[ilc] + 1):
                     time_offset = exptimes[ilc] * ((isample - 0.5) / nsamples[ilc] - 0.5)
-                    z = z_taylor_st(tc + time_offset, y0, vx, vy, ax, ay, jx, jy, sx, sy)
+                    z = sep_c(tc + time_offset, c)
                     if z > 1.0 + _k:
                         flux[j] += 1.
                     else:
@@ -650,70 +654,3 @@ def quadratic_model_s(t, k, t0, p, a, i, e, w, ldc, lcids, pbids, epids, nsample
                             flux[j] += eval_quad_z_s(z, _k, ld)
                 flux[j] /= nsamples[ilc]
     return flux
-
-
-# Quadratic model for parameter array
-# -----------------------------------
-@njit(parallel=True, fastmath=False)
-def quadratic_model_pv(t, pvp, ldc, lcids, pbids, nsamples, exptimes, npb, edt, ldt, let, kt, zt, interpolate):
-    pvp = atleast_2d(pvp)
-    ldc = atleast_2d(ldc)
-
-    if ldc.shape[1] != 2*npb:
-        raise ValueError("The quadratic model needs two limb darkening coefficients per passband")
-    if ldc.shape[0] != pvp.shape[0]:
-        raise ValueError(
-            'The parameter array and the limb darkening coefficient array have mismatching shapes. The first dimension must match.')
-
-    npv = pvp.shape[0]
-    nk = pvp.shape[1] - 6
-    npt = t.size
-    flux = zeros((npv, npt))
-
-    for ipv in prange(npv):
-        t0, p, a, i, e, w = pvp[ipv, nk:]
-        y0, vx, vy, ax, ay, jx, jy, sx, sy = vajs_from_paiew(p, a, i, e, w)
-        half_window_width = 0.025 + 0.5 * t14(pvp[ipv, 0], y0, vx, vy, ax, ay, jx, jy, sx, sy)
-
-        if interpolate and (any(pvp[ipv, :nk] < kt[0]) or any(pvp[ipv, :nk] > kt[-1])):
-            flux[ipv, :] = inf
-            continue
-
-        if any(isnan(pvp[ipv, :nk])) or isnan(a):
-            flux[ipv, :] = inf
-            continue
-
-        for j in prange(npt):
-            epoch = floor((t[j] - t0 + 0.5 * p) / p)
-            tc = t[j] - (t0 + epoch * p)
-            if abs(tc) > half_window_width:
-                flux[ipv, j] = 1.0
-            else:
-                ilc = lcids[j]
-                ipb = pbids[ilc]
-
-                if nk == 1:
-                    k = pvp[ipv, 0]
-                else:
-                    if ipb < nk:
-                        k = pvp[ipv, ipb]
-                    else:
-                        k = nan
-
-                ld = ldc[ipv, 2 * ipb:2 * (ipb + 1)]
-                if isnan(ld[0]) or isnan(ld[1]):
-                    flux[ipv, j] = inf
-                    continue
-
-                for isample in range(1, nsamples[ilc]+1):
-                    time_offset = exptimes[ilc] * ((isample - 0.5) / nsamples[ilc] - 0.5)
-                    z = z_taylor_st(tc + time_offset, y0, vx, vy, ax, ay, jx, jy, sx, sy)
-                    if z > 1.0+k:
-                        flux[ipv, j] += 1.
-                    else:
-                        if interpolate:
-                            flux[ipv, j] += quadratic_interpolated_z_s(z, k, ld, edt, ldt, let, kt, zt)
-                        else:
-                            flux[ipv, j] += eval_quad_z_s(z, k, ld)
-                flux[ipv, j] /= nsamples[ilc]
-    return flux