PyTransit 2.6.3__tar.gz → 2.6.5__tar.gz

{pytransit-2.6.3 → pytransit-2.6.5}/MANIFEST.in

@@ -1,4 +1,6 @@
 include pytransit/contamination/data/*
 include pytransit/models/opencl/*.cl
 include pytransit/models/roadrunner/*.cl
+include pytransit/models/roadrunner/*.py
+include pytransit/models/numba/*.py
 include pytransit/stars/data/*.fits

{pytransit-2.6.3 → pytransit-2.6.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyTransit
-Version: 2.6.3
+Version: 2.6.5
 Summary: Fast and painless exoplanet transit light curve modelling.
 Author-email: Hannu Parviainen <hpparvi@gmail.com>
 License: GPLv2
@@ -43,7 +43,8 @@ PyTransit
 
 *PyTransit: fast and versatile exoplanet transit light curve modelling in Python.* PyTransit provides a set of optimised
 transit models with a unified API that makes modelling complex sets of heterogeneous light curve (nearly) as easy as 
-modelling individual transit light curves. 
+modelling individual transit light curves. The models are optimised with Numba which allows for model evaluation speeds
+paralleling Fortran and C-implementations but with hassle-free platform-independent multithreading.
 
 The package has been under continuous development since 2009, and is described in [Parviainen (2015)](http://arxiv.org/abs/1504.07433), 
 [Parviainen (2020a)](https://ui.adsabs.harvard.edu/abs/2020MNRAS.499.1633P/abstract), and [Parviainen (2020b)](https://ui.adsabs.harvard.edu/abs/2020MNRAS.499.3356P/abstract). 

{pytransit-2.6.3 → pytransit-2.6.5}/PyTransit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyTransit
-Version: 2.6.3
+Version: 2.6.5
 Summary: Fast and painless exoplanet transit light curve modelling.
 Author-email: Hannu Parviainen <hpparvi@gmail.com>
 License: GPLv2
@@ -43,7 +43,8 @@ PyTransit
 
 *PyTransit: fast and versatile exoplanet transit light curve modelling in Python.* PyTransit provides a set of optimised
 transit models with a unified API that makes modelling complex sets of heterogeneous light curve (nearly) as easy as 
-modelling individual transit light curves. 
+modelling individual transit light curves. The models are optimised with Numba which allows for model evaluation speeds
+paralleling Fortran and C-implementations but with hassle-free platform-independent multithreading.
 
 The package has been under continuous development since 2009, and is described in [Parviainen (2015)](http://arxiv.org/abs/1504.07433), 
 [Parviainen (2020a)](https://ui.adsabs.harvard.edu/abs/2020MNRAS.499.1633P/abstract), and [Parviainen (2020b)](https://ui.adsabs.harvard.edu/abs/2020MNRAS.499.3356P/abstract). 

{pytransit-2.6.3 → pytransit-2.6.5}/PyTransit.egg-info/SOURCES.txt

@@ -79,6 +79,7 @@ pytransit/models/numba/__init__.py
 pytransit/models/numba/gdmodel.py
 pytransit/models/numba/general_nb.py
 pytransit/models/numba/ldmodels.py
+pytransit/models/numba/ldtkldm.py
 pytransit/models/numba/ma_chromosphere_nb.py
 pytransit/models/numba/ma_quadratic_nb.py
 pytransit/models/numba/ma_uniform_nb.py
@@ -93,12 +94,16 @@ pytransit/models/opencl/orbits.cl
 pytransit/models/opencl/qpower2.cl
 pytransit/models/roadrunner/__init__.py
 pytransit/models/roadrunner/common.py
+pytransit/models/roadrunner/ecintersection.py
 pytransit/models/roadrunner/model.py
 pytransit/models/roadrunner/model_full.py
 pytransit/models/roadrunner/model_simple.py
 pytransit/models/roadrunner/model_trspec.py
+pytransit/models/roadrunner/opmodel.py
+pytransit/models/roadrunner/opmodel_full.py
 pytransit/models/roadrunner/rrmodel.cl
 pytransit/models/roadrunner/rrmodel.py
+pytransit/models/roadrunner/rrmodel_cl.py
 pytransit/models/roadrunner/tsmodel.py
 pytransit/orbits/__init__.py
 pytransit/orbits/orbits.py

{pytransit-2.6.3 → pytransit-2.6.5}/README.md

@@ -9,7 +9,8 @@ PyTransit
 
 *PyTransit: fast and versatile exoplanet transit light curve modelling in Python.* PyTransit provides a set of optimised
 transit models with a unified API that makes modelling complex sets of heterogeneous light curve (nearly) as easy as 
-modelling individual transit light curves. 
+modelling individual transit light curves. The models are optimised with Numba which allows for model evaluation speeds
+paralleling Fortran and C-implementations but with hassle-free platform-independent multithreading.
 
 The package has been under continuous development since 2009, and is described in [Parviainen (2015)](http://arxiv.org/abs/1504.07433), 
 [Parviainen (2020a)](https://ui.adsabs.harvard.edu/abs/2020MNRAS.499.1633P/abstract), and [Parviainen (2020b)](https://ui.adsabs.harvard.edu/abs/2020MNRAS.499.3356P/abstract). 

{pytransit-2.6.3 → pytransit-2.6.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "PyTransit"
-version = "2.6.3"
+version = "2.6.5"
 description = 'Fast and painless exoplanet transit light curve modelling.'
 authors=[{name='Hannu Parviainen', email='hpparvi@gmail.com'}]
 classifiers=[

{pytransit-2.6.3 → pytransit-2.6.5}/pytransit/lpf/rvlpf.py

@@ -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):
+    def __init__(self, name: str, nplanets: int, times, rvs, rves, rvis=None, slope_order: int = 1):
         super().__init__(name)
 
         def transform_input(a):
@@ -77,7 +77,7 @@ class RVLPF(LogPosteriorFunction):
             rvis = zeros(len(times), 'int')
 
         self._tref = concatenate(times).mean()
-        self.rvm: RVModel = RVModel(self, nplanets, times, rvs, rves, rvis)
+        self.rvm: RVModel = RVModel(self, nplanets, times, rvs, rves, rvis, slope_order=slope_order)
 
     def model(self, pv):
         return self.rvm.rv_model(pv)
@@ -103,7 +103,7 @@ class RVModel:
 
     def __init__(self, lpf: LogPosteriorFunction, nplanets: int,
                  times, rvs: Iterable, rves: Iterable, rvis: Iterable,
-                 tref: Optional[float] = None):
+                 tref: Optional[float] = None, slope_order: int = 1):
         self.lpf = lpf
 
         if hasattr(lpf, 'nplanets'):
@@ -125,6 +125,7 @@ class RVModel:
         self._rva = None
         self._rvea = None
         self._rv_ids = None
+        self.slope_order = slope_order
 
         self.setup_data(times, rvs, rves, rvis)
 
@@ -183,7 +184,7 @@ class RVModel:
         self._start_rvk = ps.blocks[-1].start
         self._sl_rvk = ps.blocks[-1].slice
 
-        psl = [GParameter('rv_slope', 'linear rv slope', 'm/s', NP(0.0, 1.0), (-inf, inf))]
+        psl = [GParameter(f'rv_slope_{i}', 'rv slope', '', NP(0.0, 1.0), (-inf, inf)) for i in range(1, self.slope_order+1)]
         ps.add_global_block('rv_slope', psl)
         self._start_rv_slope = ps.blocks[-1].start
         self._sl_rv_slope = ps.blocks[-1].slice
@@ -202,7 +203,10 @@ class RVModel:
 
     def rv_slope(self, pvp, times):
         pvp = atleast_2d(pvp)
-        return times * pvp[:, self._sl_rv_slope]
+        slope = times * pvp[:, self._start_rv_slope : self._start_rv_slope + 1]
+        if self.slope_order == 2:
+            slope += times**2 * pvp[:, self._start_rv_slope + 1: self._start_rv_slope + 2]
+        return slope
 
     def rv_model(self, pvp, times=None, planets=None, add_sv=True, add_slope=True):
         times = self._timea if times is None else times - self._tref
@@ -264,10 +268,10 @@ class RVModel:
         rv_time = linspace(self._timea.min() - 1, self._timea.max() + 1, num=ntimes) + self._tref
 
         if pvp is None:
-            rv_model = self.rv_model(pv, rv_time, add_sv=False)
+            rv_model = self.rv_model(pv, rv_time, add_sv=False, add_slope=slope)
             rv_model_limits = None
         else:
-            rv_percentiles = percentile(self.rv_model(pvp, rv_time, add_sv=False), [50, 16, 84, 2.5, 97.5], 0)
+            rv_percentiles = percentile(self.rv_model(pvp, rv_time, add_sv=False, add_slope=slope), [50, 16, 84, 2.5, 97.5], 0)
             rv_model = rv_percentiles[0]
             rv_model_limits = rv_percentiles[1:]
 
@@ -279,10 +283,13 @@ class RVModel:
             colors = len(self.rvis) * ['k']
         if markers is None:
             markers = len(self.rvis) * ['.']
-        rvs = self._rva - self.rv_shifts(pv) - squeeze(self.rv_slope(pv, self._timea))
+        rvs = self._rva - self.rv_shifts(pv)
+        if not slope:
+            rvs -= squeeze(self.rv_slope(pv, self._timea))
+
         for iid, instrument in enumerate(self.rvis):
             m = self._rv_ids == iid
-            axs[0].errorbar(self._timea[m] + self._tref, rvs[m], self._rvea[m], fmt='o', marker=markers[iid],
+            axs[0].errorbar(self._timea[m] + self._tref, rvs[m], self._rvea[m], marker=markers[iid], ls='',
                             c=colors[iid], ms=4, label=instrument)
             axs[1].errorbar(self._timea[m] + self._tref, self._rva[m] - squeeze(self.rv_model(pv))[m], self._rvea[m],
                             fmt='ok', ms=4)

{pytransit-2.6.3 → pytransit-2.6.5}/pytransit/models/eclipse_model.py

@@ -38,7 +38,7 @@ class EclipseModel(TransitModel):
         Parameters
         ----------
         k
-            Radius ratio(s) either as a single float, 1D vector, or 2D array.
+            Radius ratio(s) either as a single float or a 1D vector.
         t0
             Transit center(s) as a float or a 1D vector.
         p
@@ -97,72 +97,3 @@ class EclipseModel(TransitModel):
             flux = 1.0 + (flux - 1.0) / k**2
 
         return squeeze(flux)
-
-    def evaluate_ps(self, k: float, t0: float, p: float, a: float, i: float, e: float = 0., w: float = 0., fr: Optional[float] = None) -> ndarray:
-        """Evaluate the transit model for a set of scalar parameters.
-
-         Parameters
-         ----------
-         k : array-like
-             Radius ratio(s) either as a single float or an 1D array.
-         t0 : float
-             Transit center as a float.
-         p : float
-             Orbital period as a float.
-         a : float
-             Orbital semi-major axis divided by the stellar radius as a float.
-         i : float
-             Orbital inclination(s) as a float.
-         e : float, optional
-             Orbital eccentricity as a float.
-         w : float, optional
-             Argument of periastron as a float.
-         fr : float, optional
-             Planet-star flux ratio as a float.
-
-
-         Notes
-         -----
-         This version of the `evaluate` method is optimized for calculating a single transit model (such as when using a
-         local optimizer). If you want to evaluate the model for a large number of parameters simultaneously, use either
-         `evaluate` or `evaluate_pv`.
-
-         Returns
-         -------
-         ndarray
-             Modelled flux as a 1D ndarray.
-         """
-        if self.time is None:
-            raise ValueError("Need to set the data before calling the transit model.")
-
-        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=-1.0)
-        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.6.3 → pytransit-2.6.5}/pytransit/models/ldtkldm.py

@@ -18,7 +18,7 @@ from typing import Tuple, Optional, Union
 from pathlib import Path
 
 from numba import njit
-from numpy import zeros, interp, pi, ndarray, linspace, meshgrid, transpose
+from numpy import zeros, interp, pi, ndarray, linspace, meshgrid, transpose, asarray, newaxis, errstate
 from scipy.interpolate import interpn, interpnd, RegularGridInterpolator as RGI
 
 from .ldmodel import LDModel
@@ -67,13 +67,21 @@ class LDTkLDModel(LDModel):
         self.logg0, self.dlogg, self.nlogg = loggs[0], loggs[1]-loggs[0], self.sc.client.nlogg
         self.metal0, self.dmetal, self.nmetal = zs[0], zs[1]-zs[0], self.sc.client.nz
 
-        self.ps = self.sc.create_profiles(teff=teffg.ravel(), logg=loggg.ravel(), metal=zg.ravel())
-        self.ps.resample(mu=self.mu)
-        self.profiles = transpose(self.ps._ldps.copy(), axes=(1, 0, 2)).reshape((self.nteff, self.nlogg, self.nmetal, self.npb, self.nmu))
+        with errstate(divide='ignore'):
+            self.ps = self.sc.create_profiles(teff=teffg.ravel(), logg=loggg.ravel(), metal=zg.ravel())
+            self.ps.resample(mu=self.mu)
+            self.profiles = transpose(self.ps._ldps.copy(), axes=(1, 0, 2)).reshape((self.nteff, self.nlogg, self.nmetal, self.npb, self.nmu))
 
     def __call__(self, mu: ndarray, x: ndarray) -> Tuple[ndarray, ndarray]:
         if self.mu is None or id(mu) != id(self.mu):
             self._init_interpolation(mu)
+
+        x = asarray(x)
+        if x.ndim == 1:
+            x = x[newaxis, newaxis, :]
+        elif x.ndim == 2:
+            x = x[:, newaxis, :]
+
         ldp = trilinear_interpolation_set(self.profiles, x[:, 0, 0], x[:, 0, 1], x[:, 0, 2],
                                           self.teff0, self.dteff, self.nteff,
                                           self.logg0, self.dlogg, self.nlogg,

pytransit-2.6.5/pytransit/models/numba/ldtkldm.py

@@ -0,0 +1,91 @@
+from numba import njit, prange
+from numpy import zeros, floor, sqrt, pi
+
+
+@njit
+def trilinear_interpolation_unit_cube(data, x, y, z):
+    """Trilinear interpolation inside a unit cube.
+
+    Implementation taken from Paul Bourke's notes
+    https://paulbourke.net/miscellaneous/interpolation
+    """
+    n1 = data.shape[3]
+    n2 = data.shape[4]
+    ldp = zeros((n1, n2))
+    rx, ry, rz = (1.0 - x), (1.0 - y), (1.0 - z)
+
+    a1 = rx * ry * rz
+    a2 = x * ry * rz
+    b1 = rx * y * rz
+    b2 = rx * ry * z
+    c1 = x * ry * z
+    c2 = rx * y * z
+    d1 = x * y * rz
+    d2 = x * y * z
+
+    for i1 in range(n1):
+        for i2 in range(n2):
+            ldp[i1, i2] = (data[0, 0, 0, i1, i2] * a1 +
+                           data[1, 0, 0, i1, i2] * a2 +
+                           data[0, 1, 0, i1, i2] * b1 +
+                           data[0, 0, 1, i1, i2] * b2 +
+                           data[1, 0, 1, i1, i2] * c1 +
+                           data[0, 1, 1, i1, i2] * c2 +
+                           data[1, 1, 0, i1, i2] * d1 +
+                           data[1, 1, 1, i1, i2] * d2)
+    return ldp
+
+
+@njit
+def trilinear_interpolation_single(data, x, y, z, x0, dx, nx, y0, dy, ny, z0, dz, nz):
+    x = min(max(x, x0), x0 + nx * dx)
+    y = min(max(y, y0), y0 + ny * dy)
+    z = min(max(z, z0), z0 + nz * dz)
+    ix = int(floor((x - x0) / dx))
+    iy = int(floor((y - y0) / dy))
+    iz = int(floor((z - z0) / dz))
+    ax = (x - x0 - ix * dx) / dx
+    ay = (y - y0 - iy * dy) / dy
+    az = (z - z0 - iz * dz) / dz
+    return trilinear_interpolation_unit_cube(data[ix:ix + 2, iy:iy + 2, iz:iz + 2, :, :], ax, ay, az)
+
+
+@njit(parallel=True)
+def trilinear_interpolation_set(data, xs, ys, zs, x0, dx, nx, y0, dy, ny, z0, dz, nz):
+    npv = xs.shape[0]
+    ldp = zeros((npv, data.shape[3], data.shape[4]))
+    for ipv in prange(npv):
+        ldp[ipv, :, :] = trilinear_interpolation_single(data, xs[ipv], ys[ipv], zs[ipv], x0, dx, nx, y0, dy, ny, z0, dz,
+                                                        nz)
+    return ldp
+
+
+@njit
+def integrate_profiles_single(mu, ldp):
+    nmu = mu.size
+    npb = ldp.shape[0]
+    ldi = zeros(npb)
+
+    z = sqrt(1.0 - mu ** 2)
+    dz = z[1:] - z[:-1]
+    for ipb in range(npb):
+        for i in range(1, nmu):
+            ldi[ipb] += dz[i - 1] * 0.5 * (z[i] * ldp[ipb, i] + z[i - 1] * ldp[ipb, i - 1])
+    return 2.0 * pi * ldi
+
+
+@njit(parallel=True)
+def integrate_profiles_set(mu, ldp):
+    nmu = mu.size
+    npv = ldp.shape[0]
+    npb = ldp.shape[1]
+    ldi = zeros((npv, npb))
+
+    z = sqrt(1.0 - mu ** 2)
+    dz = z[1:] - z[:-1]
+    for j in prange(npv * npb):
+        ipv = j // npb
+        ipb = j % npb
+        for i in range(1, nmu):
+            ldi[ipv, ipb] += dz[i - 1] * 0.5 * (z[i] * ldp[ipv, ipb, i] + z[i - 1] * ldp[ipv, ipb, i - 1])
+    return 2.0 * pi * ldi

{pytransit-2.6.3 → pytransit-2.6.5}/pytransit/models/numba/udmodel.py

@@ -80,8 +80,7 @@ def uniform_model_simple(times, k, t0, p, a, i, e, w, with_derivatives):
 
 
 @njit
-def uniform_model_v(times, k, t0, p, dkdp, cfs, dcfs, with_derivatives,
-                    lcids, pbids, epids, nsamples, exptimes):
+def uniform_model_v(times, k, t0, p, dkdp, cfs, dcfs, with_derivatives, lcids, pbids, epids, nsamples, exptimes):
     k = atleast_1d(asarray(k))
     dkdp = atleast_1d(asarray(dkdp))
     t0 = atleast_1d(asarray(t0))

pytransit-2.6.5/pytransit/models/roadrunner/ecintersection.py

@@ -0,0 +1,137 @@
+from math import cos, sin, sqrt, isfinite, nan
+
+from numpy import ndarray, fabs, pi, full, arange
+from numba import njit
+
+@njit
+def create_ellipse(ny: int, k: float, f: float, a: float) -> (ndarray, ndarray):
+    """
+    Create the coordinates for a rotated ellipse.
+
+    Parameters
+    ----------
+    ny : int
+        The number of sample points along the y-axis.
+    k : float
+        Scale factor for the ellipse.
+    f : float
+        Flattening factor for the ellipse. Determines the extent to which the ellipse is squashed along the y-axis.
+    a : float
+        The angle of rotation for the ellipse in radians.
+
+    Returns
+    -------
+    (ndarray, ndarray)
+        A tuple containing two ndarrays. The first ndarray is a 1D array of y-coordinates, and the second is a 2D array of x-coordinates
+        corresponding to the left and right intersections of the ellipse with vertical lines through the y-coordinates.
+
+    Notes
+    -----
+    The ellipse is initially defined with its major axis aligned with the x-axis. It is then rotated by an angle `a` and scaled by a factor `k`.
+    The flattening factor `f` adjusts the size of the minor axis relative to the major axis, with a smaller value indicating a more flattened ellipse.
+    """
+    dy = 2 / (ny+1)
+    ys = arange(1, 1+ny)*dy - 1
+    xs = full((ny, 2), nan)
+    ca, sa = cos(a), sin(a)
+    b = 1.0 - f
+    b2 = b * b
+    ca2 = ca * ca
+    sa2 = sa * sa
+
+    for i in range(ny):
+        y = ys[i]
+        y2 = y * y
+        d = b2 * ca2 + ca2 * ca2 * (-y2) - 2 * ca2 * sa2 * y2 - sa2 * sa2 * y2 + sa2
+        if d >= 0:
+            d = sqrt(d) / b
+            u = (ca * sa * y) / b2 - ca * sa * y
+            v = sa2 / b2 + ca2
+            xs[i, 0] = (-d + u) / v
+            xs[i, 1] = (d + u) / v
+    return k*ys, k*xs
+
+
+@njit
+def ellipse_circle_intersection_area(cx: float, cy: float, z: float, k: float, f: float, xs: ndarray, ys: ndarray) -> float:
+    """
+     Calculate the intersection area between a rotated ellipse and a circle using a scanline fill approach.
+
+   Parameters
+    ----------
+    cx : float
+        The ellipse's center x coordinate.
+    cy : float
+        The ellipse's center y coordinate.
+    z : float
+        The center-center distance.
+    k : float
+        Radius ratio.
+    f : float
+        Flattening factor for the ellipse. Determines the extent to which the ellipse is squashed along the y-axis.
+    xs : ndarray
+        2D array of x-coordinates corresponding to the left and right intersections of the ellipse with vertical lines through the y-coordinates.
+    ys : ndarray
+        1D array of y-coordinates.
+
+     Returns
+     -------
+     float
+         The area of the intersection between the given ellipse and circle.
+
+     Notes
+     -----
+     This function employs a numerical method that iterates over a set of horizontal lines (scanlines)
+     to approximate the area of intersection between a circle and a rotated ellipse. The calculation considers
+     the rotation of the ellipse, its eccentricity, and the relative position of the ellipse to the circle.
+     The approach is based on the principles of scanline fill in computer graphics, adapted to the mathematical
+     properties of ellipses and circles.
+
+     The algorithm calculates the intersection points between each scanline and the ellipse, then integrates these
+     intersections over the range of y-coordinates to find the total area. It handles different cases based on the
+     relative position and size of the ellipse to optimize calculations.
+     """
+    if z <= 1.0 - k:
+        return pi * k * (1.0 - f) * k
+    elif z >= 1.0 + k:
+        return 0.0
+    else:
+        ny = ys.size
+        dy = (ys[1] - ys[0])
+        l = 0.0
+        if cx < -k:
+            for i in range(ny):
+                if isfinite(xs[i, 0]):
+                    xstar = -sqrt(1.0 - (ys[i] + cy) ** 2) - cx
+                    if xstar <= xs[i, 0]:
+                        l += xs[i, 1] - xs[i, 0]
+                    elif xstar <= xs[i, 1]:
+                        l += xs[i, 1] - xstar
+        elif cx > k:
+            for i in range(ny):
+                if isfinite(xs[i, 0]):
+                    xstar = sqrt(1.0 - (ys[i] + cy) ** 2) - cx
+                    if xstar >= xs[i, 1]:
+                        l += xs[i, 1] - xs[i, 0]
+                    elif xstar >= xs[i, 0]:
+                        l += xstar - xs[i, 0]
+        else:
+            for i in range(ny):
+                if isfinite(xs[i, 0]):
+                    if fabs(ys[i] + cy) <= 1.0:
+                        xstar = sqrt(1.0 - (ys[i] + cy) ** 2)
+                        xst1 = -xstar - cx
+                        xst2 = xstar - cx
+                        if xst1 <= xs[i, 0]:
+                            l += min(xst2, xs[i, 1]) - xs[i, 0]
+                        elif xst1 > xs[i, 0]:
+                            l +=  min(xst2, xs[i, 1]) - xst1
+        return l*dy
+
+        #else:
+        #    for i in range(ny):
+        #        if isfinite(xs[i,0]):
+        #            xstar = sqrt(1.0 - (ys[i])**2) - b
+        #            if xstar < xs[i,1]:
+        #                l += xs[i,1]-  max(xstar, xs[i,0])
+        #    return pi*k*k*(1.0-f) - l*dy

{pytransit-2.6.3 → pytransit-2.6.5}/pytransit/models/roadrunner/model_trspec.py

@@ -1,5 +1,5 @@
 from math import fabs, floor
-from numba import njit, prange
+from numba import njit, prange, get_num_threads, set_num_threads
 from numpy import zeros, dot, ndarray, isnan, full, nan, mean, floor, fabs
 
 from meepmeep.xy.position import solve_xy_p5s, pd_t15sc
@@ -13,7 +13,7 @@ from .common import circle_circle_intersection_area_kite as ccia
 def tsmodel_serial(times: ndarray,
                    k: ndarray, t0: ndarray, p: ndarray, a: ndarray, i: ndarray, e: ndarray, w: ndarray,
                    nsamples: ndarray, exptimes: ndarray, ldp: ndarray, istar: ndarray,
-                   weights: ndarray, dk: float, kmin: float, kmax: float, dg: float, z_edges: ndarray) -> ndarray:
+                   weights: ndarray, dk: float, kmin: float, kmax: float, ng: int, dg: float, z_edges: ndarray) -> ndarray:
     if k.ndim != 2:
         raise ValueError(" The radius ratios must be given as a 2D array with shape (npv, npb)")
 
@@ -26,7 +26,9 @@ def tsmodel_serial(times: ndarray,
     npt = times.size
     npv = k.shape[0]
     npb = k.shape[1]
-    ng = weights.shape[1]
+
+    if weights is not None:
+        ng = weights.shape[1]
 
     flux = zeros((npv, npb, npt))  # Model flux
     ldm = zeros((npb, ng))         # Limb darkening means
@@ -43,14 +45,13 @@ def tsmodel_serial(times: ndarray,
         # -----------------------------------#
         # Calculate the limb darkening means #
         # -----------------------------------#
-        if kmin <= kmean <= kmax:
+        if weights is not None and kmin <= kmean <= kmax:
             ik = int(floor((kmean - kmin) / dk))
             ak = (kmean - kmin - ik * dk) / dk
             for ipb in range(npb):
-                ldm[ipb, :] = (1.0 - ak) * dot(weights[ik], ldp[ipv, ipb, :]) + ak * dot(weights[ik + 1],
-                                                                                         ldp[ipv, ipb, :])
+                ldm[ipb, :] = (1.0 - ak) * dot(weights[ik], ldp[ipv, ipb, :]) + ak * dot(weights[ik + 1], ldp[ipv, ipb, :])
         else:
-            _, _, wg = calculate_weights_2d(kmean, z_edges, ng)
+            _, dg, wg = calculate_weights_2d(kmean, z_edges, ng)
             for ipb in range(npb):
                 ldm[ipb, :] = dot(wg, ldp[ipv, ipb, :])
 
@@ -89,7 +90,12 @@ def tsmodel_serial(times: ndarray,
 def tsmodel_parallel(times: ndarray,
                    k: ndarray, t0: ndarray, p: ndarray, a: ndarray, i: ndarray, e: ndarray, w: ndarray,
                    nsamples: ndarray, exptimes: ndarray, ldp: ndarray, istar: ndarray,
-                   weights: ndarray, dk: float, kmin: float, kmax: float, dg: float, z_edges: ndarray) -> ndarray:
+                   weights: ndarray, dk: float, kmin: float, kmax: float, ng: int, dg: float, z_edges: ndarray,
+                   nthreads: int) -> ndarray:
+
+    #nthreads_current = get_num_threads()
+    #set_num_threads(nthreads)
+
     if k.ndim != 2:
         raise ValueError(" The radius ratios must be given as a 2D array with shape (npv, npb)")
 
@@ -102,7 +108,8 @@ def tsmodel_parallel(times: ndarray,
     npt = times.size
     npv = k.shape[0]
     npb = k.shape[1]
-    ng = weights.shape[1]
+    if weights is not None:
+        ng = weights.shape[1]
 
     flux = zeros((npv, npb, npt))  # Model flux
     ldm = zeros((npb, ng))         # Limb darkening means
@@ -119,14 +126,14 @@ def tsmodel_parallel(times: ndarray,
         # -----------------------------------#
         # Calculate the limb darkening means #
         # -----------------------------------#
-        if kmin <= kmean <= kmax:
+        if weights is not None and kmin <= kmean <= kmax:
             ik = int(floor((kmean - kmin) / dk))
             ak = (kmean - kmin - ik * dk) / dk
             for ipb in range(npb):
                 ldm[ipb, :] = (1.0 - ak) * dot(weights[ik], ldp[ipv, ipb, :]) + ak * dot(weights[ik + 1],
                                                                                          ldp[ipv, ipb, :])
         else:
-            _, _, wg = calculate_weights_2d(kmean, z_edges, ng)
+            _, dg, wg = calculate_weights_2d(kmean, z_edges, ng)
             for ipb in range(npb):
                 ldm[ipb, :] = dot(wg, ldp[ipv, ipb, :])
 
@@ -150,12 +157,10 @@ def tsmodel_parallel(times: ndarray,
             if fabs(tc) > hww:
                 flux[ipv, :, ipt] = 1.0
             else:
-                for isample in range(1, nsamples[0] + 1):
-                    time_offset = exptimes[0] * ((isample - 0.5) / nsamples[0] - 0.5)
-                    z = pd_t15sc(tc + time_offset, xyc)
-                    aplanet = ccia(1.0, kmean, z)[0]
-                    for ipb in range(npb):
-                        iplanet = interpolate_mean_limb_darkening_s(z / (1.0 + kmean), dg, ldm[ipb])
-                        flux[ipv, ipb, ipt] += (istar[ipv, ipb] - iplanet * aplanet * afac[ipb]) / istar[ipv, ipb]
-                flux[ipv, :, ipt] /= nsamples[0]
+                z = pd_t15sc(tc, xyc)
+                aplanet = ccia(1.0, kmean, z)[0]
+                for ipb in range(npb):
+                    iplanet = interpolate_mean_limb_darkening_s(z / (1.0 + kmean), dg, ldm[ipb])
+                    flux[ipv, ipb, ipt] += (istar[ipv, ipb] - iplanet * aplanet * afac[ipb]) / istar[ipv, ipb]
+    #set_num_threads(nthreads_current)
     return flux