PyTransit 2.6.3__tar.gz → 2.6.4__tar.gz

{pytransit-2.6.3 → pytransit-2.6.4}/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.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyTransit
-Version: 2.6.3
+Version: 2.6.4
 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.4}/PyTransit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyTransit
-Version: 2.6.3
+Version: 2.6.4
 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.4}/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.4}/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.4}/pyproject.toml

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

pytransit-2.6.4/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.4/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.4}/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,13 +108,14 @@ 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
     xyc = zeros((2, 5))            # Taylor series coefficients for the (x, y) position
 
-    for ipv in prange(npv):
+    for ipv in range(npv):
         if isnan(a[ipv]) or (a[ipv] <= 1.0) or (e[ipv] < 0.0):
             flux[ipv, :, :] = nan
             continue
@@ -119,15 +126,15 @@ 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)
-            for ipb in range(npb):
+            dk, dg, wg = calculate_weights_2d(kmean, z_edges, ng)
+            for ipb in prange(npb):
                 ldm[ipb, :] = dot(wg, ldp[ipv, ipb, :])
 
         # -----------------------------------------------------#
@@ -144,7 +151,7 @@ def tsmodel_parallel(times: ndarray,
         # --------------------------#
         # Calculate the light curve #
         # --------------------------#
-        for ipt in range(npt):
+        for ipt in prange(npt):
             epoch = floor((times[ipt] - t0[ipv] + 0.5 * p[ipv]) / p[ipv])
             tc = times[ipt] - (t0[ipv] + epoch * p[ipv])
             if fabs(tc) > hww:
@@ -158,4 +165,5 @@ def tsmodel_parallel(times: ndarray,
                         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]
+    set_num_threads(nthreads_current)
     return flux

pytransit-2.6.4/pytransit/models/roadrunner/opmodel.py

@@ -0,0 +1,104 @@
+#  PyTransit: fast and easy exoplanet transit modelling in Python.
+#  Copyright (C) 2010-2019  Hannu Parviainen
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+from typing import Tuple, Callable, Union, List, Optional
+
+from numpy import ndarray, linspace, isscalar, unique, atleast_1d
+from scipy.integrate import trapz
+
+from ..ldmodel import LDModel
+from ..numba.ldmodels import *
+
+from .opmodel_full import opmodel
+from .rrmodel import RoadRunnerModel
+
+__all__ = ['OblatePlanetModel']
+
+
+class OblatePlanetModel(RoadRunnerModel):
+    def evaluate(self, k: Union[float, ndarray], f: Union[float, ndarray], alpha: Union[float, ndarray],
+                 ldc: Union[ndarray, List],
+                 t0: Union[float, ndarray], p: Union[float, ndarray], a: Union[float, ndarray],
+                 i: Union[float, ndarray], e: Union[float, ndarray] = 0.0, w: Union[float, ndarray] = 0.0,
+                 copy: bool = True) -> ndarray:
+        """Evaluate the transit model for a set of scalar or vector parameters.
+
+        Parameters
+        ----------
+        k
+            Radius ratio(s) either as a single float, 1D vector, or 2D array.
+        ldc
+            Limb darkening coefficients as a 1D or 2D array.
+        t0
+            Transit center(s) as a float or a 1D vector.
+        p
+            Orbital period(s) as a float or a 1D vector.
+        a
+            Orbital semi-major axis (axes) divided by the stellar radius as a float or a 1D vector.
+        i
+            Orbital inclination(s) as a float or a 1D vector.
+        e : optional
+            Orbital eccentricity as a float or a 1D vector.
+        w : optional
+            Argument of periastron as a float or a 1D vector.
+
+        Notes
+        -----
+        The model can be evaluated either for one set of parameters or for many sets of parameters simultaneously. In
+        the first case, the orbital parameters should all be given as floats. In the second case, the orbital parameters
+        should be given as a 1D array-like.
+
+        Returns
+        -------
+        ndarray
+            Modelled flux either as a 1D or 2D ndarray.
+        """
+
+        npv = 1 if isscalar(p) else p.size
+        ldc = atleast_1d(ldc)
+
+        if isinstance(self.ldmodel, LDModel):
+            ldp, istar = self.ldmodel(self.mu, ldc)
+        else:
+            ldp = evaluate_ld(self.ldmodel, self.mu, ldc)
+
+            if self.ldmmean is not None:
+                istar = evaluate_ldi(self.ldmmean, ldc)
+            else:
+                istar = zeros((npv, self.npb))
+                ldpi = evaluate_ld(self.ldmodel, self._ldmu, ldc)
+                for ipv in range(npv):
+                    for ipb in range(self.npb):
+                        istar[ipv, ipb] = 2 * pi * trapz(self._ldz * ldpi[ipv, ipb], self._ldz)
+
+        flux = opmodel(self.time, k, f, alpha, t0, p, a, i, e, w, self.parallel,
+                       self.nlc, self.npb, self.nep, 100,
+                       self.lcids, self.pbids, self.epids, self.nsamples, self.exptimes,
+                       ldp, istar, self.weights, self.dk, self.klims[0], self.klims[1], self.dg, self.ze)
+
+        return flux