Rarity of Jupiter-like planets means planetary systems exactly like ours may be scarce

Is our little corner of the galaxy a special place? As of this date, we’ve discovered more than 1,500 exoplanets: planets orbiting stars other than our sun. Thousands more will be added to the list in the coming years as we confirm planetary candidates by alternative, independent methods.

In the hunt for other planets, we’re especially interested in those that might potentially host life. So we focus our modern exoplanet surveys on planets that might be similar to Earth: low-mass, rocky and with just the right temperature to allow for liquid water. But what about the other planets in the solar system? The Copernican principle – the idea that the Earth and the solar system are not unique or special in the universe – suggests the architecture of our planetary system should be common. But it doesn’t seem to be.

A mass-period diagram. Each dot marks the mass and orbital period of a confirmed exoplanet.
Stefano Meschiari

The figure above, called a mass-period diagram, provides a visual way to compare the planets of our solar system with those we’ve spotted farther away. It charts the orbital periods (the time it takes for a planet to make one trip around its central star) and the masses of the planets discovered so far, compared with the properties of solar system planets.

Planets like Earth, Jupiter, Saturn and Uranus occupy “empty” parts of the diagram – we haven’t found other planets with similar masses and orbits so far. At face value, this would indicate that the majority of planetary systems do not resemble our own solar system.

The solar system lacks close-in planets (planets with orbital periods between a few and a few tens of days) and super-Earths (a class of planets with masses a few times the mass of the Earth often detected in other planetary systems). On the other hand, it does feature several long-period gaseous planets with very nearly circular orbits (Jupiter, Saturn, Uranus and Neptune).

Part of this difference is due to selection effects: close-in, massive planets are easier to discover than far-out, low-mass planets. In light of this discovery bias, astronomers Rebecca Martin and Mario Livio convincingly argue that our solar system is actually more typical than it seems at first glance.

There is a sticking point, however: Jupiter still stands out. It’s an outlier based both on its orbital location (with a corresponding period of about 12 years) and its very-close-to-circular orbit. Understanding whether Jupiter’s relative uniqueness is a real feature, or another product of selection effects, has real implications for our understanding of exoplanets.

Jupiter as seen by the Hubble Space Telescope.

Throwing its weight around

According to our understanding of how our solar system formed, Jupiter shaped much of the other planets’ early history. Due to its gravity, it influenced the formation of Mars and Saturn. It potentially facilitated the development of life by shielding Earth from cosmic collisions that would have delayed or extinguished it, and by funneling water-rich bodies towards it. And its gravity likely swept the inner solar system of solid debris. Thanks to this clearing action, Jupiter might have prevented the formation of super-Earth planets with massive atmospheres, thereby ensuring that the inner solar system is populated with small, rocky planets with thin atmospheres.

Without Jupiter, it looks unlikely that we’d be here. As a consequence, figuring out if Jupiter is a relatively common type of planet might be crucial to understanding whether terrestrial planets with a similar formation environment as Earth are abundant in the galaxy.

Despite their relative heft, it’s a challenge to discover Jupiter analogs – those planets with periods and masses similar to Jupiter’s. Astronomers typically discover them using an indirect detection technique called the Doppler radial velocity method. The gravitational pull of the planet causes tiny shifts in the wavelength of features in the spectrum of the star, in a distinctive, periodic pattern. We can detect these shifts by periodically capturing the star’s light with a telescope and turning it into a spectrum with a spectrograph. This periodic signal, based on a planet’s long orbital period, can require monitoring a star over many years, even decades.

Are Jupiter-like planets rare?

In a recent paper, Dominick Rowan, a high school senior from New York, and his coauthors (including astronomers from the University of Texas, the University of California at Santa Cruz and me) analyzed the Doppler data for more than 1,100 stars. Each star was observed with the Keck Observatory telescope in Hawaii; many of them had been monitored for a decade or more. To analyze the data, he used the open-source statistical environment R together with a freely available application that I developed, called Systemic. Many universities use an online version to teach how to analyze astronomical data.

Our team studied the available data for each star and calculated the probability that a Jupiter-like planet could have been missed – either because not enough data are available, or because the data are not of high enough quality. To do this, we simulated hundreds of millions of possible scenarios. Each was created with a computer algorithm and represents a set of alternative possible observations. This procedure makes it possible to infer how many Jupiter analogs (both discovered and undiscovered) orbited the sample of 1,100 stars.

