exovetter 0.0.6__py3-none-any.whl → 0.0.8__py3-none-any.whl

exovetter/centroid/centroid.py

@@ -14,6 +14,7 @@ def compute_diff_image_centroids(
         duration_days,
         remove_transits, 
         max_oot_shift_pix=1.5,
+        starloc_pix = None,
         plot=False
 ):
     """Compute difference image centroid shifts for every transit in a dataset.
@@ -42,6 +43,9 @@ def compute_diff_image_centroids(
         (float) Duration of transit. 
     remove_transits
         (list) List of 0 indexed transit integers to not calculate on.
+    starloc_pix
+        (2d array) catalog location of target star for plotting.
+        Default is None.
     max_oot_shift_pix
         (float) Passed to `fastpsffit.fastGaussianPrfFit()
 
@@ -74,29 +78,30 @@ def compute_diff_image_centroids(
     transits = getIngressEgressCadences(
         time, period_days, epoch, duration_days)
 
-    figs = []
+    axs = []
     centroids = []
 
     for i in range(len(transits)):
         if i not in remove_transits:
             cin = transits[i]
-            cents, fig = measure_centroids(
+            cents, ax = measure_centroids(
                 cube, 
                 cin, 
                 max_oot_shift_pix=max_oot_shift_pix,
+                starloc_pix = starloc_pix,
                 plot=plot
             )
 
             if plot == True:
-                fig.suptitle('Transit '+str(i))
+                plt.gcf().suptitle('Transit '+str(i))
 
             centroids.append(cents)
-            figs.append(fig)
+            axs.append(ax)
             
     centroids = np.array(centroids)
     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
+    return centroids, axs, kept_transits
 
 
 def measure_centroid_shift(centroids, kept_transits, plot=False):
@@ -140,6 +145,51 @@ def measure_centroid_shift(centroids, kept_transits, plot=False):
         fig = covar.diagnostic_plot(dcol, drow, kept_transits, flags)
     return offset_pix, signif, fig
 
+def measure_centroid_shift_cat(centroids, kept_transits, starloc_pix, plot=False):
+    """Measure the average offset of the DIC centroids from the catalog position.
+
+    Inputs
+    ----------
+    centroids
+        (2d np array) Output of :func:`compute_diff_image_centroids`
+
+    kept_transits
+        (list) List of 0 indexed transit integers to calculate on.
+    
+    starloc_pix
+        (2d np array) col,row expected location of target star
+
+    Returns
+    -----------
+    offset
+        (float) Size of offset in pixels (or whatever unit `centroids`
+        is in)
+    signif
+        (float) The statistical significance of the transit. Values
+        close to 1 mean the transit is likely on the target star.
+        Values less than ~1e-3 suggest the target is not the
+        source of the transit.
+    fig
+        A figure handle. Is **None** if plot is **False**
+    """
+
+    # DIC - catalog
+    # dcol = centroids[:, 5] - centroids[:, 0]
+    # drow = centroids[:, 4] - centroids[:, 1]
+    dcol = centroids[:, 4] - starloc_pix[0]
+    drow = centroids[:, 5] - starloc_pix[1]
+
+    flags = centroids[:, -1].astype(bool)
+
+    offset_pix, signif = covar.compute_offset_and_signif(
+        dcol[~flags], drow[~flags])
+
+    fig = None
+    if plot:
+        fig = covar.diagnostic_plot(dcol, drow, kept_transits, flags)
+        
+    return offset_pix, signif, fig
+
 
 def getIngressEgressCadences(time, period_days, epoch_btjd, duration_days):
     assert np.all(np.isfinite(time))
@@ -151,7 +201,7 @@ def getIngressEgressCadences(time, period_days, epoch_btjd, duration_days):
     return transits
 
 
-def measure_centroids(cube, cin, max_oot_shift_pix=0.5, plot=False):
+def measure_centroids(cube, cin, max_oot_shift_pix=0.5, starloc_pix = None, plot=False):
     """Private function of :func:`compute_diff_image_centroids`
 
     Computes OOT, ITR and diff images for a single transit event,
@@ -209,17 +259,31 @@ def measure_centroids(cube, cin, max_oot_shift_pix=0.5, plot=False):
         if diffSoln.success:
             clr = "green"
 
+        fig = plt.gcf()
+        axlist = fig.axes 
+        #assert len(axlist) == 3, axlist
+
         res = diffSoln.x
-        disp.plotCentroidLocation(res[0], res[1], marker="^", color=clr,
-                                  label="diff")
+        for ax in axlist:
+            if ax.get_label() == '<colorbar>':
+                continue
+
+            plt.sca(ax)
+            disp.plotCentroidLocation(res[0], res[1], marker="^", color=clr,
+                                    label="diff")
 
