Index

Adam

Holds information used for Adaptive Moment Estimation optimization

AdamState

Holds diagonstic information on the current state of an ADAM opmitization

AdamSubWorkspace

Holds a set of model parameters and the ADAM optimizer and functions used to optimize them

BaseLinearModel

A (log) linear model without a mean (either Ms or exp(Ms)). Used for DPCA models

FrozenTelWorkspace

A workspace to optimize all of the parameters in a SSOF model (except for the tellruc template and features) and data it is to be optimized on

FullLinearModel

A (log) linear model including a mean (either μ+Ms or μexp(M*s))

GenericDatum

Holds a single preprocessed spectrum used to optimize SSOF models

ModelWorkspace(model, data)

Create a workspace for optimizing model with data Creates a FrozenTelWorkspace if the model has no telluric feature vectors and an empty telluric template

OptimSubWorkspace

Holds a set of model parameters and the Optim optimizer and functions used to optimize them

OptimTelStarWorkspace

A workspace to go back and forth optimizing the telluric and stellar parameters then the RVs in a SSOF model and data it is to be optimized on Uses methods in Optim

OptimTotalWorkspace

A workspace to optimize all of the parameters in a SSOF model and data it is to be optimized on Uses methods in Optim

OrderModel(d; kwargs...)

Constructor for the OrderModel-type objects (SSOF model for a set of 1D spectra)

Optional arguments

• instrument::String="None": The name of the instrument(s) the data was taken from. For bookkeeping
• order::Int=0: What order (if any) the data was taken from. For bookkeeping
• star_str::String="None": The name of the star the data was taken from. For bookkeeping
• n_comp_tel::Int=5: Amount of telluric feature vectors
• n_comp_star::Int=5: The maximum amount of stellar feature vectors
• oversamp::Bool=true: Whether or not to integrate the model or do linear interpolation (for the telluric model)
• dpca::Bool=false: Whether to use Doppler-constrained PCA or variable interpolation location to determine the RVs
• log_λ_gp_star::Real=1/SOAP_gp_params.λ: The log λ lengthscale of the stellar regularization GP
• log_λ_gp_tel::Real=1/LSF_gp_params.λ: The log λ lengthscale of the telluric regularization GP
• tel_log_λ::Union{Nothing,AbstractRange}=nothing: The log
• star_log_λ::Union{Nothing,AbstractRange}=nothing: The log λ lengthscale of the telluric regularization GP
• kwargs...: kwargs passed to Submodel constructors

OrderModelDPCA

SSOF model for a set of 1D spectra using Doppler-constrained PCA to measure the RVs (which are contained in the RV Submodel)

OrderModelWobble

SSOF model for a set of 1D spectra using linear interpolation of the stellar model to measure the RVs

Output(om, d)

Calculates the current outputs for the models at the observed wavelengths

OutputDPCA

Holds the current outputs for the models at the observed wavelengths

OutputWobble

Holds the current outputs for the models at the observed wavelengths

StellarInterpolationHelper

A linear interpolation holding information to interpolate the stellar model shifted by an RV to the data

Submodel

Holds information on the wavelengths, LTISDE representaiton for the GP reguarlization term, and linear model for a SSOF model component

TemplateModel

A constant model (when there are no feature vectors)

TotalWorkspace

A workspace to optimize all of the parameters in a SSOF model and data it is to be optimized on Uses our custom implementation of ADAM

flatten([eltype=Real], x::LinearModel)

Returns a "flattened" representation of x::LinearModel as a vector of vectors and a function unflatten that takes a vector of reals of the same length and returns a LinearModel object

flatten([eltype=Real], x::SubArray)

Returns a "flattened" representation of x::SubArray as a vector and a function unflatten that takes a vector of reals of the same length and returns an Array object

AdamState!(as, ℓ, Δ)

Update as with the next iteration's loss and gradient

D_to_rv(D)

Approximately converting a Doppler shift D ≡ log(λ1/λ0) in log-wavelength space to an RV using (λ1-λ0)/λ0 = λ1/λ0 - 1 = e^D - 1 ≈ β = v / c (with an extra negative sign from somewhere)

L1 norm

L2 norm

L∞ norm

Output!(o, om, d)

Recalculates the current outputs for the models at the observed wavelengths