Orbit of the newly discovered Jupiter-mass planet orbiting the star HD 32963, compared to the orbits of Earth and Jupiter around the sun.
Stefano Meschiari, CC BY-ND

While carrying out this analysis, we discovered a new Jupiter-like planet orbiting HD 32963, which is a star very similar to the sun in terms of age and physical properties. To make this discovery, we analyzed each star with an automated algorithm that tried to uncover periodic signals potentially associated with the presence of a planet.

We pinpointed the frequency of Jupiter analogs across the survey at approximately 3%. This result is broadly consistent with previous estimates, which were based on a smaller set of stars or a different discovery technique. It greatly strengthens earlier predictions because we took decades of observations into account in the simulations.

This result has several consequences. First, the relative rarity of Jupiter-like planets indicates that true solar system analogs should themselves be rare. By extension, given the important role that Jupiter played at all stages of the formation of the solar system, Earth-like habitable planets with similar formation history to our solar system will be rare.

Finally, it also underscores that Jupiter-like planets do not form as readily around stars as other types of planets do. It could be because not enough solid material is available, or because these gas giants migrate closer to the central stars very efficiently. Recent planet-formation simulations tentatively bear out the latter explanation.

Long-running, ongoing surveys will continue to help us understand the architecture of the outer regions of planetary systems. Programs including the Keck planet search and the McDonald Planet Search have been accumulating data for decades. Discovering ice giants similar to Uranus and Neptune will be even tougher than tracking down these Jupiter analogs. Because of their long orbital periods (84 and 164 years) and the very small Doppler shifts they induce on their central stars (tens of times smaller than a Jupiter-like planet), the detection of Uranus and Neptune analogs lies far in the future.

The Conversation

This article was originally published on The Conversation. Read the original article.

Link: The Sound Of Mandelbrot Set

The Ripples blog  published a very nice post about “sonifying” the Mandelbrot set. The resulting sound files (linked in the post) are quite interesting, especially the “SlowDivergence” soundbite. The post also tipped me off about  playitbyr, an R package that converts a data.frame (a table of values) into an auditory graph. The soundbites demoed on the webpage are really cool — you should check them out!

The sonification window of Systemic v1.
The sonification window of Systemic v1.

The “classic” version of Systemic (v1, Java) has a feature for sonifying the orbital dynamics of exoplanets, originally written by Aaron Wolf (now a Turner Postdoctoral Fellow at the University of Michigan).

Non-interacting planets only generate pure sine-wave tones — not very interesting. It gets much more exciting once you introduce planetary interactions. Resonant and unstable systems, in particular, generate much more delicate or dramatic samples. Oklo.org has a few posts about the sonification feature, with downloadable soundbites.

I have not been a very good steward of this feature — it didn’t make it into Systemic2 (or the web app) since I didn’t want to work on migrating the Java code.  The existence of playitbyr, though, means I do not have to reinvent the wheel, definitely reigniting my interest in implementing this feature!

[Via R-bloggers.]

New release of Systemic 2 (2.14)

I have just released a new version of Systemic 2 (2.14).  Lots of little bug fixes, together with a few features.

My favorite is the “smooth orbit plot”, which recreates plots that will appear on an upcoming planet paper (I will put proper credit here once the paper is out!). The routine takes samples of orbital elements from the output of a Markov-Chain Monte Carlo or bootstrap run, and plots the orbits with some transparency, so that it is visually evident where orbits “crowd up”.

Smooth orbit plot
Smooth orbit plot made with Systemic 2.14

On top of the samples, I plotted the “best-fit” orbit in red (which hopefully will fall on top of the range of possible orbital elements!). This plot can also give some visual sense of multi-modal or non-symmetrical element distributions.

Download Systemic 2.14

Other changes:
– Added a feature for smoother/faster plotting in GUI
– Periodograms now print out the strongest peaks
– Periodograms are zoomable
– Fixed Cross-validation for fits with only one planet
– New menu item to add random Gaussian noise to data
– Smooth orbits plot from an error estimation object
– FIXED: Improved Linux installation instructions (credit for reporting: Thomas Kosvic)
– FIXED: bug in SWIFTRMVS on 32-bit installations (credit for reporting: Thomas Kosvic)

