API documentation

tessilator.fixedconstants Module

Alexander Binks & Moritz Guenther, 2024

Licence: MIT 2024

Module containing fixed constants for the tessilator

These are the pixel size, the typical full-width half maximum of the pixel response function, the TESS zeropoints and the latest TESS sector available for download.

tessilator.tessilator Module

Alexander Binks, Moritz Guenther, 2024

License: MIT 2024

The TESSILATOR

Functions

all_sources_cutout(t_targets, period_file, ...)

Run the tessilator for all targets.

all_sources_sector(t_targets, scc, ...[, ...])

Iterate over all cameras and CCDs for a given sector.

apply_noise_corr(targ_lc, sim_lc)

Apply the correction to the lightcurve based on the noise simulation.

assess_lc(ls_results)

Decide whether to use the periodogram results from the original, or from the CBV-corrected lightcurve.

collect_contamination_data(t_targets, ...[, ...])

Collect data on contamination sources around selected targets.

convert_ffi_date_to_tess(fd)

create_table_template()

Create a template astropy table to store tessilator results.

find_xy_cont(f_file, t_cont, cutout_size)

Identify the pixel x-y positions for contaminant sources.

fix_noise_lc_local(targ_lc, med_lc, scc, ...)

Apply a flux-corrected key to the target lightcurve dictionary, and make a plot of the corrections if required.

fix_noise_lc_sim(targ_lc, targ_name, ...[, ...])

Divide the target lightcurve by the noise lightcurve

full_run_lc(file_in, t_target, scc, res_table)

Aperture photometry, lightcurve cleaning and periodogram analysis.

get_cutouts(coord, cutout_size, name_target)

Download TESS cutouts and store to a list for lightcurve analysis.

get_fits(scc)

Function which returns a list of fits files corresponding to a given Sector, Camera and CCD configuration.

get_median_lc(tables, files_loc, scc[, n_bin])

A function that makes the final noisy lightcurve.

get_name_target(t_target)

Quick function to capture a string containing the name of the target.

get_tess_pixel_xy(t_targets)

Get the pixel x-y positions for all targets in a Sector/Camera/CCD mode.

make_2d_cutout(file_in, phot_table[, im_size])

Makes a 2D cutout object of a target using the median time-stacked image.

make_lc_corr_plot(plot_name, ref_name, ...)

Make a plot of the noise corrections to the lightcurve.

make_target_row(t_targets, r, scc)

Construct table row with the input target data.

one_cc(t_targets, scc, res_table, file_ref)

Run the tessilator for targets in a given Sector/Camera/CCD configuration.

one_source_cutout(target, res_table, ref_name)

Download cutouts and run lightcurve/periodogram analysis for one target.

print_time_taken(start, finish)

Calculate the time taken for a process.

read_data(t_filename[, name_is_source_id, ...])

Read input data and convert to an astropy table ready for analysis.

run_clean_fail_modes(lc, scc)

run_test_for_contaminant(xy_arr, file_in, ...)

Run the periodogram analyses for neighbouring contaminants if required.

setup_filenames(file_ref[, scc])

Set up the file names to store data.

setup_input_parameters()

Retrieve the input parameters to run the tessilator program.

test_table_large_sectors(t_filename)

Check if the input file needs modifying at all.

tessilator.maketable Module

Alexander Binks & Moritz Guenther, 2024

Licence: MIT 2024

Make tabular data for tessilator

This module contains the functions required to convert the input data into correct formatted astropy tables to be used for further analysis in the tessilator.

Functions

get_gaia_data(gaia_table[, ...])

Reads the input table and returns a table in the correct format for TESSilator.

get_twomass_like_name(coords)

If the Gaia DR3 system is not chosen, this function returns a string which has the same format as the 2MASS identifiers.

table_from_coords(coord_table[, ang_max, ...])

Generate the formatted astropy table from a list of coordinates.

table_from_simbad(input_names)

Generate the formatted astropy table from a list of target names.

table_from_table(input_table[, ...])

Generate the formatted astropy table from a pre-formatted astropy table.

tessilator.aperture Module

Alexander Binks & Moritz Guenther, 2024

Licence: MIT 2024

This module contains functions to perform aperture photmetry.

The aperture photometry is defined by a single function ‘aper_run’, which reads the TESS image files, performs aperture phtoometry and returns an astropy table containing the timestamps, magnitudes and fluxes derived from aperture photometry. Additionally, one can use the function ‘calc_rad’, which evaluates the relative brightness of neighbouring pixels to automatically determine the size of the aperture radius. If the full-frame images are used, a function named ‘get_xy_pos’ provides a WCS transformation to convert celestial coordinates to image (x-y) pixels.

Functions

aper_run(file_in, targets[, xy_pos, ap_rad, ...])

Perform aperture photometry for the image data.

calc_rad(flux_vals, positions[, f_lim, ...])

Calculate the appropriate pixel radius for the aperture

get_xy_pos(targets, head)

Locate the X-Y position for targets in a given Sector/CCD/Camera mode

tessilator.contaminants Module

Alexander Binks & Moritz Guenther, 2024

License: MIT 2024

This module contains functions to quantify the background flux contamination from neighbouring sources in the TESS full-frame images. Each TESS pixel has a length of 21”, therefore targets are highly susceptible to background contamination when they (1) are in crowded fields, (2) are faint sources and/or (3) have high contributing sky-counts.

