Interactives/Synthetic_LV_Diagram.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Synthetic $\\ell$-v Diagram Generator\n",
    "\n",
    "### By Juan Cabanela (Minnesota State University Moorhead)\n",
    "\n",
    "This program is designed to allow you to model the neutral hydrogen line spectrum (a.k.a. the 21-cm line) as a function of galactic longitude of a model Milky Way galaxy as viewed from the Sun (assumed to be 8.5 kpc out from the center).  In other words, you are modelling the $\\ell$-v diagram of the Milky Way.\n",
    "\n",
    "This interactive interface initially loads the observed rotation curve and neutral gas density profile for the Milky Way and generates a synthetic $\\ell$-v diagram.  You can interactively sketch a new rotation curve or gas density profile and the synthetic $\\ell$-v diagram updates to reflect those changes.  You can also modify the gas velocity dispersion by sliding the slider labeled $\\sigma_v$ and see the effect that has."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Author: Juan Cabanela\n",
    "#\n",
    "# Originally written in perl (using pgplot libraries) in 2002, this could was ported to a python script \n",
    "# using matplotlib in 2013 (roughly) and in 2017 it was moved to a Jupyter notebook.  The current version\n",
    "# was ported in summer 2019 to allow use of ipywidget widgets as controls for the l-v diagram generator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import necessary libraries\n",
    "import matplotlib.cm as cm\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import random\n",
    "import string\n",
    "import numpy as np\n",
    "import io\n",
    "import sys\n",
    "import bqplot as bq\n",
    "from ipywidgets import Layout\n",
    "from ipywidgets import widgets\n",
    "from IPython.display import display\n",
    "\n",
    "# Import specific functions designed for galaxy model building\n",
    "from galaxyparam import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Configure some basic settings for this notebook here\n",
    "#\n",
    "# You will need to set up a few things before running this Jupyter notebook (the defaults are fine for the first run):\n",
    "#\n",
    "# Changing the galaxy model: You may want to edit galaxy_datafile with the filename of the file describing the \n",
    "#    galaxy.  That file must be in the same directory with the IPython notebook.  That file is a 3 column (where \n",
    "#    the columns are comma-seperated) text file.  The three columns are:\n",
    "#\n",
    "#    1. radius (in kpc): Radius of this data point in kpc\n",
    "#    2. rot_vel (in km/s): Rotational velocity of this data point in km/s\n",
    "#    3. density (in atoms/cm^3): Assumed gas density at this point (in atoms/cm^3)\n",
    "#    The 'header' row is required to be \"radius,rot_vel,density\" or this script will not properly read the file.\n",
    "#\n",
    "#   After running the default realistic Milky Way model, you will create a new galaxy model (in a different file\n",
    "#   than the original galaxy_description.csv) to represent a Keplerian (~ r^{-1/2}) rotation curve.  \n",
    "#   You will need to set galaxy_datafile to point to the file containing the new model.  Don't worry about \n",
    "#   evenly spacing data points in radius.  The part of the script below that reads this datafile will \n",
    "#   interpolate between your radial points with a spline fit, so it is pretty robust as smoothly fitting \n",
    "#   between your data points.\n",
    "#\n",
    "# Changing the image filename: Set up the image_filename for the file you will want to save the final image.\n",
    "#    It must end with .jpg, .png, or .pdf.\n",
    "\n",
    "# Initialize filenames and parameters related to data import\n",
    "galaxy_datafile = \"data/galaxy_description.csv\"  # File containing rotation curve and density data\n",
    "HIradius = 25    # Assumed radius of HI disk\n",
    "dens_drop = 0.01  # Drop in density per kpc of radius (in atoms/cm^3)\n",
    "# Load the Galaxy Data\n",
    "(rad_raw, rotvel_raw, density_raw) = LoadData(galaxy_datafile, HIradius, dens_drop) \n",
    "\n",
    "image_directory = \"tmp\"  # Name of temporary directory to store images in\n",
    "\n",
    "randkey = ''.join(random.choice(string.ascii_letters) for i in range(5) )\n",
    "basename = \"Synthetic_LVDiagram\"\n",
    "image_filename = \"{0}_{1}.png\".format(basename, randkey)     # Name of the final PNG image file to generate\n",
    "\n",
    "#\n",
    "# Constants related to the spline fit routine\n",
    "#\n",
    "dr_spline = 0.2    # Step size in kpc for spline fit (global, so it can be used within functions)\n",
    "\n",
    "# Make the initial spline fit to the rotation curve and gas density curve data\n",
    "rad_spline, rotvel_spline, density_spline = spline_curves(rad_raw, rotvel_raw, density_raw, dr_spline)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "############################################\n",
    "# Initialize Constants and other variables #\n",
    "############################################\n",
    "deg2rad = np.pi/180  # Radians per degree\n",
    "\n",
    "#\n",
    "# Constants related to building of L-V diagram\n",
    "#\n",
    "radial_step = 0.05   # Radial step size in kpc for lines of sight\n",
    "theta_step = 5       # Step size in degrees for lines of sight\n",
    "maxdens = 1.0        # Maximum allowed gas density (in atoms/cm^2)\n",
    "maxvel_LSR = 250     # Maximum magnitude LSR velocity to plot (in absolute km/s)\n",
    "maxvel = 400         # Maximum rotational velocity to plot (in km/s)\n",
    "vel_step = 5         # Velocity bin size for l-v_LSR plot in km/s\n",
    "R0 = 8.5             # Distance of Sun from Galactic Center in kpc\n",
    "\n",
    "# Constants related to converting gas density from atoms/cm^3 to\n",
    "# solar masses/Kpc^3.\n",
    "vol_factor = (3.09e21)*(3.09e21)*(3.09e21)  # cm^3/Kpc^3\n",
    "mass_factor = 1.67e-27                      # kg/atom\n",
    "solar_factor = 1.99e30                      # kg/M_solar\n",
    "factor = vol_factor*mass_factor/solar_factor  \n",
    "\n",
    "# Initialize the assumed rms velocity dispersion\n",
    "vel_sigma = 17       # velocity dispersion in km/s (actual value is about 34 km/s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##########################\n",
    "# FUNCTION LIBRARY BELOW #\n",
    "##########################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def LVarray(rotvel_spline, density_spline):\n",
    "    #\n",
    "    # Function to compute the corresponding l-v diagram\n",
    "    #\n",
    "    global maxvel_LSR, vel_step, theta_step\n",
    "    \n",
    "    # Set constants for this loop\n",
    "    maxdens = density_spline.max()               # Maximum density for later scaling\n",
    "    V0 = rotvel_spline[int(np.floor(R0/dr_spline))] # Sun's galactocentric velocity\n",
    "\n",
    "    # Decide on longitude and velocity bins and then create array to \n",
    "    # store the observed densities\n",
    "    longbins = np.arange(-180, 180, theta_step)\n",
    "    velbins = np.arange(-maxvel_LSR, maxvel_LSR, vel_step)\n",
    "    # Assume initially no gas on l-v diagram\n",
    "    dens_map = np.zeros( (velbins.size, longbins.size) )\n",
    "\n",
    "    # Loop through all the galactic longitude bins and for each galactic\n",
    "    # longitude, step radially outward, determine galactocentric radius, \n",
    "    # use that to get gas density, and then compute the radial velocity.\n",
    "    # Add that gas to l-v array.\n",
    "    for ell in longbins:\n",
    "        ell_r = ell*deg2rad # Longitude in radians\n",
    "\n",
    "        # Determine longitude bin\n",
    "        longbin = int(np.floor((ell + 180)/theta_step))\n",
    "\n",
    "        # Create array of distances from origin along line of sight\n",
    "        d = np.arange(radial_step, 2*HIradius, radial_step)\n",
    "\n",
    "        # Determine galactocentric radius via law of cosines\n",
    "        R = np.sqrt(R0**2 + d**2 - R0*d*np.cos(ell_r))\n",
    "\n",
    "        # Construct list of distances/galactocentric radii all within HI radius limit\n",
    "        d_use = d[R <= HIradius]\n",
    "        R_use = R[R <= HIradius]\n",
    "\n",
    "        # Retrieve appropritate galactocentric radial index for looking \n",
    "        # up rotational velocity and density.\n",
    "        R_idx = np.floor(R_use/dr_spline).astype(np.int64)\n",
    "\n",
    "        # Compute LSR velocity and retrieve scaled density at all these line of sight\n",
    "        # distances (in d_use)\n",
    "        V_LSR = R0 * np.sin(ell_r) * ((rotvel_spline[R_idx] / R_use) - ( V0 / R0 ))\n",
    "        dens_scaled  = density_spline[R_idx] / maxdens\n",
    "\n",
    "        # Generate n_copies copies each with random scatter\n",
    "        n_copies = 20\n",
    "        V_LSR_pop = np.array([V_LSR]*n_copies)\n",
    "        # Add random scatter to each point\n",
    "        V_LSR_pop = V_LSR_pop + np.random.normal(loc=0, scale=vel_sigma, size=V_LSR_pop.shape)\n",
    "        velbin_pop = np.floor((V_LSR_pop + maxvel_LSR)/vel_step).astype(np.int64)\n",
    "        # Build velocity and density values 1-D arrays for summation in loop\n",
    "        vels = velbin_pop.reshape(velbin_pop.size)\n",
    "        dens_scaled_pop = np.array([dens_scaled]*n_copies)/n_copies\n",
    "        dens = dens_scaled_pop.reshape(dens_scaled_pop.size)\n",
    "\n",
    "        # Record these density contributions to approprate velbin and lonbin of dens_map\n",
    "        for i in range(vels.size):\n",
    "            if (vels[i]<len(velbins)) and (vels[i]>=0):\n",
    "                dens_map[vels[i]][longbin] += dens[i]\n",
    "    \n",
    "    lon = longbins+(theta_step/2)*np.ones_like(longbins)\n",
    "    vel = velbins+(vel_step/2)*np.ones_like(velbins)\n",
    "    return lon, vel, dens_map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##\n",
    "## Functions to build plots in bqplot and matplotlib (including printable ones)\n",
    "##\n",
    "\n",
    "# Set up graph width and height\n",
    "graph_height = '250px'\n",
    "graph_width = '400px'\n",
    "\n",
    "\n",
    "def rotvel_plot(rad_spline, rotvel_spline):\n",
    "    global rotcurve_spline, rotcurve_handdraw\n",
    "    rotcurve_sc_x = bq.LinearScale()\n",
    "    rotcurve_sc_y = bq.LinearScale()\n",
    "    rotcurve_sc_y.max = maxvel\n",
    "    rotcurve_sc_y.min = 0\n",
    "    rotcurve_ax_x = bq.Axis(scale=rotcurve_sc_x, label='Galactocentric Radius (kpc)')\n",
    "    rotcurve_ax_y = bq.Axis(scale=rotcurve_sc_y, orientation='vertical', label='Rotational Velocity (km/s)')\n",
    "    rotcurve_ax_y.label_offset = '3.5em'\n",
    "    rotcurve_spline = bq.Lines(x=rad_spline, y=rotvel_spline, scales={'x': rotcurve_sc_x, 'y': rotcurve_sc_y},\n",
    "                             colors=['Blue'], labels=['cubic spline fit'], display_legend=False)\n",
    "    rotcurve_handdraw = bq.interacts.HandDraw(lines=rotcurve_spline)\n",
    "    \n",
    "    return (bq.Figure(marks=[rotcurve_spline], axes=[rotcurve_ax_x, rotcurve_ax_y], \n",
    "                      title='Galaxy Rotation Curve', legend_location='bottom', \n",
    "                      interaction=rotcurve_handdraw,\n",
    "                      layout=widgets.Layout(width=graph_width, height=graph_height, \n",
    "                                            fig_margin='0px 0px 0px 0px')))\n",
    "\n",
    "\n",
    "def densprof_plot(rad_spline, density_spline):\n",
    "    global densprof_spline, densprof_handdraw\n",
    "    densprof_sc_x = bq.LinearScale()\n",
    "    densprof_sc_y = bq.LinearScale()\n",
    "    densprof_sc_y.max = maxdens\n",
    "    densprof_sc_y.min = 0\n",
    "    densprof_ax_x = bq.Axis(scale=densprof_sc_x, label='Galactocentric Radius (kpc)')\n",
    "    densprof_ax_y = bq.Axis(scale=densprof_sc_y, orientation='vertical', label='HI Gas Density (atom/cm^3)')\n",
    "    densprof_ax_y.label_offset = '3.5em'\n",
    "    densprof_spline = bq.Lines(x=rad_spline, y=density_spline, scales={'x': densprof_sc_x, 'y': densprof_sc_y},\n",
    "                             colors=['Blue'], labels=['cubic spline fit'], display_legend=False)\n",
    "    densprof_handdraw = bq.interacts.HandDraw(lines=densprof_spline)\n",
    "    return(bq.Figure(marks=[densprof_spline], axes=[densprof_ax_x, densprof_ax_y], \n",
    "                     title='Galaxy Gas Density Profile', legend_location='top', \n",
    "                     interaction=densprof_handdraw,\n",
    "                     layout=widgets.Layout(width=graph_width, height=graph_height,\n",
    "                                           fig_margin='0px 0px 0px 0px')))\n",
    "\n",
    "\n",
    "def lv_plot(lon, vel, dens_map):\n",
    "    # \n",
    "    # Generate plot of LV diagram as an image\n",
    "\n",
    "    # Clear any existing figure and create offline figure\n",
    "    plt.clf()\n",
    "    plt.ioff()\n",
    "\n",
    "    # Adjust plot defaults\n",
    "    mpl.rc('axes',titlesize='large')\n",
    "    mpl.rc('axes',labelsize='medium')\n",
    "    mpl.rc('xtick',labelsize='medium')\n",
    "    mpl.rc('ytick',labelsize='medium')\n",
    "\n",
    "    fig = plt.figure(1, facecolor='w', edgecolor='k', figsize=((6, 4)))\n",
    "\n",
    "    # Set up the plot grid\n",
    "    ax1 = plt.subplot2grid((1,10), (0,0), colspan=9, rowspan=1)\n",
    "    ax2 = plt.subplot2grid((1,10), (0,9), colspan=1, rowspan=1)\n",
    "\n",
    "    # Set up spacing being plots\n",
    "    plt.subplots_adjust(wspace=0.3)\n",
    "    plt.subplots_adjust(hspace=0.7)\n",
    "\n",
    "    #\n",
    "    # (3) Plot the Galactic HI distribution\n",
    "    cm_name = 'Greys'\n",
    "    ax1.set_xlabel('Galactic Longitude $\\ell$ (Degrees)', fontsize='large')\n",
    "    ax1.set_ylabel('$v_{LSR}$ (km/s)', fontsize='large')\n",
    "    ax1.set_title('Galactic Model $\\ell-v_{LSR}$ Diagram', fontsize='large')\n",
    "    maxdensity = 15*np.average(dens_map)\n",
    "    if (maxdensity <0.1):\n",
    "        maxdensity = 0.1\n",
    "    dens_levels = np.linspace(0, maxdensity, 200)\n",
    "    CSF = ax1.contourf(lon, vel, dens_map, levels=dens_levels, extend='max', alpha=1, cmap = cm.get_cmap(cm_name))\n",
    "    # Reverse axis to run the way we normally plot this\n",
    "    ax1.set_xlim(ax1.get_xlim()[::-1])\n",
    "    ax1.set_ylim(-maxvel_LSR, maxvel_LSR)\n",
    "\n",
    "    # Create a colorbar\n",
    "    mpl.colorbar.ColorbarBase(ax2, cmap=cm.get_cmap(cm_name),\n",
    "            norm=mpl.colors.Normalize(vmin=0,vmax=maxdensity),\n",
    "            orientation='vertical')\n",
    "\n",
    "    # Display the plot to a PNG memory buffer\n",
    "    buf = io.BytesIO()\n",
    "    fig = plt.gcf()\n",
    "    fig.savefig(buf, format='png', dpi=150)\n",
    "    buf.seek(0)\n",
    "    pngimg = buf.read()\n",
    "    buf.close()\n",
    "    _ = plt.clf()\n",
    "    \n",
    "    return(pngimg)\n",
    "\n",
    "\n",
    "def make_printable_plot(b=None):\n",
    "    global imgfile_name\n",
    "    global rad_raw, rotvel_raw, density_raw\n",
    "    global rad_spline, rotvel_spline, density_spline\n",
    "    global lon, vel, dens_map, vel_sigma\n",
    "        \n",
    "    # Adjust plot defaults\n",
    "    mpl.rc('axes',titlesize='large')\n",
    "    mpl.rc('axes',labelsize='medium')\n",
    "    mpl.rc('xtick',labelsize='medium')\n",
    "    mpl.rc('ytick',labelsize='medium')\n",
    "\n",
    "    fig = plt.figure(1, facecolor='w', edgecolor='k')\n",
    "    fig.set_size_inches(14,10)\n",
    "    gc = plt.gca()\n",
    "\n",
    "    # Set up the plot grid\n",
    "    ax1 = plt.subplot2grid((3,10), (0,0), colspan=5)\n",
    "    ax2 = plt.subplot2grid((3,10), (0,5), colspan=5)\n",
    "    ax3 = plt.subplot2grid((3,10), (1,0), colspan=9, rowspan=2)\n",
    "    ax4 = plt.subplot2grid((3,10), (1,9), colspan=1, rowspan=2)\n",
    "\n",
    "    # Set up spacing being plots\n",
    "    plt.subplots_adjust(wspace=1.5)\n",
    "    plt.subplots_adjust(hspace=0.5)\n",
    "\n",
    "    #\n",
    "    # (1) Plot the rotation curve\n",
    "    #\n",
    "    ax1.set_xlabel('Galactocentric Radius (kpc)', fontsize='medium')\n",
    "    ax1.set_ylabel('Rotational Velocity (km/s)', fontsize='medium')\n",
    "    ax1.set_title('Galaxy Rotation Curve', fontsize='large')\n",
    "    ax1.set_ylim(0.0, maxvel)\n",
    "    ax1.plot(rad_spline, rotvel_spline, 'b-', label='spline fit')\n",
    "\n",
    "    #\n",
    "    # (2) Plot the density profile\n",
    "    #\n",
    "    ax2.set_xlabel('Galactocentric Radius (kpc)', fontsize='medium')\n",
    "    ax2.set_ylabel('HI Gas Density (atom/cm$^3$)', fontsize='medium')\n",
    "    ax2.set_title('Galaxy Gas Density Profile', fontsize='large')\n",
    "    ax2.set_ylim(0.0, maxdens)\n",
    "    ax2.plot(rad_spline, density_spline, 'b-', label='spline fit')\n",
    "\n",
    "    #\n",
    "    # (3) Plot the Galactic HI distribution\n",
    "    cm_name = 'Greys'\n",
    "    ax3.set_xlabel('Galactic Longitude $\\ell$ (Degrees)', fontsize='large')\n",
    "    ax3.set_ylabel('$v_{LSR}$ (km/s)', fontsize='large')\n",
    "    ax3.set_title('Galactic Model $\\ell-v$ Diagram (assuming $\\sigma_V$={:02d} km/s)'.format(vel_sigma), \n",
    "                  fontsize='large')\n",
    "    maxdensity = 15*np.average(dens_map)\n",
    "    if (maxdensity <0.1):\n",
    "        maxdensity = 0.1\n",
    "    dens_levels = np.linspace(0, maxdensity, 200)\n",
    "    CSF = ax3.contourf(lon, vel, dens_map, levels=dens_levels, extend='max', alpha=1, cmap = cm.get_cmap(cm_name))\n",
    "\n",
    "    # Reverse axis to run the way we normally plot this\n",
    "    ax3.set_xlim(ax3.get_xlim()[::-1]) \n",
    "    ax3.set_ylim(-maxvel_LSR, maxvel_LSR)\n",
    "\n",
    "    # Create a colorbar\n",
    "    mpl.colorbar.ColorbarBase(ax4, cmap=cm.get_cmap(cm_name),\n",
    "            norm=mpl.colors.Normalize(vmin=0,vmax=maxdensity),\n",
    "            orientation='vertical')\n",
    "\n",
    "    # Create the image file and create a link if the filename is legitimate\n",
    "    filetypes = [\"jpg\", \"png\", \"pdf\"]\n",
    "    img_type = imgfile_name.value[-3:]\n",
    "    if img_type in filetypes:\n",
    "        # Store images in a temporary directory\n",
    "        true_loc = \"{0}/{1}\".format(image_directory,imgfile_name.value)\n",
    "        plt.savefig(true_loc, dpi=300)\n",
    "        savelink.value=\"<a href=\\\"{}\\\">Click to download!</a>\".format(\"DisplayRecentImage.ipynb\")\n",
    "    else:\n",
    "        savelink.value=\"<b>Illegal image type ({})!</b>\".format(img_type)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# Functions for handling interactive elements\n",
    "#\n",
    "\n",
    "def replot(b=None):\n",
    "    global lv_dia, rotvel_spline, density_spline, lon, vel, dens_map\n",
    "    \n",
    "    # Generate the default LV_diagram\n",
    "    lon, vel, dens_map = LVarray(rotvel_spline, density_spline)\n",
    "\n",
    "    # Update l-v diagram plot\n",
    "    lv_dia.value = lv_plot(lon, vel, dens_map)\n",
    "    \n",
    "\n",
    "def sigma_changed(change):\n",
    "    global vel_sigma\n",
    "    \n",
    "    # Update the sigma value\n",
    "    vel_sigma = change.new\n",
    "    \n",
    "    # Replot\n",
    "    replot()    \n",
    "    \n",
    "def update_rotcurve(change):\n",
    "    global rotcurve_spline, rad_spline, rotvel_spline, density_spline\n",
    "    \n",
    "    # Force any negative points to zero\n",
    "    # (there doesn't seem to be a way to update handdrawn line)\n",
    "    rotcurve_spline.y[rotcurve_spline.y<0] = 0\n",
    "    \n",
    "    # Update spline based on handdraw action on rotcurve_spline\n",
    "    rotvel_spline = rotcurve_spline.y\n",
    "    \n",
    "    # Replot\n",
    "    replot()\n",
    "\n",
    "def update_densprof(change):\n",
    "    global densprof_spline, rad_spline, rotvel_spline, density_spline\n",
    "\n",
    "    # Force any negative points to zero\n",
    "    # (there doesn't seem to be a way to update handdrawn line)\n",
    "    densprof_spline.y[densprof_spline.y<0] = 0\n",
    "\n",
    "    # Update spline based on handdraw action on densprof_spline\n",
    "    density_spline = densprof_spline.y\n",
    "    \n",
    "    # Replot\n",
    "    replot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture --no-stderr --no-stdout \n",
    "\n",
    "#########################################\n",
    "#  CREATE THE PROFILES AND l-v DIAGRAM  #\n",
    "#########################################\n",
    "\n",
    "# Generate the default LV_diagram\n",
    "lon, vel, dens_map = LVarray(rotvel_spline, density_spline)\n",
    "\n",
    "# Generate plots\n",
    "# (1) Generate plot of plot of the rotation curve of the Galaxy\n",
    "# (2) Draw the density profile of the Galaxy\n",
    "# (3) Using matplotlib to generate the l-v diagram, since bqplot doesn't seem cut out for it.\n",
    "#\n",
    "rot_curve = rotvel_plot(rad_spline, rotvel_spline)\n",
    "density_profile = densprof_plot(rad_spline, density_spline)\n",
    "lv_dia = widgets.Image(value=lv_plot(lon, vel, dens_map), format='png', width=600, height=400)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [],
   "source": [
    "#\n",
    "# Create Control Sliders/Fields/Buttons\n",
    "#\n",
    "sigma_label = widgets.Label(value='$\\sigma_V$ (km/s): ')\n",
    "sigma_slider = widgets.IntSlider(min=0, max=50, step=1, value=vel_sigma,\n",
    "                                 continuous_update=False, orientation='horizontal',\n",
    "                                 readout=True, readout_format='02d',\n",
    "                                 layout=widgets.Layout(height='75px', min_height='50px', max_height='100px',\n",
    "                                                       min_width='50px', width='200px', max_width='300px',\n",
    "                                                       overflow='hidden'))\n",
    "sigma_control = widgets.HBox([sigma_label, sigma_slider], \n",
    "                             layout=widgets.Layout(align_content='center', align_items='center'))\n",
    "\n",
    "imgfile_label = widgets.HTML(value='Image Filename: ', \n",
    "                             layout=widgets.Layout(min_width='70px', width='100px', max_width='200px'))\n",
    "imgfile_name = widgets.Text(value=image_filename, \n",
    "                             layout=widgets.Layout(min_width='100px', width='200px', max_width='300px'))\n",
    "imgfile_control = widgets.HBox([imgfile_label, imgfile_name], \n",
    "                               layout=widgets.Layout(align_content='center', align_items='center'))\n",
    "\n",
    "savefile_button = widgets.Button(description='Save Plots', disabled=False,\n",
    "                                 tooltip='Click to save image file',\n",
    "                                 layout=widgets.Layout(min_width='100px', width='150px', max_width='200px'))\n",
    "\n",
    "savelink = widgets.HTML(value='')\n",
    "\n",
    "#\n",
    "# Display the plots\n",
    "#\n",
    "settings_top = widgets.HBox([sigma_control, imgfile_control, savefile_button, savelink], \n",
    "                               layout=widgets.Layout(align_content='center', align_items='center',\n",
    "                                                     margin='0px', width='850px', \n",
    "                                                     overflow='hidden'))\n",
    "settings_bottom = widgets.HBox([rot_curve, density_profile], \n",
    "                            layout=widgets.Layout(margin='0px', width='850px', \n",
    "                                                  overflow='hidden'))\n",
    "settings = widgets.VBox([settings_top, settings_bottom], \n",
    "                        layout=widgets.Layout(align_content='center', align_items='center',\n",
    "                                              margin='0px', width='850px', \n",
    "                                              overflow='hidden'))\n",
    "MainDisplay = widgets.VBox([settings, lv_dia], \n",
    "                           layout=widgets.Layout(align_content='center', align_items='center',\n",
    "                                                 margin='0px', width='850px', \n",
    "                                                 overflow='hidden'))\n",
    "display(MainDisplay)\n",
    "\n",
    "#\n",
    "# Direct functions to be called if various widgets change\n",
    "#\n",
    "sigma_slider.observe(sigma_changed, 'value')\n",
    "rotcurve_spline.observe(update_rotcurve, names=['y'])\n",
    "densprof_spline.observe(update_densprof, names=['y'])\n",
    "savefile_button.on_click(make_printable_plot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}