exovetter 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

exovetter/vetters.py

@@ -4,6 +4,7 @@ import pprint
 from abc import ABC, abstractmethod
 
 import astropy.units as u
+import numpy as np
 
 from exovetter.centroid import centroid as cent
 from exovetter import transit_coverage
@@ -17,10 +18,15 @@ from exovetter import utils
 from exovetter import const
 from exovetter import model
 from exovetter import viz_transits
+from exovetter import leo
 
+__all__ = ['BaseVetter', 'ModShift', 'Lpp', 'OddEven', 
+           'TransitPhaseCoverage', 'Sweet', 'Centroid',
+           'VizTransits', 'LeoVetter']
 
 class BaseVetter(ABC):
     """Base class for vetters.
+
     Each vetting test should be a subclass of this class.
 
     Parameters
@@ -37,7 +43,7 @@ class BaseVetter(ABC):
         self.metrics = None
 
     def name(self):
-        name = str(type(self)).split('.')[-1][:-2]
+        name = str(type(self)).split(".")[-1][:-2]
         return name
 
     def __str__(self):
@@ -87,15 +93,48 @@ class BaseVetter(ABC):
 class ModShift(BaseVetter):
     """Modshift vetter."""
 
-    def __init__(self, lc_name="flux", **kwargs):
+    def __init__(self, lc_name="flux"):
         """
         Parameters
         ----------
         lc_name : str
             Name of the flux array in the ``lightkurve`` object.
+
+         Attributes
+        ----------
+        time : array
+            Time values of the TCE, populated by :meth:`run`.
+
+        lc_name : str
+            Input ``lc_name``.
+
+        flux : array
+            Flux values of the TCE, populated by :meth:`run`.
+
+        period_days : float
+            period of the TCE in days, populated by :meth:`run`.
+
+        epoch_days : float
+            epoch of the TCE in days, populated by :meth:`run`.
+
+        duration_hrs : float
+            transit duration of the TCE in hours, populated by :meth:`run`.
+
+        box : astropy.units.Quantity object
+            Flux from boxcar model of the TCE, populated by :meth:`run`.
+
+        metrics : dict
+            modshift result dictionary populated by :meth:`run`.
         """
-        self.metrics = None
+
         self.lc_name = lc_name
+        self.time = None
+        self.flux = None
+        self.period_days = None
+        self.epoch_days = None
+        self.duration_hrs = None
+        self.box = None
+        self.metrics = None
 
     def run(self, tce, lightcurve, plot=False):
         """
@@ -107,12 +146,16 @@ class ModShift(BaseVetter):
             tce object is a dictionary that contains information about the tce
             to vet, like period, epoch, duration, depth
 
-        lc : lightkurve object
+        lightcurve : lightkurve object
             lightkurve object with the time and flux to use for vetting.
 
+        plot: bool
+            option to show plot when initialy populating the metrics.
+            Same as using the plot() method.
+
         Returns
         ------------
-        modshift : dict
+        metrics : dict
             modshift result dictionary containing the following:
                 pri : primary signal
                 sec : secondary signal
@@ -133,9 +176,8 @@ class ModShift(BaseVetter):
         self.epoch_days = tce.get_epoch(time_offset_q).to_value(u.day)
         self.duration_hrs = tce["duration"].to_value(u.hour)
 
