Keir Ashby and Dr. Darin Ragozzine, Department of Physics and Astronomy
For centuries, humans have imagined if there are other worlds like ours and how we would be able to find them. Today, we are closer than ever to discovering the answer. In 2009 scientists launched the Kepler Space Telescope with the object of discovering exoplanets, or planets orbiting other stars. During the next four years, Kepler returned incredibly precise measurements of stellar brightness for over 200,000 stars, equipping researchers with more exoplanet data than ever before. The more we can understand from this data, the more we will know about planet/system formation and which of these exoplanets might have the potential to hold life.
Exoplanets are detected by observing miniscule dips in stellar brightness as the planet “transits” or passes in front of it’s host star. Although this detection method has produced thousands of exoplanet candidates, there are so many limiting factors inherent in this approach that if a telescope in another system attempted to detect transits from our Sun, it would have less than a 1% probability of detecting our Earth. Since we are particularly interested in finding planets similar to ours, this is especially problematic. Because of such limiting factors as geometric transit probability (or how Kepler is oriented relative to a particular system’s plane) and the satellite’s signal-to-noise-ratio (or clarity of measurements) we believe that there are many planets Kepler wasn’t able to see at all.
In order to discover what most exoplanetary systems actually look like, Dr. Ragozzine and his fellow researchers are developing a Planetary System Simulator or “SysSim”. This computer program generates hundreds of simulated models of exoplanet systems, calculates what these systems would look like to Kepler (called the observed catalog) and compares that to the actual observed data from Kepler (Hsu et al. 2017). If an observed catalog matches Kepler’s original observations, we can then say that our simulated model could potentially represent the true underlying population of exoplanets.
My role in SysSim’s development has been to take tables of signal-to-noise-ratio (SNR) arranged by the Kepler team (Burke et al. 2015) and write an efficient code to interpolate the data and determine the probability that a planet of certain properties is detectable by Kepler. The first step is to load these tables into SysSim. The data is stored in a 3-dimensional array holding the SNR value for 400 possible planet periods, 14 transit durations (how long the planet was crossing in front of its host star), and 91446 star IDs (for each star observed by Kepler). We want to allow the user to provide a list of particular star IDs as well as periods and durations for each of the planets orbiting those stars. My function will take these inputs and return to the user the SNR values for each planet provided.
Once we have loaded the 3-D array we will utilize the user’s values to reduce the data to a 2-D array holding just the periods and transit durations for one star ID at a time. At this point we can use Julia’s lininterp function on the 2-D array to interpolate the SNR for each period and transit duration given by the user. By applying this process to every system of stars and planets, we can determine the SNR values for an entire catalog of planets.
Results & Conclusion
SysSim is an advanced and complex program. One of the greatest challenges of this project, along with learning a new programming language, was developing a solid understanding of how to navigate SysSim’s vast web of function calls and myriad of unique variable types. In time, however, I was able to understand how my code fit into the program’s various components.
SysSim already has several functions that work together to determine the SNR of a given exoplanet. However, these functions use over-simplified equations to approximate SNR values and are thus less-accurate. Since it is always better to finish testing new code before deleting old code, I wrote my new functions just below them and re-routed the function calls, like switching out a few resistors on a circuit board. The first issue I recognized was that the original code used completely different inputs in it’s calculations. I traced back to all the locations in SysSim where the functions were called, learned how to extract the data that I needed, and sent those as the inputs to my new functions. I then ensured that my function outputs would be of the right type and be allocated to all the right places so that the code could continue running smoothly.
Finally, since SNR values need to be calculated thousands of times for each run of SysSim and loading the large 3-dimensional array is a time-consuming process that only needs to be done once, I made sure that this was completed in the setup stages. After running the code several times and comparing the results to that of the older version, it became clear that my code not only improved SysSim’s accuracy but even decreased computation time by an average of 20%! Our success in these crucial tests ensures that my code will remain as an integral component in SysSim’s detection probability methods, bringing us closer to a solid understanding of the true population of exoplanets.
As we continue improving on our current model of SysSim, it will be necessary to update the SNR tables to those most recently released by the Kepler team. I will also be developing additional code to produce figures (such as that on the previous page) to allow us to better visualize how SysSim’s various components are functioning and allow us to correct errors.