-        res = ootSoln.x
-        disp.plotCentroidLocation(res[0], res[1], marker="o", color=clr,
-                                  label="OOT")
+            res1 = ootSoln.x
+            disp.plotCentroidLocation(res1[0], res1[1], marker="o", color=clr,
+                                    label="OOT")
 
-        res = intransSoln.x
-        disp.plotCentroidLocation(res[0], res[1], marker="+", color=clr,
-                                  label="InT")
+            res2 = intransSoln.x
+            disp.plotCentroidLocation(res2[0], res2[1], marker="+", color=clr,
+                                    label="InT")
+            
+            if starloc_pix is not None:
+                disp.plotCentroidLocation(starloc_pix[0], starloc_pix[1], marker="*",
+                                        color='red', label="Cat", ms=10)
+            
         plt.legend(fontsize=12, framealpha=0.7, facecolor='silver')
 
     out = []
@@ -236,7 +300,7 @@ def measure_centroids(cube, cin, max_oot_shift_pix=0.5, plot=False):
     return out, ax
 
 
-def generateDiffImg(cube, transits, plot=False):
+def generateDiffImg(cube, transits, starloc_pix = None, plot=False):
     """Generate a difference image.
 
     Also generates an image for each the $n$ cadedences before
@@ -249,6 +313,8 @@ def generateDiffImg(cube, transits, plot=False):
         (np 3 array) Datacube of postage stamps
     transits
         (2-tuples) Indices of the first and last cadence
+    starloc_pix
+        (np 2 element array) col, row position of star
 
     Optional Inputs
     -----------------
@@ -286,6 +352,7 @@ def generateDiffImg(cube, transits, plot=False):
         fig = plt.figure()
         fig.set_size_inches(16, 4)
         disp.plotTransit(fig, oot, during, diff)
+
     else:
         fig = None
 

exovetter/centroid/disp.py

@@ -8,15 +8,15 @@ import numpy as np
 
 def plotTransit(fig, oot, during, diff, **kwargs):
 
-    fig.add_subplot(131)
+    ax1 = fig.add_subplot(131)
     plotImage(oot, **kwargs)
     plt.title("OOT")
 
-    fig.add_subplot(132)
+    ax2 = fig.add_subplot(132)
     plotImage(during, **kwargs)
     plt.title("In-transit")
 
-    fig.add_subplot(133)
+    ax3 = fig.add_subplot(133)
     plotDiffImage(diff, **kwargs)
     plt.title("Difference")
 

exovetter/utils.py

@@ -2,12 +2,19 @@
 
 import sys
 import warnings
-
+from exovetter import lightkurve_utils
+from exovetter import utils
+from exovetter import const as exo_const
+import astropy.units as u
+from exovetter import vetters as vet
+from matplotlib.backends.backend_pdf import PdfPages
+import matplotlib.pyplot as plt
 import numpy as np
+import os
 
 __all__ = ['sine', 'estimate_scatter', 'mark_transit_cadences', 'median_detrend', 
            'plateau', 'set_median_flux_to_zero', 'set_median_flux_to_one', 'sigmaClip', 
-           'get_mast_tce', 'WqedLSF', 'compute_phases', 'first_epoch']
+           'get_mast_tce', 'WqedLSF', 'compute_phases', 'first_epoch', 'run_all']
 
 def sine(x, order, period=1):
     """Sine function for SWEET vetter."""
@@ -653,3 +660,164 @@ def first_epoch(epoch, period, lc):
         first_epoch = epoch + N*period
 
     return first_epoch
+
+def run_all(tce, lc, tpf=None, vetters=None, remove_metrics=None, plot=False, plot_dir=None):
+    """Run a set of vetters on a tce and lc, returning a dictionary of all metrics collected
+    
+    Parameters
+    ----------
+    tce : tce object
+        tce object is a dictionary that contains information about the tce
+        to vet, like period, epoch, duration, depth
+
+    lc : lightkurve object
+        lightkurve object with the time and flux to use for vetting.
+
+    tpf : obj
+        ``lightkurve`` target pixel file object with pixels in column lc_name
+
+    vetters : list
+        list of vetter objects to run on, ie [vet.ModShift(), vet.OddEven(dur_frac=0.75)]
+        Defaults to all vetters
+    
+    remove_metrics : list
+        metrics to not store, defaults to removing plotting values
+
+    plot : bool
+        Option to return a pdf of the vetting diagnostic plots, defaults to False
+
+    plot_dir : str
+        Path to store diagnostic pdfs in, defaults to current working directory
+
+    Returns
+    -------
+    results_dict : dictionary
+        Dictionary of the kept vetting metrics
+    """
+    
+    # Set initial parameters
+    if not vetters:
+        vetters = [vet.VizTransits(), vet.ModShift(), vet.Lpp(), vet.OddEven(), vet.TransitPhaseCoverage(), vet.Sweet(), vet.LeoTransitEvents(), vet.Centroid()]
+
+    if not remove_metrics:
+        remove_metrics = ['plot_data']
+
+    if not plot_dir:
+        plot_dir = os.getcwd()+'/'
+
+    if not tpf:
+        if any(vetter.__class__.__name__ == 'Centroid' for vetter in vetters):
+            raise Exception("TPF file required while running centroid")
+
+    # Run all listed vetters
+    results_list = []
+
+    if not plot:
+        for vetter in vetters:
+            if vetter.__class__.__name__ != 'Centroid':
+                vetter_results = vetter.run(tce, lc, plot=False) # dictionary returned from each vetter
+                results_list.append(vetter_results)
+            else:
+                vetter_results = vetter.run(tce, tpf, plot=False) # centroid uses tpf rather than lc
+                results_list.append(vetter_results)
+
+    else:
+        plot_name = lc.LABEL
+
+        diagnostic_plot = PdfPages(plot_dir+plot_name+'.pdf') # initialize a pdf to save each figure into
+        plot_figures = []
+        
+        # Manually run viz transits with an extra mark cadences plot
+        cadences_plot = mark_cadences_plot(lc, tce)
+        diagnostic_plot.savefig(cadences_plot)
+
+        for vetter in vetters:
+            if vetter.__class__.__name__ not in ['VizTransits', 'Centroid', 'LeoTransitEvents']: # viz_transits and Centroid generate more than one figures so handle later
+                vetter_results = vetter.run(tce, lc, plot=True) # dictionary returned from each vetter
+                plot_figures.append(plt.gcf())
+                plt.close() # Make them not show up if running in a notebook
+                results_list.append(vetter_results)
+
+            if vetter.__class__.__name__ == 'Centroid': # centroid produces 2 plots, the second of which is the most useful so just collect that one
+                vetter_results = vet.Centroid(lc_name=vetter.lc_name, diff_plots=False, centroid_plots=True).run(tce, tpf)
+                plot_figures.append(plt.gcf())
+                plt.close()
+                results_list.append(vetter_results)
+                
+        # run viz_transits plots
+        transit = vet.VizTransits(transit_plot=True, folded_plot=False).run(tce, lc)
+        transit_plot = plt.gcf()
+        transit_plot.suptitle(plot_name+' Transits')
+        transit_plot.tight_layout()
+        plt.close()
+        diagnostic_plot.savefig(transit_plot)
+
+        folded = vet.VizTransits(transit_plot=False, folded_plot=True).run(tce, lc)
+        folded_plot = plt.gcf()
+        folded_plot.suptitle(plot_name+' Folded Transits')
+        folded_plot.tight_layout()
+        plt.close()
+        diagnostic_plot.savefig(folded_plot)
+        
+        # Save each diagnostic plot stored in plot_figures to diagnostic_plot pdf file
+        for plot in plot_figures:
+            diagnostic_plot.savefig(plot)
+
+        diagnostic_plot.close()
+    
+    # Convert to a single dictionary output
+    results_dict = {k: v for d in results_list for k, v in d.items()} # Combine all dictionaries returned from vetters
+
+    # delete specified metrics
+    for key in remove_metrics:
+        if results_dict.get(key):
+            del results_dict[key]
+    
+    return results_dict
+
+
+def mark_cadences_plot(lc, tce):
+    """return figure object of the lightcurve with epochs oeverplotted"""
+    
+    fig, ax1 = plt.subplots(nrows=1, ncols=1, figsize=(9,5))
+
+    # Get lightcurve data
+    time, flux, time_offset_str = lightkurve_utils.unpack_lk_version(lc, "flux")  # noqa: E50
+    time_offset_q = getattr(exo_const, time_offset_str)
+    epoch = tce.get_epoch(time_offset_q).to_value(u.day)
+    
+    # Get points of lightcurve found to be in transit
+    period = tce["period"].to_value(u.day)
+    dur = tce["duration"].to_value(u.day)
+    intransit = mark_transit_cadences(time, period, epoch, dur)
+
+    # Plot epoch
+    ax1.axvline(x=epoch, lw='0.6', color='r', label='epoch', alpha=0.5)
+
+    # Plot transit train
+    ax1.plot(time, flux, lw=0.72, alpha=0.9)
+    ax1.scatter(time, flux, color='k', s=3, label='cadences', alpha=0.5)
+    
+    # TODO This only plots forward in time from the epoch, works fine assuming tce epoch is first in light curve but not robust
+    transit_epochs = epoch-dur/2
+    while transit_epochs <= time[-1]:
+        ax1.axvline(x=transit_epochs, lw='0.6', color='r', alpha=0.3, ls='--')
+        transit_epochs = transit_epochs+dur
+        ax1.axvline(x=transit_epochs, lw='0.6', color='r', alpha=0.3, ls='--')
+        transit_epochs = transit_epochs-dur + period
+        
+    # Plot cadences in transit
+    ax1.scatter(time[intransit], flux[intransit], color='r', s=4, label='cadences in transit');
+
+    # Plotting params
+    ax1.set_ylabel('Flux')
+    ax1.set_xlabel('Time '+time_offset_str)
+    ax1.set_title(lc.label+' period='+'{0:.2f}'.format(period)+'d, dur='+'{0:.2f}'.format(dur)+'d')
+    ax1.legend();
+
+    cadences_plot = plt.gcf()
+    plt.close()
+
+    return cadences_plot
+
+    

exovetter/version.py

@@ -5,4 +5,4 @@ try:
     from setuptools_scm import get_version
     version = get_version(root='..', relative_to=__file__)
 except Exception:
-    version = '0.0.6'
+    version = '0.0.8'

exovetter/vetters.py

@@ -6,10 +6,10 @@ from abc import ABC, abstractmethod
 import astropy.units as u
 import numpy as np
 import pandas as pd
-import time as py_time
+# import time as py_time
 import os
-import matplotlib.pyplot as plt
-from matplotlib.backends.backend_pdf import PdfPages
+# import matplotlib.pyplot as plt
+# from matplotlib.backends.backend_pdf import PdfPages
 
 from exovetter.centroid import centroid as cent
 from exovetter import transit_coverage
@@ -26,7 +26,7 @@ from exovetter import leo
 
 __all__ = ['BaseVetter', 'ModShift', 'Lpp', 'OddEven', 
            'TransitPhaseCoverage', 'Sweet', 'Centroid',
-           'VizTransits', 'LeoTransitEvents', 'run_all']
+           'VizTransits', 'LeoTransitEvents']
 
 class BaseVetter(ABC):
     """Base class for vetters.
