Hands-on Practice: Local Group Cartography

Astro-RPS Week 6 Saturday Bootcamp¶

Mapping the Local Group of Galaxies¶

Context¶

In this practice, we are going to make a map of the Local Group of galaxies (and associated star clusters). Roughly speaking, the Local Group refers to the gravitationally-bound group of galaxies within which the Milky Way resides; it spans out to roughly 10 million light years from the Milky Way (3 Megaparsecs, in more common units in the field). This volume contains just two massive galaxies -- the Milky Way and Andromeda -- in addition to hundreds of low-mass dwarf galaxies and thousands of star clusters.

We usually think of the positions of things in the Local Group in Galactocentric Cartesian coordinates (X, Y, Z), where the origin is at the center of the Milky Way galaxy. However, we cannot observe these directly. Instead, we typically record the angular positions of stars/galaxies, etc., in “Right Ascension” (0-360 degrees) and “Declination” (-90 to 90 degrees) as well as their distances with respect to the Sun (their “heliocentric distances”). These measurable quantities can be converted to the Galactocentric coordinate system, assuming a reference frame for the Milky Way.

For today’s exercise, we’re going to give you this conversion in the form of a function below.

from astropy import units as u
from astropy.coordinates import SkyCoord, Galactocentric
import numpy as np

def convert_to_galactocentric(ra, dec, distance_kpc):
    """
    Convert RA, Dec, and heliocentric distance to Galactocentric Coordinates.
    
    Parameters:
        ra (float): Right Ascension in degrees
        dec (float): Declination in degrees
        distance_kpc (float): Heliocentric distance in kpc
        
    Returns:
        tuple: (GCX, GCY, GCZ) in kpc
    """
    # Create a SkyCoord object
    coord = SkyCoord(ra=ra * u.deg, dec=dec * u.deg, distance=distance_kpc * u.kpc, frame='icrs')
    
    # Convert to Galactocentric coordinates
    gc_coord = coord.transform_to(Galactocentric())
    
    # Convert to Cartesian coordinates
    gcx = gc_coord.cartesian.x.to(u.kpc).value
    gcy = gc_coord.cartesian.y.to(u.kpc).value
    gcz = gc_coord.cartesian.z.to(u.kpc).value
    
    return gcx, gcy, gcz

An example of using this function for a single trio of (RA,DEC,distance):

# Example usage:
ra = 180.0  # degrees
dec = 45.0  # degrees
distance = 10.0  # kpc
x, y, z = convert_to_galactocentric(ra, dec, distance)
print(f"X: {sgx:.2f} kpc")
print(f"Y: {sgy:.2f} kpc")
print(f"Z: {sgz:.2f} kpc")

X: -11.13 kpc
Y: 1.79 kpc
Z: 9.39 kpc

Exercise Part 1: Assembling a Database of Galactocentric Cartesian Coordinates for Local Group Galaxies

In this exercise, we will use the “Local Volume Database” published by Pace (2024), available through a GitHub repository (https://github.com/apace7/local_volume_database).

Navigate to the link above and locate the “Releases” section on the right-hand side. Click on the latest release and download the file named “comb_all.csv”.
Load the file you just downloaded using pandas. Perform some basic checks: print out the header, inspect the columns, etc. Most importantly, locate the column labeled distance_modulus.
Write a function to convert the distance modulus to distance. Recall from a previous lab that the distance $d$ in parsecs can be calculated from the distance modulus μ using the formula:

d = 10^{\frac{\mu + 5}{5}}

(1)

where:

( d ) is the distance in parsecs (pc), and ( \mu ) is the distance modulus.

We need the distance in Megaparsecs (Mpc), so modify your function to return the distance in that unit (1 Mpc = ( 10^3 ) pc).

Create a new column in your dataframe called distance_kpc by applying your function to the dataframe (no need for loops).
Next, use the RA, DEC, and distance_kpc columns to calculate the corresponding SGX, SGY, and SGZ coordinates. Store these results in three new columns in the dataframe.
Finally, filter the dataframe to include only objects in the Local Group (i.e., those with distance_kpc < 3000 kpc) and overwrite the current dataframe.

That’s it for now.

Exercise Part 2: Detailed Maps of the Local Group

In this part of the exercise, you will create multiple three-panel figures showing different projections of the Local Group in the Galactocentric Cartesian coordinate system.

Using the dataframe from Part 1, plot the following projections in a single set of three subplots.
- X vs Y
- X vs Z
- Y vs Z For each plot, label the axes appropriately including units.
There should be two major clumps visible in these projections. Let’s first dig into the Milky Way specifically, which is definitionally at (0,0,0) in our coordinate sytem. Filter out to distance of 350 kpc and store the result into a dataframe.
Create a filter for the globular star clusters of the Milky Way by using the table column (look for the entries with “gc_harris”). Plot these as black "x"s. Feel free to play around with the marker size and the transparency/alpha parameter to make the plot look nice. Give your plot a descriptive title. Also set reasonable axes limits that are equal aspect (i.e., one unit of X should be the same about of space on the plot as one unit of Y - if needed, google how to do this!). Save the figure as a PDF.
Create a new figure where you repeat the same for the dwarf galaxies around the Milky Way (entries with “dwarf_mw”). Color these as blue dots. How does the distribution of the dwarf galaxies compare to the distribution of the globular clusters? Save the figure as a PDF.
Now, create a 3D map of the Local Group including Andromeda (distance_kpc < 3 should suffice). Be as creative as you want with how you separate objects - e.g., split MW and M31 satellites by filtering on the coordinates directly, as opposed to using the table column. See here https://matplotlib.org/stable/gallery/mplot3d/scatter3d.html#sphx-glr-gallery-mplot3d-scatter3d-py for tips on 3D plotting.

Week 6

Hands-on Practice: Exoplanets Example

Week 6

Astro-RPS Bootcamp: Pandas