PyTransit 2.6.10__tar.gz → 2.6.11__tar.gz

{pytransit-2.6.10 → pytransit-2.6.11}/PKG-INFO

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

{pytransit-2.6.10 → pytransit-2.6.11}/PyTransit.egg-info/PKG-INFO

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

{pytransit-2.6.10 → pytransit-2.6.11}/pytransit/__init__.py

@@ -41,7 +41,7 @@ Date
 
 """
 
-__version__ = '2.6.10'
+__version__ = '2.6.11'
 
 # Generic
 # -------

{pytransit-2.6.10 → pytransit-2.6.11}/pytransit/lpf/logposteriorfunction.py

@@ -136,11 +136,12 @@ class LogPosteriorFunction:
 
     def optimize_global(self, niter=200, npop=50, population=None, pool=None, lnpost=None, vectorize=True,
                         label='Global optimisation', leave=False, plot_convergence: bool = True, use_tqdm: bool = True,
-                        plot_parameters: tuple = (0, 2, 3, 4)):
+                        plot_parameters: tuple = (0, 2, 3, 4), min_ptp: float = 1e-2):
 
         lnpost = lnpost or self.lnposterior
         if self.de is None:
-            self.de = DiffEvol(lnpost, clip(self.ps.bounds, -1, 1), npop, maximize=True, vectorize=vectorize, pool=pool)
+            self.de = DiffEvol(lnpost, clip(self.ps.bounds, -1, 1), npop, maximize=True, vectorize=vectorize,
+                               pool=pool, min_ptp=min_ptp)
             if population is None:
                 self.de._population[:, :] = self.create_pv_population(npop)
             else:
@@ -179,24 +180,28 @@ class LogPosteriorFunction:
             raise ValueError('The MCMC sampler is set to save the results, but the result directory is not set.')
 
         lnpost = lnpost or self.lnposterior
-        if self.sampler is None:
-            if population is not None:
-                pop0 = population
-            elif hasattr(self, '_local_minimization') and self._local_minimization is not None:
-                pop0 = multivariate_normal(self._local_minimization.x, diag(full(len(self.ps), 0.001 ** 2)), size=npop)
-            elif self.de is not None:
-                pop0 = self.de.population.copy()
+        if population is not None:
+            pop0 = population
+        else:
+            if self.sampler is None:
+                if hasattr(self, '_local_minimization') and self._local_minimization is not None:
+                    pop0 = multivariate_normal(self._local_minimization.x, diag(full(len(self.ps), 0.001 ** 2)), size=npop)
+                elif self.de is not None:
+                    pop0 = self.de.population.copy()
+                else:
+                    raise ValueError('Sample MCMC needs an initial population.')
             else:
-                raise ValueError('Sample MCMC needs an initial population.')
+                pop0 = self.sampler.chain[:, -1, :].copy()
+
+        if self.sampler is None:
             self.sampler = EnsembleSampler(pop0.shape[0], pop0.shape[1], lnpost, vectorize=vectorize, pool=pool)
-        else:
-            pop0 = self.sampler.chain[:, -1, :].copy()
 
         for i in tqdm(range(repeats), desc=label, disable=(not use_tqdm), leave=leave):
-            if reset or i > 0:
+            if (self.sampler is not None and reset) or i > 0:
                 self.sampler.reset()
-            for _ in tqdm(self.sampler.sample(pop0, iterations=niter, thin=thin), total=niter,
-                          desc='Run {:d}/{:d}'.format(i + 1, repeats), leave=False, disable=(not use_tqdm)):
+            for _ in tqdm(self.sampler.sample(pop0, iterations=niter, thin=thin, skip_initial_state_check=False),
+                          total=niter, desc='Run {:d}/{:d}'.format(i + 1, repeats), leave=False,
+                          disable=(not use_tqdm)):
                 pass
             if save:
                 self.save(self.result_dir)

{pytransit-2.6.10 → pytransit-2.6.11}/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.10 → pytransit-2.6.11}/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.10 → pytransit-2.6.11}/pytransit/models/gdmodel.py

@@ -227,9 +227,9 @@ class GravityDarkenedModel(TransitModel):
 
         # Plot the info
         # -------------
-        ax.text(0.025, 0.95, f"i$_\star$ = {degrees(istar):.1f}$^\circ$", transform=ax.transAxes)
-        ax.text(0.025, 0.90, f"i$_\mathrm{{p}}$ = {degrees(inc):.1f}$^\circ$", transform=ax.transAxes)
-        ax.text(1 - 0.025, 0.95, fr"$\alpha$ = {degrees(alpha):.1f}$^\circ$", transform=ax.transAxes, ha='right')
+        ax.text(0.025, 0.95, f"i$_\\star$ = {degrees(istar):.1f}$^\\circ$", transform=ax.transAxes)
+        ax.text(0.025, 0.90, f"i$_\\mathrm{{p}}$ = {degrees(inc):.1f}$^\\circ$", transform=ax.transAxes)
+        ax.text(1 - 0.025, 0.95, fr"$\\alpha$ = {degrees(alpha):.1f}$^\\circ$", transform=ax.transAxes, ha='right')
         ax.text(0.025, 0.05, f"f = {f:.1f}", transform=ax.transAxes)
 
         setp(ax, xlim=(-1.1, 1.1), ylim=(-1.1, 1.1), xticks=[], yticks=[])

{pytransit-2.6.10 → pytransit-2.6.11}/pytransit/models/ldtkldm.py

@@ -17,9 +17,8 @@
 from typing import Tuple, Optional, Union
 from pathlib import Path
 
+from numpy import ndarray, linspace, meshgrid, transpose, asarray, newaxis, errstate
 from numba import njit
-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
 from .numba.ldtkldm import trilinear_interpolation_set, integrate_profiles_set

{pytransit-2.6.10 → pytransit-2.6.11}/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.10 → pytransit-2.6.11}/pytransit/models/roadrunner/ecintersection.py

@@ -4,9 +4,93 @@ 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):
+def rotated_ellipse_bbox(a: float, f: float):
+    """
+    Parameters
+    ----------
+    a : float
+        The angle (in radians) by which the ellipse is rotated.
+    f : float
+        The eccentricity of the ellipse, with a value between 0 and 1.
+
+    Returns
+    -------
+    hw : float
+        The half-width of the bounding box of the rotated ellipse.
+    hh : float
+        The half-height of the bounding box of the rotated ellipse.
+
+    """
+    r1, r2 = 1.0, 1.0-f
+    ux = r1 * cos(a)
+    uy = r1 * sin(a)
+    vx = r2 * cos(a + pi/2)
+    vy = r2 * sin(a + pi/2)
+    hw = sqrt(ux*ux + vx*vx)
+    hh = sqrt(uy*uy + vy*vy)
+    return hw, hh
+
+@njit
+def rotated_ellipse_x(y: float, a: float, f: float) -> tuple[float, float]:
+    """Calculate the x coordinates for a rotated ellipse given the y coordinate and the flattening factor.
+
+    Parameters
+    ----------
+    y
+        The y-coordinate of the point on the ellipse.
+    a
+        The angle (in radians) of rotation for the ellipse.
+    f
+        The flattening parameter of the ellipse.
+
+    Returns
+    -------
+    tuple[float, float]
+        The ellipse x-coordinates for the given y coordinate.
+    """
+    ca, sa = cos(a), sin(a)
+    b = 1.0 - f
+    d = b**2*ca**2 - y**2*sa**4 - 2*y**2*sa**2*ca**2 - y**2*ca**4 + sa**2
+    if d >= 0.0:
+        xl = (y*(-sa*ca + sa*ca/b**2) - sqrt(d)/b) / (ca**2 + sa**2/b**2)
+        xr = (y*(-sa*ca + sa*ca/b**2) + sqrt(d)/b) / (ca**2 + sa**2/b**2)
+        return xl, xr
+    else:
+        return nan, nan
+
+
+@njit
+def rotated_ellipse_dxdy(y: float, a: float, f: float) -> tuple[float, float]:
+    """Calculate dx/dy for a rotated ellipse given the y coordinate and the flattening factor.
+
+    Parameters
+    ----------
+    y
+        The y-coordinate of the point on the ellipse.
+    a
+        The angle, in radians, of rotation of the ellipse.
+    f
+        The flattening parameter of the ellipse.
+
+    Returns
+    -------
+    tuple[float, float]
+        The ellipse derivatives (dx/dy) for the given y coordinate.
     """
-    Create the coordinates for a rotated ellipse.
+    ca, sa = cos(a), sin(a)
+    b = 1.0 - f
+    d = b**2*ca**2 - y**2*sa**4 - 2*y**2*sa**2*ca**2 - y**2*ca**4 + sa**2
+    if d >= 0.0:
+        dxl = (-sa*ca - (-y*sa**4 - 2*y*sa**2*ca**2 - y*ca**4)/(b*sqrt(d)) + sa*ca/b**2)/(ca**2 + sa**2/b**2)
+        dxr = (-sa*ca + (-y*sa**4 - 2*y*sa**2*ca**2 - y*ca**4)/(b*sqrt(d)) + sa*ca/b**2)/(ca**2 + sa**2/b**2)
+        return dxl, dxr
+    else:
+        return nan, nan
+
+
+@njit
+def create_ellipse(ny: int, k: float, f: float, a: float) -> (ndarray, ndarray):
+    """Create the coordinates for a rotated ellipse.
 
     Parameters
     ----------
@@ -54,8 +138,7 @@ def create_ellipse(ny: int, k: float, f: float, a: float) -> (ndarray, ndarray):
 
 @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.
+    """Calculate the intersection area between a rotated ellipse and a circle using a scanline fill approach.
 
    Parameters
     ----------

{pytransit-2.6.10 → pytransit-2.6.11}/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.10 → pytransit-2.6.11}/pytransit/utils/de.py

@@ -118,7 +118,7 @@ class DiffEvol(object):
     """
 
     def __init__(self, fun, bounds, npop, f=None, c=None, seed=None, maximize=False, vectorize=False, cbounds=(0.25, 1),
-                 fbounds=(0.25, 0.75), pool=None, min_ptp=1e-2, args=[], kwargs={}):
+                 fbounds=(0.25, 0.75), pool=None, min_ptp=0.01, args=[], kwargs={}):
         if seed is not None:
             rseed(seed)