@@ -585,13 +585,19 @@ class Sweet(BaseVetter):
 class Centroid(BaseVetter):
     """Class to handle centroid vetting"""
 
-    def __init__(self, lc_name="flux"):
+    def __init__(self, lc_name="flux", diff_plots=False, centroid_plots=False, starloc_pix=None):
         """
         Parameters
         ----------
         lc_name : str
             Name of the flux array in the ``lightkurve`` object.
 
+        diff_plots : bool
+            Show centroid difference plots
+
+        centroid_plots : bool
+            Show centroid summary plot
+
         Attributes
         ----------
         tce : tce object
@@ -608,6 +614,9 @@ class Centroid(BaseVetter):
         self.tce = None
         self.tpf = None
         self.metrics = None
+        self.diff_plots = diff_plots
+        self.centroid_plots = centroid_plots
+        self.starloc_pix = starloc_pix
 
     def run(self, tce, lk_tpf, plot=False, remove_transits=None):
         """Runs cent.compute_diff_image_centroids and cent.measure_centroid_shift
@@ -642,6 +651,10 @@ class Centroid(BaseVetter):
         self.tce = tce
         self.tpf = lk_tpf
 
+        if plot:
+            self.diff_plots = True
+            self.centroid_plots = True
+
         time, cube, time_offset_str = lightkurve_utils.unpack_tpf(
             self.tpf, self.lc_name
         )  # noqa: E50
