-
-
-
- Loading TLS Summary…
- Scanning saved results
-
-
-
-
-
-
- Loading TLS Summary…
- Scanning saved results
-
-
-
+
+
+
+ {{ title }}
+ {{ subtitle }}
+
+
+
@@ -430,7 +424,9 @@
TLS Results Summary
{% endif %}
-
+{% endblock %}
+
+{% block scripts %}
-
-
-
-
- Loading TLS results…
-
-
-
-
+{{ components.page_loading('Loading TLS results…', subtitle_id='pageLoadingPath') }}
@@ -909,5 +897,4 @@
Browse for TLS results directory
});
})();
-
-
+{% endblock %}
diff --git a/quicklook/inject.py b/quicklook/inject.py
index c7660f2..5a0d8cb 100644
--- a/quicklook/inject.py
+++ b/quicklook/inject.py
@@ -16,6 +16,7 @@
import matplotlib.pyplot as plt
from wotan import flatten
from transitleastsquares import transitleastsquares
+from loguru import logger
# --------------------------------------------------------------------
@@ -164,7 +165,7 @@ def select_best_window(df, depth_min=0.9, duration_tol=0.2, asym_max=0.002):
# Select optimal window
best_window, valid = select_best_window(df)
- print("Selected window length:", best_window)
+ logger.info(f"Selected window length: {best_window}")
# Run grid with different flatten method
# method2 = 'rspline'
diff --git a/quicklook/pipelines.py b/quicklook/pipelines.py
new file mode 100644
index 0000000..6a93f47
--- /dev/null
+++ b/quicklook/pipelines.py
@@ -0,0 +1,56 @@
+"""Single source of truth for the TESS light-curve pipelines we support.
+
+Two orthogonal classifications live here:
+
+* ``FULL_FRAME_TESS_PIPELINES`` — pipelines that derive light curves from
+ Full Frame Images (FFI). These need separate handling in the analysis
+ path (cadence detection, aperture choice, etc.).
+* ``HLSP_PIPELINES`` — pipelines whose saved output filenames follow the
+ HLSP naming convention ``
_s__``. This
+ set drives the filename → pipeline reverse-lookup used by the GUI.
+
+These overlap but are not identical: TASOC is not full-frame derived but
+its output filenames use the HLSP convention, so it appears in
+``HLSP_PIPELINES`` only.
+
+Adding a new pipeline:
+ 1. Append the lowercase name to ``ALL_TESS_PIPELINES`` (preserves the
+ order shown in the GUI form).
+ 2. If it derives from FFI, add to ``FULL_FRAME_TESS_PIPELINES``.
+ 3. If its saved-file stems embed the pipeline name as the lctype
+ token, add to ``HLSP_PIPELINES``.
+"""
+
+from __future__ import annotations
+
+# Order is meaningful — the GUI form renders pipelines in this order.
+FULL_FRAME_TESS_PIPELINES: list[str] = [
+ "tess-spoc",
+ "qlp",
+ "tglc",
+ "cdips",
+ "pathos",
+ "eleanor",
+ "t16",
+ "gsfc-eleanor-lite",
+ "tequila",
+ "tica",
+ "diamante",
+]
+
+ALL_TESS_PIPELINES: list[str] = ["spoc", "tasoc"] + FULL_FRAME_TESS_PIPELINES
+
+# Pipelines whose saved-file stems put the pipeline name as the lctype
+# token (e.g. "TIC123_s12_qlp_lc_tls.h5"). Used by app.py's filename
+# parser when recovering pipeline/cadence from a stem.
+HLSP_PIPELINES: frozenset[str] = frozenset(
+ {
+ "qlp",
+ "tglc",
+ "tasoc",
+ "cdips",
+ "pathos",
+ "tess-spoc",
+ "t16",
+ }
+)
diff --git a/quicklook/plot.py b/quicklook/plot.py
index a796e53..4dc6354 100755
--- a/quicklook/plot.py
+++ b/quicklook/plot.py
@@ -255,7 +255,7 @@ def plot_periodogram(
ax.set_xlim(xmin, period_max)
ax.legend(title="Prot peaks [d]")
if verbose:
- print(pg.show_properties())
+ logger.info(pg.show_properties())
return pg
@@ -495,7 +495,7 @@ def plot_gaia_sources_on_tpf(
survey image and Gaia DR2 positions
"""
if verbose:
- print("Plotting nearby Gaia sources on tpf.")
+ logger.info("Plotting nearby Gaia sources on tpf.")
assert target_gaiaid is not None
img = np.nanmedian(tpf.flux, axis=0)
# make aperture mask
@@ -509,7 +509,7 @@ def plot_gaia_sources_on_tpf(
if gaia_sources is None:
if verbose:
- print("Querying Gaia sources around the target.")
+ logger.info("Querying Gaia sources around the target.")
target_coord = SkyCoord(
ra=tpf.get_header()["RA_OBJ"],
dec=tpf.get_header()["DEC_OBJ"],
@@ -541,9 +541,9 @@ def plot_gaia_sources_on_tpf(
# sources_inside_aperture.append(isinside)
min_gmag = gaia_sources.loc[isinside, "phot_g_mean_mag"].min()
if (target_gmag - min_gmag) != 0:
- print(
- f"target Gmag={target_gmag:.2f} is not the brightest \
- within aperture (Gmag={min_gmag:.2f})"
+ logger.warning(
+ f"target Gmag={target_gmag:.2f} is not the brightest "
+ f"within aperture (Gmag={min_gmag:.2f})"
)
else:
min_gmag = gaia_sources.phot_g_mean_mag.min() # brightest
@@ -695,7 +695,7 @@ def plot_gaia_sources_on_survey(
errmsg = f"{survey} not in {list(dss_description.keys())}"
assert survey in list(dss_description.keys()), errmsg
if verbose:
- print("Plotting nearby Gaia sources on survey image.")
+ logger.info("Plotting nearby Gaia sources on survey image.")
assert target_gaiaid is not None
ny, nx = tpf.flux.shape[1:]
if fov_rad is None:
@@ -704,7 +704,7 @@ def plot_gaia_sources_on_survey(
target_coord = SkyCoord(ra=tpf.ra * u.deg, dec=tpf.dec * u.deg)
if gaia_sources is None:
if verbose:
- print("Querying Gaia sources around the target.")
+ logger.info("Querying Gaia sources around the target.")
gaia_sources = Catalogs.query_region(
target_coord,
radius=fov_rad,
@@ -722,7 +722,7 @@ def plot_gaia_sources_on_survey(
extent = np.array([-1, nx, -1, ny])
if verbose:
- print(f"Querying {survey} ({fov_rad:.2f} x {fov_rad:.2f}) archival image...")
+ logger.info(f"Querying {survey} ({fov_rad:.2f} x {fov_rad:.2f}) archival image...")
# -----------create figure---------------#
if (ax is None) or (hdu is None):
# get img hdu for subplot projection
diff --git a/quicklook/tglc.py b/quicklook/tglc.py
index fac23e4..1789d0e 100644
--- a/quicklook/tglc.py
+++ b/quicklook/tglc.py
@@ -34,6 +34,15 @@
Gaia.ROW_LIMIT = -1
Gaia.MAIN_GAIA_TABLE = "gaiadr3.gaia_source" # TODO: dr3 MJD = 2457388.5, TBJD = 388.5
+# astroquery's MAST service connection imposes a 600 s (10 min) request
+# timeout by default, which aborts large TESScut FFI-cutout downloads and
+# slow catalog queries mid-run. Raise it so TGLC jobs are not cut off.
+_MAST_TIMEOUT = 3600
+for _mast_client in (Catalogs, Tesscut):
+ _conn = getattr(_mast_client, "_service_api_connection", None)
+ if _conn is not None:
+ _conn.TIMEOUT = _MAST_TIMEOUT
+
def _gaia_async_query(query_str, max_retries=3, timeout=120):
"""Run a Gaia TAP async query with retries and a timeout."""
@@ -1117,8 +1126,11 @@ def fit_lc(
A_cut, e_psf[j]
)
aperture = aperture.reshape((len(source.time), up - down, right - left))
- target_5x5 = np.dot(A_target, np.nanmedian(e_psf, axis=0)).reshape(cut_size, cut_size)
- field_stars_5x5 = np.dot(A_cut, np.nanmedian(e_psf, axis=0)).reshape(cut_size, cut_size)
+ # Reshape to the actual cut-region shape, which is smaller than 5x5 when
+ # the star sits near a cutout edge; the block below pads it back to 5x5.
+ region_shape = (up - down, right - left)
+ target_5x5 = np.dot(A_target, np.nanmedian(e_psf, axis=0)).reshape(region_shape)
+ field_stars_5x5 = np.dot(A_cut, np.nanmedian(e_psf, axis=0)).reshape(region_shape)
if target_5x5.shape != (cut_size, cut_size):
# Pad with nans to get to 5x5 shape
# Pad amount in a direction is (expected_num_pix) - (actual_num_pix)
@@ -1141,7 +1153,7 @@ def fit_lc(
over_size = psf_size * factor + 1
if near_edge: # TODO: near_edge
psf_lc = np.zeros(len(source.time))
- psf_lc[:] = np.NaN
+ psf_lc[:] = np.nan
e_psf_1d = np.nanmedian(e_psf[:, : over_size**2], axis=0).reshape(over_size, over_size)
portion = (
(36 / 49) * np.nansum(e_psf_1d[8:15, 8:15]) / np.nansum(e_psf_1d)
@@ -1293,7 +1305,7 @@ def fit_lc_float_field(
over_size = psf_size * factor + 1
if near_edge: # TODO: near_edge
psf_lc = np.zeros(len(source.time))
- psf_lc[:] = np.NaN
+ psf_lc[:] = np.nan
e_psf_1d = np.nanmedian(e_psf[:, : over_size**2], axis=0).reshape(over_size, over_size)
portion = (
(36 / 49) * np.nansum(e_psf_1d[8:15, 8:15]) / np.nansum(e_psf_1d)
@@ -1537,6 +1549,25 @@ def bg_mod(
return local_bg, aper_lc, psf_lc, cal_aper_lc, cal_psf_lc
+def _fit_epsf_series(A, source, over_size, bg_dof, power=0.8, no_progress_bar=False):
+ """Fit the effective PSF at every cadence.
+
+ Shows a tqdm status bar in interactive terminals and additionally emits
+ a loguru progress line every ~5% of cadences, so progress stays visible
+ when stdout is captured to a log file (e.g. the web GUI job log) where
+ the tqdm bar does not render.
+ """
+ ntime = len(source.time)
+ e_psf = np.zeros((ntime, over_size**2 + bg_dof))
+ log_every = max(1, ntime // 20)
+ for i in trange(ntime, desc="Fitting ePSF", disable=no_progress_bar):
+ e_psf[i] = fit_psf(A, source, over_size, power=power, time=i)
+ done = i + 1
+ if not no_progress_bar and (done % log_every == 0 or done == ntime):
+ logger.info(f"ePSF fitting: {done}/{ntime} ({100 * done // ntime}%)")
+ return e_psf
+
+
def epsf(
source,
psf_size=11,
@@ -1583,7 +1614,7 @@ def epsf(
)
lc_directory = f"{local_directory}lc/{source.camera}-{source.ccd}/"
epsf_loc = f"{local_directory}epsf/{source.camera}-{source.ccd}/epsf_{target}_sector_{sector}_{source.camera}-{source.ccd}.npy"
- if isinstance(Source_cut, source):
+ if isinstance(source, Source_cut):
bg_dof = 3
lc_directory = f"{local_directory}lc/"
epsf_loc = f"{local_directory}epsf/epsf_{target}_sector_{sector}.npy"
@@ -1600,9 +1631,9 @@ def epsf(
e_psf = np.load(epsf_loc)
logger.info(f"Loaded ePSF {target} from directory.")
else:
- e_psf = np.zeros((len(source.time), over_size**2 + bg_dof))
- for i in trange(len(source.time), desc="Fitting ePSF", disable=no_progress_bar):
- e_psf[i] = fit_psf(A, source, over_size, power=power, time=i)
+ e_psf = _fit_epsf_series(
+ A, source, over_size, bg_dof, power=power, no_progress_bar=no_progress_bar
+ )
if np.isnan(e_psf).any():
logger.warning(
f"TESS FFI cut includes NaN values. Please shift the center of the cutout to remove NaN near edge. Target: {target}"
@@ -1618,7 +1649,7 @@ def epsf(
index_1 = np.where(np.array(source.quality) == 0)[0]
index_2 = np.where(quality_raw == 0)[0]
index = np.intersect1d(index_1, index_2)
- if isinstance(Source_cut, source):
+ if isinstance(source, Source_cut):
in_frame = np.where(np.invert(np.isnan(source.flux[0])))
x_left = np.min(in_frame[1]) - 0.5
x_right = source.size - np.max(in_frame[1]) + 0.5
@@ -1811,36 +1842,238 @@ def epsf(
)
-def get_tglc_lc(target_name, sector=None, size=50, limit_mag=16, verbose=True):
+def _point_to_point_scatter(flux):
+ """Robust white-noise estimate: MAD of successive flux differences / sqrt(2).
+
+ Unlike a plain MAD of the light curve, the first-difference scatter
+ isolates high-frequency (instrumental / photon) noise and is *not*
+ inflated by genuine astrophysical variability. This makes it safe to use
+ when picking the less-noisy of two light curves: a plain MAD would
+ systematically penalise the light curve of a truly variable star.
+
+ Parameters
+ ----------
+ flux : np.ndarray
+ Light curve flux (NaNs allowed).
+
+ Returns
+ -------
+ float
+ Point-to-point scatter, or ``np.nan`` if there are <3 finite points.
+ """
+ finite = flux[np.isfinite(flux)]
+ if finite.size < 3:
+ return np.nan
+ diff = np.diff(finite)
+ return 1.4826 * np.nanmedian(np.abs(diff - np.nanmedian(diff))) / np.sqrt(2)
+
+
+def _choose_photometry(
+ cal_aper_lc,
+ cal_psf_lc,
+ near_edge,
+ contamination,
+ tess_mag,
+ contam_high=1.0,
+ contam_low=0.05,
+ bright_mag=12.0,
+ faint_mag=13.0,
+ margin=0.05,
+):
+ """Decide whether the aperture or PSF light curve is the better product.
+
+ The decision is deterministic and applied in priority order:
+
+ 1. Hard eliminations -- if the PSF light curve is undefined (target near
+ a CCD edge) or has too few valid cadences, aperture is the only option.
+ 2. Crowding -- a high contamination ratio favours PSF photometry, whose
+ explicit forward model decontaminates better than a fixed 3x3 aperture;
+ a bright, isolated star favours the simpler aperture photometry.
+ 3. Precision -- otherwise pick the light curve with the lower
+ point-to-point scatter, requiring a margin to avoid noise-driven
+ flip-flopping (see :func:`_point_to_point_scatter`).
+ 4. Soft default -- faint stars favour PSF; otherwise aperture, which is
+ the upstream convention (TGLC plotting helpers default to
+ ``cal_aper_flux``).
+
+ Returns
+ -------
+ tuple(str, str, dict)
+ ``(choice, reason, metrics)`` where ``choice`` is ``"aperture"`` or
+ ``"psf"``, ``reason`` is a human-readable explanation, and ``metrics``
+ holds the scalar values behind the decision.
+ """
+ aper_p2p = _point_to_point_scatter(cal_aper_lc)
+ psf_p2p = _point_to_point_scatter(cal_psf_lc)
+ aper_valid = int(np.sum(np.isfinite(cal_aper_lc)))
+ psf_valid = int(np.sum(np.isfinite(cal_psf_lc)))
+ metrics = {
+ "APER_P2P": aper_p2p,
+ "PSF_P2P": psf_p2p,
+ "APER_NVALID": aper_valid,
+ "PSF_NVALID": psf_valid,
+ "CONTAMRT": contamination,
+ }
+
+ # 1. Hard eliminations: PSF unusable -> must use aperture.
+ if near_edge:
+ return "aperture", "near edge: PSF light curve is undefined", metrics
+ if psf_valid == 0 or not np.isfinite(psf_p2p):
+ return "aperture", "PSF light curve has no valid cadences", metrics
+ if aper_valid > 0 and psf_valid < 0.5 * aper_valid:
+ return (
+ "aperture",
+ f"PSF has too few valid cadences ({psf_valid} < 50% of {aper_valid})",
+ metrics,
+ )
+
+ # 2. Crowding: explicit forward model decontaminates better.
+ if np.isfinite(contamination) and contamination >= contam_high:
+ return (
+ "psf",
+ f"high contamination ({contamination:.3f} >= {contam_high})",
+ metrics,
+ )
+ if (
+ np.isfinite(contamination)
+ and contamination <= contam_low
+ and np.isfinite(tess_mag)
+ and tess_mag <= bright_mag
+ ):
+ return (
+ "aperture",
+ f"bright (T={tess_mag:.1f}) and isolated "
+ f"(contamination {contamination:.3f} <= {contam_low})",
+ metrics,
+ )
+
+ # 3. Precision tie-break on point-to-point scatter.
+ if np.isfinite(aper_p2p) and np.isfinite(psf_p2p):
+ if psf_p2p < aper_p2p * (1.0 - margin):
+ return (
+ "psf",
+ f"lower point-to-point scatter " f"(PSF {psf_p2p:.5f} < aperture {aper_p2p:.5f})",
+ metrics,
+ )
+ if aper_p2p < psf_p2p * (1.0 - margin):
+ return (
+ "aperture",
+ f"lower point-to-point scatter " f"(aperture {aper_p2p:.5f} < PSF {psf_p2p:.5f})",
+ metrics,
+ )
+
+ # 4. Soft default: faint stars favour PSF; otherwise aperture.
+ if np.isfinite(tess_mag) and tess_mag >= faint_mag:
+ return "psf", f"faint star (T={tess_mag:.1f}); metrics within margin", metrics
+ return "aperture", "default (aperture, upstream convention)", metrics
+
+
+def get_tglc_lc(
+ target_name,
+ sector=None,
+ size=50,
+ limit_mag=16,
+ photometry="auto",
+ cache_dir=None,
+ use_cache=True,
+ verbose=True,
+):
"""Run the TGLC ePSF pipeline for a single target and return a TessLightCurve.
This function downloads an FFI cutout via TESScut, runs the TGLC effective
- PSF photometry pipeline, and packages the calibrated PSF light curve as a
- ``lightkurve.TessLightCurve`` object.
+ PSF photometry pipeline, and packages the light curve as a
+ ``lightkurve.TessLightCurve`` object. Both the aperture and PSF products
+ are attached as extra columns; ``photometry`` selects which one becomes
+ the primary ``flux`` column.
Parameters
----------
target_name : str
Target identifier resolved by MAST (e.g. "TIC 12345", "TOI-1234").
sector : int or None
- TESS sector. ``None`` uses the first available sector.
+ TESS sector to extract. ``None`` selects the first available
+ sector, ``-1`` the latest available sector, and a positive
+ integer that specific sector.
size : int
- Side length in pixels of the TESScut FFI cutout (default 25).
+ Side length in pixels of the TESScut FFI cutout (default 50).
limit_mag : float
Faintest TESS magnitude to include in the PSF model (default 16).
+ photometry : str
+ Which light curve becomes the primary ``flux`` column:
+ ``"auto"`` (default) lets :func:`_choose_photometry` decide,
+ ``"aperture"`` or ``"psf"`` force a specific product.
+ cache_dir : str or None
+ Directory for cached FFI cutouts and ePSF models. ``None`` uses
+ ``~/.tglc``. Re-running the same target/sector/size reloads the
+ cached ``Source_cut`` pickle and ``e_psf`` array instead of
+ re-downloading and re-fitting (the ePSF fit dominates runtime).
+ use_cache : bool
+ Read from and write to ``cache_dir`` (default ``True``). Set
+ ``False`` to force a fresh download and ePSF fit.
verbose : bool
Print progress information.
Returns
-------
lightkurve.TessLightCurve
- Calibrated PSF light curve with BTJD times and normalized flux.
+ Calibrated light curve with BTJD times and normalized flux. The
+ primary ``flux`` column is the chosen product; ``cal_aper_flux``,
+ ``cal_psf_flux``, ``aperture_flux`` and ``psf_flux`` are attached as
+ extra columns. ``meta`` records the selection (``FLUX_ORIGIN``,
+ ``PHOT_SEL``, ``PHOT_RSN``, ``CONTAMRT``, ``APER_P2P``, ``PSF_P2P``).
"""
+ valid_modes = ("auto", "aperture", "psf")
+ if photometry not in valid_modes:
+ raise ValueError(f"photometry must be one of {valid_modes}, got {photometry!r}")
import lightkurve as lk
from astropy.time import Time
- # 1. Build the Source_cut object (downloads FFI cutout + Gaia catalog)
- source = Source_cut(target_name, size=size, sector=sector, limit_mag=limit_mag)
+ # Resolve cache locations. Re-running the same target/sector/size reuses
+ # the cached FFI cutout and ePSF model instead of re-downloading and
+ # re-fitting.
+ if cache_dir is None:
+ cache_dir = os.path.expanduser("~/.tglc")
+ source_dir = os.path.join(cache_dir, "source")
+ epsf_dir = os.path.join(cache_dir, "epsf")
+ if use_cache:
+ os.makedirs(source_dir, exist_ok=True)
+ os.makedirs(epsf_dir, exist_ok=True)
+ slug = target_name.replace(" ", "")
+ # Resolve the sector request. None -> first available, -1 -> latest
+ # available (matching the GUI's "-1 = latest" convention), a positive
+ # integer -> that specific sector. Passing "first"/"last" (rather than
+ # None) makes TESScut download only that one sector's cutout instead of
+ # one cutout per observed sector.
+ if sector is None:
+ source_sector_arg = "first"
+ sector_tag = "first"
+ elif int(sector) == -1:
+ source_sector_arg = "last"
+ sector_tag = "last"
+ else:
+ source_sector_arg = int(sector)
+ sector_tag = f"s{int(sector)}"
+ source_pkl = os.path.join(source_dir, f"source_{slug}_{sector_tag}_size{size}.pkl")
+
+ # 1. Build (or load) the Source_cut object (downloads FFI cutout + Gaia).
+ source = None
+ if use_cache and exists(source_pkl) and os.path.getsize(source_pkl) > 0:
+ try:
+ with open(source_pkl, "rb") as fh:
+ source = pickle.load(fh)
+ if verbose:
+ logger.info(f"Loaded cached TGLC source from {source_pkl}")
+ except (pickle.UnpicklingError, EOFError, AttributeError, ImportError) as e:
+ logger.warning(f"Cached source unreadable ({e}); rebuilding.")
+ source = None
+ if source is None:
+ source = Source_cut(target_name, size=size, sector=source_sector_arg, limit_mag=limit_mag)
+ if use_cache:
+ try:
+ with open(source_pkl, "wb") as fh:
+ pickle.dump(source, fh, pickle.HIGHEST_PROTOCOL)
+ except Exception as e: # cache write is best-effort
+ logger.warning(f"Could not cache source ({e}).")
# 2. Build the PSF model
A, star_info, over_size, x_round, y_round = get_psf(source)
@@ -1848,10 +2081,31 @@ def get_tglc_lc(target_name, sector=None, size=50, limit_mag=16, verbose=True):
# Determine background degrees of freedom
bg_dof = 3
- # 3. Fit the ePSF at every cadence
- e_psf = np.zeros((len(source.time), over_size**2 + bg_dof))
- for i in trange(len(source.time), desc="Fitting ePSF", disable=not verbose):
- e_psf[i] = fit_psf(A, source, over_size, power=0.8, time=i)
+ # 3. Fit (or load) the ePSF at every cadence. Keyed on the resolved
+ # sector so explicit and "auto" sector requests share the cache.
+ epsf_npy = os.path.join(epsf_dir, f"epsf_{slug}_s{source.sector}_size{size}.npy")
+ expected_shape = (len(source.time), over_size**2 + bg_dof)
+ e_psf = None
+ if use_cache and exists(epsf_npy) and os.path.getsize(epsf_npy) > 0:
+ try:
+ cached = np.load(epsf_npy)
+ if cached.shape == expected_shape:
+ e_psf = cached
+ if verbose:
+ logger.info(f"Loaded cached ePSF from {epsf_npy}")
+ else:
+ logger.warning("Cached ePSF shape mismatch; refitting.")
+ except (OSError, ValueError, EOFError) as e:
+ logger.warning(f"Cached ePSF unreadable ({e}); refitting.")
+ if e_psf is None:
+ e_psf = _fit_epsf_series(
+ A, source, over_size, bg_dof, power=0.8, no_progress_bar=not verbose
+ )
+ if use_cache:
+ try:
+ np.save(epsf_npy, e_psf)
+ except Exception as e: # cache write is best-effort
+ logger.warning(f"Could not cache ePSF ({e}).")
# 4. Quality flags
quality_raw = np.zeros(len(source.time), dtype=np.int16)
@@ -1878,7 +2132,7 @@ def get_tglc_lc(target_name, sector=None, size=50, limit_mag=16, verbose=True):
)
# 6. Extract the light curve for the target star
- aperture, psf_lc, star_y, star_x, portion, _, _ = fit_lc(
+ aperture, psf_lc, star_y, star_x, portion, target_5x5, field_stars_5x5 = fit_lc(
A,
source,
star_info=star_info,
@@ -1919,8 +2173,36 @@ def get_tglc_lc(target_name, sector=None, size=50, limit_mag=16, verbose=True):
star_num=star_idx,
)
- # 8. Build the TessLightCurve
- flux = cal_psf_lc # cal_aper_lc
+ # 8. Choose between aperture and PSF photometry
+ contamination = float(np.nansum(field_stars_5x5[1:4, 1:4]) / np.nansum(target_5x5[1:4, 1:4]))
+ tess_mag = float(source.gaia[star_idx]["tess_mag"])
+
+ if photometry == "auto":
+ choice, reason, metrics = _choose_photometry(
+ cal_aper_lc, cal_psf_lc, near_edge, contamination, tess_mag
+ )
+ else:
+ choice = photometry
+ reason = f"user-specified photometry='{photometry}'"
+ metrics = {
+ "APER_P2P": _point_to_point_scatter(cal_aper_lc),
+ "PSF_P2P": _point_to_point_scatter(cal_psf_lc),
+ }
+
+ if choice == "psf":
+ flux = cal_psf_lc
+ flux_origin = "cal_psf_flux"
+ else:
+ flux = cal_aper_lc
+ flux_origin = "cal_aper_flux"
+
+ if choice == "psf" and not np.any(np.isfinite(cal_psf_lc)):
+ logger.warning(
+ "Selected PSF light curve has no valid cadences (target near edge?); "
+ "use photometry='aperture' or 'auto'."
+ )
+
+ # 9. Build the TessLightCurve
flux_err = np.full_like(flux, 1.4826 * np.nanmedian(np.abs(flux - np.nanmedian(flux))))
# BTJD times (TESS Barycentric Julian Date, BJD - 2457000)
@@ -1937,14 +2219,26 @@ def get_tglc_lc(target_name, sector=None, size=50, limit_mag=16, verbose=True):
"CAMERA": source.camera,
"CCD": source.ccd,
"EXPOSURE": exposure_time,
- "FLUX_ORIGIN": "cal_psf_flux",
+ "FLUX_ORIGIN": flux_origin,
+ "PHOT_SEL": photometry,
+ "PHOT_RSN": reason,
+ "CONTAMRT": contamination,
+ "NEAREDGE": near_edge,
+ "APER_P2P": metrics["APER_P2P"],
+ "PSF_P2P": metrics["PSF_P2P"],
},
)
+ # Keep both photometry products available on the returned light curve.
+ lc["cal_aper_flux"] = cal_aper_lc
+ lc["cal_psf_flux"] = cal_psf_lc
+ lc["aperture_flux"] = aper_lc / portion
+ lc["psf_flux"] = psf_lc
lc.sector = source.sector
if verbose:
logger.info(
- f"TGLC light curve for {target_name} (sector {source.sector}): {len(lc)} cadences"
+ f"TGLC light curve for {target_name} (sector {source.sector}): "
+ f"{len(lc)} cadences; photometry={choice} ({reason})"
)
return lc
@@ -1957,13 +2251,12 @@ def get_tglc_lc(target_name, sector=None, size=50, limit_mag=16, verbose=True):
sector = None
prior = None
transient = None
- if not exists():
- os.makedirs("~/.tglc")
- data_path = f"~/.tglc/{target.replace(' ', '')}"
- os.makedirs(data_path + "logs/", exist_ok=True)
- os.makedirs(data_path + "lc/", exist_ok=True)
- os.makedirs(data_path + "epsf/", exist_ok=True)
- os.makedirs(data_path + "source/", exist_ok=True)
+
+ # Output directory ~/.tglc// -- the trailing separator is required
+ # because the pipeline builds sub-paths via f-string concatenation.
+ data_path = os.path.join(os.path.expanduser("~/.tglc"), target.replace(" ", ""), "")
+ for _sub in ("logs", "lc", "epsf", "source"):
+ os.makedirs(os.path.join(data_path, _sub), exist_ok=True)
target_ = Catalogs.query_object(target, radius=42 * 0.707 / 3600, catalog="Gaia", version=2)
ra = target_[0]["ra"]
diff --git a/quicklook/tql.py b/quicklook/tql.py
index 2e3fabb..ad8e56d 100755
--- a/quicklook/tql.py
+++ b/quicklook/tql.py
@@ -54,20 +54,12 @@
warnings.filterwarnings("ignore", category=Warning, message=".*datfix.*")
warnings.filterwarnings("ignore", category=Warning, message=".*obsfix.*")
-FULL_FRAME_TESS_PIPELINES = [
- "tess-spoc",
- "qlp",
- "tglc",
- "cdips",
- "pathos",
- "eleanor",
- "t16",
- "gsfc-eleanor-lite",
- "tequila",
- "tica",
- "diamante",
-]
-ALL_TESS_PIPELINES = ["spoc", "tasoc"] + FULL_FRAME_TESS_PIPELINES
+# Pipeline registry is centralized in quicklook.pipelines; these
+# re-exports preserve the old import path for callers (and notebooks).
+from quicklook.pipelines import ( # noqa: E402
+ ALL_TESS_PIPELINES,
+ FULL_FRAME_TESS_PIPELINES,
+)
DATA_PATH = files("quicklook").joinpath("data")
@@ -229,9 +221,8 @@ def parse_exofop_info(self):
"""
self.star_names = np.array(self.exofop_data.get("basic_info")["star_names"].split(", "))
if self.verbose:
- print("Catalog names:")
- for n in self.star_names:
- print(f"\t{n}")
+ names_block = "\n".join(f"\t{n}" for n in self.star_names)
+ logger.info(f"Catalog names:\n{names_block}")
self.gaia_name = self.star_names[
np.array([i[:4].lower() == "gaia" for i in self.star_names])
][0]
@@ -427,8 +418,8 @@ def get_lc(self, **kwargs: dict) -> lk.TessLightCurve:
# Display available light curves
cols = ["author", "mission", "t_exptime"]
if self.verbose:
- print("All available lightcurves:")
- print(search_result_all_lcs.table.to_pandas()[cols])
+ lc_table = search_result_all_lcs.table.to_pandas()[cols]
+ logger.info(f"All available lightcurves:\n{lc_table.to_string()}")
# Validate the requested sector. If the user asked for a specific
# sector that the MAST search did not return (e.g. a stale value
@@ -437,7 +428,7 @@ def get_lc(self, **kwargs: dict) -> lk.TessLightCurve:
# than killing the job, and the warning still surfaces in the log.
if kwargs.get("sector") is None:
if self.verbose:
- print(f"Available sectors: {self.all_sectors}")
+ logger.info(f"Available sectors: {self.all_sectors}")
else:
if kwargs.get("sector") not in self.all_sectors:
logger.warning(
@@ -492,8 +483,11 @@ def get_lc(self, **kwargs: dict) -> lk.TessLightCurve:
# Download and return light curve
if sector_orig == "all":
if self.verbose:
- print(f"Filtered lightcurves based on query ({kwargs}):")
- print(search_result.table.to_pandas()[cols])
+ filtered_table = search_result.table.to_pandas()[cols]
+ logger.info(
+ f"Filtered lightcurves based on query ({kwargs}):\n"
+ f"{filtered_table.to_string()}"
+ )
msg = f"Downloading all {kwargs.get('author')} lcs..."
if self.verbose:
logger.info(msg)
@@ -537,9 +531,15 @@ def get_lc(self, **kwargs: dict) -> lk.TessLightCurve:
logger.info(msg)
self.sector = lc.sector
- # Select flux type for SPOC data
- if lc.meta["AUTHOR"].lower() == "spoc":
+ # Select flux type / photometry for pipelines that expose a choice.
+ author = lc.meta["AUTHOR"].lower()
+ if author == "spoc":
lc = lc.select_flux(self.flux_type + "_flux")
+ elif author == "tglc" and self.flux_type in ("aperture", "psf"):
+ # MAST TGLC HLSP files carry both calibrated flux columns.
+ tglc_col = {"aperture": "cal_aper_flux", "psf": "cal_psf_flux"}[self.flux_type]
+ if tglc_col in lc.colnames:
+ lc = lc.select_flux(tglc_col)
# Set exposure time and cadence
if self.exptime is None:
@@ -644,10 +644,16 @@ def _get_tglc_lc_fallback(self, sector):
logger.info("No TGLC products on MAST; running local ePSF extraction...")
self.pipeline = "tglc"
self.all_pipelines = {"TGLC"}
- sector_arg = None if sector in (None, -1) else int(sector)
+ # Pass the request through to get_tglc_lc unchanged: None -> first
+ # available, -1 -> latest available, positive int -> that sector.
+ sector_arg = None if sector is None else int(sector)
+ # flux_type carries the GUI's aperture/psf choice for TGLC; anything
+ # else (e.g. a stale "pdcsap") falls back to automatic selection.
+ photometry = self.flux_type if self.flux_type in ("aperture", "psf", "auto") else "auto"
lc = get_tglc_lc(
self.query_name,
sector=sector_arg,
+ photometry=photometry,
verbose=self.verbose,
)
self.sector = lc.sector
@@ -689,8 +695,8 @@ def get_tpf(self, **kwargs: dict) -> lk.targetpixelfile.TargetPixelFile:
cols = ["author", "mission", "t_exptime"]
if self.verbose:
- print("All available TPFs:")
- print(search_result_all_tpfs.table.to_pandas()[cols])
+ tpf_table = search_result_all_tpfs.table.to_pandas()[cols]
+ logger.info(f"All available TPFs:\n{tpf_table.to_string()}")
tpf_authors = search_result_all_tpfs.table.to_pandas()["author"].unique()
if kwargs.get("author").upper() not in tpf_authors:
if self.verbose:
@@ -787,7 +793,7 @@ def get_toi_ephem(self, params=["epoch", "per", "dur"]) -> list:
if planet_params is None:
return (None, None, None, None)
if self.verbose:
- print(f"Parameters for {planet_params.get('name', 'unknown')}:")
+ logger.info(f"Parameters for {planet_params.get('name', 'unknown')}:")
# Initialize variables
toi_epoch = None
@@ -803,7 +809,7 @@ def get_toi_ephem(self, params=["epoch", "per", "dur"]) -> list:
err = planet_params.get(p + "_e")
err = float(err) if err else 0.1
if self.verbose:
- print(f"{p}: {val}, {err} {unit}")
+ logger.info(f"{p}: {val}, {err} {unit}")
if p == "epoch":
toi_epoch = np.array((val, err))
toi_epoch[0] -= TESS_TIME_OFFSET
@@ -1545,7 +1551,7 @@ def plot_tql(self, return_fig_and_paths=False, **kwargs: dict) -> pl.Figure:
# Take a snapshot and find any unclosed resources
snapshot = tracemalloc.take_snapshot()
for stat in snapshot.statistics("lineno"):
- print(stat)
+ logger.debug(stat)
else:
fig = ql.plot_tql()
diff --git a/quicklook/utils.py b/quicklook/utils.py
index 1d0b43a..c1577e3 100755
--- a/quicklook/utils.py
+++ b/quicklook/utils.py
@@ -231,7 +231,7 @@ def get_tois(
msg += f"{keys} planets are removed.\n"
msg += f"Saved: {fp}\n"
if verbose:
- print(msg)
+ logger.info(msg)
return d.sort_values("TOI")
@@ -278,7 +278,7 @@ def get_tic_id(target_name: str) -> int:
def get_toi_ephem(target_name: str, idx=1, params=["epoch", "per", "dur"]) -> list:
- print(f"Querying ephemeris for {target_name}:")
+ logger.info(f"Querying ephemeris for {target_name}:")
r = get_exofop_json(target_name)
planet_params = r["planet_parameters"][idx]
vals = []
@@ -287,7 +287,7 @@ def get_toi_ephem(target_name: str, idx=1, params=["epoch", "per", "dur"]) -> li
val = float(val) if val else 0.1
err = planet_params.get(p + "_e")
err = float(err) if err else 0.1
- print(f" {p}: {val}, {err}")
+ logger.info(f" {p}: {val}, {err}")
vals.append((val, err))
return vals
@@ -332,13 +332,13 @@ def parse_aperture_mask(
"""Parse and make aperture mask"""
if verbose:
if sap_mask == "round":
- print("aperture photometry mask: {} (r={} pix)\n".format(sap_mask, aper_radius))
+ logger.info(f"aperture photometry mask: {sap_mask} (r={aper_radius} pix)")
elif sap_mask == "square":
- print("aperture photometry mask: {0} ({1}x{1} pix)\n".format(sap_mask, aper_radius))
+ logger.info(f"aperture photometry mask: {sap_mask} ({aper_radius}x{aper_radius} pix)")
elif sap_mask == "percentile":
- print("aperture photometry mask: {} ({}%)\n".format(sap_mask, percentile))
+ logger.info(f"aperture photometry mask: {sap_mask} ({percentile}%)")
else:
- print("aperture photometry mask: {}\n".format(sap_mask))
+ logger.info(f"aperture photometry mask: {sap_mask}")
median_img = np.nanmedian(tpf.flux, axis=0).value
if (sap_mask == "pipeline") or (sap_mask is None):
@@ -389,8 +389,8 @@ def make_round_mask(img, radius, xy_center=None):
xy_center = [x, y]
# check if near edge
if np.any([abs(x - xcen) > offset, abs(y - ycen) > offset]):
- print("Brightest star is detected far from the center.")
- print("Aperture mask is placed at the center instead.\n")
+ logger.info("Brightest star is detected far from the center.")
+ logger.info("Aperture mask is placed at the center instead.")
xy_center = [xcen, ycen]
Y, X = np.ogrid[: img.shape[0], : img.shape[1]]
@@ -426,8 +426,8 @@ def make_square_mask(img, size, xy_center=None):
xy_center = [x, y]
# check if near edge
if np.any([abs(x - xcen) > offset, abs(y - ycen) > offset]):
- print("Brightest star detected is far from the center.")
- print("Aperture mask is placed at the center instead.\n")
+ logger.info("Brightest star detected is far from the center.")
+ logger.info("Aperture mask is placed at the center instead.")
xy_center = [xcen, ycen]
mask = np.zeros_like(img, dtype=bool)
mask[ycen - size : ycen + size + 1, xcen - size : xcen + size + 1] = True # noqa
diff --git a/tests/test_tglc.py b/tests/test_tglc.py
new file mode 100644
index 0000000..8f2f30f
--- /dev/null
+++ b/tests/test_tglc.py
@@ -0,0 +1,56 @@
+import os
+import numpy as np
+import pytest
+import requests
+import lightkurve as lk
+from astroquery.exceptions import RemoteServiceError
+
+from quicklook.tglc import get_tglc_lc
+
+_NETWORK_ERRORS = (
+ RemoteServiceError,
+ requests.exceptions.HTTPError,
+ requests.exceptions.ConnectionError,
+ ConnectionError,
+ TimeoutError,
+)
+
+
+@pytest.fixture
+def tglc_inputs():
+ """Bright, isolated, single-target config for a fast TGLC smoke run.
+
+ pi Men (TIC 261136679) has short-cadence SPOC in sector 1 and enough
+ FFI coverage to exercise the ePSF pipeline end-to-end. A 15x15 cutout
+ is below TGLC's recommended 25x25 (the module will warn) but keeps the
+ TESScut payload small enough to stay under MAST timeouts in CI.
+ """
+ return {
+ "target_name": "TIC 261136679",
+ "sector": 1,
+ "size": 15,
+ "limit_mag": 13,
+ "verbose": False,
+ }
+
+
+@pytest.mark.network
+def test_get_tglc_lc(tglc_inputs):
+ """End-to-end TGLC ePSF pipeline smoke test.
+
+ Regression coverage for three bugs introduced in commit efbe476:
+ - lowercase 'designation' column from MAST gaiadr3
+ - missing f-string prefix on sector_{N}_x/y column writes
+ - swapped isinstance(Source, source) argument order
+ """
+ try:
+ lc = get_tglc_lc(**tglc_inputs)
+ except _NETWORK_ERRORS as e:
+ if os.getenv("CI", "false") == "true":
+ pytest.xfail(f"Network failure (not a bug): {e}")
+ raise
+
+ assert isinstance(lc, lk.LightCurve)
+ assert len(lc) > 0
+ assert np.isfinite(np.nanmedian(lc.flux.value))
+ assert lc.sector == tglc_inputs["sector"]