_OSW_optimize!(osw, options)

Optimize the model in osw

_eval_lm(M, s, μ; log_lm=false)

Evaluate a LinearModel

_eval_lm_vec(om, v; log_lm=_log_lm_default)

Evaluate a vectorized version of a linear model in v

_eval_regularization(om, mws, training_inds, testing_inds; kwargs...)

Training om on the training data, evaluating _loss() on the testing data after optimizing the RVs and scores

_loss_recalc_rv_basis(o, om, d; kwargs...)

_loss() but including an AD-compliant way to recalcuate the Doppler basic vector

_lower_inds!(lower_inds, lower_inds_adj, model_log_λ, rvs, log_λ_obs)

find the model_log_λ indices (incl. RV shifts) that bracket each log_λ_obs

_shift_log_λ_model(log_λ_obs_from, log_λ_obs_to, log_λ_model_from)

Getting model log λ in a different reference frame using the shifts in the different log_λ_obs

_spectra_interp_gp!(fluxes, log_λ, flux_obs, var_obs, log_λ_obs; gp_mean=0., gp_base=SOAP_gp, mask_flux=Array{Bool}(undef, length(flux_obs)), mask_var=Array{Bool}(undef, length(flux_obs)))

Use a GP to interpolate flux_obs observed at log_λ_obs onto log_λ

affected_pixels!(affected1, affected2)

Store the indicies in both affected1 and affected2 in affected1

affected_pixels(bad)

