exovetter 0.0.2__tar.gz → 0.0.4__tar.gz

{exovetter-0.0.2 → exovetter-0.0.4}/.github/workflows/ci_workflows.yml

@@ -10,14 +10,12 @@ on:
 
 jobs:
   pep_and_audit:
-    runs-on: ubuntu-16.04
+    runs-on: ubuntu-latest
     steps:
     - name: Checkout code
-      uses: actions/checkout@v2
-    - name: Fetch tags
-      run: git fetch --prune --unshallow --tags
+      uses: actions/checkout@v4
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v4
       with:
         python-version: '3.x'
     - name: Lint with pyflakes
@@ -36,38 +34,33 @@ jobs:
     #    python -m pip install --upgrade bandit
     #    bandit -r . -c .bandit.yaml
 
-  # Python 3.7 + Numpy 1.19 resulted in NaN results, so we downgrade Numpy.
   initial_tests:
-    runs-on: ubuntu-16.04
+    runs-on: ubuntu-latest
     steps:
     - name: Checkout code
-      uses: actions/checkout@v2
-    - name: Fetch tags
-      run: git fetch --prune --unshallow --tags
+      uses: actions/checkout@v4
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v4
       with:
-        python-version: '3.7'
+        python-version: '3.11'
     - name: Install and build
       run: |
         sudo apt-get install libxml2-utils
         python -m pip install --upgrade pip setuptools
-        python -m pip install 'numpy<1.19'
         python -m pip install -e .[test,all]
     - name: Test with stable deps and coverage
-      run: pytest --cov=./ --cov-report=xml --remote-data
+      run: pytest --remote-data
+#      run: pytest --cov=./ --cov-report=xml --remote-data
 #    - name: Coverage report
-#      uses: codecov/codecov-action@v2
+#      uses: codecov/codecov-action@v3
 
 #  dev_deps_tests:
 #    runs-on: ubuntu-latest
 #    steps:
 #    - name: Checkout code
-#      uses: actions/checkout@v2
-#    - name: Fetch tags
-#      run: git fetch --prune --unshallow --tags
+#      uses: actions/checkout@v4
 #    - name: Set up Python
-#      uses: actions/setup-python@v2
+#      uses: actions/setup-python@v4
 #      with:
 #        python-version: '3.x'
 #    - name: Install and build

exovetter-0.0.4/.readthedocs.yml

@@ -0,0 +1,30 @@
+# Read the Docs configuration file for Sphinx projects
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Set the OS, Python version and other tools you might need
+build:
+  os: ubuntu-22.04
+  apt_packages:
+    - graphviz
+  tools:
+    python: "3.11"
+
+# Build documentation in the "docs/" directory with Sphinx
+sphinx:
+  builder: html
+  configuration: docs/conf.py
+  fail_on_warning: true
+
+python:
+  install:
+    - method: pip
+      path: .
+      extra_requirements:
+        - docs
+        - all
+
+# Don't build any extra formats
+formats: []

{exovetter-0.0.2 → exovetter-0.0.4}/PKG-INFO

@@ -1,16 +1,29 @@
 Metadata-Version: 2.1
 Name: exovetter
-Version: 0.0.2
-Summary: Transiting Exoplanet Vetting Package for TESS and Kepler
+Version: 0.0.4
+Summary: Exoplanet vetting package
 Home-page: https://github.com/spacetelescope/exovetter
 Author: Susan Mullally et al.
 Author-email: smullally@stsci.edu
+License: BSD 3-Clause
 Requires-Python: >=3.7
 Description-Content-Type: text/x-rst
+License-File: LICENSE.rst
+Requires-Dist: numpy
+Requires-Dist: astropy>=3
+Requires-Dist: scipy
 Provides-Extra: all
+Requires-Dist: matplotlib; extra == "all"
+Requires-Dist: scikit-learn; extra == "all"
+Requires-Dist: lightkurve>=2; extra == "all"
+Requires-Dist: lpproj; extra == "all"
 Provides-Extra: test
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-remotedata; extra == "test"
+Requires-Dist: pytest-doctestplus; extra == "test"
 Provides-Extra: docs
-License-File: LICENSE.rst
+Requires-Dist: sphinx-astropy; extra == "docs"
+Requires-Dist: sphinx_rtd_theme; extra == "docs"
 
 exovetter: Exoplanet Vetting
 ============================

{exovetter-0.0.2 → exovetter-0.0.4}/docs/utils.rst

