GSoC 2015 ideas Page for TARDIS SN
- Testing (easy)
- Visualization (easy)
- Web interface (easy)
- Atomic Dataset (moderate)
- Plasma module (moderate)
- Search Algorithms (hard)
If you are interested in participating, please join our mailing list, tardis-sn-dev, and also fill out this application form (this is just an initial form there is more to this application including a sign-up to the official Melange Google site). We are also on Gitter (https://gitter.im/tardis-sn/tardis) and have a weekly videocon that you can participate in if there is interest. For more information you can also go to the Manual. Please contact us through the mailing list and introduce yourself. Gitter is also a good option.
A good first step is probably to start installing the software (http://tardis.readthedocs.org/en/latest/installation.html) and then running the included example file (http://tardis.readthedocs.org/en/latest/running.html). For the actual development we try to stick to a test driven model (http://tardis.readthedocs.org/en/latest/workflow/development_workflow.html) using git and github (http://tardis.readthedocs.org/en/latest/workflow/git_workflow.html).
The next steps are:
- Get in contact with the mailing list or gitter (introduce yourself)
- Select a project
- Many projects have additional specific instructions. They often involve the suggestion for a Pull Request.
- Make a Pull Request to our repository
- Start writing an application (some good pointers are here http://www.quora.com/How-to-write-a-good-GSoC-proposal). Be as specific as you can how you will spend 3 months with us. If you have a good draft - feel free to share it with us and discuss.
- Submit application to Melange (this is very important as this is the official GSoC application)
A supernova (here we show SN1994D in the Galaxy NGC4526) marks the brilliant death throes of a star, during which it outshines its entire galaxy. It not only marks death, though: supernova ejecta change the evolution of the universe and enable the formation of planets and life as we know it. From the iron in your blood to the gold in your jewellery, supernovae return heavy elements assembled from the primordial hydrogen and helium left after the big bang.
There are still many mysteries surrounding supernovae (e.g. their precise origins, inner workings, ...). One way to study these objects in more detail is to split the light coming from these objects into its components (like using a prism) and analyzing the resulting data (which is called a spectrum). Here we show a few different spectra (in black; courtesy of LBL) where we can see so called atomic lines (troughs in the spectrum) that are caused by certain chemical elements (each element - like fingerprints - has a line at certain places). This allows us to identify what the supernova is made of.
With sophisticated computer simulations astronomers try to reproduce their observed spectra to draw conclusion on the properties of the supernova ejecta and ultimately the explosion mechanism and progenitor stars. TARDIS is a code that can simulate spectra from inputs like supernova brightness, amount of Oxygen, amount of Silicon, etc. The idea is that if we put in the parameters that actually describe the supernovae the generated spectrum will closely match the observed spectrum.
TARDIS aims to be an easy to use piece of software for research and training purposes. Unlike many other scientific codes, we have purposefully made it open-source. This enables scientists to use the code to analyze their observations, but also review the code and potentially fix errors.
Below are ideas of projects for students. For any questions about the projects, please ask on our mailing list. If you have ideas of other projects, please also feel free to suggest these (but well in advance, so we have time to discuss possible plans)!
Difficulty: Easy
Astronomy knowledge needed: Low
Description: The test coverage of TARDIS is currently somewhat spurious. This project would involve making sure that all aspects of TARDIS are covered by unit tests. This includes the core simulation routines that are written in C and all the Python code. The prospective student would have to come up with ways of testing C code (most likely via Cython wrappers) and write the tests within py.test framework which is what we use. For simulation code the student would have to capture typical output for various functions involved in physical simulations and build tests on top of that. This is needed for regression testing whenever any refactoring or changes happen in the simulation code.
Preliminaries: Before the beginning of the program the student should choose a couple of untested bits of code, write tests for them and make a pull request.
Specific Instructions: https://github.com/tardis-sn/tardis/issues/249
Difficulty: Easy
Astronomy knowledge needed: None/Low
Description: TARDIS is based on a relatively complex physical model (the exploding star is dividided into concentric shells with different temperatures, elemental abundances, etc.) and for a given model it is very useful to explore this further. Currently, TARDIS provides a rather limited GUI (built on QT and matplotlib). For this project we would like someone to extend the graphical user interface to be able to display all the intricacies of the model. After the first part of the visualisation is done, we would like to add features so that TARDIS can be run as a fully-fledged graphical program. This will not only let the user explore the output, but also set parameters and re-run the simulation (which would be great for research and teaching purposes).
Preliminaries: Currently the GUI has some issues with PySide and displaying table headers. It might be a nice quick fix to deal with that.
Specific Instructions: https://github.com/tardis-sn/tardis/issues/264
Difficulty: Easy
Astronomy knowledge required: None/Low
Description: Currently TARDIS has to take a YAML file with all the parameters needed for the simulation. The goal of this project would be to develop a web based interface that would allow you to enter those parameters via a web interface, run the simulation, plot the results and allow one to download the resulting data file. This would allow novice users, students and other researchers interested in trying out TARDIS to quickly run a simulation and see the results without any complicated local installation. The prospective student should propose web technologies they would be willing to use for this project.
Preliminaries: Before the beginning of the program the student should create a simple web interface for creating TARDIS YAML files.
Specific Instructions: https://github.com/tardis-sn/tardis/issues/241
Difficulty: Moderate
Astronomy knowledge needed: None/Low - could be helpful
Programming skills: Python, Parsing, Databases (SQLAlchemy experience would be great)
Description: In addition to the input parameters (brightness of the supernova, ejected mass of the different chemical elements, etc.) TARDIS requires data for describing the structure of atoms from different elements (e.g. a sodium atom is differently structured than an iron atom; see the figure for a quick overview for carbon).
This data is not measured by astronomers, but most often gathered in a lab by atomic physicists. As measurement equipment gets more and more precise, so do the measured structures of different elements. Thus these values update from time to time and are often available in simple ASCII files (http://kurucz.harvard.edu/atoms/1401/gf1401.gam). While we have compiled a small atom data set from some specific sources for our initial work, we would like to get a collection of parsers that can read the different ASCII formats of the group and put this information in a uniform database.
For this project you would help us make parsers for a variety of formats from a collection of atomic data sources (e.g. http://cdsweb.u-strasbg.fr/topbase/home.html, http://www.nist.gov/pml/data/asd.cfm, etc.) and in the second part put this into a database. The assembled database will not only be very interesting for us, but also for many other fields of astronomy that do rely on atomic data. A useful resource of understanding atomic structure description can be found in http://www.physics.byu.edu/faculty/bergeson/physics571/notes/L27spectnotation.pdf.
Preliminaries: The student might write a small parser for some of the data tables that are publicly accessible (maybe using pyparsing).
Specific Instructions: https://github.com/tardis-sn/tardis/issues/242
Difficulty: Moderate
Astronomy knowledge needed: None/Low - physics is helpful
Programming skills: advanced python
Description: One of the main calculations that TARDIS performs is that of the state of the plasma. This plasma state is calculated from the density and temperature in the simulation in multiple steps. Currently it is not easily possible to add new physics by implementing new steps, however we are in the process of switching to a new framework. Currently we have transferred a small set of functions from the old framework to the new framework in the pull-request: https://github.com/tardis-sn/tardis/pull/215. The new framework is also able to visualize the calculation (see https://www.dropbox.com/s/biqohufc2rwmgc0/plasma_overview.pdf?dl=0).
This project sees you performing open-heart surgery on one of the critical parts of TARDIS. The first step will be to move all existing functionality to the new framework make sure that everything works as before. Over the summer, we will add further physics to the code using the new framework and your help.
Specific Instructions: https://github.com/tardis-sn/tardis/issues/263
Difficulty: Hard
Astronomy knowledge needed: None/Low
Description: In order to use TARDIS to estimate parameters of real supernovae we need to select TARDIS simulation parameters in such a way so as to produce spectra resembling those of real supernovae. When having a real spectrum, however, we don't know what those simulation parameters may be. The goal of this project would be to develop algorithms that when given a spectrum of a real supernova would produce a set of TARDIS simulation parameters (elemental abundances, etc.) that would produce a similar synthetic spectrum. This lets us estimate supernova parameters given it's spectrum. The problem here is that of optimization - we compare the two spectra (real and synthetic), estimate the difference between them numerically (as a single real number that is smaller when the spectra are more similar) and try to find parameters that lower that number. Estimating the difference between spectra is relatively straight forward. One way of doing it is to make the two spectra have the same number of points via interpolation and then use RMS error for each corresponding pair of points. Doing the actual optimization is harder and is subject to various practical and theoretical constraints. There exist already a lot of algorithms and methods for doing such optimization. These include but are not limited to:
- various gradient descent methods or methods approximating them,
- evolutionary algorithms,
- differential evolution,
- simulated annealing,
- particle swarm optimization
For this project the student would have to implement several optimization algorithms. One of the complications is that these algorithms require multiple runs of the TARDIS simulation which means they will have to run on supercomputer clusters. We will provide the prospective student access to compute clusters to allow to implement and test the methods. The algorithms then will have to be run several times with different real supernova spectra as inputs and the results of those algorithms (final error estimate and convergence speed) evaluated in order to determine which approaches are the most promising for this problem.
Specific Instructions: https://github.com/tardis-sn/tardis/issues/243