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

exovetter/centroid/__init__.py

@@ -0,0 +1 @@
+

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/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/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/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/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/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/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/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:

exovetter/utils.py

@@ -5,6 +5,9 @@ import warnings
 
 import numpy as np
 
+__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']
 
 def sine(x, order, period=1):
     """Sine function for SWEET vetter."""
@@ -115,7 +118,8 @@ def mark_transit_cadences(time, period_days, epoch_bkjd, duration_days,
     big_num = sys.float_info.max  # A large value that isn't NaN
     max_diff = 0.5 * duration_days * num_durations
 
-    idx = np.zeros_like(time, dtype=np.bool8)
+    idx = np.zeros_like(time, dtype=np.bool_) 
+    # Changed from np.bool8 to np.bool_ for py 3.11  
     for tt in transit_times:
         diff = time - tt
         diff[flags] = big_num
@@ -150,25 +154,32 @@ def median_detrend(flux, nPoints):
 
 
 def plateau(array, threshold):
-    """Find plateaus in an array, i.e continuous regions that exceed threshold
+    """Find plateaus in an array, i.e continuous regions that exceed threshold.
 
     Given an array of numbers, return a 2d array such that
     out[:,0] marks the indices where the array crosses threshold from
     below, and out[:,1] marks the next time the array crosses that
     same threshold from below.
 
-    Inputs:
-    array       (1d numpy array)
-    threshold   (float or array) If threshold is a single number, any point
-                above that value is above threshold. If it's an array,
-                it must have the same length as the first argument, and
-                an array[i] > threshold[i] to be included as a plateau
-
-    Returns:
-    Numpy 2d array with 2 columns.
+    Parameters
+    ----------
+    array : array_like
+        Numpy 1D array 
+
+    threshold : float or array_like
+        If threshold is a single number, any point 
+        above that value is above threshold. If it's an array,
+        it must have the same length as the first argument, and
+        an array[i] > threshold[i] to be included as a plateau
+    
+    Returns
+    -------
+    loc : array_like
+        Numpy 2d array with 2 columns.
 
 
-    Notes:
+    Notes
+    -----
     To find the length of the plateaus, use
     out[:,1] - out[:,0]
 
@@ -180,7 +191,7 @@ def plateau(array, threshold):
     to ensure floating point arithmetic prevents two numbers being
     exactly equal.
     """
-
+    
     arr = array.astype(np.float32)
     arr = arr - threshold + 1e-12
     arrPlus = np.roll(arr, 1)
@@ -316,6 +327,7 @@ def get_mast_tce(name):
     url = planeturl + name + "/properties/"
 
     r = requests.get(url = url, headers = header)
+    
     if len(r.json()) < 1:
         print("No TCE Information was returned from MAST.")
         return []
@@ -330,6 +342,7 @@ def get_mast_tce(name):
             epoch_offset_str = 'mjd'
             depth = prop['transit_depth']
             duration = prop['transit_duration']
+            catalog_name = prop['catalog_name']
             if duration is None:
                 duration  = 0
             durunit = prop['transit_duration_unit']
@@ -341,7 +354,8 @@ def get_mast_tce(name):
                        epoch_offset = const.__dict__['string_to_offset'][epoch_offset_str],
                        depth = depth * const.frac_amp,
                        duration = duration * u.__dict__[durunit],
-                       target = name
+                       target = name,
+                       catalog_name = catalog_name
                        )
             
             tces.append(atce)
@@ -437,7 +451,8 @@ class WqedLSF:
         covar = np.linalg.inv(A)
 
         wy = self.y / self.s
-        beta = np.dot(wy, df)
+        df = df.T # transposed to work with np.dot updates MD 2023
+        beta = np.dot(df, wy) # swapped order in dot product MD 2023
         params = np.dot(beta, covar)
 
         # Store results
@@ -600,7 +615,32 @@ def compute_phases(time, period, epoch, offset=0.5):
 
     return phases
 
+def first_epoch(epoch, period, lc):
+    """Returns epoch of the first time in a lc file. Usefull when pulling down TCEs from MAST.
 
-    
-    
-    
+    Parameters
+    ----------
+    epoch : float
+        Time of transit from a given TCE in same time system as lc.
+
+    period : float
+        Period in units of time.
+
+    lc : lightkurve object
+        lightkurve object with flux and time.
+
+    Returns
+    -------
+    first_epoch : float
+        Epoch of first transit in lc in the time system of the lc. 
+
+    """
+    # TODO might need to assert epoch.value is within lc.time.value
+    if epoch.value >= lc.time.value[0]:
+        N = np.floor((epoch.value-lc.time.value[0])/period.value)
+        first_epoch = epoch - N*period
+    else:
+        N = np.ceil((lc.time.value[0]-epoch.value)/period.value)
+        first_epoch = epoch + N*period
+
+    return first_epoch

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.2'
+    version = '0.0.4'