lya_and_lyc_maps.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Author: M. Riley Owens (GitHub: mrileyowens)\n",
    "\n",
    "# This notebook creates a figure showing the north and\n",
    "# northwest arcs of the Sunburst Arc in LyC and Lyman-alpha"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "from reproject import reproject_interp\n",
    "\n",
    "from regions import CircleSkyRegion, RectangleSkyRegion\n",
    "\n",
    "from astropy.io import fits\n",
    "from astropy.wcs import WCS\n",
    "import astropy.units as u\n",
    "from astropy.coordinates import Angle, SkyCoord\n",
    "from astropy.visualization.wcsaxes import add_scalebar\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.colors import SymLogNorm\n",
    "import matplotlib.patheffects as pe\n",
    "import matplotlib.patches as patches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot():\n",
    "\n",
    "    '''\n",
    "    Make a plot showing the two main arcs of the Sunburst Arc\n",
    "    in their LyC and Lyman-alpha maps\n",
    "    '''\n",
    "\n",
    "    def rotate_wcs(wcs, angle):\n",
    "\n",
    "        '''\n",
    "        Rotates a WCS projection by some angle\n",
    "\n",
    "        Parameters:\n",
    "\n",
    "            wcs : astropy.wcs.wcs.WCS\n",
    "                The original WCS projection\n",
    "\n",
    "            angle : int\n",
    "                The angle (in degrees) to rotate the WCS projection\n",
    "\n",
    "        Returns:\n",
    "\n",
    "            rotated_wcs : astropy.wcs.wcs.WCS\n",
    "                The rotated WCS projection\n",
    "        '''\n",
    "\n",
    "        # Define the rotation angle\n",
    "        angle = Angle(angle, unit='deg')\n",
    "\n",
    "        # Get the CD matrix from the original WCS projection\n",
    "        cd_matrix = wcs.wcs.cd\n",
    "\n",
    "        # Calculate the rotation matrix\n",
    "        cos_angle = np.cos(angle.rad)\n",
    "        sin_angle = np.sin(angle.rad)\n",
    "        rotation_matrix = np.array([[cos_angle, -sin_angle], [sin_angle, cos_angle]], dtype=np.float64)\n",
    "\n",
    "        # Apply the rotation to the CD matrix\n",
    "        rotated_cd_matrix = np.dot(cd_matrix, rotation_matrix)\n",
    "\n",
    "        # Update the CD matrix in the rotated WCS projection\n",
    "        rotated_wcs = wcs.deepcopy()\n",
    "        rotated_wcs.wcs.cd = rotated_cd_matrix\n",
    "\n",
    "        return rotated_wcs\n",
    "\n",
    "    # Dictionary containing information of the images of the different source plane regions of the Sunburst Arc appearing in the zoom-in inset axes, including their coordinates \n",
    "    # (RA, declination), color, and label orientation. The image labels and colors follow the terminology and color scheme of Sharon et al. (2022) (ApJ, 941, 203)\n",
    "    images = {\n",
    "        '1.1': [237.530818, -78.182515, '#ff0000', 'left', 45], '1.2': [237.525561, -78.182754, '#ff0000', 'right', 60], '1.3': [237.524859, -78.182817, '#ff0000', 'right', 75],\n",
    "        '1.4': [237.519097, -78.183181, '#ff0000', 'right', -45], '1.5': [237.518255, -78.183256, '#ff0000', 'right', 45], '1.6': [237.517455, -78.183354, '#ff0000', 'right', -45],\n",
    "        '1.7': [237.509198, -78.184647, '#ff0000', 'left', -45], '1.8': [237.501508, -78.186259, '#ff0000', 'right', 45], '1.9': [237.499785, -78.186745, '#ff0000', 'right', 45],\n",
    "        '1.10': [237.498917, -78.187077, '#ff0000', 'right', 45],\n",
    "\n",
    "        '2.1': [237.528078, -78.182604, '#ff6f00', 'left', 60], '2.2': [237.527379, -78.182635, '#ff6f00', 'left', 60], '2.3': [237.523906, -78.182902, '#ff6f00', 'left', 45],\n",
    "        '2.4': [237.520126, -78.183100, '#ff6f00', 'right', -45], '2.7': [237.508784, -78.184748, '#ff6f00', 'left', -45], '2.8': [237.503795, -78.185731, '#ff6f00', 'left', 45],\n",
    "\n",
    "        '3.3': [237.523472, -78.182926, '#00eb00', 'right', 75], '3.4': [237.520701, -78.183058, '#00eb00', 'right', 75], '3.7': [237.508271, -78.184839, '#00eb00', 'right', 60],\n",
    "        '3.8': [237.504896, -78.185501, '#00eb00', 'right', 60],\n",
    "\n",
    "        '4.3': [237.523614, -78.182962, '#9C27B0', 'right', -45], '4.4': [237.520679, -78.183110, '#9C27B0', 'left', 45], '4.7': [237.509090, -78.184749, '#9C27B0', 'left', 30],\n",
    "        '4.8': [237.5025603 - 0.0000547, -78.1861470 + 0.0000541, '#9C27B0', 'right', 75], '4.9': [237.499970, -78.186785, '#9C27B0', 'left', 45], '4.10': [237.499155, -78.187089, '#9C27B0', 'left', 45],\n",
    "\n",
    "        '5.1': [237.530472, -78.182525, '#c62828', 'right', -45], '5.2': [237.525924, -78.182728, '#c62828', 'left', 60], '5.3': [237.524665, -78.182835, '#c62828', 'left', 60],\n",
    "        '5.4': [237.519300, -78.183166, '#c62828', 'right', 75],\n",
    "\n",
    "        '6.1': [237.530282, -78.182473, '#e53935', 'left', -45], '6.2': [237.526374, -78.182639, '#e53935', 'right', 45],\n",
    "\n",
    "        '7.1': [237.529282, -78.182482, '#ef5350', 'right', 45], '7.2': [237.527034, -78.182569, '#ef5350', 'right', 45], '7.3': [237.523693, -78.182846, '#ef5350', 'left', -60],\n",
    "        '7.4': [237.520049, -78.183013, '#ef5350', 'right', 45], '7.7': [237.507458, -78.184894, '#ef5350', 'right', 45], '7.8': [237.505953, -78.185193, '#ef5350', 'right', 45],\n",
    "\n",
    "        '8.1': [237.528607, -78.182557, '#ef9a9a', 'right', 45], '8.2': [237.527136, -78.182623, '#ef9a9a', 'right', -45], '8.3': [237.523917, -78.182875, '#ef9a9a', 'left', -45],\n",
    "        '8.4': [237.520032, -78.183080, '#ef9a9a', 'right', 30], '8.7': [237.508469, -78.184775, '#ef9a9a', 'left', -45], '8.8': [237.504388, -78.185573, '#ef9a9a', 'right', 60],\n",
    "\n",
    "        '9.3': [237.523676, -78.182928, '#43a047', 'left', 60], '9.4': [237.520492, -78.183090, '#43a047', 'right', -45], '9.8': [237.504180, -78.185652, '#43a047', 'left', 45],\n",
    "\n",
    "        '10.3': [237.523251, -78.182942, '#8bc34a', 'right', -45], '10.4': [237.521002, -78.183046, '#8bc34a', 'left', 45], '10.7': [237.508163, -78.184876, '#8bc34a', 'left', 60],\n",
    "        '10.8': [237.505064, -78.185473, '#8bc34a', 'left', 45],\n",
    "\n",
    "        '11.3': [237.523067, -78.182913, '#66bb6a', 'right', 45], '11.4': [237.521062, -78.182998, '#66bb6a', 'left', -45],\n",
    "\n",
    "        '12.3': [237.522753, -78.182948, '#aed581', 'right', -45], '12.4': [237.521510, -78.182999, '#aed581', 'left', -45],\n",
    "\n",
    "        '13.7': [237.507614, -78.185015, '#a5d6a7', 'right', 60], '13.8': [237.506255, -78.185277, '#a5d6a7', 'right', 45],\n",
    "\n",
    "        '14.7': [237.507415, -78.185061, '#dcedc8', 'left', 75], '14.8': [237.506400, -78.185256, '#dcedc8', 'right', -60],\n",
    "\n",
    "        '15.7': [237.507203, -78.185102, '#1b5e20', 'right', 45], '15.8': [237.506595, -78.185218, '#1b5e20', 'left', 45],\n",
    "\n",
    "        '101.1': [237.532701, -78.182363, '#FF00FF', 'right', 0], '101.6': [237.517073, -78.183258, '#FF00FF', 'right', 0], '101.8': [237.503649, -78.185600, '#FF00FF', 'right', 15]\n",
    "        }\n",
    "\n",
    "    # Dictionary with information describing how to place label text \n",
    "    # around images based on a keyword\n",
    "    image_label_positions = {\n",
    "        'left': [-5, -5, 'right', 'center'],\n",
    "        'right': [5, 5, 'left', 'center']\n",
    "        }\n",
    "\n",
    "    # Dictionary containing information about the position (RA, DEC), width \n",
    "    # (arcseconds), orientation (degrees), and style of the slit apertures\n",
    "    slits = {\n",
    "        'M5' : ['15:50:01.1649 -78:11:07.822', 0.85, 313, 'dashed'],\n",
    "        'M4' : ['15:50:04.9279 -78:10:59.032', 0.85, 0, 'dashed'],\n",
    "        'M6' : ['15:50:06.6389 -78:10:57.412', 0.85, 12, 'dashed'],\n",
    "        'M3' : ['15:50:00.6009 -78:11:09.912', 0.85, 298, 'dashed'],\n",
    "        'M0' : ['15:50:04.4759 -78:10:59.652', 1.0, 349, 'solid'],\n",
    "        'M2' : ['15:49:59.7480 -78:11:13.482', 0.85, 52, 'solid'],\n",
    "        'M7' : ['15:50:07.3959 -78:10:56.962', 0.85, 0, 'solid'],\n",
    "        'M8' : ['15:49:59.9499 -78:11:12.242', 0.85, 330, 'solid'],\n",
    "        'M9' : ['15:50:00.3719 -78:11:10.512', 0.85, 302, 'solid']\n",
    "    }\n",
    "\n",
    "    # Positions of the slit labels in terms of fractions of axes\n",
    "    slit_label_positions = {\n",
    "        'M5' : (0.305,0.1),\n",
    "        'M4' : (0.65,0.1),\n",
    "        'M6' : (0.41,0.1),\n",
    "        'M3' : (0.47,0.1),\n",
    "        'M0' : (0.87,0.1),\n",
    "        'M2' : (0.86,0.7),\n",
    "        'M7' : (0.2,0.1),\n",
    "        'M8' : (0.87,0.05),\n",
    "        'M9' : (0.685,0.77)\n",
    "    }\n",
    "\n",
    "    # Structured list of the slit apertures (by their slit ID) that appear on \n",
    "    # each arc. The first sublist is the apertures on the north arc and the \n",
    "    # second is the apertures on the northwest arc\n",
    "    slits_arc = [['M7', 'M6', 'M4', 'M0'], ['M5', 'M3', 'M9', 'M8', 'M2']]\n",
    "    \n",
    "    # The labels specifying the displayed arc and what the data shows\n",
    "    arc_labels = np.array(['N', 'NW'], dtype=str)\n",
    "    filter_labels = np.array(['Lyα (F555W)', 'Lyα (F390W)', 'F275W'], dtype=str)\n",
    "\n",
    "    # Establish common directories\n",
    "    home = os.getcwd()\n",
    "    data = f'{home}/data'\n",
    "    figs = f'{home}/figs'\n",
    "    results = f'{home}/results'\n",
    "\n",
    "    # Establish file paths to the necessary files\n",
    "    hst_f275w_file = f'{data}/hst/V5.0_PSZ1G311.65-18.48_F275W_0.03g0.6_crsc1.2_0.7crsn3.5_3.0_drc_sci.fits'\n",
    "    hst_f606w_file = f'{data}/hst/V5.0_PSZ1G311.65-18.48_F606W_0.03g0.6_crsc1.2_0.7crsn3.5_3.0_drc_sci.fits'\n",
    "    lya_nb_f390w_file = f'{results}/lya_maps/Lya_cont_sub_F390W.fits'\n",
    "    lya_nb_f555w_file = f'{results}/lya_maps/Lya_cont_sub_F555W.fits'\n",
    "\n",
    "    # Put the files we will display data from into an array. We will loop over this array\n",
    "    # to make the figure\n",
    "    files = np.array([lya_nb_f555w_file, lya_nb_f390w_file, hst_f275w_file], dtype=str)\n",
    "\n",
    "    # Position, dimensions, and orientations of the boxes defining the areas of the inset, zoom-in axes, \n",
    "    # defined in pixel coordinates of the HST F606W observation's WCS projection\n",
    "    width, height = 464, 86\n",
    "    centers = np.array([[4591,5303],[5093,4944]], dtype=int)\n",
    "    angles = np.array([-19, -48], dtype=np.float64)\n",
    "\n",
    "    # Pixel coordinates of the compass centers in either of the inset axes\n",
    "    compass_positions = np.array([[464-2,12],[464-2,20]], dtype=int)\n",
    "\n",
    "    # Get the WCS projection of the HST F606W observations\n",
    "    hst_f606w_wcs = WCS(fits.getheader(hst_f606w_file))\n",
    "\n",
    "    # Loop to create the WCS projections of each set of panels\n",
    "\n",
    "    # Create an empty list to append the rotated WCS projections to\n",
    "    WCSs = []\n",
    "\n",
    "    # For each angle that each WCS projection \n",
    "    # is rotated relative to the original WCS projection\n",
    "    for i, angle in enumerate(angles):\n",
    "\n",
    "        # Rotate the original WCS by the angle\n",
    "        wcs_rotated = rotate_wcs(hst_f606w_wcs, angle)\n",
    "\n",
    "        # Add the rotated WCS to the list of rotated WCS projections\n",
    "        WCSs = np.append(WCSs, wcs_rotated)\n",
    "\n",
    "    # Create the figure\n",
    "    fig = plt.Figure(figsize=(10,10*516/464))\n",
    "\n",
    "    # For the file of each map we want to plot\n",
    "    for i, file in enumerate(files):\n",
    "\n",
    "        # Get the image data from the file\n",
    "        data = fits.getdata(file)\n",
    "\n",
    "        # For each set of axes we will plot portions of the image on\n",
    "        for j in range(2):\n",
    "\n",
    "            # Rotate the data so that the pixel grid aligns with the axes\n",
    "            data_rotated, _ = reproject_interp((data, hst_f606w_wcs), WCSs[j], (6000,6000))\n",
    "\n",
    "            axes = fig.add_subplot(611 + 3 * j + i, projection=WCSs[j])\n",
    "\n",
    "            # Set the minimum and maximum values used to create the colormap in the image.\n",
    "            # The F275W has a much different absolute scale, so we assign a different \n",
    "            # minimum and maximum\n",
    "            vmin = -0.01 if i == 2 else -0.1\n",
    "            vmax = 0.01 if i == 2 else 0.1\n",
    "\n",
    "            # Plot the data on the axes with a symmetric, logarithmic color scale\n",
    "            axes.imshow(data_rotated, origin='lower', cmap='coolwarm', norm=SymLogNorm(vmin=vmin, vmax=vmax, linthresh=0.0001, linscale=0.0001, base=10), \n",
    "                interpolation='none')\n",
    "\n",
    "            # Get the pixel coordinate center of the panel in the new, rotated WCS projection\n",
    "            center = WCSs[j].world_to_pixel_values([hst_f606w_wcs.pixel_to_world_values([[*centers[j]]])[0]])[0]\n",
    "\n",
    "            # Set the axes limits to match the footprint of the arc zoom-in insets in the overview map figure\n",
    "            axes.set_xlim(center[0] - width/2, center[0] + width/2)\n",
    "            axes.set_ylim(center[1] - height/2, center[1] + height/2)\n",
    "\n",
    "            # For each coordinate axis\n",
    "            for k, coord_ax in enumerate([*axes.coords]):\n",
    "\n",
    "                # Disable the ticks, tick labels, and axis label of the cordinate axis\n",
    "                coord_ax.set_ticks_visible(False)\n",
    "                coord_ax.set_ticklabel_visible(False)\n",
    "                coord_ax.set_axislabel('')\n",
    "\n",
    "            # Add a label to the top left corner of the axes indicating which arc the panel shows\n",
    "            arc_label = axes.annotate(arc_labels[j], xy=(0.01, 1 - 0.01 * 464 / 86), xycoords='axes fraction', ha='left', va='top', fontsize=10, fontweight='bold')\n",
    "\n",
    "            # Add a label to the top right corner of the axes identifying the displayed map\n",
    "            filter_label = axes.annotate(filter_labels[i], xy=(0.99, 1 - 0.01 * 464 / 86), xycoords='axes fraction', ha='right', va='top', fontsize=10, fontweight='bold')\n",
    "\n",
    "            # Add an outline around the labels to make them easier to read\n",
    "            arc_label.set_path_effects([pe.withStroke(linewidth=1, foreground='white')])\n",
    "            filter_label.set_path_effects([pe.withStroke(linewidth=1, foreground='white')])\n",
    "\n",
    "            # Add a compass to the axes\n",
    "\n",
    "            # Add the arrows\n",
    "            n_arrow = axes.annotate('', xy=(center[0] - 464/2 + compass_positions[j][0] - 2 + 20 * np.cos(np.radians(90 - angles[j])), center[1] - 86/2 + compass_positions[j][1] + 20 * np.sin(np.radians(90 - angles[j]))), \n",
    "                xytext=(center[0] - 464/2 + compass_positions[j][0] - 2, center[1] - 86/2 + compass_positions[j][1]), ha='right', va='bottom', color='black', \n",
    "                arrowprops={'facecolor':'black', 'edgecolor':'black', 'arrowstyle':'-|>'}, xycoords='data')\n",
    "            e_arrow = axes.annotate('', xy=(center[0] - 464/2 + compass_positions[j][0] - 2 + 20 * np.cos(np.radians(180 - angles[j])), center[1] - 86/2 + compass_positions[j][1] + 20 * np.sin(np.radians(180 - angles[j]))), \n",
    "                xytext=(center[0] - 464/2 + compass_positions[j][0] - 2, center[1] - 86/2 + compass_positions[j][1]), ha='right', va='top', color='black', \n",
    "                arrowprops={'facecolor':'black', 'edgecolor':'black', 'arrowstyle':'-|>'}, xycoords='data')\n",
    "\n",
    "            # The arrows (for some reason) do not completely reach to the specified origin, so add a circle at their specified origin to conceal this\n",
    "            axes.add_patch(patches.Circle((center[0] - 464/2 + compass_positions[j][0] - 2, center[1] - 86/2 + compass_positions[j][1]), radius=2, facecolor='black', transform=axes.transData))\n",
    "\n",
    "            # Add text labels indicating the cardinal directions (in a (RA, dec) coordinate system) of each arrow\n",
    "            n_label = axes.annotate('N', xy=(center[0] - 464/2 + compass_positions[j][0] - 2 + 18 * np.cos(np.radians(90 - angles[j])), center[1] - 86/2 + compass_positions[j][1] + 18 * np.sin(np.radians(90 - angles[j]))), \n",
    "                rotation=-angles[j], rotation_mode='anchor', xycoords='data', color='black', ha='center', va='bottom', fontsize='x-small', fontweight='bold')\n",
    "            e_label = axes.annotate('E', xy=(center[0] - 464/2 + compass_positions[j][0] - 2 + 18 * np.cos(np.radians(180 - angles[j])), center[1] - 86/2 + compass_positions[j][1] + 18 * np.sin(np.radians(180 - angles[j]))), \n",
    "                rotation=-angles[j], rotation_mode='anchor', xycoords='data', color='black', ha='right', va='center', fontsize='x-small', fontweight='bold')\n",
    "\n",
    "            # Add an outline around the compass arrows and labels to make them easier to read\n",
    "            n_arrow.set_path_effects([pe.withStroke(linewidth=1, foreground='white')])\n",
    "            e_arrow.set_path_effects([pe.withStroke(linewidth=1, foreground='white')])\n",
    "            n_label.set_path_effects([pe.withStroke(linewidth=1, foreground='white')])\n",
    "            e_label.set_path_effects([pe.withStroke(linewidth=1, foreground='white')])\n",
    "\n",
    "            # Add a scale bar to the axes\n",
    "            add_scalebar(axes, 1 * u.arcsecond, label='1\\'\\'', corner='bottom left')\n",
    "\n",
    "            # For each slit aperture ID\n",
    "            for k, slit_id in enumerate(slits_arc[j]):\n",
    "\n",
    "                # Instantiate the slit as a RectangleSkyRegion\n",
    "                slit_region = RectangleSkyRegion(center=SkyCoord(slits[slit_id][0], unit=(u.hourangle, u.deg), frame='fk5'), \n",
    "                    width=slits[slit_id][1] * u.arcsecond, height=10 * u.arcsecond, angle=slits[slit_id][2] * u.deg)\n",
    "\n",
    "                # Convert the slit region object to a pixel-based representation\n",
    "                slit_region_pxl = slit_region.to_pixel(WCSs[j])\n",
    "    \n",
    "                # Plot the slit region on the axes\n",
    "                slit_region_pxl.plot(ax=axes, color='#D41159', lw=1, linestyle=slits[slit_id][3])\n",
    "\n",
    "                # Add a label to the slit\n",
    "                label = axes.annotate(slit_id, xy=slit_label_positions[slit_id], color='#D41159', fontsize=10, fontweight='bold',\n",
    "                    xycoords='axes fraction')\n",
    "\n",
    "                # Add an outline around the labels to make them easier to read\n",
    "                label.set_path_effects([pe.withStroke(linewidth=1, foreground='white')])\n",
    "\n",
    "            # For each image of a source plane region that appears in one of the panels of the two arc segments\n",
    "            for k, image in enumerate(images):\n",
    "\n",
    "                # Get the color used for the region in the lens model from Sharon et al. (2022) (ApJ, 941, 203)\n",
    "                color = images[image][2]\n",
    "\n",
    "                # Get the position keyword used to orient the label text\n",
    "                loc = images[image][3]\n",
    "\n",
    "                # Get the angle to orient the text around the image\n",
    "                angle = images[image][4]\n",
    "\n",
    "                # The radius (half width) of the circle (square) around an image. Image 4.8 requires a larger radius\n",
    "                # because it is a series of images of unclear, but similar relation\n",
    "                radius = 0.4 * u.arcsecond if image == '4.8' else 0.1 * u.arcsecond\n",
    "\n",
    "                # Pixel coordinates of a manual offset for all label text. This is necessary because the astrometry \n",
    "                # used for the presented image coordinates in Sharon et al. (2022) (ApJ, 941, 203) appears to be offset \n",
    "                # or less accurate than available with the current data reduction\n",
    "                offset = [1.1, 1.0]\n",
    "\n",
    "                # Instantiate a circular region (unless the image is one of the images of the LyC-leaking region; then instantiate it as a rectangular (square) region). \n",
    "                # The manual coordinate offset from the listed dictionary value is necessary because of the astrometry difference mentioned above\n",
    "                image_region = RectangleSkyRegion(center=SkyCoord(images[image][0] + 0.0000547, images[image][1] - 0.0000541, unit='deg', frame='fk5'), width=2 * radius, height=2 * radius, angle=angles[j] * u.deg) if image[:2] == '1.' \\\n",
    "                    else CircleSkyRegion(center=SkyCoord(images[image][0] + 0.0000547, images[image][1] - 0.0000541, unit='deg', frame='fk5'), radius=radius)\n",
    "\n",
    "                # Convert the slit region object to a pixel-based representation\n",
    "                image_region_pxl = image_region.to_pixel(WCSs[j])\n",
    "    \n",
    "                # Plot the slit region on the axes\n",
    "                image_region_pxl.plot(ax=axes, color=color, lw=1.0)\n",
    "\n",
    "                # Get the pixel coordinates of the image using the same manual coordinate offset mentioned previously\n",
    "                image_pxl_coords = WCSs[j].world_to_pixel_values([[images[image][0] + 0.0000547, images[image][1] - 0.0000541]])\n",
    "                image_pxl_coords = np.array([image_pxl_coords[0][0], image_pxl_coords[0][1]])\n",
    "\n",
    "                # The radius of the text label in pixel coordinates from the coordinate center of the image. Image 4.8 requires a much larger\n",
    "                # radius because the circle around it is much larger\n",
    "                radius_text = [16,16] if image == '4.8' else image_label_positions[loc]\n",
    "\n",
    "                # Add additional padding to the text for images of the LyC-leaking region since it is marked with a square (the corners jut out \n",
    "                # farther than a circle would)\n",
    "                radius_text = [radius_text[0], radius_text[1]] + np.sign([radius_text[0], radius_text[1]]) if image[:2] == '1.' else radius_text\n",
    "\n",
    "                # Calculate the position of the annotation in pixel coordinates\n",
    "                xytext = (image_pxl_coords[0] + radius_text[0] * np.cos(np.radians(angle)),\n",
    "                    image_pxl_coords[1] - offset[j] + radius_text[1] * np.sin(np.radians(angle)))\n",
    "\n",
    "                # Annotate the image with a label\n",
    "                label = axes.annotate(image.upper(), xy=xytext, rotation=angle, rotation_mode='anchor', \n",
    "                    ha=image_label_positions[loc][2], va=image_label_positions[loc][3], color=color, fontsize='small')\n",
    "\n",
    "                # Add an outline around the labels to make them easier to read\n",
    "                label.set_path_effects([pe.withStroke(linewidth=1, foreground='black')])\n",
    "\n",
    "    # Save the figure\n",
    "    fig.savefig(f'{figs}/lya_and_lyc_maps.pdf', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}