Actividad_4_Extragaláctico.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Actividad 4 - Extragaláctico.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python2",
      "display_name": "Python 2"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/suafle/Clase4/blob/master/Actividad_4_Extragal%C3%A1ctico.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "metadata": {
        "id": "2btHIAg5WJh_",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#EI2001 : Ciencia de Datos en Astronomía\n",
        "**Profesores:** Pía Cortés, Daniela Barrientos, Matías Mattamala, Matías Suazo\n",
        "##Actividad Clase 4 - Extragaláctico\n",
        "###Objetivos:\n",
        "1. Utilizar el paquete **astropy** para trabajar con unidades de medidas, coordenadas y archivos fits.\n",
        "2. Utilizar datos del google drive personal de cada uno.\n",
        "3. Lectura de archivos *fits* en objetos extragalácticos en forma de cubo de datos.\n",
        "4. Utilizar el paquete **astroquery** para hacer query de objetos del SDSS.\n"
      ]
    },
    {
      "metadata": {
        "id": "HowE5btf15kX",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#Sistema de coordenadas\n",
        "\n",
        "Un sistema de coordenadas es un conjunto de convenciones establecidas con el fin de determinar las posiciones de un cuerpo en el espacio. Existen muchos sistemas de coordenadas en astronomía, algunos ejemplos son coordenadas galácticas, coordenadas eclípticas, coordenadas ecuatoriales y coordenadas horizontales. El sistema que revisaremos hoy dia es el **sistema de coordenadas ecuatorial.**\n",
        "\n",
        "##Coordenadas ecuatoriales\n",
        "\n",
        "Para entender un poco como funcionan los sistemas de coordenadas en astronomía, tomaremos como ejemplo las coordenadas esféricas. \n",
        "\n",
        "![](https://upload.wikimedia.org/wikipedia/commons/thumb/4/4f/3D_Spherical.svg/240px-3D_Spherical.svg.png) \n",
        "\n",
        "Como debiesen saber, en coordenadas esféricas la posición de una partícula queda determinada por la distancia al objeto y dos ángulos llamados ángulo azimutal y ángulo cenital, el primer ángulo recorre el plano x-y partiendo de la semirrecta x-positivo y se desplaza en sentido antihorario, mientras que el segundo ángulo parte en la recta z-positiva y se desplaza hacia el plano x-y. Inspirados en este sistema de coordenas y el hecho de que la tierra es **esférica**, resulta natural describir las estrellas y cualquier objeto en el cielo mediante estas coordenadas, sin embargo, la distancia a un determinado objeto no es algo que se pueda determinar a priori. \n",
        "\n",
        "Las cordenadas ecuatoriales se basan en este sistema de coordenadas, en el cual se defina la posición de los objetos solo con un par de ángulos, los cuales son la **ascención recta** y la **declinación**. La ascención recta vendría a ser un equivalente al ángulo azimutal, pues parte de eje-x positivo y se desplaza en el plano x-y en sentido antihorario. La declinación a diferencia del ángulo cenital parte del plano x-y, desplazándose hacia el eje z a diferencia del ángulo cenital. Si bien ya definimos la ascención recta (**AR**,$\\alpha$) y la declinación (**DEC**,$\\delta$), falta definir las ejes y los planos utilizados en el espacio real.\n",
        "\n",
        "El plano X-Y está definido por el ecuador celeste, el cual es la proyección de la línea del ecuador. Mientras que el eje Z se encuetra definido por el eje de rotación de la Tierra.\n",
        "\n",
        "![](http://ircamera.as.arizona.edu/astr_250/images/cel_sphere.jpg)\n",
        "\n",
        "El eje X está definido por la recta que parte en el centro de la Tierra y se propaga hasta el punto Aries (o punto Vernal), el cual corresponde a la posición del Sol para el equinoccio de primavera (en el hemisferio norte).  Por razones histórica a veces la unidad de medida de alguno de estos ángulo puede estar en horas, lo cual corresponde a 15 grados.\n",
        "\n",
        "![](https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSW4PNLfsDuYAVIiZGtDBVLWxOVMZTL1IDYalaitBV2NULlAJY4Ww)\n",
        "\n",
        "Ya habiendo entendido esto procederemos a revisar un poco sobre como trabajar con coordenadas en astropy. Primero revisaremos las unidades de medidas.\n"
      ]
    },
    {
      "metadata": {
        "id": "Ebt-KO698Hi7",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "##International Celestial Reference Frame (ICRS)\n",
        "\n",
        "El Sistema de Referencia Celestial Internacional es el sistema de referencia celestial estándar actual adoptado por la Unión Astronómica Internacional (IAU). Su origen esta en el baricentro del sistema solar. [Más información](http://hpiers.obspm.fr/icrs-pc/newwww/misc/icrs.php). En términos de coordenadas, se asemeja al sistema de coordenadas ecuatoriales."
      ]
    },
    {
      "metadata": {
        "id": "GZB-dJSHPQx8",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from astropy import units as u\n",
        "from astropy.coordinates import SkyCoord\n",
        "\n",
        "# el importar la funcion units como u permite crear variables con unidades al multiplicarse por este valor\n",
        "# en http://docs.astropy.org/en/stable/units/ pueden encontrar la lista con todas las posibles unidades\n",
        "desplazamiento = 1 * u.m\n",
        "tiempo = 2 * u.s\n",
        "velocidad = desplazamiento/tiempo\n",
        "print desplazamiento\n",
        "print tiempo\n",
        "print velocidad"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "EUJt3fmQTQEK",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Ahora revisaremos la clase SkyCoord. Una clases que viene con el sub-paquete astropy.coordinates y que utilizaremos más adelante. [Coordenadas Astropy](http://docs.astropy.org/en/stable/coordinates/)"
      ]
    },
    {
      "metadata": {
        "id": "xpBT7pLsUX_z",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "c = SkyCoord(ra=10.625*u.degree, dec=41.2*u.degree, frame='icrs')\n",
        "c = SkyCoord(10.625, 41.2, frame='icrs', unit='deg')\n",
        "c = SkyCoord('00h42m30s', '+41d12m00s', frame='icrs')\n",
        "c = SkyCoord('00h42.5m', '+41d12m')\n",
        "c = SkyCoord('00 42 30 +41 12 00', unit=(u.hourangle, u.deg))\n",
        "c = SkyCoord('00:42.5 +41:12', unit=(u.hourangle, u.deg))\n",
        "print c"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Gf66SWguPLJH",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "#Surveys Extragalácticos:\n",
        "\n",
        "Existen muchos *surveys* que incluyen observaciones de galaxias (tanto fotometría como espectroscopía). El [Sloan Digital Sky Survey (SDSS)](https://www.sdss.org) se ha caracterizado por ser unos de los más importantes contando con 15 Data Release a la fecha. Sin embargo para el ejercicio de hoy trabajaremos principalmente con datos de [Calar Alto Legacy Integral Field Area Survey (CALIFA)](http://www.caha.es/CALIFA/public_html/?q=node/1) el cual consiste en un survey de más de 600 galaxias aplicando la técnica de *Integral Field Spectroscopy* (IFS). \n"
      ]
    },
    {
      "metadata": {
        "id": "i_vhyH0YVqO3",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#Cubo de datos\n",
        "##Visualización Espacial\n",
        "\n",
        "Como recuerdan de la semana pasada, los archivos se guardan en un formato llamado *fits*, debido a lo conveniente de su tamaño. Hoy a diferencia de la clase pasada trabajaremos con *fits* cubo de datos. En principio un fits es un arreglo bidimensional representado por coordenadas espaciales, en la cual se le asigna un valor a cada elemento de este arreglo bidimensional, lo cual suele ser el flujo, intensidad, número de cuentas, etc. En un cubo de datos extendemos la componente bidimensional a una tridimensional la cual puede representar alguna variable física.\n",
        "\n",
        "En los siguientes videos se muestra como funciona un cubo de datos en caso de que esta tercera variable sea la longitud de onda.\n",
        "\n",
        "[![MUSE datacubes](https://i.imgur.com/2feyFlG.png)](https://youtu.be/rNbdDKuDMoY?t=147)\n",
        "\n",
        "\n",
        "[![MUSE datacubes](http://cdn.eso.org/videos/videoframe/eso1407d.jpg)](https://www.youtube.com/watch?v=ghVv74y_d1Q)\n",
        "\n",
        "Como estos archivos son fits, se trabajan con astropy de la misma manera que se vio la clase pasada. Pero primero necesitamos revisar otra función antes de ponernos a trabajar con los fits."
      ]
    },
    {
      "metadata": {
        "id": "E1Q-8dHmdmkM",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#Montar Google Drive\n",
        "\n",
        "En las clases anteriores hemos trabajado con datos descargados de github en tiempo real, sin embargo, esto ha sido posible porque esos archivos has sido livianos, sin embargo, en los cubos de datos suelen ser algo más pesados. Por esto a veces es necesario guardar información en nuestro **Google Drive**."
      ]
    },
    {
      "metadata": {
        "id": "udoNnsIUdlv4",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/gdrive')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "CGvtX_eLVpRg",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#Con los simples comandos anteriores ya podemos acceder a todos los archivos que estén en nuestro drive\n",
        "from astropy.io import fits\n",
        "from astropy.wcs import WCS\n",
        "filename = ('/content/gdrive/My Drive/Colab Notebooks/NGC5406.V500.rscube.fits.gz') #basta con el nombre\n",
        "hdu_fits = fits.open(filename) #abre los fits, pueden abrirse comprimidos en gz\n",
        "hdu = fits.open(filename)[0] #abre los fits, pueden abrirse comprimidos en gz\n",
        "header = hdu.header\n",
        "wcs = WCS(header) #permite leer el header world coordinate system\n",
        "print wcs"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "zhvE_D5zmq-B",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#Cargamos los datos\n",
        "data = hdu.data\n",
        "print data"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "UgGfd-Agm-z-",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#para poder visualizar una slice basta con usar la función imshow pía mostró la clase pasada aplicada a una matrix\n",
        "plt.imshow(data[0],cmap='inferno')\n",
        "plt.colorbar()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "_Zr_t1gmnqcU",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#ahora es necesario entra a refinar\n",
        "#En primer y acorde al header la información de cada pixel es el flujo en la respectiva longitud de onda\n",
        "#acorde al header las unidades de medidas son 1e-16 erg/s/cm**2/A\n",
        "#También se observan flujos negativos, lo cual se debe probablemente a ruido en la cámara\n",
        "\n",
        "units = header['HIERARCH PIPE UNITS'] #podemos rescatar la unidades con esta key o llave\n",
        "plt.imshow(data[0],cmap='inferno',vmax=0.6,vmin=0)\n",
        "cb = plt.colorbar()\n",
        "cb.set_label('Flux [10$^{-16}$ erg/s/cm$^2$/$\\AA$]')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Qcq5F6aHpiOk",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#ahora es necesario entra a refinar\n",
        "#En primer y acorde al header la información de cada pixel es el flujo en la respectiva longitud de onda\n",
        "#acorde al header las unidades de medidas son 1e-16 erg/s/cm**2/A\n",
        "#También se observan flujos negativos, lo cual se debe probablemente a ruido en la cámara\n",
        "\n",
        "units = header['HIERARCH PIPE UNITS'] #podemos rescatar la unidades con esta key o llave\n",
        "\n",
        "plt.imshow(data[0],cmap='inferno',vmax=0.6,vmin=0,origin='lower') #vmax y vmin sirven para setear los máximos y minimos del colorbar\n",
        "#origin='lower' pone el origen en el origen del plano cartesiano\n",
        "cb = plt.colorbar()\n",
        "cb.set_label('Flux [10$^{-16}$ erg/s/cm$^2$/$\\AA$]')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "s98YFlc6qGcC",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#Lo último que queda es revisar bien los ejes X e Y, hacer que sean variables físicas, ra y dec.\n",
        "\n",
        "print 'Valor 1 en el pixel de referencia = ',header['CRVAL1'] #valor inicial de la RA en el pixel de referencia\n",
        "print 'Valor 2 en el pixel de referencia = ',header['CRVAL2'] #valor inicial de la DEC en el pixel de referencia\n",
        "print 'Valor 3 en el pixel de referencia = ',header['CRVAL3'] #valor inicial de la longitud de onda en el pixel de referencia\n",
        "\n",
        "print 'Pixel de referencia para variable 1 = ', header['CRPIX1'] #pixel de referencia para la RA inicial\n",
        "print 'Pixel de referencia para variable 2 = ', header['CRPIX2'] #pixel de referencia para la DEC inicial\n",
        "print 'Pixel de referencia para variable 3 = ', header['CRPIX3'] #pixel de referencia para la longitud de onda inicial\n",
        "\n",
        "print 'Step para variable 1 = ', header['CD1_1'] #step o paso en deg entre cada pixel para la RA\n",
        "print 'Step para variable 2 = ', header['CD2_2'] #step o paso en deg entre cada pixel para la DEC\n",
        "print 'Step para variable 3 = ', header['CD3_3'] #step o paso en deg entre cada pixel para la Longitud de onda\n",
        "\n",
        "delt1 = np.arange(0,header['NAXIS1']) - (header['CRPIX1']-1)\n",
        "step1 = delt1*header['CD1_1']\n",
        "ra = step1 + header['CRVAL1']\n",
        "\n",
        "delt2 = np.arange(0,header['NAXIS2']) - (header['CRPIX2']-1)\n",
        "step2 = delt2*header['CD2_2']\n",
        "dec = step2 + header['CRVAL2']\n",
        "\n",
        "delt3 = np.arange(0,header['NAXIS3'])\n",
        "step3 = delt3*header['CD3_3']\n",
        "lo = step3 + header['CRVAL3']\n",
        "\n",
        "plt.imshow(data[1],cmap='inferno',origin='lower',vmin=0,vmax=1)\n",
        "plt.xticks((0,20,40,60),(round(ra[0],3),round(ra[20],3),round(ra[40],3),round(ra[60],3))) #xticks, tupla con numeros originales, tupla con nuevos digitos\n",
        "plt.yticks((0,20,40,60),(round(dec[0],3),round(dec[20],3),round(dec[40],3),round(dec[60],3))) #yticks, tupla con numeros originales, tupla con nuevos digitos\n",
        "plt.xlabel('RA [deg]')\n",
        "plt.ylabel('DEC [deg]')\n",
        "plt.grid(b=None) #Esto para quitar las lineas de la imagen\n",
        "cb = plt.colorbar()\n",
        "cb.set_label('Flux [10$^{-16}$ erg/s/cm$^2$/$\\AA$]')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "oKYkOERzzGWK",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "##Espectros\n",
        "\n",
        "Con estos datos del cubo, podemos observar el espectro de cada pixel de la imagen.\n",
        "Para ello basta con acceder a la información en cada pixel. "
      ]
    },
    {
      "metadata": {
        "id": "10P0lbZo0JQC",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "plt.plot(lo,data[:,30,30])\n",
        "plt.xlim(3750,7500)\n",
        "#plt.ylim(0,0.16)\n",
        "plt.xlabel('Wavelength [$\\AA$]')\n",
        "plt.ylabel('Flux 10$^{-16}$ erg/s/cm$^2$/$\\AA$')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "mgVnypbtOSKf",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#Database Query\n",
        "\n",
        "Un *query* es una solicitud a una base de datos para poder acceder a la información que existe en dicha base de datos. En general, los query se hacen en un lenguaje de programación específico para esta tarea llamada SQL, por ahora revisaremos una forma muy sencilla de hacerlo mediante el uso del paque **astroquery**."
      ]
    },
    {
      "metadata": {
        "id": "VZnzFPps2VF2",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#!pip install astroquery #esto para instalar astroquery\n",
        "from astroquery.sdss import SDSS\n",
        "pos = SkyCoord('0h8m05.63s +14d50m23.3s', frame='icrs')\n",
        "xid = SDSS.query_region(pos, radius = 2*u.arcsec, spectro=True) #radius por defecto es 2 arcsec\n",
        "print xid #mejor imprimir xid[0] por la visualización\n",
        "#podemos descargar los datos de todos los objetos encontrados en xid\n",
        "\n",
        "#Algunas pequeñas funciones de conversión\n",
        "#print (8*u.arcmin + 5.63*u.arcsec).to(u.deg)\n",
        "#print (14*u.deg + 50*u.arcmin + 23.3*u.arcsec).to(u.deg)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "sJ0HEHsHCkkl",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "sp = SDSS.get_spectra(matches=xid)\n",
        "img = SDSS.get_images(matches=xid, band='g') #fotometría en la banda g\n",
        "imu = SDSS.get_images(matches=xid, band='u') #fotometría en la banda u"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "rCy8HhxW0BHq",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#Hojiemos la fotometría\n",
        "#print repr(imu[0][0].header)\n",
        "\n",
        "header = img[0][0].header\n",
        "wcs = WCS(header) #permite leer el header world coordinate system\n",
        "print wcs\n",
        "\n",
        "print 'Valor 1 en el pixel de referencia = ',header['CRVAL1'] #valor inicial de la RA en el pixel de referencia\n",
        "print 'Valor 2 en el pixel de referencia = ',header['CRVAL2'] #valor inicial de la DEC en el pixel de referencia\n",
        "\n",
        "print 'Pixel de referencia para variable 1 = ', header['CRPIX1'] #pixel de referencia para la RA inicial\n",
        "print 'Pixel de referencia para variable 2 = ', header['CRPIX2'] #pixel de referencia para la DEC inicial\n",
        "\n",
        "print 'Step para variable 1 = ', header['CD1_1'] #step o paso en deg entre cada pixel para la RA\n",
        "print 'Step para variable 2 = ', header['CD2_2'] #step o paso en deg entre cada pixel para la DEC\n",
        "\n",
        "delt1 = np.arange(0,header['NAXIS1']) - (header['CRPIX1']-1)\n",
        "step1 = delt1*header['CD1_1']\n",
        "ra = step1 + header['CRVAL1']\n",
        "\n",
        "delt2 = np.arange(0,header['NAXIS2']) - (header['CRPIX2']-1)\n",
        "step2 = delt2*header['CD2_2']\n",
        "dec = step2 + header['CRVAL2']\n",
        "\n",
        "datag = img[0][0].data\n",
        "datau = imu[0][0].data\n",
        "\n",
        "#imagen banda g\n",
        "plt.imshow(datag,cmap='viridis',origin='lower',vmin=0,vmax=0.1)\n",
        "plt.xticks((0,len(ra)/3,2*len(ra)/3,len(ra)),(round(ra[0],3),round(ra[len(ra)/3],3),round(ra[2*len(ra)/3],3),round(ra[-1],3))) #xticks, tupla con numeros originales, tupla con nuevos digitos\n",
        "plt.yticks((0,len(dec)/3,2*len(dec)/3,len(dec)),(round(dec[0],3),round(dec[len(dec)/3],3),round(dec[2*len(dec)/3],3),round(dec[-1],3))) #yticks, tupla con numeros originales, tupla con nuevos digitos\n",
        "plt.xlabel('RA [deg]')\n",
        "plt.ylabel('DEC [deg]')\n",
        "plt.grid(b=None) #Esto para quitar las lineas de la imagen\n",
        "cb = plt.colorbar()\n",
        "cb.set_label('Flux density [3.631$ \\cdot 10^{-6}$ Jy]')\n",
        "plt.show()\n",
        "\n",
        "#imagen banda u\n",
        "plt.imshow(datau,cmap='viridis',origin='lower',vmin=0,vmax=0.1)\n",
        "plt.xticks((0,len(ra)/3,2*len(ra)/3,len(ra)),(round(ra[0],3),round(ra[len(ra)/3],3),round(ra[2*len(ra)/3],3),round(ra[-1],3))) #xticks, tupla con numeros originales, tupla con nuevos digitos\n",
        "plt.yticks((0,len(dec)/3,2*len(dec)/3,len(dec)),(round(dec[0],3),round(dec[len(dec)/3],3),round(dec[2*len(dec)/3],3),round(dec[-1],3))) #yticks, tupla con numeros originales, tupla con nuevos digitos\n",
        "plt.xlabel('RA [deg]')\n",
        "plt.ylabel('DEC [deg]')\n",
        "plt.grid(b=None) #Esto para quitar las lineas de la imagen\n",
        "cb = plt.colorbar()\n",
        "cb.set_label('Flux density [3.631$ \\cdot 10^{-6}$ Jy]')\n",
        "plt.show()\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "H1nvHQAW2mQQ",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#Revisemos la espectrometría ahora\n",
        "#print repr(sp[0][0].header)\n",
        "#print WCS(sp[0][0].header)\n",
        "fits = sp[0]\n",
        "#print repr(fits.info())\n",
        "#print fits[1].columns\n",
        "scidata = fits[1].data\n",
        "flux = scidata['flux']\n",
        "lam = scidata['loglam']\n",
        "plt.plot(10**(lam), flux)\n",
        "plt.xlabel('Wavelength [$\\AA$]')\n",
        "plt.ylabel('Flux density [10$^{-17}$ erg/cm$^2$/s/$\\AA$]')"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}