@@ -13,9 +13,6 @@ These provide low-level functionality for ``exovetter``.
 .. automodapi:: exovetter.model
     :no-inheritance-diagram:
 
-.. automodapi:: exovetter.lcutils
-    :no-inheritance-diagram:
-
 .. automodapi:: exovetter.lightkurve_utils
     :no-inheritance-diagram:
 

exovetter-0.0.4/exovetter/centroid/__init__.py

@@ -0,0 +1 @@
+

{exovetter-0.0.2 → exovetter-0.0.4}/exovetter/centroid/centroid.py

@@ -11,7 +11,8 @@ def compute_diff_image_centroids(
         cube, 
         period_days, 
         epoch, 
-        duration_days, 
+        duration_days,
+        remove_transits, 
         max_oot_shift_pix=1.5,
         plot=False
 ):
@@ -38,7 +39,9 @@ def compute_diff_image_centroids(
     epoch
         (float) Epoch of transit centre in the same time system as `time`.
     duration_days
-        (float) Duration of transit.
+        (float) Duration of transit. 
+    remove_transits
+        (list) List of 0 indexed transit integers to not calculate on.
     max_oot_shift_pix
         (float) Passed to `fastpsffit.fastGaussianPrfFit()
 
@@ -73,21 +76,30 @@ def compute_diff_image_centroids(
 
     figs = []
     centroids = []
+
     for i in range(len(transits)):
-        cin = transits[i]
-        cents, fig = measure_centroids(
-            cube, 
-            cin, 
-            max_oot_shift_pix=max_oot_shift_pix,
-            plot=plot
-        )
-        centroids.append(cents)
-        figs.append(fig)
+        if i not in remove_transits:
+            cin = transits[i]
+            cents, fig = measure_centroids(
+                cube, 
+                cin, 
+                max_oot_shift_pix=max_oot_shift_pix,
+                plot=plot
+            )
+
+            if plot == True:
+                fig.suptitle('Transit '+str(i))
+
+            centroids.append(cents)
+            figs.append(fig)
+            
     centroids = np.array(centroids)
-    return centroids, figs
+    all_transits = list(np.arange(len(transits)))
+    kept_transits = [x for x in all_transits if x not in remove_transits]
+    return centroids, figs, kept_transits
 
 
-def measure_centroid_shift(centroids, plot=False):
+def measure_centroid_shift(centroids, kept_transits, plot=False):
     """Measure the average offset of the DIC centroids from the OOT centroids.
 
     Inputs
@@ -95,6 +107,9 @@ def measure_centroid_shift(centroids, plot=False):
     centroids
         (2d np array) Output of :func:`compute_diff_image_centroids`
 
+    kept_transits
+        (list) List of 0 indexed transit integers to calculate on.
+
     Returns
     -----------
     offset
@@ -122,7 +137,7 @@ def measure_centroid_shift(centroids, plot=False):
 
     fig = None
     if plot:
-        fig = covar.diagnostic_plot(dcol, drow, flags)
+        fig = covar.diagnostic_plot(dcol, drow, kept_transits, flags)
     return offset_pix, signif, fig
 
 

{exovetter-0.0.2 → exovetter-0.0.4}/exovetter/centroid/covar.py

@@ -45,7 +45,7 @@ import numpy as np
 """
 
 
-def diagnostic_plot(x, y, flag=None):
+def diagnostic_plot(x, y, kept_transits, flag=None):
 
     if flag is None:
         flag = np.zeros(len(x))
@@ -57,7 +57,8 @@ def diagnostic_plot(x, y, flag=None):
     mu_y = np.mean(y[~idx])
     sma, smi = compute_eigen_vectors(x[~idx], y[~idx])
 
-    plt.clf()
+    # plt.clf()
+    plt.figure()
     plt.gcf().set_size_inches((10, 8))
     plt.plot(x, y, "ko", mec="w", label="Centroids", zorder=+5)
     if np.any(idx):
@@ -71,7 +72,8 @@ def diagnostic_plot(x, y, flag=None):
 
     # prob = compute_prob_of_points(x, y, sma, smi)
     for i in range(len(x)):
-        plt.text(x[i], y[i], " %i" % (i), zorder=+5)
+
+        plt.text(x[i], y[i], " %i" % (kept_transits[i]), zorder=+5)
 
     sigma_a = np.linalg.norm(sma)
     sigma_b = np.linalg.norm(smi)

exovetter-0.0.4/exovetter/leo.py

@@ -0,0 +1,227 @@
+import numpy as np
+
+def phasefold(t, per, epo):
+    # Phase will span -0.5 to 0.5, with transit centred at phase 0
+    phase = np.mod(t - epo, per) / per
+    phase[phase > 0.5] -= 1
+    return phase
+
+def weighted_mean(y, dy):
+    w = 1 / dy**2
+    mean = np.sum(w * y) / np.sum(w)
+    return mean
+
+def weighted_std(y, dy):
+    w = 1 / dy**2
+    N = len(w)
+    mean = np.sum(w * y) / np.sum(w)
+    std = np.sqrt(np.sum(w * (y - mean) ** 2) / ((N - 1) * np.sum(w) / N))
+    return std
+
+def weighted_err(y, dy):
+    w = 1 / dy**2
+    err = 1 / np.sqrt(np.sum(w))
+    return err
+
+class Leo:
+    def __init__(self, time, per, epo, dur, flux, flux_err, frac, max_chases_phase):
+        '''
+        Parameters
+        -----------
+        time : array
+            Array of times from lc
+
+        per : float
+            Orbital period in days
+
+        epo : float
+            Time of first transit in TESS BJD
+
+        dur : float
+            Transit duration in days
+
+        flux : array
+            Array of flux values from lc
+
+        flux_err : array
+            Array of flux error values from lc
+        
+        frac : float
+            fraction of SES for a transit which triggers the chases false alarm statistic (default 0.7)
+
+        max_chases_phase : float
+            maximum  to allow the chases search to run on (default 0.1)
+
+        Attributes
+        ------------
+        qtran : Transit duration divided by the period of the transit
+        phase : Array of phases for the time series spanning -0.5 to 0.5 with transit at 0
+        in_tran : Phases in transit
+        near_tran : Boolean of cadences within 1 transit duration
+        epochs : Number of transits accounting for gaps
+        tran_epochs : Epochs of the transits
+        N_transit : Length of tran_epochs
+        fit_tran : Cadences within 2 transit durations
+        zpt : Out-of-transit wieghted mean of the fluxes
+        dep : Depth of the transit based on the weighted mean of the in transit points
+        '''
+        self.time = time
+        self.per = per
+        self.epo = epo
+        self.dur = dur
+        self.flux = flux
+        self.flux_err = flux_err
+        self.qtran = dur / per
+        
+        # Phase spans -0.5 to 0.5 with transit at 0
+        self.phase = phasefold(time, per, epo)
+        # Cadences in-transit
+        self.in_tran = abs(self.phase) < 0.5 * self.qtran
+        # Cadences within 1 transit duration
+        self.near_tran = abs(self.phase) < self.qtran
+        # Actual number of transits accounting for gaps
+        self.epochs = np.round((time - epo) / per)
+
+        self.tran_epochs = np.unique(self.epochs[self.in_tran])
+        self.N_transit = len(self.tran_epochs)
+        # Cadences within 2 transit durations
+        self.fit_tran = abs(self.phase) < 2 * self.qtran # can change to a variable other than 2
+        # Number of transit datapoints
+        self.n_in = np.sum(self.in_tran)
+        
+        # Out-of-transit flux and transit depth
+        self.zpt = weighted_mean(self.flux[~self.near_tran], self.flux_err[~self.near_tran])
+        self.dep = self.zpt - weighted_mean(self.flux[self.in_tran], self.flux_err[self.in_tran])
+
+        self.frac = frac
+        self.max_chases_phase = max_chases_phase
+
+
+    def get_SES_MES(self):
+        N = len(self.time)
+        dep_SES = np.zeros(N)
+        n_SES = np.zeros(N)
+        dep_MES = np.zeros(N)
+        n_MES = np.zeros(N)
+        N_transit_MES = np.zeros(N)
+        bin_flux = np.zeros(N)
+        bin_flux_err = np.zeros(N)
+        phase = phasefold(self.time, self.per, self.epo)
+        phase[phase < 0] += 1
+        for i in np.arange(N):
+            # Get individual transit depth at this cadence, i.e. only use datapoints close in time
+            in_tran = abs(self.time - self.time[i]) < 0.5 * self.dur
+            n_SES[i] = np.sum(in_tran)
+            dep_SES[i] = self.zpt - weighted_mean(
+                self.flux[in_tran], self.flux_err[in_tran]
+            )
+            # Get overall transit depth at this cadence, i.e. use all datapoints close in phase
+            all_tran = (abs(phase - phase[i]) < 0.5 * self.qtran) | (
+                abs(phase - phase[i]) > 1 - 0.5 * self.qtran
+            )
+            n_MES[i] = np.sum(all_tran)
+            dep_MES[i] = self.zpt - weighted_mean(
+                self.flux[all_tran], self.flux_err[all_tran]
+            )
+            epochs = np.round((self.time - self.time[i]) / self.per)
+            tran_epochs = np.unique(epochs[all_tran])
+            N_transit_MES[i] = len(tran_epochs)
+            # Get running mean and uncertainty of out-of-transit fluxes, binned over transit timescale
+            in_bin = in_tran & ~self.near_tran
+            bin_flux[i] = weighted_mean(self.flux[in_bin], self.flux_err[in_bin])
+            bin_flux_err[i] = weighted_err(self.flux[in_bin], self.flux_err[in_bin]).value
+        # Estimate white and red noise following Hartman & Bakos (2016)
+        mask = ~np.isnan(bin_flux) & ~self.near_tran
+        std = weighted_std(self.flux[mask], self.flux_err[mask])
+        bin_std = weighted_std(bin_flux[mask], bin_flux_err[mask])
+        expected_bin_std = (
+            std
+            * np.sqrt(np.nanmean(bin_flux_err[mask] ** 2))
+            / np.sqrt(np.nanmean(self.flux_err[mask] ** 2))
+        ).value
+        self.sig_w = std
+        sig_r2 = bin_std**2 - expected_bin_std**2
+        self.sig_r = np.sqrt(sig_r2) if sig_r2 > 0 else 0
+        # Estimate signal-to-pink-noise following Pont et al. (2006)
+        self.err = np.sqrt(
+            (self.sig_w**2 / self.n_in) + (self.sig_r**2 / self.N_transit)
+        )
+        err_SES = np.sqrt((self.sig_w**2 / n_SES) + self.sig_r**2)
+        err_MES = np.sqrt((self.sig_w**2 / n_MES) + (self.sig_r**2 / N_transit_MES))
+        self.SES_series = dep_SES / err_SES
+        self.dep_series = dep_MES
+        self.err_series = err_MES
+        self.MES_series = dep_MES / err_MES
+        self.MES = self.dep / self.err
+        Fmin = np.nanmin(-self.dep_series)
+        Fmax = np.nanmax(-self.dep_series)
+        self.SHP = Fmax / (Fmax - Fmin)
+
+    def get_chases(self):
+        deps = np.zeros(self.N_transit)
+        errs = np.zeros(self.N_transit)
+        self.SES = np.zeros(self.N_transit)
+        self.rubble = np.zeros(self.N_transit)
+        self.chases = np.zeros(self.N_transit)
+        # self.redchi2 = np.zeros(self.N_transit)
+        # Search range for chases metric is between 1.5 durations and n times the period away
+        chases_tran = (abs(self.phase) > 1.5 * self.qtran) & (abs(self.phase) < self.max_chases_phase)
+    
+        # Get metrics for each transit event
+        for i in range(self.N_transit):
+            epoch = self.tran_epochs[i]
+            in_epoch = self.in_tran & (self.epochs == epoch)
+            # Compute the transit time, depth, and SES for this transit
+            transit_time = self.epo + self.per * epoch
+            n_in = np.sum(in_epoch)
+            dep = self.zpt - weighted_mean(self.flux[in_epoch], self.flux_err[in_epoch])
+            err = np.sqrt((self.sig_w**2 / n_in) + self.sig_r**2)
+            deps[i], errs[i] = dep, err
+            self.SES[i] = dep / err
+            # Find the most significant nearby event
+            chases_epoch = (chases_tran & (self.epochs == epoch) & (np.abs(self.SES_series) > self.frac * self.SES[i]))
+
+            if np.any(chases_epoch):
+                self.chases[i] = np.min(np.abs(self.time[chases_epoch] - transit_time)) / (
+                    self.max_chases_phase * self.per
+                )
+            else:
+                self.chases[i] = 1
+            # Find how much of the transit falls in gaps
+            fit_epoch = self.fit_tran & (self.epochs == epoch)
+            n_obs = np.sum(fit_epoch)
+            cadence = np.nanmedian(np.diff(self.time[fit_epoch]))
+            n_exp = 4 * self.dur / cadence # 4 is used because of the 2 transit duration on either side above in fit_tran
+            self.rubble[i] = n_obs / n_exp
+            # if ("transit_aic" in tlc.metrics) and ~np.isnan(tlc.metrics["transit_aic"]):
+            #     tm = TransitModel(
+            #         tlc.metrics["transit_per"],
+            #         tlc.metrics["transit_epo"],
+            #         tlc.metrics["transit_RpRs"],
+            #         tlc.metrics["transit_aRs"],
+            #         tlc.metrics["transit_b"],
+            #         tlc.metrics["transit_u1"],
+            #         tlc.metrics["transit_u2"],
+            #         tlc.metrics["transit_zpt"],
+            #     )
+            #     resid = tm.residual(
+            #         tm.params,
+            #         tlc.time[fit_epoch],
+            #         tlc.flux[fit_epoch],
+            #         tlc.flux_err[fit_epoch],
+            #     )
+            #     chi2 = np.sum(resid**2)
+            #     tlc.redchi2[i] = chi2 / (np.sum(fit_epoch) - 6)
+            # else:
+            #     tlc.redchi2[i] = np.nan
+        O = self.SES
+        E = self.dep / errs
+        chi2 = np.sum((O - E) ** 2 / E)
+        self.CHI = self.MES / np.sqrt(chi2 / (self.N_transit - 1))
+        self.med_chases = np.nanmedian(self.chases)
+        self.mean_chases = np.nanmean(self.chases)
+        self.max_SES = np.nanmax(self.SES)
+        self.DMM = np.nanmean(deps) / np.nanmedian(deps)
+
+    def plot (self):
+        print('Plotting not yet implemented')

{exovetter-0.0.2 → exovetter-0.0.4}/exovetter/lightkurve_utils.py

@@ -2,7 +2,7 @@
 
 import astropy
 
-__all__ = ['unpack_lk_version']
+__all__ = ['unpack_lk_version', 'unpack_tpf']
 
 
 def unpack_lk_version(lightcurve, flux_name):

{exovetter-0.0.2 → exovetter-0.0.4}/exovetter/lpp.py

@@ -325,7 +325,8 @@ def plot_lpp_diagnostic(data, target, norm_lpp):
     ax2.plot(flux, 'k.', ms=5, label=f"LPP Norm = {norm_lpp:5.3f}")
     ax2.set_xlabel('Bin Number')
     ax2.legend()
-
+    
+    fig.tight_layout()
     plt.draw()
 
     return fig

{exovetter-0.0.2 → exovetter-0.0.4}/exovetter/sweet.py

@@ -1,4 +1,4 @@
-"""Module ot handle SWEET vetter."""
+"""Module to handle SWEET vetter."""
 
 import os
 
@@ -63,7 +63,8 @@ def sweet(time, flux, period, epoch, duration, plot=False):
 
     if plot:
         import matplotlib.pyplot as plt
-        plt.clf()
+        #plt.clf() # swapped with a plt.figure below MD 2023
+        plt.figure(figsize=(7,7))
 
     out = []
     for i, per in enumerate([period * 0.5, period, 2 * period]):
@@ -77,9 +78,11 @@ def sweet(time, flux, period, epoch, duration, plot=False):
         if plot:
             srt = np.argsort(phase)
             plt.subplot(3, 1, i + 1)
-            plt.plot(phase, flux, 'ko')
+            plt.plot(phase, flux, 'ko', ms=2.5)
             plt.plot(phase[srt], f_obj.get_best_fit_model(phase[srt]), '-')
             plt.ylabel("P=%g" % (per))
+            if i==0:
+                plt.title('SWEET: Folded at 1/2, 1, and 2 times the period')
 
     result = np.array(out)
 

{exovetter-0.0.2 → exovetter-0.0.4}/exovetter/tce.py

@@ -130,9 +130,15 @@ class Tce(dict):
         """
         if 'epoch' not in self or 'epoch_offset' not in self:
             raise KeyError('epoch and epoch_offset must be defined first')
+
+        # Puts into bjd
         epoch = self["epoch"] - self["epoch_offset"]
+        
         if offset is not None:
+            # Transforms from bjd into desired time system
             epoch = epoch + offset
+            
+
         return epoch
 
     def validate(self):

{exovetter-0.0.2 → exovetter-0.0.4}/exovetter/trapezoid_fit.py

@@ -742,7 +742,8 @@ class TrapezoidFit:
 
         """
         import scipy.optimize as opt
-        from astropy.utils.compat.context import nullcontext
+        # from astropy.utils.compat.context import nullcontext # removed as depricated MD 2023
+        from contextlib import nullcontext # added instead of astropy's nullcontext ^
         from astropy.utils.misc import NumpyRNGContext
 
         if options is None: