🖼️ Visualizing Planets

We often want to visualize one or more exoplanet populations in fairly standard ways. Here we summarize some predefined visualizations for populations and explain how you can create your own multi-panel, multi-population visualizations with exoatlas.

We’ll modify the default plot aspect ratio, so they don’t take up too much space.

Let’s generate some populations to visualize.

Make Your Own Plots with exoatlas Data¶

It is, of course, possible to make your own plots using data from exoatlas populations. You probably have some brilliant idea, and just working with the raw quantities might be where you want to start. Here’s a basic example.

You can build up whatever beautiful, transparent, creative, and useful visualizations you want on your own.

However, often we may want to fill a panel with multiple different planet populations, and maybe even across multiple linked plots. That can be a little annoying to keep track of, so we tried to add a few shortcuts to make it easier to sets of quantities for groups of populations.

These tools are all contained within the exoatlas.visualizations module.

📏 Plottable 📏 objects prepare data for visualization¶

To get data ready for visualizing, a Plottable will generally define some of the following:

• source = where does the quantity come from? This should be the name of a method that’s available for all the populations you might want to use.

• label = a human-friendly label. This may appear as axis labels or in figure legends.

• scale = are the data better displayed linearly or logarithmically? This will set the scale for x or y axes, or how colors or sizes are normalized.

• lim = what are reasonable limits? This would set default axis limits, or how colors and sizes are define their minimum and maximum values.

• **kw = if source is a method that takes keyword arguments (such as teq(albedo_bond=..., f=...)), any additional keywords you provide when creating a Plottable will get passed along to the method

Let’s create a few:

We indicate these variables as Plottable by a little ruler 📏, indicating each is ready to draw some data at the right locations on a plot.

For a given population, it can retrieve values and symmetric or asymmetric uncertainties.

We can also calculate normalized values, which may be useful for representing sizes or colors. The normalization will pay attention to the scale and lim keywords.

If we wanted to stop here, we could use these three Plottable objects to help create a plot. Practically, this isn’t much different from just making the plot ourselves from the raw data; basically it’s just the size normalization that’s helping.

We provide a number of preset Plottable objects to use as visual components. These can be accessed directly as variables in vi, or as elements of the vi.preset_plottables dictionary.

🗺️ Map 🗺️ objects draw plots with plottables¶

With a Map, we can combine a few Plottable objects together to build up a plot. The Map is responsible for:

• managing the figure and axes where data will be drawn

• looping over populations and representing them

• serving as a building block for multi-panel linked visualizations

The two main maps we use are BubbleMap for scatter plots and ErrorMap for including error bars.

BubbleMap for x, y, size, color

For basic scatter plots, we might try BubbleMap, where the four ways we might represent data are:

• xaxis = bubble position along the x-axis

• yaxis = bubble position along the y-axis

• size = bubble area, based on normalized_value

• color = bubble color, based on normalized_value, according to a colormap

Let’s try this with a basic example. We create a Map (🗺️) from two Plottable (📏) objects. We can use this Map to plot individual populations one-by-one with plot()...

...or use build() to build up the plot by looping over populations.

Let’s use one more data dimension by having the size represent the brightness of the star as seen from Earth, using color simply to represent the two different populations.

Or, if we’re focusing primarily on one Population, we might use color to represent another quantity. In the plot below, we can see that while stellar brightness at Earth (size) generally increases toward closer distances, stars with cooler stellar effective temperatures (color) have lower intrinsic luminosities and therefore appear less bright, even at nearby distances.

ErrorMap for x, y with uncertainties

Including errorbars on exoplanet population data can get tricky because planets can have wildly heteroscedastic uncertainties. If we just plot errorbars for all data points equally, our eyes are visually drawn to the largest uncertainties, while we’d like them to do the opposite: focus in on the best data! As such, in the ErrorMap we by default scale the intensity of errorbars to visually emphasize the points with the smallest uncertainties.

We provide some preset Maps objects to use as visual components. These can be accessed directly as variables in vi, or as elements of the vi.preset_maps dictionary. Some of these maps have extra functions defined inside of them, like for plotting habitable zones or models.

🖼️ Gallery 🖼️ objects collects maps together¶

Often, we may want to look at multiple plots side-by-side, to see how trends in one view might relate to other properties. A Gallery can be built up from a collection of Map objects, like this. Let’s add one more planet population for comparison, and then look at a few examples.

Let’s start by creating a Gallery from a list of Map objects, which will then be organized and built into a multipanel plot. For example, let’s try to make an approximate version of a “cosmic shoreline” plot, including a few extra Solar System populations.

Next, let’s try TransitGallery, a preset Gallery that works well for transiting exoplanet populations.

The definition of TransitGallery effectively just chooses a few default Map objects to include. Let’s make a similar one on our own, with just the first two panels, to see how that’d work.

The GridGallery can be used to specify a grid of maps with shared x and y axes, starting from the Plottable quantities you want along each row and column.

Arbitrarily complicated custom Gallery definitions can be created by overwriting the .setup_maps and .refine_maps methods. That’s how PlanetGallery and EverythingGallery were made!

These examples are not entirely exhaustive, but hopefully they give you a little taste of what might be possible using exoatlas for visualizations!