Python in Astronomy 2017 talks
Petr Kubánek
Use of Python in observatory environment
Abstract: This talk focuses on using Python for various roles in observatory environment. Python can
be used for observations scripting (so observers don't need to pay attention to details of ongoing
observation, or the observation can be run fully unattended), observation planning and observation
data processing. I will demonstrate how to use Python as a glue, leveraging available Python
packages.
Eduardo Enrique Rodas Quito
First steps towards developing cultural astronomy software
Abstract: When the archaeoastronomical study of El Puente archaeological site (located in Western
Honduras) started, improving the knowledge about this site was the main objective, since it had been
poorly studied relative to other sites in the Mayan Cultural area. However, as we worked in the
project, we realized about the relevance of implementing a software capable of reproducing with
high accuracy both the geographical and the celestial landscape. This way, future studies can be
extended for a much larger number of archaeological sites without raising the expenses in an
extended field campaign, waiting for the occurrence of astronomical events in the location. Also, this
work shows the conclusions of the first uses of this beta version of the Archaeoastronomical
software in El Puente archaeological site.
Ana Afonso
DOPTERIAN: a python version for artificially redshifting galaxies
Abstract: DOPTERIAN is a translation of the core algorithm of FERENGI (Full and Efficient Redshifting
of Ensembles of Nearby Galaxies, Barden et al. 2008) into Python, which includes a more general
treatment of the intrinsic luminosity evolution of galaxies as a function of redshift. This algorithm
allows to test the hypothesis of evolution studies across large redshift intervals by accounting for
image resolution, cosmological surface brightness dimming, and average luminosity evolution
effects. In Paulino-Afonso et al. (submitted to MNRAS) we use this algorithm to measure the
evolution of Ha-selected galaxies sizes across the last 11Gyrs of the Universe taking into account the
bias and systematics induced by the aforementioned effects. Here I will present the overall
description of the algorithm and its application in our research project. Since it can be applied to
other studies and it is written in a modular form making the improvements and adaptations really
easy to implement, I will discuss to the future improvements to extend its applications to spectral
data.
Meredith Rawls
From standalone scripts to software development
Abstract: I recently made the transition from being a casual python user to working with a team to
build the LSST alert production pipeline. I will discuss how your ability to make plots and do
calculations with python for your research has prepared you better for this kind of work than you
might think. I will demonstrate some of the techniques you can work on now to start making
contributions to large software projects regardless of whether it's an official part of your job.
Andre Gradvohl
Presenting SEA (SunPy Environment Application)
Abstract: We are developing an application called SEA (SunPy Environment Application), which aims
to gather and show data from some solar instruments. In the talk, we will like to present SEA, some
of its features, and collect suggestions from the audience to improve it. SEA is fully implemented in
Python, and works as a tool for other research activities of HighPIDS research group.
Berndette Randles
Sharing your code: Factors about going public
Abstract: If an astronomer is using Python/Python libraries as part of her research workflow, she/he
is already in the open source software world without perhaps knowing it. There are many facets to
the open source software world which the astronomer may not be aware; for example, what are
current best practices for sharing and citing created and existing code? What are ways astronomers
can contribute to open source software projects? What are some concerns relating to copyright work
for code researchers produce? What can researchers do when required by funding agencies to make
code and data repositories public?
K. Azalee Bostroem (Keynote)
Code review: Building a community to talk about coding
Abstract: As researchers we frequently discuss our scientific results in group meetings, however, very
few of us show the actual code we use, even though writing this code is how we spend most of our
time. We teach ourselves to use new packages, new languages, and new techniques without sharing
this knowledge with our peers. Furthermore, testing typically begins and ends with simple sanity
checks. At UC Davis, I founded a group to discuss the code we are writing for our research. Each
week, a volunteer presents something they are working on. Some weeks we learn about a new
package (e.g. Astropy modeling) or a new way to use a package (e.g. interactive plotting in
Matplotlib), other days we focus on a technique (e.g. how do you test your code), and on still other
days we look at a few functions or a class that someone has written. In all cases we are looking at
code line by line, allowing for a casual discussion of best coding practices and the techniques we have
developed. This is an incredibly efficient way to spread knowledge. The code shared has already been
written for a research project - so volunteering to present is little more than identifying an
appropriate piece of code to share. New Python learners are exposed to different coding styles and
best practices in an environment built for questions. Experienced learners can share information
amongst each other. I believe building a local community to discuss the code we use in our research
allows us to produce better scientific results with more ease.
Alex Hamilton
SunPy and time related datasets
Abstract: SunPy is the leading open source python astronomy package developed for solar physics.
Recent major releases include the creation of a new TimeSeries data class that allows a far greater
control and flexibility when reading and manipulating the data and maintain lightcurves and similar
time-centric observational data. This talk will discuss some of the challenges of dealing with such
data and the methods used to overcome them, including: presenting a robust method for handling
metadata across multiple files in such a way that tractability of data is conserved; development of a
single streamlined interface for the reading of data from multiple source files types. During this we
will also generally be introducing people to these and other new tools available in SunPy. Examples
include using a SunPy database to organise files of time series data. Note: the work was undertaken
as part of the ESA SoCiS programme in 2016.
David Shupe
Python widgets for astronomy visualization
Abstract: The huge data volumes that will come from LSST will require astronomers to shift from a
"download all the data, then figure out what to do" model, to using remote workspaces. The Science
User Interface and Tools group for LSST is based at Caltech/IPAC and is working to provide the
necessary interfaces to astronomers. My own contributions to this effort have included interfacing
Python to the Java/Javascript-based Firefly viewer developed for the Spitzer and IRSA archives. I will
give a talk on my experiences in developing Jupyter widgets for Firefly and how these are used in
Jupyter notebooks and the new Jupyterlab interface. The code repository for the widgets is available
at https://github.com/Caltech-IPAC/firefly_widgets.
Lucia Klarmann
Project based python teaching: Lessons from the two-body problem and beyond
Abstract: Compulsory basic programming classes (in python) for master students are a good way to
make sure each student learns basic programming skills, but it is very challenging to provide good
content for beginners and advanced students at the same time. One possibility is to offer an
independent project for students that score high enough in an initial skills test. The basic goal of the
project was to solve the two-body problem using different numerical techniques and document the
results in a final report and an animation. The numerical module had to be unit tested, well
documented and easily re-usable. Once this was done, I asked the students to develop the code
further, looking at more than two bodies, a specific setup like the solar system, objects with changing
mass etc., anything they might be interested in. This approach worked very well. The students were
motivated, invested more time then was allotted to the course, and the final reports were all in the
good to very good range. The main point of improvement is a stronger emphasis on unit testing, also
as a 'debugging technique' while the code is being written, not only as a test suit constructed at the
end of the project. It is also important to provide support for the literature research for the free part
of the projects. Students are good at finding help for python related problems online, but often
struggle to find or read scientific papers. Overall, I really recommend extra projects to keep more
advanced students happy in a beginner's python class.
Duncan Macleod
Using python to study gravitational-wave data
Abstract: The joint LSC-Virgo collaboration has announced the first detection of gravitational waves,
and has begun to publicly release GW strain data around those events. In this talk I will introduce
GWpy (https://gwpy.github.io) and other open-source python packages that can be used to read
public data hosted by the LIGO Open Science Center (https://losc.ligo.org), and describe how to
process and visualise those data. Additionally I will discuss possible avenues of closer collaboration
between GW python codes and those in the wider astrophysics community.
Johannes King
Astropy regions
Abstract: Astropy regions is an in-development package for region handling based on Astropy
(http://astropy-regions.readthedocs.io/en/latest/). It was already discussed at PyAstro15 and
PyAstro16 (http://astropy-regions.readthedocs.io/en/latest/development.html#notes). The
motivation for the regions package was to merge the functionality from pyregion
(http://pyregion.readthedocs.io/en/latest/) and photutils apertures
(http://photutils.readthedocs.io/en/latest/photutils/aperture.html) into a single package and add
more functionality. We plan to propose the new regions package for inclusion into the Astropy core
as 'astropy.regions' in April 2017, well in time for the Astropy 2.0 release. In my talk I will present the
functionality that is currently available (http://astropyregions.readthedocs.io/en/latest/getting_started.html), with the main goal of getting you to use
astropy regions for yourprojects/software packages.