PyTransit 2.6.4__tar.gz → 2.6.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyTransit
-Version: 2.6.4
+Version: 2.6.5
 Summary: Fast and painless exoplanet transit light curve modelling.
 Author-email: Hannu Parviainen <hpparvi@gmail.com>
 License: GPLv2

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyTransit
-Version: 2.6.4
+Version: 2.6.5
 Summary: Fast and painless exoplanet transit light curve modelling.
 Author-email: Hannu Parviainen <hpparvi@gmail.com>
 License: GPLv2

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

@@ -1,6 +1,6 @@
 [project]
 name = "PyTransit"
-version = "2.6.4"
+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.4 → 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.4 → 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.4 → 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.4 → 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.4 → pytransit-2.6.5}/pytransit/models/roadrunner/model_trspec.py

@@ -93,8 +93,8 @@ def tsmodel_parallel(times: 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)
+    #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)")
@@ -115,7 +115,7 @@ def tsmodel_parallel(times: ndarray,
     ldm = zeros((npb, ng))         # Limb darkening means
     xyc = zeros((2, 5))            # Taylor series coefficients for the (x, y) position
 
-    for ipv in range(npv):
+    for ipv in prange(npv):
         if isnan(a[ipv]) or (a[ipv] <= 1.0) or (e[ipv] < 0.0):
             flux[ipv, :, :] = nan
             continue
@@ -133,8 +133,8 @@ def tsmodel_parallel(times: ndarray,
                 ldm[ipb, :] = (1.0 - ak) * dot(weights[ik], ldp[ipv, ipb, :]) + ak * dot(weights[ik + 1],
                                                                                          ldp[ipv, ipb, :])
         else:
-            dk, dg, wg = calculate_weights_2d(kmean, z_edges, ng)
-            for ipb in prange(npb):
+            _, dg, wg = calculate_weights_2d(kmean, z_edges, ng)
+            for ipb in range(npb):
                 ldm[ipb, :] = dot(wg, ldp[ipv, ipb, :])
 
         # -----------------------------------------------------#
@@ -151,19 +151,16 @@ def tsmodel_parallel(times: ndarray,
         # --------------------------#
         # Calculate the light curve #
         # --------------------------#
-        for ipt in prange(npt):
+        for ipt in range(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:
                 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]
-    set_num_threads(nthreads_current)
+                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

{pytransit-2.6.4 → pytransit-2.6.5}/pytransit/models/roadrunner/opmodel.py

@@ -41,6 +41,13 @@ __all__ = ['OblatePlanetModel']
 
 
 class OblatePlanetModel(RoadRunnerModel):
+    def __init__(self, ldmodel: Union[str, Callable, Tuple[Callable, Callable]] = 'quadratic',
+                 precompute_weights: bool = False, klims: tuple = (0.005, 0.5), nk: int = 256,
+                 nzin: int = 20, nzlimb: int = 20, zcut: float = 0.7, ng: int = 100, nlines: int = 100,
+                 nthreads: int = 1, small_planet_limit: float = 0.05, **kwargs):
+        super().__init__(ldmodel, precompute_weights, klims, nk, nzin, nzlimb, zcut, ng, nthreads, small_planet_limit, **kwargs)
+        self.nlines = nlines
+
     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],
@@ -97,7 +104,7 @@ class OblatePlanetModel(RoadRunnerModel):
                         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.nlc, self.npb, self.nep, self.nlines,
                        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)
 

{pytransit-2.6.4 → pytransit-2.6.5}/pytransit/models/roadrunner/tsmodel.py

@@ -28,6 +28,7 @@
 #  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 from typing import Union, List, Optional
 
+from numba import get_num_threads, set_num_threads
 from numpy import ndarray, isscalar, atleast_2d, atleast_1d, array
 from pytransit.models.roadrunner.common import calculate_weights_3d
 from scipy.integrate import trapz
@@ -84,6 +85,9 @@ class TransmissionSpectroscopyModel(RoadRunnerModel):
         t0, p, a, i, e, w = map(atleast_1d, (t0, p, a, i, e, w))
         npv = k.shape[0]
 
+        nthreads_cur = get_num_threads()
+        set_num_threads(self.nthreads)
+
         # Limb darkening
         # --------------
         ldc = array(ldc)
@@ -127,6 +131,7 @@ class TransmissionSpectroscopyModel(RoadRunnerModel):
             flux = tsmodel_serial(self.time, k, t0, p, a, i, e, w, self.nsamples, self.exptimes,
                                   ldp, istar, weights, dk, self.klims[0], self.klims[1], self.ng, dg, self.ze)
 
+        set_num_threads(nthreads_cur)
         return flux.squeeze()
 
     def __call__(self, k: Union[float, ndarray], ldc: Union[ndarray, List],