-        self.box = model.create_box_model_for_tce(
-            tce, self.time * u.day, time_offset_q)
-        metrics, conv = modshift.compute_modshift_metrics(
+        self.box = model.create_box_model_for_tce(tce, self.time * u.day, time_offset_q)
+        self.metrics, conv = modshift.compute_modshift_metrics(
             self.time,
             self.flux,
             self.box,
@@ -145,9 +187,7 @@ class ModShift(BaseVetter):
             show_plot=plot,
         )
 
-        self.modshift = metrics
-
-        return self.modshift
+        return self.metrics
 
     def plot(self):
         met, c = modshift.compute_modshift_metrics(
@@ -162,8 +202,7 @@ class ModShift(BaseVetter):
 
 
 class Lpp(BaseVetter):
-    """Class to handle LPP Vetter functionality.
-    """
+    """LPP vetter."""
 
     def __init__(self, map_filename=None, lc_name="flux"):
         """
@@ -176,7 +215,6 @@ class Lpp(BaseVetter):
         lc_name : str
             Name of the flux array in the ``lightkurve`` object.
 
-
         Attributes
         ----------
         map_info : `~exovetter.lpp.Loadmap`
@@ -201,16 +239,44 @@ class Lpp(BaseVetter):
         plot_data : dict
             The folded, binned transit prior to the LPP transformation,
             populated by :meth:`run`.
+
+        metrics : dict
+            lpp result dictionary populated by :meth:`run`.
         """
-        self.map_info = lpp.Loadmap(filename=map_filename)
         self.lc_name = lc_name
+        self.map_info = lpp.Loadmap(filename=map_filename)
         self.tce = None
         self.lc = None
         self.norm_lpp = None
         self.raw_lpp = None
         self.plot_data = None
+        self.metrics = None
 
-    def run(self, tce, lightcurve, plot=False):
+    def run(self, tce, lightcurve, plot=False):  
+        """
+        Runs lpp.compute_lpp_Transitmetric to populate the vetter object.
+
+        Parameters
+        -----------
+        tce : tce object
+            tce object is a dictionary that contains information about the tce
+            to vet, like period, epoch, duration, depth
+
+        lightcurve : lightkurve object
+            lightkurve object with the time and flux to use for vetting.
+
+        plot: bool
+            option to show plot when initialy populating the metrics.
+            Same as using the plot() method.
+
+        Returns
+        ------------
+        metrics : dict
+            lpp result dictionary containing the following:
+                raw_lpp : Raw LPP value
+                norm_lpp : LPP value normalized by period and SNR
+                plot_data : The folded, binned transit prior to the LPP transformation
+        """
         self.tce = tce
         self.lc = lightcurve
 
@@ -220,16 +286,21 @@ class Lpp(BaseVetter):
             self.lpp_data, self.map_info
         )  # noqa: E501
 
-        return {
+        if plot:
+            target = self.tce.get("target_name", "Target")
+            lpp.plot_lpp_diagnostic(self.plot_data, target, self.norm_lpp)
+
+        self.metrics = {
             "raw_lpp": self.raw_lpp,
             "norm_lpp": self.norm_lpp,
             "plot_data": self.plot_data,
         }
 
+        return self.metrics
+
     def plot(self):  # pragma: no cover
         if self.plot_data is None:
-            raise ValueError(
-                "LPP plot data is empty. Execute self.run(...) first.")
+            raise ValueError("LPP plot data is empty. Execute self.run(...) first.")
 
         # target is populated in TCE, assume it already exists.
         target = self.tce.get("target_name", "Target")
@@ -237,30 +308,31 @@ class Lpp(BaseVetter):
 
 
 class OddEven(BaseVetter):
-    """Class to calculate whether the depth of the odd transits is
-    different than the depth of the even transits
-    """
+    """OddEven vetter"""
 
-    def __init__(self, lc_name="flux", dur_frac=0.3, plot=False):
+    def __init__(self, lc_name="flux", dur_frac=0.3):
         """
         Parameters
         ----------
         lc_name : str
-            Input ``lc_name``.
+            Name of the flux array in the ``lightkurve`` object.
 
         dur_frac:
             Fraction of in-transit duration to use for depth calculation.
 
         Attributes
         ------------
-        oe_sigma
-            significance of difference of odd/even depth measurements
-
         odd_depth : tuple
-            depth and error on depth of the odd transits
+            depth and error on depth of the odd transits, populated by :meth:`run`.
 
         even_depth : tuple
-            depth and error on depth of the even transits
+            depth and error on depth of the even transits, populated by :meth:`run`.
+
+        oe_sigma : astropy.utils.masked.core.MaskedNDArray
+            significance of difference of odd/even depth measurements, populated by :meth:`run`.
+
+        metrics : dict
+            modshift result dictionary populated by :meth:`run`.
         """
 
         self.lc_name = lc_name
@@ -268,20 +340,34 @@ class OddEven(BaseVetter):
         self.odd_depth = None
         self.even_depth = None
         self.oe_sigma = None
+        self.metrics = None
 
-    def run(self, tce, lightcurve):
+    def run(self, tce, lightcurve, plot=False):
         """
+        Runs odd_even.calc_odd_even to populate the vetter object.
+
         Parameters
         ----------
-        tce : `~exovetter.tce.Tce`
-            TCE.
+        tce : tce object
+            tce object is a dictionary that contains information about the tce
+            to vet, like period, epoch, duration, depth
 
-        lightcurve : obj
-            ``lightkurve`` object that contains the detrended lightcurve's
-            time and flux arrays.
+        lightcurve : lightkurve object
+            lightkurve object with the time and flux to use for vetting.
 
+        plot: bool
+            option to show plot when initialy populating the metrics.
+            Same as using the plot() method.
 
+        Returns
+        ------------
+        metrics : dict
+            odd_even result dictionary containing the following:
+                oe_sigma : significance of difference of odd/even depth measurements
+                odd_depth : depth and error on depth of the odd transits
+                even_depth : depth and error on depth of the even transits
         """
+
         self.time, self.flux, time_offset_str = lightkurve_utils.unpack_lk_version(  # noqa
             lightcurve, self.lc_name
         )
@@ -302,9 +388,24 @@ class OddEven(BaseVetter):
             dur_frac=self.dur_frac,
         )
 
-        return {'oe_sigma': self.oe_sigma,
-                'odd_depth': self.odd_depth,
-                'even_depth': self.even_depth}
+        self.metrics = {
+            "oe_sigma": self.oe_sigma,
+            "odd_depth": self.odd_depth,
+            "even_depth": self.even_depth,
+        }
+
+        if plot:
+            odd_even.diagnostic_plot(
+                self.time,
+                self.flux,
+                self.period,
+                self.epoch,
+                self.duration * self.dur_frac,
+                self.odd_depth,
+                self.even_depth,
+            )
+
+        return self.metrics
 
     def plot(self):  # pragma: no cover
         odd_even.diagnostic_plot(
@@ -319,48 +420,62 @@ class OddEven(BaseVetter):
 
 
 class TransitPhaseCoverage(BaseVetter):
-    """Transit Phase Coverage Vetter
-    """
+    """Transit Phase Coverage Vetter"""
 
     def __init__(self, lc_name="flux", nbins=10, ndur=2):
         """
         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 of the data to use for vetting.
+        lc_name : str
+            Name of the flux array in the ``lightkurve`` object.
 
         nbins : integer
-        number bins to divide-up the in transit points. default is 10, giving
-        an accuracy of 0.1.
+            number bins to divide-up the in transit points. default is 10, giving
+            an accuracy of 0.1.
 
         ndur : float
-        the code considers a phase that cover ndur * transit_duration as
-        "in transit"
+            the code considers a phase that cover ndur * transit_duration as
+            "in transit". Default is 2
+
+        Attributes
+        ------------
+        hist : array
+            histogram of the times of length nbins, populated by :meth:`run`.
+
+        bins : array
+            corners of the bins for the histogram, length of nbins+1,
+            populated by :meth:`run`.
 
+        metrics : dict
+            TransitPhaseCoverage result dictionary populated by :meth:`run`.
         """
         self.lc_name = lc_name
         self.nbins = nbins
         self.ndur = ndur
+        self.hist = None
+        self.bins = None
+        self.metrics = None
 
-    def run(self, tce, lc, plot=False):
-        """Run the vetter on the specified Threshold Crossing Event (TCE)
-        and lightcurve to obtain metric.
+    def run(self, tce, lightcurve, plot=False):
+        """Runs transit_coverage.calc_coverage to populate the vetter object.
 
         Parameters
         ----------
-        tce : `~exovetter.tce.Tce`
-            TCE.
+        tce : tce object
+            tce object is a dictionary that contains information about the tce
+            to vet, like period, epoch, duration, depth.
 
-        lc : obj
-            ``lightkurve`` object that contains the detrended lightcurve's
-            time and flux arrays to use for vetting.
+        lightcurve : lightkurve object
+            lightkurve object with the time and flux of the data to use for vetting.
+
+        Returns
+        ------------
+        metrics : dict
+            transit_coverage result dictionary containing the following:
+                transit_phase_coverage : Fraction of coverage
         """
         time, flux, time_offset_str = lightkurve_utils.unpack_lk_version(
-            lc, self.lc_name
+            lightcurve, self.lc_name
         )  # noqa: E50
 
         p_day = tce["period"].to_value(u.day)
@@ -372,23 +487,27 @@ class TransitPhaseCoverage(BaseVetter):
         tp_cover, self.hist, self.bins = transit_coverage.calc_coverage(
             time, p_day, epoch, dur_hour, ndur=self.ndur, nbins=self.nbins)
 
+        self.metrics = {"transit_phase_coverage": tp_cover}
+
         if plot:
             transit_coverage.plot_coverage(self.hist, self.bins)
 
-        return {'transit_phase_coverage': tp_cover}
+        return self.metrics
 
     def plot(self):  # pragma: no cover
         transit_coverage.plot_coverage(self.hist, self.bins)
 
 
 class Sweet(BaseVetter):
-    """Class to handle SWEET Vetter functionality.
-    """
+    """SWEET Vetter"""
 
     def __init__(self, lc_name="flux", threshold_sigma=3):
         """
         Parameters
         ----------
+        lc_name : str
+            Name of the flux array in the ``lightkurve`` object.
+
         threshold_sigma : float
             Threshold for comparing signal to transit period.
 
@@ -396,27 +515,46 @@ class Sweet(BaseVetter):
         ----------
         tce : tce object
             tce object is a dictionary that contains information about the tce
-            to vet, like period, epoch, duration, depth
+            to vet, like period, epoch, duration, depth.
 
         lc : lightkurve object
-        lightkurve object with the time and flux of the data to use for vetting.
-
-        result : dict
-            ``'amp'`` contains the best fit amplitude, its uncertainty, and
-            amplitude-to-uncertainty ratio for half-period, period, and
-            twice the period. ``'msg'`` contains warnings, if applicable.
-            Populated by :meth:`run`.
+            lightkurve object with the time and flux of the data to use for vetting.
 
-        lsf : `~exovetter.utils.WqedLSF`
-            Least squares fit object, populated by :meth:`run`.
+        metrics : dict
+            SWEET result dictionary populated by :meth:`run`.
         """
+
+        self.lc_name = lc_name
+        self.sweet_threshold_sigma = threshold_sigma
         self.tce = None
         self.lc = None
-        self.result = None
-        self.sweet_threshold_sigma = threshold_sigma
-        self.lc_name = lc_name
+        self.metrics = None
 
     def run(self, tce, lightcurve, plot=False):
+        """Runs sweet.sweet and sweet.construct_message to populate the vetter object.
+
+        Parameters
+        ----------
+        tce : tce object
+            tce object is a dictionary that contains information about the tce
+            to vet, like period, epoch, duration, depth.
+
+        lightcurve : lightkurve object
+            lightkurve object with the time and flux of the data to use for vetting.
+
+        plot: bool
+            option to show plot when initialy populating the metrics.
+            Same as using the plot() method.
+
+        Returns
+        ------------
+        metrics : dict
+            ``'msg'`` contains warnings, if applicable.
+            ``'amp'`` contains the best fit amplitude, its uncertainty, and
+            amplitude-to-uncertainty ratio for half-period, period, and
+            twice the period.
+
+        """
         self.tce = tce
         self.lc = lightcurve
 
@@ -432,47 +570,70 @@ class Sweet(BaseVetter):
         result_dict = sweet.sweet(
             time, flux, period_days, epoch, duration_days, plot=plot
         )
-        result_dict = sweet.construct_message(
-            result_dict, self.sweet_threshold_sigma)
-        return result_dict
+        self.metrics = sweet.construct_message(result_dict, self.sweet_threshold_sigma)
+
+        return self.metrics
 
     def plot(self):  # pragma: no cover
         self.run(self.tce, self.lc, plot=True)
 
 
 class Centroid(BaseVetter):
-    """Class to handle centroid vetting
+    """Class to handle centroid vetting"""
 
-    Parameters
-    ----------
-    lc_name : str
-        Name of the flux array in the ``lightkurve`` object.
+    def __init__(self, lc_name="flux"):
+        """
+        Parameters
+        ----------
+        lc_name : str
+            Name of the flux array in the ``lightkurve`` object.
 
-    threshold_sigma : float
-        Threshold for comparing signal to transit period.
+        Attributes
+        ----------
+        tce : tce object
+            tce object is a dictionary that contains information about the tce
+            to vet, like period, epoch, duration, depth.
 
-    Attributes
-    ----------
-    tce : `~exovetter.tce.Tce`
-        TCE object, a dictionary that contains information about the TCE
-        to vet, like period, epoch, duration, depth.
+        tpf : obj
+            ``lightkurve`` target pixel file object with pixels in column lc_name
 
-    lk_tpf: obj
-        ``lightkurve`` target pixel file object with pixels in column lc_name
+        metrics : dict
+            Centroid result dictionary populated by :meth:`run`."""
 
-    sweet : dict
-        ``'amp'`` contains the best fit amplitude, its uncertainty, and
-        amplitude-to-uncertainty ratio for half-period, period, and
-        twice the period. ``'msg'`` contains warnings, if applicable.
-        They are populated by running the :meth:`run` method.
+        self.lc_name = lc_name
+        self.tce = None
+        self.tpf = None
+        self.metrics = None
 
-    """
+    def run(self, tce, lk_tpf, plot=False, remove_transits=None):
+        """Runs ent.compute_diff_image_centroids and cent.measure_centroid_shift
+        to populate the vetter object.
 
-    def __init__(self, lc_name="flux"):
-        self.tce = None
-        self.lc_name = lc_name
+        Parameters
+        ----------
+        tce : tce object
+            tce object is a dictionary that contains information about the tce
+            to vet, like period, epoch, duration, depth.
+
+        lk_tpf: obj
+            ``lightkurve`` target pixel file object with pixels in column lc_name
 
-    def run(self, tce, lk_tpf, plot=False):
+        plot : bool
+            option to show plot when initialy populating the metrics.
+            Same as using the plot() method.
+
+        remove_transits : list
+            List of 0 indexed transit integers to not calculate on.
+
+        Returns
+        ------------
+        metrics : dict
+            centroid result dictionary containing the following:
+                offset : (float) Size of offset in pixels (or whatever unit centroids is in)
+                significance : (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.
+        """
 
         self.tce = tce
         self.tpf = lk_tpf
@@ -486,18 +647,22 @@ class Centroid(BaseVetter):
         epoch = tce.get_epoch(time_offset_q).to_value(u.day)
         duration_days = tce["duration"].to_value(u.day)
 
-        centroids, figs = cent.compute_diff_image_centroids(
-            time, cube, period_days, epoch, duration_days, plot=plot
-        )
-        offset, signif, fig = cent.measure_centroid_shift(centroids, plot)
+        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)
+        
+        offset, signif, fig = cent.measure_centroid_shift(centroids, kept_transits, plot)
         figs.append(fig)
 
         # TODO: If plot=True, figs is a list of figure handles.
         # Do I save those figures, put them in a single pdf,
         # close them all?
 
-        out = dict(offset=offset, significance=signif)
-        return out
+        self.metrics = dict(offset=offset, significance=signif)
+        return self.metrics
 
     def plot(self):  # pragma: no cover
         self.run(self.tce, self.tpf, plot=True)
@@ -509,15 +674,80 @@ class VizTransits(BaseVetter):
     with a folded transit.
     """
 
-    def __init__(self, lc_name="flux", max_transits=10, transit_only=False,
-                 smooth=10,):
-        self.tce = None
+    def __init__(self, lc_name="flux", max_transits=10, transit_only=False, 
+                 smooth=10, transit_plot=False, folded_plot=False):
+        """
+        Parameters
+        ----------
+        lc_name : str
+            Name of the flux array in the ``lightkurve`` object.
+
+        max_transits : bool
+            Total number of transits to plot.
+
+        transit_only : bool
+            Zoom in on the transit
+
+        smooth : type
+            description
+
+        transit_plot : bool
+            Whether or not to show the transit plot
+
+        folded_plot : book
+            Wheter or not to show the folded plot
+
+         Attributes
+        ----------
+        tce : tce object
+            tce object is a dictionary that contains information about the tce
+            to vet, like period, epoch, duration, depth.
+
+        metrics : dict
+            VizTransits result dictionary populated by :meth:`run`.
+        """
+
         self.lc_name = lc_name
         self.max_transits = max_transits
         self.transit_only = transit_only
+        self.transit_plot = transit_plot
+        self.folded_plot = folded_plot
         self.smooth = smooth
+        self.tce = None
+        self.metrics = None
+        self.lc = None
 
     def run(self, tce, lightcurve, plot=False):
+        """Runs viz_transits.plot_all_transits to populate the vetter object.
+
+        Parameters
+        ----------
+        tce : tce object
+            tce object is a dictionary that contains information about the tce
+            to vet, like period, epoch, duration, depth.
+
+        lightcurve : lightkurve object
+            lightkurve object with the time and flux of the data to use for vetting.
+
+        plot: bool
+            option to show folded and unfolded plot. If true both will show.
+
+        Returns
+        ------------
+        metrics : dict
+            centroid result dictionary containing the following:
+                num_transits : Number of transits with data in transit (3*duration).
+        """
+
+        if plot == True:
+            run_transit_plot = True
+            run_folded_plot = True
+        else:
+            run_transit_plot = self.transit_plot
+            run_folded_plot = self.folded_plot
+
+        self.tce = tce
+        self.lc = lightcurve
 
         time, flux, time_offset_str = lightkurve_utils.unpack_lk_version(
             lightcurve, self.lc_name)  # noqa: E50
@@ -526,25 +756,200 @@ class VizTransits(BaseVetter):
         time_offset_q = getattr(exo_const, time_offset_str)
         epoch = tce.get_epoch(time_offset_q).to_value(u.day)
         duration_days = tce["duration"].to_value(u.day)
-        depth = tce['depth']
+        depth = tce["depth"]
 
         n_has_data = viz_transits.plot_all_transits(time, flux, period_days,
                                                     epoch,
                                                     duration_days,
                                                     depth, max_transits=self.max_transits,
                                                     transit_only=self.transit_only,
-                                                    plot=plot, units="d")
+                                                    plot=run_transit_plot, units="d")
 
         viz_transits.plot_fold_transit(time, flux, period_days,
                                        epoch, depth, duration_days,
                                        smooth=self.smooth,
                                        transit_only=self.transit_only,
-                                       plot=plot, units="d")
+                                       plot=run_folded_plot, units="d")
 
-        return {'num_transits': n_has_data}
+        self.metrics = {"num_transits": n_has_data}
 
-    def plot(self, tce, lightcurve):
+        return self.metrics
+
+    def plot(self):  # pragma: no cover
+        # This will always show both. If you want one or the other do run with whichever one initialized
+        self.run(self.tce, self.lc, plot=True)
+    
+    # def plot(self, tce, lightcurve): # old plot method
+
+    #     _ = self.run(tce, lightcurve, max_transits=self.max_transits,
+    #                  transit_only=self.transit_only, smooth=self.smooth,
+    #                  plot=True)
+
+class LeoVetter(BaseVetter):
+    """Leo based vetter (see https://github.com/mkunimoto/LEO-vetter)"""
+
+    def __init__(self, lc_name="flux", flux_err=None, frac=0.7, max_chases_phase=0.1):
+        """
+        Parameters
+        ----------
+        lc_name : str
+            Name of the flux array in the ``lightkurve`` object.
+
+        flux_err : string
+            If none provided, defaults to flux_err column of lightkurve. LeoVetter requires realistic flux errors to give meaningful results.
+
+        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
+        ----------
+        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 of the data to use for vetting.
+
+        metrics : dict
+            LeoVetter result dictionary populated by :meth:`run`.
+        """
+
+        self.tce = None
+        self.lc_name = lc_name
+        self.flux_err= flux_err
+        self.frac= frac
+        self.max_chases_phase = max_chases_phase
+        self.metrics = None
+
+    def run(self, tce, lightcurve, plot=False):
+        """
+        Runs leo vetters to populate the vetter object.
 
-        _ = self.run(tce, lightcurve, max_transits=self.max_transits,
-                     transit_only=self.transit_only, smooth=self.smooth,
-                     plot=True)
+        Parameters
+        ----------
+        tce : tce object
+            Dictionary that contains information about the tce
+            to vet, like period, epoch, duration, depth
+
+        lightcurve : lightkurve object
+            lightkurve object with the time and flux to use for vetting.
+
+        plot: bool
+            Option to show plot when initialy populating the metrics.
+            Same as using the plot() method.
+
+        Attributes
+        ----------
+        MES_series : dep_series/err_series 
+        N_transit : Number of transits
+        SES : Single Event Statistic
+        SES_series : Single Event Statistic series for every timestamp
+        chases : range for chases metric is between 1.5 transit durations and user specified max_chases_phase
+        err_series : Error of MES
+        rubble : rubble statistic
+        sig_w : White noise following Hartman & Bakos (2016)
+        sig_r : Red noise following Hartman & Bakos (2016)
+        err : Signal-to-pink-noise following Pont et al. (2006)
+        MES : Multiple Event Statistic calculated from mean depth of in transit points
+        SHP : MES shape metric
+        CHI :
+        med_chases : median of chases
+        mean_chases : mean of chases
+        max_SES : maximum of SES 
+        DMM : 
+
+        Returns
+        ------------
+        metrics : dict
+            Result dictionary containing sig_w, sig_r, err, 
+            MES, SHP, CHI, med_chases, mean_chases, max_SES, DMM  
+        """
+
+        self.time, self.flux, time_offset_str = lightkurve_utils.unpack_lk_version(  # noqa
+            lightcurve, self.lc_name
+        )
+
+        self.period = tce["period"].to_value(u.day)
+        self.duration = tce["duration"].to_value(u.day)
+        time_offset_q = getattr(exo_const, time_offset_str)
+        self.epoch = tce.get_epoch(time_offset_q).to_value(u.day)
+
+        # epo needs to be the time of first transit in TESS BJD 
+        # (above converted to BTJD but here check it is actually at the beggining of the time series)
+        if self.epoch >= self.time[0]:
+            N = np.floor((self.epoch-self.time[0])/self.period)
+            self.epo = self.epoch - N*self.period
+        else:
+            N = np.ceil((self.time[0]-self.epoch)/self.period)
+            self.epo = self.epoch + N*self.period
+        
+        # create flux_err array defaulted to flux_err col of lc
+        if self.flux_err is None:
+            print("No flux error given, defaulting to 'flux_err' column of light curve")
+            self.flux_err = lightcurve['flux_err']
+        else:
+            self.flux_err = lightcurve[self.flux_err]
+
+        # get initial values needed to run transit_event vetter
+        leo_vetter = leo.Leo(self.time, self.period, self.epo, self.duration, self.flux, self.flux_err, self.frac, self.max_chases_phase)
+
+        # calculate SES
+        leo_vetter.get_SES_MES()
+
+        # calculated rubble, chases, etc
+        leo_vetter.get_chases()
+
+        # All available attributes (removed some which aren't very useful)
+        self.MES_series = leo_vetter.MES_series 
+        self.N_transit = leo_vetter.N_transit 
+        self.SES = leo_vetter.SES 
+        self.SES_series = leo_vetter.SES_series 
+        self.chases = leo_vetter.chases 
+        #self.dep = leo_vetter.dep 
+        #self.dep_series = leo_vetter.dep_series 
+        #self.epochs = leo_vetter.epochs 
+        self.err_series = leo_vetter.err_series 
+        #self.fit_tran = leo_vetter.fit_tran 
+        #self.in_tran = leo_vetter.in_tran
+        #self.n_in =  leo_vetter.n_in 
+        #self.near_tran = leo_vetter.near_tran 
+        #self.phase = leo_vetter.phase 
+        #self.qtran = leo_vetter.qtran 
+        self.rubble = leo_vetter.rubble
+        #self.tran_epochs = leo_vetter.tran_epochs 
+        #self.zpt = leo_vetter.zpt
+        self.sig_w = leo_vetter.sig_w
+        self.sig_r = leo_vetter.sig_r
+        self.err = leo_vetter.err
+        self.MES = leo_vetter.MES
+        self.SHP = leo_vetter.SHP
+        self.CHI = leo_vetter.CHI
+        self.med_chases = leo_vetter.med_chases
+        self.mean_cases = leo_vetter.mean_chases
+        self.max_SES = leo_vetter.max_SES
+        self.DMM = leo_vetter.DMM
+
+        # Important metrics to directly return
+        self.metrics = {
+            "sig_w": self.sig_w,
+            "sig_r": self.sig_r,
+            "err": self.err,
+            "MES": self.MES,
+            "SHP": self.SHP,
+            "CHI": self.CHI,
+            "med_chases": self.med_chases,
+            "mean_chases": self.mean_cases,
+            "max_SES": self.max_SES,
+            "DMM": self.DMM,
+        }
+
+        if plot:
+            leo_vetter.plot()
+
+        return self.metrics
+
+    def plot(self):  # pragma: no cover
+        self.run(self.tce, self.lc, plot=True)