@@ -653,12 +666,16 @@ class Centroid(BaseVetter):
 
         if remove_transits is None: # reformat to be a blank list
             remove_transits = []
-        
+    
         centroids, figs, kept_transits = cent.compute_diff_image_centroids(
             time, cube, period_days, epoch, duration_days, 
-            remove_transits, plot=plot)
+            remove_transits, starloc_pix=self.starloc_pix, plot=self.diff_plots)
         
-        offset, signif, fig = cent.measure_centroid_shift(centroids, kept_transits, plot)
+        if (self.starloc_pix is not None) and (len(self.starloc_pix) == 2):
+            offset, signif, fig = cent.measure_centroid_shift_cat(centroids, kept_transits, self.starloc_pix, self.centroid_plots)
+        else:
+            offset, signif, fig = cent.measure_centroid_shift(centroids, kept_transits, self.centroid_plots)
+
         figs.append(fig)
 
         # TODO: If plot=True, figs is a list of figure handles.
@@ -901,16 +918,14 @@ class LeoTransitEvents(BaseVetter):
     def plot(self):
         pass
 
-def run_all(tces, lcs, vetters=[VizTransits(), ModShift(), Lpp(), OddEven(), TransitPhaseCoverage(), Sweet(), LeoTransitEvents()], plot=False, verbose=False, plot_dir=None):
-    # TODO Add centroid, maybe rething plotting in general since plotting uses vetter.plot which essentially doubles runtime, 
-    # probably should run initially with vet.run(plot=True) and not store them unless run_all plot=True
-    """Runs vetters and packs results into a dataframe.
+def run_all(tce, lc, vetters=[VizTransits(), ModShift(), Lpp(), OddEven(), TransitPhaseCoverage(), Sweet(), LeoTransitEvents()], remove_metrics = ['plot_data'], plot=False, plot_dir='', plot_name=None ,verbose=False):
+    """Runs vetters on a tce and lc and packs results into a dictionary.
 
     Parameters
     ----------