Store the first indicies where bad` is true

Akaike information criterion

Akaike information criterion (corrected for small sample sizes)

Bayesian information criterion

build_gp(params)

Builds a Matern 5/2 TemporalGPs GP

calculate_initial_model(data; kwargs...)

Find a SSOF model for a given dataset, data. Defaults to returning the AIC-minimum model

Optional arguments

• instrument::String="None": The name of the instrument(s) the data was taken from. For bookkeeping
• desired_order::Int=0: What order (if any) the data was taken from. For bookkeeping
• star::String="None": The name of the star the data was taken from. For bookkeeping
• times::AbstractVector=1:size(data.flux, 2): The list of times (in days). Used to calculate intra-night RMS
• μ_min::Real=0: Set the minimum flux value for the output of make_template()
• μ_max::Real=Inf: Set the maximum flux value for the output of make_template()
• use_mean::Bool=true: Whether to use the mean or median for make_template()
• stop_early::Bool=false: Whether to stop the model search the first time adding a component increases the AIC
• remove_reciprocal_continuum::Bool=false: Whether you should attempt to remove places where the telluric template and stellar template are opposing each other (i.e. where continuum goes up in one and down in the other)
• return_full_path::Bool=false: Whether to return all of the searched models and metrics
• max_n_tel::Int=5: The maximum amount of telluric feature vectors to look for
• max_n_star::Int=5: The maximum amount of stellar feature vectors to look for
• use_all_comps::Bool=false: Whether to use all feature vectors, regardless of AIC
• careful_first_step::Bool=true: Whether to shrink the learning rates until the loss improves on the first iteration
• speed_up::Bool=false: Whether to inflate the learning rates until the loss is no longer improving throughout the optimization
• log_λ_gp_star::Real=1/SOAP_gp_params.λ: The log λ lengthscale of the stellar regularization GP
• log_λ_gp_tel::Real=1/LSF_gp_params.λ: The log λ lengthscale of the telluric regularization GP
• kwargs...: kwargs passed to OrderModel constructor

check_converged(as, f_reltol, g_reltol, g_L∞tol)

Check to see if the Adam optimization has coverged based on the change in loss or its gradient

check_for_valid_regularization(reg)

Make sure all the keys in reg are in SSOF.keylist

choose_reg_and_ℓ(reg_fields, om, reg_key, reg_hold, ℓs, j)

Set the reg_key regularization for om once the local minimum is found

copy_reg!(from, to)

Copy the regularizations from one OrderModel to another

create_λ_template(log_λ_obs; upscale=1.)

Creating a uniform grid of log wavelengths for the SSOF models to be evaluated on

downsize(lm, n_comp)

Create a smaller version of lm that only copies some amount of the feature vectors

downsize(lm, n_comp)

Create a smaller view of lm that can only see some amount of the feature vectors

estimate_σ_bootstrap(mws; n=50, return_holders=false, recalc_mean=false, multithread=nthreads() > 3, verbose=true)

Estimate the uncertainties (and potentially covariances) for the RVs and scores in mws based on looking at the distribution of best-fit parameters after re-injecting photon noise. Slower than estimate_σ_curvature(), but more reliable.

estimate_σ_bootstrap_helper!(rv_holder, tel_holder, star_holder, i, mws, data_noise, n; verbose=true)

Refit the RVs and scores after re-injecting photon noise and store the results in rv_holder, tel_holder, and star_holder

estimate_σ_bootstrap_reducer(shaper, holder, reducer)

Apply reducer on the first axis of holder and store the results in an array the shape of shaper

estimate_σ_curvature(mws; kwargs...)

Estimate the uncertainties for the RVs and scores in mws based on the local curvature of the loss function. Faster than estimate_σ_bootstrap(), but less reliable from ignoring cross terms in the Hessian.

estimate_σ_curvature_helper(x, ℓ; n=7, use_gradient=false, multithread=nthreads() > 3, print_every=10, kwargs...)

Estimate the uncertainties for the best-fit parameters x for ~Gaussian function ℓ based on the local curvature

estimate_σ_curvature_helper_finalizer!(σs, _ℓs, x_test, i; use_gradient=false, param_str="", print_every=10, verbose=false, show_plots=false)

Calculate uncertanties (filling σs) based on the _ℓs calculated at x_test

eval_regularization(reg_fields, reg_key, reg_val, mws, training_inds, testing_inds; kwargs...)

Setting regularizaiton values for a copy of mws.om then training it on the training data and evaluating _loss() on the testing data after optimizing the RVs and scores

fill_OrderModel!(om1, om2, inds_tel, inds_star)

Replace the models in om1 with those in om2

fill_StarModel!(om, lm; inds=2:size(lm.M, 2))

Replace the stellar model in om with lm

fill_TelModel!(om, lm)

Replace the telluric model in om with lm

finalize_scores!(score_trainer, mws)

Run score_trainer and update the output in mws

finalize_scores!(mws; kwargs...)

Optimize the scores in mws

finalize_scores_setup(mws; verbose=_verbose_def, f_tol=_f_reltol_def_s, g_tol=_g_L∞tol_def_s, careful_first_step=true, speed_up=false, kwargs...)

Create a function that optimizes the model scores with Optim

first_iterate!(l, l0, θs, θ, ∇θ, opt; ind=[], verbose=false)

Perform an ADAM optimization step based on the contents of opt on θ and decreases the learning rate to ensure the loss actually decreases

fit_regularization!(mws, testing_inds; key_list=_key_list_fit, share_regs=false, kwargs...)

Fit all of the regularization values in key_list for the model in mws

fit_regularization!(mws; verbose=true, testing_ratio=0.33, careful_first_step=true, speed_up=false, kwargs...)

Find the best fit model without regularization then fit all of the regularization values in key_list for the model in mws

fit_regularization_helper!(reg_fields, reg_key, before_ℓ, mws, training_inds, testing_inds, test_factor, reg_min, reg_max; start=10e3, cullable=Symbol[], robust_start=true, thres=8, kwargs...)

Setting reg_key values in each Dict in mws.om.x (where x is each symbol in $reg_fields$) for a copy of mws.om then training it on the training data and evaluating _loss() on the testing data after optimizing the RVs and scores

flip_feature_vectors!(lm)

Make each feature vector's median value negative

get_marginal_GP(finite_GP, ys, xs)

Marginalizes a TemporalGPs GP on ys and xs

get_mean_GP(finite_GP, ys, xs)

Gets the mean of the posterior of a TemporalGPs GP

gp_Δℓ(y, A_k, Σ_k, H_k, P∞; kwargs...)

Calculate the gradient of gp_ℓ() w.r.t. y

gp_Δℓ_coefficients(n, A_k, Σ_k; H_k=H_k, P∞=P∞, sparsity=0, kwargs...)

Precalculate coefficients that can be used to calculate gradient of gp_ℓ() w.r.t. y

gp_Δℓ_helper_K(n, A_k, Σ_k, H_k, P∞; σ²_meas=_σ²_meas_def)

Precalculate all of the K matrices for at each time

gp_Δℓ_helper_γ(y, A_k, Σ_k, H_k, P∞; σ²_meas=_σ²_meas_def)

Precalculate all of the γ values for at each time

gp_ℓ(y, A_k, Σ_k; σ²_meas=_σ²_meas_def, H_k=H_k, P∞=P∞)

Getting the posterior likelihood that y is from a LTISDE described by A_k and Σ_k, equivalent to a GP

gp_ℓ_nabla(y, A_k, Σ_k; σ²_meas=_σ²_meas_def, H_k=H_k, P∞=P∞)

Getting the posterior likelihood that y is from a LTISDE described by A_k and Σ_k, equivalent to a GP. Same as gp_ℓ() but removing things that Nabla doesn't like

gp_ℓ_precalc(ℓ_coeff, x, A_k, Σ_k; kwargs...)

A version of gp_ℓ() using the coefficients calculated by gp_Δℓ_coefficients()

improve_initial_model!(mws; careful_first_step=true, speed_up=false, kwargs...)

Train the model in mws with an extra step to ensure we are at a local maximum for the scores and RVs Defaults to taking a careful first step

improve_model!(mws; verbose=true, kwargs...)

Train the model in mws with an extra step to ensure we are at a local maximum for the scores and RVs

	insert_and_dedup!(v, x)

Insert x into sorted list v without duplicates

intra_night_std(rvs, times; thres=3, show_warn=true)

Calculates the intra-night std for rvs time series observed at times (in days)

iterate!(θ, ∇θ, opt)

Perform an ADAM optimization step based on the contents of opt on θ

Whether a LinearModel is log linear

loss_func(mws; include_priors=false)

Create a loss function for the model and data in mws

loss_funcs_frozen_tel(o, om, d)

Create loss functions for changing - the stellar templates, features, and scores and telluric scores - the telluric and stellar scores and RVs

Used to fit models with a set telluric model

loss_funcs_telstar(o, om, d)

Create loss functions for changing - the telluric and stellar templates, features, and scores - the telluric and stellar scores - the RVs

Used to fit scores efficiently with L-BFGS

loss_funcs_total(o, om, d)

Create loss functions for changing - the telluric and stellar templates, features, and scores - the telluric and stellar scores and RVs

Used to fit models with ADAM

mask!(var, bad_inds; using_weights=false)

Setting var to reflect that the pixels at bad_inds should be masked

mask_stellar_feature!(var, log_λ_star, log_λ_low, log_λ_high; verbose=true, inverse=false, kwargs...)

Masking where log_λ_star is between (or outside if inverse=true) log_λ_low and log_λ_high

mask_stellar_pixel!(var, log_λ_star, log_λ_star_bounds, i; padding=0, verbose=true, kwargs...)

Masking a pixel in the stellar frame to prevent different lines from coming in at different times

mask_stellar_feature!(var, log_λ_obs, log_λ_star, log_λ_low, log_λ_high; verbose=true, include_bary_shifts=true, kwargs...)

Masking where log_λ_obs is between log_λ_low and log_λ_high. Can also perform in the stellar frame to prevent different lines from coming in at different times with include_bary_shifts

model_prior(lm, om, key)

Calulate the model prior on lm with the regularization terms in om.reg_ * key

model_s_prior(s, reg)

Add an L2 term to the scores if there are any regularization terms applied to the feature vectors

no_tellurics(model)

Figure out whether a model uses its telluric model

opt_funcs(loss, pars)

Create an objective object for Optim from loss that uses a flattened verison of pars

oversamp_interp_helper(to_bounds, from_x)

Finding the coefficients to integrate the model between observed pixel bounds

ratio_clarifier_string(ratio)

Convert ratio to a nice 3 digit-rounded string

recalc_total!(o, d)

Recalulates the current outputs for the total model at the observed wavelengths

remove_lm_score_means!(lm; prop=0.)

Recenter the scores in lm around 0

reset_regularization!(om)

Reset all of the keys in the regularization Dicts to the default values

rm_GP_regularization!(om)

Remove all of the GP keys in the regularization Dicts

rm_dict!(d, key_start)

Remove all keys starting with key_start in a Dict

rm_dict!(d)

Remove all keys in a Dict

rm_regularization!(om)

Remove all of the keys in the regularization Dicts

rv_model(om; lm=om.rv.lm)

Gets RV model interpolated onto the observed wavelengths (used by OrderModelDPCA)

rv_to_D(v)

Approximately converting an RV to a Doppler shift D ≡ log(λ1/λ0) in log-wavelength space using (λ1-λ0)/λ0 = λ1/λ0 - 1 = e^D - 1 ≈ β = v / c (with an extra negative sign from somewhere)

rvs(model)

Get RVs (in m/s) from an OrderModel The negative sign is only in the DPCA version because of how SSOF was originally coded

scale_α_helper!(opt, α_ratio, θ, α, scale_α)

Optionally scale opt.α based on the amplitudes in θ

shared_attention(M)

Ad-hoc regularization that punishes feature vectors with power in the same place

spectra_interp(model_flux, rvs, sih)

Interpolate the stellar model to the data using the lower inds in sih

spectra_interp(model, interp_helper)

Interpolates model using the interoplation described by interp_helper

speed_up_iterate!(l, θs, θ, ∇θ, opt; ind=[], verbose=false)

Perform an ADAM optimization step based on the contents of opt on θ and increases the learning rate to attempt to speed up the optimization

star_model(om; lm=om.star.lm)

Gets stellar model interpolated onto the observed wavelengths

star_prior(om)

Calulate the stellar model prior on om.star.lm with the regularization terms in om.star_tel

tel_model(om; lm=om.tel.lm)

Gets telluric model interpolated onto the observed wavelengths

tel_prior(om)

Calulate the telluric model prior on om.tel.lm with the regularization terms in om.reg_tel

total_length(mws)

Calculates the number of parameters of mws

total_model(tel, star)

Multiply the telluric and stellar models

train_OrderModel!(mws; ignore_regularization=false, verbose=_verbose_def, shift_scores=true, μ_positive=true, tel_μ_lt1=false, rm_doppler=true, kwargs...)

Train the model in mws with some optional modifications to the optimization (ignoreregularization, shiftscore, μpositive, telμlt1, rmdoppler)

train_OrderModel!(ow::OptimTelStarWorkspace; verbose=_verbose_def, iter=_iter_def, f_tol=_f_reltol_def, g_tol=_g_L∞tol_def, train_telstar=true, ignore_regularization=false, μ_positive=false, careful_first_step=true, speed_up=false, kwargs...)

Train the model in ow, training the telluric and stellar parameters, then the RVs

train_OrderModel!(ow::OptimTelStarWorkspace; verbose=_verbose_def, iter=_iter_def, f_tol=_f_reltol_def, g_tol=_g_L∞tol_def, train_telstar=true, ignore_regularization=false, μ_positive=false, careful_first_step=true, speed_up=false, kwargs...)

Train the model in ow, training the telluric and stellar parameters, then the RVs

train_SubModel!(aws; iter=_iter_def, f_reltol=_f_reltol_def, g_reltol=_g_reltol_def, g_L∞tol=_g_L∞tol_def, cb=(as::AdamState)->(), careful_first_step=true, speed_up=false, kwargs...)

Train the model parameters in aws for up to iter Adam iterations until it converges based on check_converged()

train_rvs_optim!(rv_ws, rv, optim_cb; g_tol=_g_L∞tol_def_s, f_tol=_f_reltol_def_s, iter=_iter_def, ignore_regularization=false, μ_positive=false, kwargs...)

Train the RVs from the rv_ws with Optim

undersamp_interp_helper(to_x, from_x)

Finding the coefficients to linear interpolate the model at observed pixel locations

update!(aws; careful_first_step=true, speed_up=false)

Perform an ADAM optimization step for the model parameters in aws

update_interpolation_locations!(om, d; use_mean=false)

Make sure the linear iterpolation locations for going from the stellar model to the data are correct as the RVs change

zero_regularization(om; include_L1_factor=false)

Zero-out all of the keys in the regularization Dicts

gp_ℓ_precalc(ℓ_coeff, x, A_k, Σ_k; kwargs...)

Calculate the gradient of gp_ℓ_precalc() w.r.t. y

Gaussian log-likelihood function

ℓ_prereqs(vars)

Calculate some terms needed to calculate the log-likelihood