The background is quantified by acquistioning RP-band magnitudes in the Gaia DR3 catalogue for potential contaminants in the surrounding image apertures, and then calculating their flux contribution which is incident within the target aperture using an analytical formula provided as equation 3b-10 in Biser & Millman (1965).

An additional function can be called which stores the potential neighbouring contaminants. Periodogram analyses for these neighbouring sources are then performed to help distinguish whether the lightcurve/periodogram signal is that of the target, or from neighbouring sources.

Functions

contamination(t_targets[, ap_rad, n_cont, ...])

Estimate flux from neighbouring contaminant sources.

flux_fraction_contaminant(pix_sep, s[, d_thr])

Quantify the flux contamination from a neighbouring source.

is_period_cont(d_target, d_cont, t_cont[, ...])

Identify neighbouring contaminants that may cause the periodicity.

run_sql_query_contaminants(t_target[, ...])

Perform an SQL query to identify neighbouring contaminants.

tessilator.detrend_cbv Module

Alexander Binks & Moritz Guenther, December 2024

Licence: MIT 2024

This module contains the functions needed to perform the co-trending basis vector corrections to the TESS lightcurves, if required. The functions were originally designed for Kepler-data analysis, and written by Suzanne Aigrain -> https://github.com/saigrain/CBVshrink

Functions

apply_basis(weights, basis)

Calculate the dot product between the weights and the CBVs.

bayes_linear_fit_ard(X, y)

Fit linear basis model with design matrix X to data y.

block_mean(t, f[, block_size, block_size_min])

calculate the block mean

cdpp()

fit_basis(flux, basis[, scl])

Calculate the flux-correction weights for the co-trending basis vectors (CBVs).

fixed_nb(flux, cbv[, nB, use, doPlot])

Correct light curve for systematics using first nB CBVs.

get_cbv_scc(scc, lc)

Run the CBV fits for a given lightcurve

interpolate_cbv(cbv_file, lc[, type_cbv])

Selects the type of CBV correction and applies them to the lightcurve

logdet(a)

Compute log of determinant of matrix a using Cholesky decomposition

medransig(array)

calculate the medransig

savgol_filter(t, f[, window, order])

The savgol filter

sel_nb(flux, cbv[, nBmax, use])

Correct light curve for systematics using upt to nB CBVs (automatically select best number).

tessilator.lc_analysis Module

Alexander Binks & Moritz Guenther, 2024

Licence: MIT 2024

This module contains functions to normalise, detrend, and clean lightcurves.

The cleaning and detrending of the lightcurve takes part in 9 steps, each of which are called by the parent function ‘run_make_lc_steps’. The steps are:

(1) Normalise the raw lightcurve.
(2) Split the lightcurve into segments of contiguous data (no large time gaps between datapoints)
(3) Remove sparse data, i.e., data segments with only a few data points.
(4) Detrend the lightcurve.
(5) Clean the edges: remove flux outliers.
(6) Clean the edges: scattered, noisy datapoints.
(7) Remove extreme outliers from the lightcurve
(8) Normalise the flux in each segment, using the median of qualified data.
(9) Store the lightcurve to file.

Functions

aic_selector(x, y[, poly_max, cov_min])

Select the detrending polynomial from the Aikaike Information Criterion

cbv_fit_test(t, of, cf)

Determine whether the cbv-corrected lightcurve should be considered.

clean_edges_outlier(f[, MAD_fac])

Remove spurious outliers at the start and end parts of groups.

clean_edges_scatter(f[, MAD_fac, ...])

Remove highly-scattered data at the edges of each group.

clean_flux_algorithm(g)

A basic algorithm that trims both sides of a contiguous data string if a condition is not satisfied, until the condition is met for the first time.

detrend_lc(t, f, lc[, MAD_fac, poly_max])

Detrend and normalise the lightcurves.

get_time_segments(t[, t_fac])

Split the lightcurve into groups of contiguous data

make_lc(phot_table[, name_lc, store_lc, ...])

Construct the normalised, detrended, cleaned TESS lightcurve.

norm_choice(t_orig, f_orig, lc_part[, ...])

Choose whether to detrend the lightcurve as one by individual groups.

relative_root_mean_squared_error(true, pred)

Return the relative root mean squared error (RRMSE)

remove_sparse_data(x_first, x_last[, ...])

Removes very sparse data groups, when there are 3 or more groups.

run_make_lc_steps(f_lc, f_orig[, ...])

Process the lightcurve: cleaning, normalisation and detrending functions

sin_fit(x, y0, A, phi)

Returns the best parameters (y_offset, amplitude, and phase) to a regular sinusoidal function.

sin_fit_per(t, y0, A, per, phi)

Returns the best parameters (y_offset, amplitude, and phase) to a regular sinusoidal function.

smooth_test(time, flux[, n_avg])

Determine how to detrend a lightcurve, based on a smoothness algorithm

tessilator.makeplots Module

Alexander Binks & Moritz Guenther, 2024

Licence: MIT 2024

Generate pixel images, light-curves and periodogram plots

Functions

create_plot(im_plot, clean, LS, scc, ...[, ...])

Produce a plot of tessilator results.