-    tces: list of tce objects to vet on
+    tces: tce object to vet on
 
-    lc: list of lightkurve objects to vet on
+    lc: lightkurve object to vet on
     
     vetters : list
         List of vetter classes to run
@@ -918,126 +933,180 @@ def run_all(tces, lcs, vetters=[VizTransits(), ModShift(), Lpp(), OddEven(), Tra
     plot : bool
         Toggle diagnostic plots
     
-    plot_dir : str
-        path to store plots in, defaults to current working directory
-    
     verbose : bool
         Toggle timing info and other print statements
 
     Returns
     ------------
-    results : dataframe
-        Pandas dataframe of all the numerical results from the vetters
+    results : dictionary
+        Dictionary of all the numerical results from the vetters
           
     """
 
-    results_dicts = [] # initialize a list to pack results from each tce into
-    tce_names = []
-    run_start = py_time.time()
+    results = run_vetters.run_all(tce, lc, vetters, remove_metrics, plot, plot_dir, plot_name, verbose)
+
+    return results
+
+    # results_list = []
+
+    # if plot == False:
+    #     for vetter in vetters:
+    #         vetter_results = vetter.run(tce, lc, plot=False) # dictionary returned from each vetter
+    #         results_list.append(vetter_results)
+
+    # else:
+    #     
+    #     if plot_name is None:
+    #         plot_name = tce['target'] 
+    #     diagnostic_plot = PdfPages(plot_dir+plot_name+'.pdf') # initialize a pdf to save each figure into
+    #     plot_figures = []
+
+    #     for vetter in vetters:
+    #         vetter_results = vetter.run(tce, lc, plot=True)
+    #         plot_figures.append(plt.gcf())
+    #         plt.close()
+    #         results_list.append(vetter_results)
+
+    #     # Save each diagnostic plot ran on that tce/lc
+    #     for plot in plot_figures:
+    #         diagnostic_plot.savefig(plot)
+
+    #     diagnostic_plot.close()
+
+    # results_dict = {k: v for d in results_list for k, v in d.items()}
+
+    # # delete dictionary entries that are huge arrays to save space
+    # for key in remove_metrics:
+    #     if results_dict.get(key):
+    #         del results_dict[key]
+
+    # return results_dict
+        
+    # OLDER CODE
+        # if plot:
+        #     if vetter.__class__.__name__ != 'VizTransits' and vetter.__class__.__name__ != 'LeoTransitEvents': 
+        #         # viz_transits generates 2 figures so it's handled later, LeoTransitEvents just doesn't have a plot
+        #         vetter.plot()
+        #         vetter_plot = plt.gcf()
+        #         vetter_plot.suptitle(tce['target']+' '+vetter.__class__.__name__)
+        #         vetter_plot.tight_layout()
+        #         plt.close()
+        #         plot_figures.append(vetter_plot)
+
+        # if verbose:
+        #     time_end = py_time.time()
+        #     print(vetter.__class__.__name__, 'finished in', time_end - time_start, 's.')
+        
+        # results_list.append(vetter_results)
+    
+
+    # results_dicts = [] # initialize a list to pack results from each tce into
+    # tce_names = []
+    # run_start = py_time.time()
 
-    if plot_dir is None:
-        plot_dir = os.getcwd()
+    # if plot_dir is None:
+    #     plot_dir = os.getcwd()
     
-    if plot or verbose: 
-        for tce in tces:
-            if 'target' not in tce.keys():
-                print("ERROR: Please supply a 'target' key to all input tces to use the plot or verbose parameters")
-                return
-
-    for tce, lc in zip(tces, lcs):
-        if verbose:
-            print('Vetting', tce['target'], ':')
-
-        tce_names.append(tce['target'])
-        results_list = [] # initialize a list to pack result dictionaries into
+    # if plot or verbose: 
+    #     for tce in tces:
+    #         if 'target' not in tce.keys():
+    #             print("ERROR: Please supply a 'target' key to all input tces to use the plot or verbose parameters")
+    #             return
+
+    # for tce, lc in zip(tces, lcs):
+    #     if verbose:
+    #         print('Vetting', tce['target'], ':')
+
+    #     tce_names.append(tce['target'])
+    #     results_list = [] # initialize a list to pack result dictionaries into
         
-        # run each vetter, if plotting is true fill the figures into a list to save later
-        plot_figures = []
-        for vetter in vetters:
-            time_start = py_time.time()
-            vetter_results = vetter.run(tce, lc)
+    #     # run each vetter, if plotting is true fill the figures into a list to save later
+    #     plot_figures = []
+    #     for vetter in vetters:
+    #         time_start = py_time.time()
+    #         vetter_results = vetter.run(tce, lc)
             
-            if plot:
-                if vetter.__class__.__name__ != 'VizTransits' and vetter.__class__.__name__ != 'LeoTransitEvents': 
-                    # viz_transits generates 2 figures so it's handled later, LeoTransitEvents just doesn't have a plot
-                    vetter.plot()
-                    vetter_plot = plt.gcf()
-                    vetter_plot.suptitle(tce['target']+' '+vetter.__class__.__name__)
-                    vetter_plot.tight_layout()
-                    plt.close()
-                    plot_figures.append(vetter_plot)
-
-            if verbose:
-                time_end = py_time.time()
-                print(vetter.__class__.__name__, 'finished in', time_end - time_start, 's.')
+    #         if plot:
+    #             if vetter.__class__.__name__ != 'VizTransits' and vetter.__class__.__name__ != 'LeoTransitEvents': 
+    #                 # viz_transits generates 2 figures so it's handled later, LeoTransitEvents just doesn't have a plot
+    #                 vetter.plot()
+    #                 vetter_plot = plt.gcf()
+    #                 vetter_plot.suptitle(tce['target']+' '+vetter.__class__.__name__)
+    #                 vetter_plot.tight_layout()
+    #                 plt.close()
+    #                 plot_figures.append(vetter_plot)
+
+    #         if verbose:
+    #             time_end = py_time.time()
+    #             print(vetter.__class__.__name__, 'finished in', time_end - time_start, 's.')
             
-            results_list.append(vetter_results)
+    #         results_list.append(vetter_results)
         
-        if verbose: # add some whitespace for readability
-            print()
-
-        if plot: # save a pdf of each figure made for that vetter
-            diagnostic_plot = PdfPages(plot_dir+tce['target']+'.pdf') # initialize a pdf to save each figure into
-
-            # plot the lightcurve with epochs oeverplotted
-            time, flux, time_offset_str = lightkurve_utils.unpack_lk_version(lc, "flux")  # noqa: E50
-            period = tce["period"].to_value(u.day)
-            dur = tce["duration"].to_value(u.day)
-
-            time_offset_q = getattr(exo_const, time_offset_str)
-            epoch = tce.get_epoch(time_offset_q).to_value(u.day)
-            intransit = utils.mark_transit_cadences(time, period, epoch, dur, num_durations=3, flags=None)
-
-            fig, ax1 = plt.subplots(nrows=1, ncols=1, figsize=(9,5))
-            ax1.plot(time, flux, lw=0.4);
-            ax1.axvline(x=epoch, lw='0.6', color='r', label='epoch');
-            ax1.fill_between(time, 0,1, where=intransit, transform=ax1.get_xaxis_transform(), color='r', alpha=0.15, label='in transit')
-
-            ax1.set_ylabel('Flux')
-            ax1.set_xlabel('Time '+time_offset_str)
-            if 'target' in tce:
-                ax1.set_title(tce['target']);
-
-            ax1.legend();
-            lightcurve_plot = plt.gcf()
-            plt.close()
-            diagnostic_plot.savefig(lightcurve_plot)
-
-            # run viz_transits plots
-            transit = VizTransits(transit_plot=True, folded_plot=False).run(tce, lc)
-            transit_plot = plt.gcf()
-            transit_plot.suptitle(tce['target']+' Transits')
-            transit_plot.tight_layout()
-            plt.close()
-            diagnostic_plot.savefig(transit_plot)
-
-            folded = VizTransits(transit_plot=False, folded_plot=True).run(tce, lc)
-            folded_plot = plt.gcf()
-            folded_plot.suptitle(tce['target']+' Folded Transits')
-            folded_plot.tight_layout()
-            plt.close()
-            diagnostic_plot.savefig(folded_plot)
-
-            # Save each diagnostic plot ran on that tce/lc
-            for plot in plot_figures:
-                diagnostic_plot.savefig(plot)
-
-            diagnostic_plot.close()
+    #     if verbose: # add some whitespace for readability
+    #         print()
+
+    #     if plot: # save a pdf of each figure made for that vetter
+    #         diagnostic_plot = PdfPages(plot_dir+tce['target']+'.pdf') # initialize a pdf to save each figure into
+
+    #         # plot the lightcurve with epochs oeverplotted
+    #         time, flux, time_offset_str = lightkurve_utils.unpack_lk_version(lc, "flux")  # noqa: E50
+    #         period = tce["period"].to_value(u.day)
+    #         dur = tce["duration"].to_value(u.day)
+
+    #         time_offset_q = getattr(exo_const, time_offset_str)
+    #         epoch = tce.get_epoch(time_offset_q).to_value(u.day)
+    #         intransit = utils.mark_transit_cadences(time, period, epoch, dur, num_durations=3, flags=None)
+
+    #         fig, ax1 = plt.subplots(nrows=1, ncols=1, figsize=(9,5))
+    #         ax1.plot(time, flux, lw=0.4);
+    #         ax1.axvline(x=epoch, lw='0.6', color='r', label='epoch');
+    #         ax1.fill_between(time, 0,1, where=intransit, transform=ax1.get_xaxis_transform(), color='r', alpha=0.15, label='in transit')
+
+    #         ax1.set_ylabel('Flux')
+    #         ax1.set_xlabel('Time '+time_offset_str)
+    #         if 'target' in tce:
+    #             ax1.set_title(tce['target']);
+
+    #         ax1.legend();
+    #         lightcurve_plot = plt.gcf()
+    #         plt.close()
+    #         diagnostic_plot.savefig(lightcurve_plot)
+
+    #         # run viz_transits plots
+    #         transit = VizTransits(transit_plot=True, folded_plot=False).run(tce, lc)
+    #         transit_plot = plt.gcf()
+    #         transit_plot.suptitle(tce['target']+' Transits')
+    #         transit_plot.tight_layout()
+    #         plt.close()
+    #         diagnostic_plot.savefig(transit_plot)
+
+    #         folded = VizTransits(transit_plot=False, folded_plot=True).run(tce, lc)
+    #         folded_plot = plt.gcf()
+    #         folded_plot.suptitle(tce['target']+' Folded Transits')
+    #         folded_plot.tight_layout()
+    #         plt.close()
+    #         diagnostic_plot.savefig(folded_plot)
+
+    #         # Save each diagnostic plot ran on that tce/lc
+    #         for plot in plot_figures:
+    #             diagnostic_plot.savefig(plot)
+
+    #         diagnostic_plot.close()
         
-        # put all values from each results dictionary into a single dictionary
-        results_dict = {k: v for d in results_list for k, v in d.items()}
+    #     # put all values from each results dictionary into a single dictionary
+    #     results_dict = {k: v for d in results_list for k, v in d.items()}
         
-        # delete dictionary entries that are huge arrays to save space
-        if results_dict.get('plot_data'):
-            del results_dict['plot_data']
+    #     # delete dictionary entries that are huge arrays to save space
+    #     if results_dict.get('plot_data'):
+    #         del results_dict['plot_data']
         
-        # add the dictionary to the final list
-        results_dicts.append(results_dict)
+    #     # add the dictionary to the final list
+    #     results_dicts.append(results_dict)
 
-    results_df = pd.DataFrame(results_dicts) # Put the values from each result dictionary into a dataframe
+    # results_df = pd.DataFrame(results_dicts) # Put the values from each result dictionary into a dataframe
     
-    results_df.insert(loc=0, column='tce', value=tce_names)
-    if verbose:
-        print('Execution time:', (py_time.time() - run_start), 's')
+    # results_df.insert(loc=0, column='tce', value=tce_names)
+    # if verbose:
+    #     print('Execution time:', (py_time.time() - run_start), 's')
 
-    return results_df
+    # return results_df

{exovetter-0.0.6.dist-info → exovetter-0.0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: exovetter
-Version: 0.0.6
+Version: 0.0.8
 Summary: Exoplanet vetting package
 Home-page: https://github.com/spacetelescope/exovetter
 Author: Susan Mullally et al.

{exovetter-0.0.6.dist-info → exovetter-0.0.8.dist-info}/RECORD

@@ -9,20 +9,20 @@ exovetter/sweet.py,sha256=prbuteEaahFWhAoCtQCVP47SbA6h4pYJn1Wn9JkEalc,3066
 exovetter/tce.py,sha256=5JFKkbKoKCtdhm5EuW6FMAvp0LiaHLuqpFUbY0joyLI,7302
 exovetter/transit_coverage.py,sha256=Wix6TaQmEgRxlEZKB6WF3OFQVXqtJN1tBkltFaMDrHM,2194
 exovetter/trapezoid_fit.py,sha256=Dok-H0zRsfigh4zfVO4R6Wi2TgK6hQXh4EIIYGouxiQ,31097
-exovetter/utils.py,sha256=4HNRJkzgHI9XlRYvPSLZqJIQMG8ihX0UujSSTpiRTvU,18430
-exovetter/version.py,sha256=EnOl1cJ7hjy3aYox8oAzHbnkOWXlNbTHGaVr_NVNfR0,337
-exovetter/vetters.py,sha256=MRQjRR-PDXuPfGk5Z0DuW4muOpTsp6ygp47lGpnChZ8,35132
+exovetter/utils.py,sha256=1K34N6sQ7iomf4oFHyqGubcDhNwTa2lF_uKEOGJGrCk,24909
+exovetter/version.py,sha256=CNeb6A0ENE0jLt2wd0GA-qc99gr3KYBjtMQVwKtJGN0,337
+exovetter/vetters.py,sha256=muqjSzFRs5gCrOV1OAjnTd2y7y_dU9hWJfKpqUK_9RY,37732
 exovetter/viz_transits.py,sha256=FUc8DEedaQQ8YDoeVvR1QyGPmh2oPGmVg27W3WrVguQ,5648
 exovetter/centroid/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-exovetter/centroid/centroid.py,sha256=LWqjn-Oerdw5j2wDCFYqB6omE4K9gckIwAA0-WZvgkY,8655
+exovetter/centroid/centroid.py,sha256=tNT1ZEQqN1t1Sijn9hJYjGQYCnguVE9iJp2MlL-vWN8,10785
 exovetter/centroid/covar.py,sha256=suSgPjOVVEOclIi7rnhqc7wBbcSVsPOrdad91NXjX3Y,8973
-exovetter/centroid/disp.py,sha256=scVCRj16mNSqugHY28_uLt5bOkcdumIlJeFG3BXfldU,3674
+exovetter/centroid/disp.py,sha256=Y7UeecpHuhzEyNb6F6_FoureXdIttongS_L4jbdNYgE,3692
 exovetter/centroid/fastpsffit.py,sha256=eRMxYUJ_4hsCxso4u1d1zQvFSJQlJ_gRzhNa2PXkKuE,4532
 exovetter/modshift/__init__.py,sha256=j5665q0RHVzbzdPBXv_jUozGB4sex8ANXtzB41EYzRQ,68
 exovetter/modshift/modshift.py,sha256=VEnj7ITvYRfqICyRiNeCZ9tqQ4d4fPOw8avB6TTbhIU,14773
 exovetter/modshift/plotmodshift.py,sha256=MMLkvxkOqBGIYGPN97_WtrHgTZsDzY_XRRNswhz5YQI,2452
-exovetter-0.0.6.dist-info/LICENSE.rst,sha256=uhiFz7eEG8WszLtRtYIT89FNMI3ijy1aACnvl5BOz2Y,1492
-exovetter-0.0.6.dist-info/METADATA,sha256=ionvGOGowwq37EvLogal4vsPZ46y5oKK4SxQOEvgTW0,3706
-exovetter-0.0.6.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-exovetter-0.0.6.dist-info/top_level.txt,sha256=wh0_U5IPEspONX8zhGRaFUqfuovCGkgYjAmWuQe0w6Q,10
-exovetter-0.0.6.dist-info/RECORD,,
+exovetter-0.0.8.dist-info/LICENSE.rst,sha256=uhiFz7eEG8WszLtRtYIT89FNMI3ijy1aACnvl5BOz2Y,1492
+exovetter-0.0.8.dist-info/METADATA,sha256=rz9jh06oK8QeTWjgvsHYteiZRucjVbEsGnnQ7AUds7s,3706
+exovetter-0.0.8.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+exovetter-0.0.8.dist-info/top_level.txt,sha256=wh0_U5IPEspONX8zhGRaFUqfuovCGkgYjAmWuQe0w6Q,10
+exovetter-0.0.8.dist-info/RECORD,,

{exovetter-0.0.6.dist-info → exovetter-0.0.8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any