Project

A repository for my Masters Project on exoplanet transit timing variations.

Motivation

Transiting exoplanets are growing ever more numerous, since Kepler launched in 2009, we have seen an explosive growth in the number of them detected. There are thousands visible in any single patch of the sky, and that's awesome.

What interests me, however, is the potential hidden planets in those systems. The planets whose transit is off axis to our line of sight, and slip past silent in the night. Through their gravitational influence on the planets we can see, hints of their presence are evident, hints that we will attempt to locate programmatically.

File Structure

The file structure of this repository is as follows:

Repo/
├ Files/
│ ├ Documents /
│ │ ├ Literature_Review.pdf
│ │ ├ Poster.pdf
│ │ ├ ProjectPresentation.pptx
│ │ └ ProjectProposal.pdf
│ └ Images /                    *Contains various images generated for use in the research paper*
├ Source/
│ ├ old_code /                  *Contains various bits legacy code that is kept for reference*
│ ├ raw_data/
│ │ ├ midTransitTimes/          *Contains CSV Data for all exoplanets mid-transit times*
│ │ ├ tess_data/                *Contains CSV Data and Light-curve fits for all exoplanet TESS Data*
│ │ ├ ETDEphemerides.csv        *ephemerides from Exoplanet Transit database*
│ │ ├ exoClockEphemerides.csv   *ephemerides from ExoClock database*
│ │ ├ exoplanetList.csv         *list of all exoplanets with mid-transit times*
│ │ ├ ps.csv                    *NASA Exoplanet Archive planetary information table*
│ │ └ pscomparrs.csv            *NASA Exoplanet Archive composite planetary table*
│ ├ sim_data/                   *Contains the outputs of any simulations that were run*
│ ├ TransitProject/
│ │ ├ __init__.py
│ │ ├ modelling.py
│ │ ├ Simulation.py
│ │ ├ tesslc.py
│ │ └ webScraping.py
│ ├ ControlCandidates.csv
│ ├ determineTTVCandidates.py
│ ├ fetchData.py
│ ├ processing.py
│ └ simulationPipeline.py
├ .gitignore
├ README.md
└ requirements.txt

In the Source/ folder is all of the python scripts to be ran. These scripts are:

• determineTTVCandidates.py - Determine which, of all exoplanets, are ideal candidates for testing TTV Models.
• fetchData.py - Fetch Ephemerides and mid-transit times for exoplanets.
• processing.py - Fit a transiting model to the observed data.
• simulationPipeline.py - Simulate the known properties of an exoplanetary system to fetch transit times.

Additionally, there are the following files in Source/:

• ControlCandidates.csv - Comma separated list of ideal testing candidates, in decreasing order of mid-transit data-points

Contained within Source/TransitProject/ is the individual code modules common across the project. Additionally, within Source/old_code/ is legacy code that may still be useful.

At some point, I will probably have to write some unit-tests for all of my methods to ensure we have the expected outputs. Unfortunately, although I know how useful those are, I don't like doing that, so that may be a while (or possibly never, I'm not sure)

Overview

The (Current) High-level plan for this project is (as everything else is) subject to change. It is as follows:

• Find suitable observation targets (See Project Proposal).
• Observe targets to collect data.
• Fit data to transit model and upload to Exoclock (See Literature Review).
• Summarise methodology (See Poster).
• Write code.
  • Select target planetary system
  • Find all ExoClock/ETD data for the planetary system.
  • Find the known system information (ie: NASA Exoplanet Archive search).
  • Simulate the known parts of the system.
  • Fit the simulation to the ExoClock/ETD data.
  • Determine whether the system does exhibit TTV.
  • Run hundreds of simulations to suggest possible system layout.
  • Summarise every stage with graphs and charts.
• Compile results (see Presentation).
• Summarise findings and results, and suggest options for future work (see Dissertation).

Programming steps

This is a general overview of the "Write Code" step above, and is of course subject to change. Next to each item is a tickbox that marks its completion status.

• Collect all required data
  • ETD Lightcurves or mid-transit times
  • Exoclock
    • Lightcurves or mid-transit times
    • ephemerides
  • Exoplanet Archive System info
  • Exoplanet Catalogue
    • System info (Completed from another of my projects, available here)
    • digital renders for pretty graphs (Completed from another of my projects, available here)
  • TESS/Kepler raw data > fit lightcurves to that for comparisons.
  • Refactor code
• Combine data
  • Merge ETD & Exoclock data so as to plot hisotrical lightcurves
  • Merge Exoplanet Archive & Exoplanet Catalogue & ExoClock to find system information
    • Figure out how to deal with conflicting information
  • Refactor code
• Simulation
  • Write a shared library for simulation
    • Simulation pipeline
      • Fetch the planetary system to simulate
      • Fetch the system parameters
      • Simulate the system with all known bodies to determine perturbed transit times
      • Simulate the above with all known errors to determine error bars on perturbed transit times
  • Setup a pipeline with multithreading instances for many simulations in parallel
  • Allow the inclusion of other factors (Ie: maybe we want to look at the Effect of GR?)
  • Determine a standardised output
  • Refactor code
• Processing & Fitting
  • Determine a simpler model that can produce the sinusoid for a given system layout
    • Ensure this is accurate to system simulation
    • Should be decently fast to run
    • Is possible to give to an MCMC fitter
  • Linear fit to the visual data
    • Fit a line to the data
    • compare against exoclock ephemerides
    • Search through Residuals for TTV
  • Use multiple fitting types, ie: Idealised Sine, Sinusoid from known parameters, simple simulation
  • Fit using some extensive methodology, ie: MCMC, Simple Polyfit
  • Refactor code
• Analysis
  • Determine accuracy of fit to known data.
    • BIC Fit from bayesian analysis
  • Run MCMC fitting using TTVFast
  • Probably run Fourier analysis.
  • Determine a way of pulling out key frequency terms.
  • Map key information to system parameters. ie: frequency to orbital period mapping.
  • Determine if the known parameters of the system adequately map to the observed variation
    • If not, determine the parameters of the perturbation.
  • Refactor code
• Re-simulate
  • Use analysis to construct a range of possible system layouts (See Analysis)
  • Simulate each system layout (See Simulation step)
  • Re-perform analysis of simulation, determine which, if any, simulated system layouts fit the data.
  • Refactor code
• Pretty outputs
  • Graphical representations of all system layouts.
  • Annotated charts of any fit data.
  • Nice system parameter layout à la wikipedia.
  • Refactor code
• Code Objectives Complete