old_plots.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import marvin\n",
    "\n",
    "from random import randint\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import marvin.utils.plot.map as mapplot\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "from newer_Galaxy import SpiralGalaxy\n",
    "from copy import deepcopy\n",
    "from marvin.tools import Maps\n",
    "\n",
    "from matplotlib.lines import Line2D\n",
    "from matplotlib.patches import Patch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.style.use('ggplot')\n",
    "plt.style.use('seaborn-colorblind')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "def append_directory(path):\n",
    "    fits_list = []\n",
    "    \n",
    "    for root, dirs, files in os.walk(path):\n",
    "        for file in files:\n",
    "            if file.endswith(\".fits.gz\"):\n",
    "                element = str(path) + str(file)\n",
    "                fits_list.append(element)\n",
    "    return fits_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def append_usable_galaxies(fits_list):\n",
    "    usable_galaxy_list = []\n",
    "    \n",
    "    for path in fits_list:\n",
    "        try:\n",
    "            try:\n",
    "                gal = SpiralGalaxy(path)\n",
    "            except:\n",
    "                gal = SpiralGalaxy(path)\n",
    "        except:\n",
    "            print(\"{} failed to load, it  may have not been processed in MPL-6. ¯\\_(ツ)_/¯ Check the SDSS track website to make sure.\".format(gal.mangaid))\n",
    "            continue\n",
    "            \n",
    "        if gal.check_usability():\n",
    "            usable_galaxy_list.append(path)\n",
    "            \n",
    "    return usable_galaxy_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "gal_list = append_directory('/home/sshamsi/sas/mangawork/manga/sandbox/galaxyzoo3d/v1_0_0/')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#usable_gals = append_usable_galaxies(gal_list)\n",
    "\n",
    "usable_gals = np.load('usable_path_list.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_random_plots(num_gals, test_gal_list):\n",
    "    run_frac = num_gals/6\n",
    "    num_runs = int(run_frac)\n",
    "    last_run = 6 * (run_frac - num_runs)\n",
    "    \n",
    "    for j in range(num_runs):\n",
    "        fig, axes = plt.subplots(6, 4, figsize=(32, 6 * 8))\n",
    "        \n",
    "        for i in range(6):\n",
    "            gal = BarGalaxy(test_gal_list.pop(random.randint(0, len(test_gal_list)-1)))\n",
    "            \n",
    "            img_ax = axes[i, 0]\n",
    "            img_ax.axis('off')\n",
    "            img_ax.add_patch(gal.data.get_hexagon(correct_hex=True, edgecolor='C4'))\n",
    "            img_ax.imshow(gal.data.image)\n",
    "            \n",
    "            ax_list = axes[i][1:]\n",
    "            \n",
    "            gal.make_hamap_bar_masks()\n",
    "            \n",
    "            cbrange = gal.hamap.plot(return_cbrange=True)\n",
    "            \n",
    "            mask_list = [gal.hamap.mask, gal.hamap_bar_mask, gal.hamap_non_bar_mask]\n",
    "            \n",
    "            for ax, mask in zip(ax_list, mask_list):\n",
    "                mapplot.plot(dapmap = gal.hamap, fig=fig, ax=ax, mask = mask, cbrange=cbrange, title = str(gal.mangaid))\n",
    "                \n",
    "        fig.savefig(str(j) + '.png')\n",
    "        \n",
    "    fig, axes = plt.subplots(last_run, 4, figsize=(32, last_run * 8))\n",
    "    \n",
    "    for k in range(j, j + last_run):\n",
    "        gal = BarGalaxy(test_gal_list.pop(random.randint(0, len(test_gal_list)-1)))\n",
    "\n",
    "        img_ax = axes[i, 0]\n",
    "        img_ax.axis('off')\n",
    "        img_ax.add_patch(gal.data.get_hexagon(correct_hex=True, edgecolor='C4'))\n",
    "        img_ax.imshow(gal.data.image)\n",
    "        \n",
    "        ax_list = axes[i][1:]\n",
    "        \n",
    "        gal.make_hamap_bar_masks()\n",
    "        \n",
    "        cbrange = gal.hamap.plot(return_cbrange=True)\n",
    "\n",
    "        mask_list = [gal.hamap.mask, gal.hamap_bar_mask, gal.hamap_non_bar_mask]\n",
    "\n",
    "        for ax, mask in zip(ax_list, mask_list):\n",
    "            mapplot.plot(dapmap = gal.hamap, fig=fig, ax=ax, mask = mask, cbrange=cbrange, title = str(gal.mangaid))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tot_sfr_vals = []\n",
    "spiral_sfr_vals = []\n",
    "non_spiral_sfr_vals = []\n",
    "\n",
    "tot_sfr_stdv = []\n",
    "spiral_sfr_stdv = []\n",
    "non_spiral_sfr_stdv = []\n",
    "\n",
    "sfr_dapall = []\n",
    "\n",
    "for gal in gal_objs:\n",
    "    tot_sfr_vals.append(gal.get_integrated_sfr()[0])\n",
    "    tot_sfr_stdv.append(gal.get_integrated_sfr()[1])\n",
    "    \n",
    "    spiral_sfr_vals.append(gal.get_integrated_sfr(mode='spirals')[0])\n",
    "    spiral_sfr_stdv.append(gal.get_integrated_sfr(mode='spirals')[1])\n",
    "    \n",
    "    non_spiral_sfr_vals.append(gal.get_integrated_sfr(mode='non-spirals')[0])\n",
    "    non_spiral_sfr_stdv.append(gal.get_integrated_sfr(mode='non-spirals')[1])\n",
    "    \n",
    "    sfr_dapall.append(gal.maps.dapall['sfr_1re'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "calc_dap_ratio = []\n",
    "\n",
    "for i in range(len(gal_objs)):\n",
    "    ratio = tot_sfr_vals[i]/sfr_dapall[i]\n",
    "    if ratio < 25:\n",
    "        calc_dap_ratio.append(ratio)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize = (16, 12))\n",
    "\n",
    "plt.hlines(y=1, xmin=0, xmax=len(calc_dap_ratio), linestyle = '--', label = '$y=1$')\n",
    "plt.scatter(range(len(calc_dap_ratio)), calc_dap_ratio, color='g', marker='x', label='Galaxy')\n",
    "\n",
    "lobf = np.polyfit(range(len(calc_dap_ratio)), calc_dap_ratio, 1)\n",
    "plt.plot(range(len(calc_dap_ratio)), np.poly1d(lobf)(range(len(calc_dap_ratio))), label = '$y = {} x + {}$'.format(lobf[0], lobf[1]), color='purple')\n",
    "\n",
    "plt.xticks([], [])\n",
    "\n",
    "plt.ylim(0, 25)\n",
    "\n",
    "plt.ylabel('Ratio\\n$SFR_{calculated}/SFR_{DAPall}$', rotation=0, labelpad=80)\n",
    "plt.xlabel('Galaxies', labelpad = 20)\n",
    "\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sfr_pc_spiral = []\n",
    "sfr_pc_spiral_stdv = []\n",
    "\n",
    "for i in range(len(gal_objs)):\n",
    "    pc = 100 * spiral_sfr_vals[i]/tot_sfr_vals[i]\n",
    "    sfr_pc_spiral.append(pc)\n",
    "    \n",
    "    sfr_pc_spiral_stdv.append(pc * ((spiral_sfr_stdv[i]/spiral_sfr_vals[i]) + (tot_sfr_stdv[i]/tot_sfr_vals[i])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(16, 12))\n",
    "\n",
    "plt.hist(sfr_pc_spiral, bins = 20)\n",
    "\n",
    "plt.xlabel('Percent SFR in Spiral Arms', labelpad=20)\n",
    "plt.ylabel('Num Galaxies', rotation=0, labelpad=60)\n",
    "plt.title('20 Bins')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mass_list = []\n",
    "mangaid_list = []\n",
    "\n",
    "for gal in gal_objs:    \n",
    "    mass_list.append(gal.get_lgmass())\n",
    "    mangaid_list.append(gal.mangaid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "main_df = pd.DataFrame()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "main_df['mangaid'] = mangaid_list\n",
    "main_df['tot_sfr'] = tot_sfr_vals\n",
    "main_df['sig_tot_sfr'] = tot_sfr_stdv\n",
    "main_df['spiral_sfr'] = spiral_sfr_vals\n",
    "main_df['sig_spiral_sfr'] = spiral_sfr_stdv\n",
    "main_df['nonspiral_sfr'] = non_spiral_sfr_vals\n",
    "main_df['sig_nonspiral_sfr'] = non_spiral_sfr_stdv\n",
    "main_df['dap_sfr'] = sfr_dapall\n",
    "main_df['lgmass'] = mass_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "main_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = np.arange(1, 11)\n",
    "\n",
    "main_df['mass_bin'] = pd.qcut(main_df['lgmass'], len(labels), labels = labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "main_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "main_df['pc_in_spirals'] = sfr_pc_spiral\n",
    "main_df['sig_pc_in_spirals'] = sfr_pc_spiral_stdv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "avg_pc_spirals_binned = main_df.drop(82).groupby('mass_bin').pc_in_spirals.mean().values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "main_df['sig2_pc_in_spirals'] = main_df.sig_pc_in_spirals ** 2\n",
    "sig_avg_pc_spirals_binned = (main_df.drop(82).groupby('mass_bin').sig2_pc_in_spirals.mean() ** 0.5).values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "main_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "output, qcut_bins = pd.qcut(main_df.lgmass, len(labels), labels = labels, retbins=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "qcut_bins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(qcut_bins)-1):\n",
    "    print('\"${0:.2f}$\",'.format((qcut_bins[i] + qcut_bins[i + 1])/2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xtick_labels = [\"$9.40$\\n12 Galaxies\", \"$9.89$\\n11 Galaxies\", \"$10.09$\\n11 Galaxies\", \"$10.26$\\n11 Galaxies\",\n",
    "                \"$10.38$\\n11 Galaxies\", \"$10.48$\\n11 Galaxies\", \"$10.61$\\n11 Galaxies\", \"$10.76$\\n11 Galaxies\",\n",
    "                \"$10.86$\\n11 Galaxies\", \"$11.13$\\n12 Galaxies\",]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xtick_labels1 = [\"$9.40$\\n12 Galaxies\", \"$10.09$\\n11 Galaxies\", \"$10.48$\\n11 Galaxies\",\n",
    "                 \"$10.76$\\n11 Galaxies\", \"$11.13$\\n12 Galaxies\",]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.arange(1, 11, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(12 * 1.1, 9 * 1.1))\n",
    "\n",
    "plt.plot(labels, avg_pc_spirals_binned, color='red')\n",
    "plt.scatter(labels, avg_pc_spirals_binned, color='red')\n",
    "\n",
    "plt.errorbar(labels, avg_pc_spirals_binned, fmt='none', elinewidth=2, ecolor='red', capsize=10, capthick=2,\n",
    "             yerr=sig_avg_pc_spirals_binned)\n",
    "\n",
    "plt.xlabel('Mass Bins $log_{10}(M_☉)$', labelpad=30, fontsize=50)\n",
    "plt.xticks(np.arange(1, 11, 2), labels=xtick_labels1, fontsize=20)\n",
    "plt.yticks(fontsize = 25)\n",
    "plt.ylabel('% Total SFR in Spiral Arms', fontsize=50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "gal_dfs = []\n",
    "\n",
    "for gal in gal_objs:\n",
    "    gal.spax_df['lgmass'] = gal.get_lgmass()\n",
    "    gal_dfs.append(gal.spax_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "main_spax_df = pd.concat(gal_dfs, ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "main_spax_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "main_spax_df['rad_bin'] = pd.cut(main_spax_df.r_re, np.arange(0, 1.1, 0.1), labels = np.arange(1, 11))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "main_spax_df['lgmass_bin'] = pd.qcut(main_spax_df['lgmass'], 3, labels = [1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "out, bins = pd.qcut(main_spax_df['lgmass'], 3, labels = [1, 2, 3], retbins=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(bins)-1):\n",
    "    print((bins[i]+bins[i+1])/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "main_spax_df = main_spax_df.dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "main_spax_df = main_spax_df[2 * main_spax_df.sig_sfr < main_spax_df.sfr]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "main_spax_df['sig2_sfr'] = (main_spax_df.sig_sfr ** 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "main_spax_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "main_spax_df.groupby('rad_bin').mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "radbin_spiral_sfr1 = main_spax_df[(main_spax_df.spaxel_type == 'Spiral') & (main_spax_df.lgmass_bin==1)].groupby('rad_bin').sfr.mean().values\n",
    "sig_radbin_spiral_sfr1 = (main_spax_df[(main_spax_df.spaxel_type == 'Spiral') & (main_spax_df.lgmass_bin==1)].groupby('rad_bin').sig2_sfr.mean().values) ** 0.5\n",
    "\n",
    "radbin_spiral_sfr2 = main_spax_df[(main_spax_df.spaxel_type == 'Spiral') & (main_spax_df.lgmass_bin==2)].groupby('rad_bin').sfr.mean().values\n",
    "sig_radbin_spiral_sfr2 = (main_spax_df[(main_spax_df.spaxel_type == 'Spiral') & (main_spax_df.lgmass_bin==2)].groupby('rad_bin').sig2_sfr.mean().values) ** 0.5\n",
    "\n",
    "radbin_spiral_sfr3 = main_spax_df[(main_spax_df.spaxel_type == 'Spiral') & (main_spax_df.lgmass_bin==3)].groupby('rad_bin').sfr.mean().values\n",
    "sig_radbin_spiral_sfr3 = (main_spax_df[(main_spax_df.spaxel_type == 'Spiral') & (main_spax_df.lgmass_bin==3)].groupby('rad_bin').sig2_sfr.mean().values) ** 0.5\n",
    "\n",
    "\n",
    "radbin_nspiral_sfr1 = main_spax_df[(main_spax_df.spaxel_type == 'Non Spiral') & (main_spax_df.lgmass_bin==1)].groupby('rad_bin').sfr.mean().values\n",
    "sig_radbin_nspiral_sfr1 = (main_spax_df[(main_spax_df.spaxel_type == 'Non Spiral') & (main_spax_df.lgmass_bin==1)].groupby('rad_bin').sig2_sfr.mean().values) ** 0.5\n",
    "\n",
    "radbin_nspiral_sfr2 = main_spax_df[(main_spax_df.spaxel_type == 'Non Spiral') & (main_spax_df.lgmass_bin==2)].groupby('rad_bin').sfr.mean().values\n",
    "sig_radbin_nspiral_sfr2 = (main_spax_df[(main_spax_df.spaxel_type == 'Non Spiral') & (main_spax_df.lgmass_bin==2)].groupby('rad_bin').sig2_sfr.mean().values) ** 0.5\n",
    "\n",
    "radbin_nspiral_sfr3 = main_spax_df[(main_spax_df.spaxel_type == 'Non Spiral') & (main_spax_df.lgmass_bin==3)].groupby('rad_bin').sfr.mean().values\n",
    "sig_radbin_nspiral_sfr3 = (main_spax_df[(main_spax_df.spaxel_type == 'Non Spiral') & (main_spax_df.lgmass_bin==3)].groupby('rad_bin').sig2_sfr.mean().values) ** 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(12, 9))\n",
    "\n",
    "x = np.arange(10)\n",
    "\n",
    "plt.errorbar(x, radbin_spiral_sfr1, fmt='-b', elinewidth=3, ecolor='b', capsize=0, yerr=sig_radbin_spiral_sfr1)\n",
    "plt.errorbar(x, radbin_nspiral_sfr1, fmt='--b', elinewidth=1, ecolor='b', capsize=0, yerr=sig_radbin_nspiral_sfr1)\n",
    "\n",
    "#plt.scatter(x, radbin_spiral_sfr1, marker='X', color='blue')\n",
    "#plt.scatter(x, radbin_nspiral_sfr1, marker='X', color='blue')\n",
    "\n",
    "\n",
    "\n",
    "plt.errorbar(x, radbin_spiral_sfr2, fmt='-g', elinewidth=3, ecolor='g', capsize=0, yerr=sig_radbin_spiral_sfr2)\n",
    "plt.errorbar(x, radbin_nspiral_sfr2, fmt='--g', elinewidth=1, ecolor='g', capsize=0, yerr=sig_radbin_nspiral_sfr2)\n",
    "\n",
    "#plt.scatter(x, radbin_spiral_sfr2, marker='o', color='g')\n",
    "#plt.scatter(x, radbin_nspiral_sfr2, marker='o', color='g')\n",
    "\n",
    "\n",
    "plt.errorbar(x, radbin_spiral_sfr3, fmt='-r', elinewidth=3, ecolor='r', capsize=0, yerr=sig_radbin_spiral_sfr3)\n",
    "plt.errorbar(x, radbin_nspiral_sfr3, fmt='--r', elinewidth=1, ecolor='r', capsize=0, yerr=sig_radbin_nspiral_sfr3)\n",
    "\n",
    "#plt.scatter(x, radbin_spiral_sfr3, marker='^', color='r')\n",
    "#plt.scatter(x, radbin_nspiral_sfr3, marker='^', color='r')\n",
    "\n",
    "'''\n",
    "plt.plot(x, radbin_spiral_sfr2, '-g')\n",
    "plt.plot(x, radbin_nspiral_sfr2, '--g')\n",
    "\n",
    "plt.plot(x, radbin_spiral_sfr3, '-r')\n",
    "plt.plot(x, radbin_nspiral_sfr3, '--r')\n",
    "'''\n",
    "\n",
    "plt.xlabel('$r/r_e$', fontsize=50, labelpad=15)\n",
    "plt.ylabel('Average SFR\\n$ M_☉year^{-1}Kpc^{-2}$', fontsize=50, labelpad=15)\n",
    "\n",
    "plt.xticks([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9], fontsize=30)\n",
    "plt.yticks(fontsize=30)\n",
    "\n",
    "custom_lines = [Line2D([0], [0], marker='s', color='blue', linestyle='none', markersize=10),\n",
    "                Line2D([0], [0], marker='s', color='green', linestyle='none', markersize=10),\n",
    "                Line2D([0], [0], marker='s', color='red', linestyle='none', markersize=10),\n",
    "                Line2D([0], [0], linestyle='-', color = 'black', lw=2),\n",
    "                Line2D([0], [0], linestyle='--', color = 'black', lw=2)]\n",
    "\n",
    "#plt.legend(custom_lines, ['22153 Spaxels (9.018 - 10.156 $M_☉$)', '20849 Spaxels (10.156 - 10.590 $M_☉$)',\n",
    " #                         '19727 Spaxels (10.590 - 11.348 $M_☉$)', 'Inside Spiral Arms',\n",
    "  #                        'Outside Spiral Arms'], prop={'size': 25})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "radbin_spiral_sfr = main_spax_df[main_spax_df.spaxel_type == 'Spiral'].groupby('rad_bin').sfr.mean().values\n",
    "sig_radbin_spiral_sfr = (main_spax_df[main_spax_df.spaxel_type == 'Spiral'].groupby('rad_bin').sig2_sfr.mean().values) ** 0.5\n",
    "\n",
    "radbin_nspiral_sfr = main_spax_df[main_spax_df.spaxel_type == 'Non Spiral'].groupby('rad_bin').sfr.mean().values\n",
    "sig_radbin_nspiral_sfr = (main_spax_df[main_spax_df.spaxel_type == 'Non Spiral'].groupby('rad_bin').sig2_sfr.mean().values) ** 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(main_spax_df[main_spax_df.lgmass_bin==1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(main_spax_df[main_spax_df.lgmass_bin==2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(main_spax_df[main_spax_df.lgmass_bin==3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "gal_boi = SpiralGalaxy('/raid5/homes/sshamsi/sas/mangawork/manga/sandbox/galaxyzoo3d/v1_0_0/1-38550_127_5679053.fits.gz')\n",
    "\n",
    "fig, axes = plt.subplots(4, 1, figsize=(8, 32))\n",
    "img_ax = axes[0]\n",
    "img_ax.axis('off')\n",
    "img_ax.add_patch(gal_boi.data.get_hexagon(correct_hex=True, edgecolor='C4'))\n",
    "img_ax.imshow(gal_boi.data.image)\n",
    "\n",
    "ax_list = axes[1:]\n",
    "\n",
    "gal_boi.make_hamap_spiral_masks()\n",
    "            \n",
    "cbrange = gal_boi.hamap.plot(return_cbrange=True)\n",
    "            \n",
    "mask_list = [gal_boi.hamap.mask, gal_boi.hamap_spiral_mask, gal_boi.hamap_non_spiral_mask]\n",
    "            \n",
    "for ax, mask in zip(ax_list, mask_list):\n",
    "    mapplot.plot(dapmap = gal.hamap, fig=fig, ax=ax, mask = mask, cbrange=cbrange, title = 'H-α Flux Map')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for gal in gal_objs:\n",
    "    boolean = np.zeros(gal.hamap.shape, dtype=bool)\n",
    "    \n",
    "    a, b = boolean.shape\n",
    "    j, i = (a-1)/2, (b-1)/2\n",
    "    \n",
    "    for y, x in [(y, x) for y in range(a) for x in range(b)]:\n",
    "        if ((y - j)**2 + (x - i)**2) ** 0.5 < 4:\n",
    "            boolean[y, x] = True\n",
    "    \n",
    "    centre_mask = boolean * 2**30\n",
    "    gal.hamap.plot(mask=centre_mask)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def central_hole(test_gal_list, size):\n",
    "    run_frac = len(test_gal_list)/6\n",
    "    num_runs = int(run_frac)\n",
    "    last_run = 6 * (run_frac - num_runs)\n",
    "    \n",
    "    for j in range(num_runs):\n",
    "        fig, axes = plt.subplots(6, 2, figsize=(8 * 2, 6 * 8))\n",
    "        \n",
    "        for i in range(6):\n",
    "            gal = SpiralGalaxy(test_gal_list.pop(random.randint(0, len(test_gal_list)-1)))\n",
    "            cbrange = gal.hamap.plot(return_cbrange=True)\n",
    "            gal.make_hamap_spiral_masks()\n",
    "            \n",
    "            mapplot.plot(dapmap = gal.hamap, fig=fig, ax=axes[i, 0], cbrange=cbrange, title = str(gal.mangaid))\n",
    "            \n",
    "            boolean = np.zeros(gal.hamap.shape, dtype=bool)\n",
    "            \n",
    "            a, b = boolean.shape\n",
    "            j, i = (a-1)/2, (b-1)/2\n",
    "            \n",
    "            for y, x in [(y, x) for y in range(a) for x in range(b)]:\n",
    "                if ((y - j)**2 + (x - i)**2) ** 0.5 < size:\n",
    "                    boolean[y, x] = True\n",
    "                    \n",
    "            centre_hole = boolean * 2**30\n",
    "            centre_mask = deepcopy(gal.hamap.mask) | centre_hole\n",
    "            \n",
    "            mapplot.plot(dapmap = gal.hamap, fig=fig, ax=axes[i, 1], mask = centre_mask, cbrange=cbrange, title = str(gal.mangaid))\n",
    "                                    \n",
    "                \n",
    "        fig.savefig(str(j) + '.png')\n",
    "        \n",
    "    fig, axes = plt.subplots(last_run, 2, figsize=(8 * 2, 8 * last_run))\n",
    "    \n",
    "    for k in range(num_runs, num_runs + last_run):\n",
    "        gal = SpiralGalaxy(test_gal_list.pop(random.randint(0, len(test_gal_list)-1)))\n",
    "        cbrange = gal.hamap.plot(return_cbrange=True)\n",
    "        gal.make_hamap_spiral_masks()\n",
    "        \n",
    "        mapplot.plot(dapmap = gal.hamap, fig=fig, ax=axes[k - num_runs, 0], cbrange=cbrange, title = str(gal.mangaid))\n",
    "            \n",
    "        boolean = np.zeros(gal.hamap.shape, dtype=bool)\n",
    "            \n",
    "        a, b = boolean.shape\n",
    "        j, i = (a-1)/2, (b-1)/2\n",
    "\n",
    "        for y, x in [(y, x) for y in range(a) for x in range(b)]:\n",
    "            if ((y - j)**2 + (x - i)**2) ** 0.5 < size:\n",
    "                boolean[y, x] = True\n",
    "\n",
    "        centre_hole = boolean * 2**30\n",
    "        centre_mask = deepcopy(gal.hamap.mask) | centre_hole\n",
    "\n",
    "        mapplot.plot(dapmap = gal.hamap, fig=fig, ax=axes[k - num_runs, 1], mask = centre_mask, cbrange=cbrange, title = str(gal.mangaid))                    \n",
    "                \n",
    "        fig.savefig(str(k) + '.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "central"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}