Systemic 2 Cookbook: Markov-Chain Monte Carlo

This post is the second in the “Systemic Cookbook” series, which will show how to use Systemic 2 for scientific purposes (especially its more advanced features not readily accessible from its user interface). More comprehensive documentation for Systemic is forthcoming.

All posts in this series will be collected in the “Systemic 2″ category.

I wrote a short draft guide to doing Markov-Chain Monte Carlo-type of fitting and error analysis with Systemic2. This guide covers the very basics of the algorithm, the input parameters, and a step-by-step guide on how to drive the algorithm from the user interface, or from the C library. Please note that more sophisticated MCMC algorithms are available as R packages on CRAN.

→ Download PDF

Systemic 2 Cookbook: Parallel computation with R

This post is the first in the “Systemic Cookbook” series, which will show how to use Systemic 2 for scientific purposes (especially its more advanced features not readily accessible from its user interface). More comprehensive documentation for Systemic is forthcoming.

All posts in this series will be collected in the “Systemic 2” category.

Systemic 2 automatically parallelizes so-called “embarrassingly parallelizable” workloads that do not need shared data or synchronization. Such workloads include bootstrap resampling and periodograms (each resampled data set is analyzed independently), Markov Chain Monte Carlo (each chain runs in parallel, and only synchronizes at infrequent intervals), jackknife, and other algorithms. Some algorithms can even be launched on Xgrid-connected clusters (Why, Apple?!).

The majority of embarrassingly parallelizable workloads, however, will be better defined by the user. In the rest of this article, I will show how to easily parallelize dynamical integration over a grid using an R script. (The following problem could be just as easily set up using C, but I will be showing how to accomplish it in R since the code will be most transparent in a high-level language.)

Setting up dynamical integration over a grid

The (somewhat artificial) problem is as follows. Imagine that we would like to investigate the survival time of a two-planet system, as we increase the eccentricity of the outer planet. Intuitively, we expect the system to become unstable faster as the eccentricity increases.

Let’s first set up a sample system and integrate it forward in time with Systemic2.

To run this script, type

Rscript scriptname.r

from the shell (edit the script beforehand to point it to the correct path to Systemic).

This script sets up a two-planet system around a 0.95 solar mass star, integrate it forward 50,000 years using the SWIFT backend and plot it to a PDF file. The “k” object is called a kernel within Systemic; it contains all the data and functions associated with the planetary system (internally, it is a handle returned by the C library).integration_1e5 Next, we create a grid of eccentricity and longitude of periastron angles. The rationale here is to average the survival times for each eccentricity, over the longitude of pericenter in order to remove the dependency on the phase angle (again, this is an artificial exercise!).

This part of the script involve some idiomatic R functions (not too dissimilar from the strategies used by Matlab, Numpy and other vectorized languages). To create a grid of eccentricity/phase angles (a cartesian product), I used the expand.grid function. Subsequently, I loop over the (e, lop) pairs using mapply. Mapply (m-apply) applies a function over each element of the two vectors and collects the return values of the function.

The function called by mapply sets up a kernel with the given eccentricity and longitude angle, and integrates the system forward in time using kintegrate. Kintegrate is the Systemic function that integrates a system forward in time,  returning an object containing information about the dynamical evolution of the system. One of the fields of the object is “survival.time”, how long the system survives (in this case, whether there is a close encounter or an ejection of one of the bodies).  Then, we collect the survival times, group them by eccentricity (using split) and take the median (using sapply).  Finally, we plot the eccentricity vs. the survival time.

Parallelizing the problem

Recent R builds include the parallel package. The parallel package includes various implementations of apply (map) functions that are drop-in replacements for the builtin R functions (e.g. the *apply family of functions). Parallelization is achieved by transparently launching a number of “worker” processes, executing the function on each worker and finally collecting the result (the workers are heavyweight processes rather than threads, so you will see several R processes if you inspect your running programs).

Screen Shot 2014-01-16 at 8.36.07 PM

Here is the revised script:

Note that the only change was using the “mcmapply” (multicore-mapply) function instead of the “mapply” builtin! Since this problem is eminently parallelizable, the speedup is linear in the number of physical cores.

Closing words

In this case, parallelization was trivial; in other cases, it might be more involved (for instance, when balancing is required).