Actividad_3_Astronomía_Galáctica.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Actividad 3 - Astronomía Galáctica.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/astrodatos/Clase3/blob/master/Actividad_3_Astronom%C3%ADa_Gal%C3%A1ctica.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "metadata": {
        "id": "nMI-_4E2YNGW",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#EI2001: Ciencia de datos en Astronomía\n",
        "**Profesores:** Pía Cortés, Daniela Barrientos, Matías Suazo, Matías Mattamala\n",
        "\n",
        "#Actividad Clase 3 - Uso de Astropy y Pandas.\n",
        "\n",
        "###Objetivos:\n",
        "1. Conocer la librerías Astropy y Pandas.\n",
        "2. Reconocer el uso de Astropy con imágenes astronómicas. \n",
        "3. Trabajar con Pandas y bases de datos de exoplanetas."
      ]
    },
    {
      "metadata": {
        "id": "vxFUSoX3Xg-j",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "##Astropy\n",
        "\n",
        "([Documentación](https://docs.astropy.org/en/stable/))\n",
        "\n",
        "\n",
        "`Astropy` es una de las librerías de Python que más se ocupan en astronomía. Incluye módulos y herramientas muy útiles y necesarias en astronomía, como por ejemplo:\n",
        "- Constantes astronómicas y cosmológicas.\n",
        "- Conversiones de tiempo y distancias.\n",
        "- Manejo de datos astronómicos en formas de `ndarray`.\n",
        "- Transformaciones de systemas de coordenadas.\n",
        "- Herramientas para analysis estadístico y modelamiento.\n",
        "- etc.\n",
        "\n",
        "Como vimos en clases, el tipo de archivo más utilizado para manejar imágenes astrómicas es el `FIT: Flexible Image Transport`. La mayoría de los telescopios en el mundo utiliza este sistema de almacenaje de datos y la comunidad astronómica lo ha hecho uno de sus estándares más importantes.\n",
        "\n",
        "###FIT\n",
        "\n",
        "Sistema de almacenamiento de datos astronómicos en forma de `ndarray`. Tiene dos componentes principales: header y data. Header es una tabla de información con la forma de diccionario, mientras que data puede ser un `array` de 2 dimiensiones o un cubo, con más de dos dimensiones. Para los siguientes ejempos consideraremos la componente data como un `ndarray` de dos dimensiones.\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "I5erEMh76iEi",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "###1. Abrir y leer un archivo `FIT` de la Nebulosa Horse Head"
      ]
    },
    {
      "metadata": {
        "id": "8M2RZFUYYCy4",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Importar las librerías que usaremos: matplotlib y astropy. \n",
        "# Considerar que solo ocuparemos los módulos fits y download_file de astropy.\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "from astropy.io import fits \n",
        "from astropy.utils.data import download_file\n",
        "import numpy as np\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "EswVghLj7HzM",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Descargamos el archivo FIT\n",
        "file = download_file(\"https://github.com/astrodatos/Clase3/raw/master/HorseHead.fits\", cache=True )"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "0s0mdyrH7P2Y",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Abrir archivo fits guardado en file\n",
        "hdu = fits.open(file)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Qk3DL-SyBm-L",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Por si solo, es un objeto\n",
        "hdu"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "vCAdiNY_Bn-u",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "hdu.info()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "UMicVD9iXyCP",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### 2. Guardar header y data en variables independientes"
      ]
    },
    {
      "metadata": {
        "id": "RWhiRmxKB-fO",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Guardamos el header en una variable\n",
        "header_data = hdu[0].header\n",
        "print(header_data)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Ix_o_ix-NwuG",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(\"Tercer elemento del header:\")\n",
        "print(header_data[2])\n",
        "\n",
        "print(\"Valor de la casilla DATE:\")\n",
        "print(header_data[\"DATE\"])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "dGVNz3kzGZGp",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Guardamos los datos del fit en otra variable\n",
        "image_data = hdu[0].data\n",
        "print(image_data)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "RLlVN2HNOSBL",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(\"Elemento de los datos en la fila 0:\")\n",
        "print(image_data[0])\n",
        "\n",
        "print(\"Primer elemento de la matriz de datos:\")\n",
        "print(image_data[1][1])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "JwbzaF_2HK_f",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(image_data.shape)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "_DqYdAegMZdy",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print('Min:', np.min(image_data))\n",
        "print('Max:', np.max(image_data))\n",
        "print('Mean:', np.mean(image_data))\n",
        "print('Stdev:', np.std(image_data))\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "GzWvbZaJX7nH",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "###3. Plotear la imagen"
      ]
    },
    {
      "metadata": {
        "id": "vKA6LnNNHRmN",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Plot de los datos del fit\n",
        "plt.figure(figsize=(10,10))\n",
        "plt.imshow(image_data, cmap='viridis') #grey, inferno, etc\n",
        "plt.colorbar()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "h-VKmIkPHWnl",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "WdCRYBaeVZGa",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#Pandas\n",
        "\n",
        "La librería `Pandas`es muy útil para el manejo de estructuras de datos. Está basado en `Numpy` pero incluye un nuevo concepto llamado Data Frame. Los Data Frame son arreglos multidimensionales, con sus respectivas etiquetas en filas y columnas, los cuales generalmente tienen distintos tipos de datos en su estructura como también datos faltantes. Todo lo anterior hace que `Pandas`  sea la mejor librería para trabajar con bases de datos."
      ]
    },
    {
      "metadata": {
        "id": "6SoFHNlhYE2F",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Importar librería\n",
        "import pandas as pd"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "-uJDif72Zl5e",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "###1. El objeto Serie\n",
        "\n",
        "Una `Serie` es un arreglo unidimensional de datos indexados, esto quiere decir que está formado por una secuencia de valores y una secuencia de índices.\n",
        "Se construye de la forma: \n",
        "\n",
        "```\n",
        "pd.Series(data,index=index)\n",
        "```\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "JY39H1NmZotj",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Creamos un objeto Series de Pandas\n",
        "data = pd.Series([0.5, 0.32, 3])\n",
        "print(data)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "3GJXT0fYZt8z",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(\"Mostrar los valores que guarda la Serie data:\")\n",
        "print(data.values)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "dxfHn0jjaak0",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(\"Mostrar los índices de la Serie data:\")\n",
        "print(data.index)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "HegDUHXLab15",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(\"Tercer elemento de la Serie data:\")\n",
        "print(data[2])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "l6B9Cbz-afo8",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(\"Podemos hacer slicing:\")\n",
        "print(data[0:2])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "YXg5OldBakO9",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Podemos cambiar el formato de los índices\n",
        "data = pd.Series(data= [0.25, 0.5, 0.75, 1.0],index=['a', 'b', 'c', 'd'])\n",
        "\n",
        "print(data)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "_P5ldm5-cMgh",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(\"Ahora el que vive en el índice b es:\")\n",
        "print(data['b'])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "-AolqU83ceqM",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# No necesariamente tienen que ser índices consecutivos\n",
        "data = pd.Series([0.25, 0.5, 0.75, 1.0], index=[2, 5, 3, 7])\n",
        "\n",
        "print(data)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "5K0wo3OCcmOD",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(\"El elemento del índice 3:\")\n",
        "print(data[3])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "xmxxUKq-cnoZ",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Se pueden crear máscaras: masking\n",
        "print(\"Los elementos mayores que 0.3 pero menores que 0.8:\")\n",
        "print(data[(data > 0.3) & (data < 0.8)])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Dh8KtxqNttJa",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "###2. El objeto Data Frame\n",
        "\n",
        "Los `Data Frame` de `Pandas` son `Series` en 2 dimensiones, con flexibilidad en los índices de las filas y en las etiquetas de las columnas. Se puede pensar que los `Data Frame` son secuencias alineadas (que comparten el mismo índice) de varias Series."
      ]
    },
    {
      "metadata": {
        "id": "BS8JVRqQylml",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Creamos diccionario, con forma de Serie, con las poblaciones de distintos estados de USA\n",
        "\n",
        "population_dict = {'California': 38332521,\n",
        "                   'Texas': 26448193,\n",
        "                   'New York': 19651127,\n",
        "                   'Florida': 19552860,\n",
        "                   'Illinois': 12882135}\n",
        "\n",
        "population = pd.Series(population_dict)\n",
        "\n",
        "print(population)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "70_ibd2Dym8H",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(\"La poblacion de California es:\")\n",
        "print(population['California'])\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "iPUeP6mqyqzM",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(population['California':'Illinois'])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "ksi_Ihl6yuKr",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Creamos diccionario con el área superficial de los mismos estados utilizados anteriormente:\n",
        "\n",
        "area_dict = {'California': 423967, 'Texas': 695662, 'New York': 141297,\n",
        "             'Florida': 170312, 'Illinois': 149995}\n",
        "\n",
        "area = pd.Series(area_dict)\n",
        "\n",
        "print(area)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "B6vZQ1x7yw-Y",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Creamos Data Frame de los estados, considerando area y población:\n",
        "\n",
        "states = pd.DataFrame({'population': population,\n",
        "                       'area': area})\n",
        "print(states)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "8y_SYia4yzvj",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(\"Los indices son:\")\n",
        "print(states.index)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Pzz15QBvy1-e",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(\"Las columnas del Data Frame son:\")\n",
        "print(states.columns)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "u1hZHnI4y3eQ",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(\"Los valores solo de la columna area:\")\n",
        "print(states['area'])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "IhfuGyOmy8sZ",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Creamos un Data Frame solo con la columna population:\n",
        "\n",
        "pop = pd.DataFrame(population, columns=['population'])\n",
        "\n",
        "print(pop)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "R9ZDfLV5zGWT",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "hA4c5LYv4Yzv",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "###3. Usar Pandas para trabajar con la base de datos de NASA Exoplanet Archive.\n"
      ]
    },
    {
      "metadata": {
        "id": "0vkf9ilZ4pTf",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Cargamos la base de datos\n",
        "archivo = download_file('https://raw.githubusercontent.com/piacortes/astroclases/master/planets.csv?token=AXWBlnRlbOADXAfY-qtBxFJQ3SugzCucks5cpBbnwA%3D%3D')\n",
        "planetas = pd.read_csv(archivo, comment=\"#\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "kSjhUJSR41OC",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Revisar los primeros elementos de la base de datos:\n",
        "planetas.head()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "oUqg-BxOE_M4",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(\"Cuántas filas y columnas tiene?:\")\n",
        "print(planetas.shape)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "KflAIDUl8PG8",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Promedio del período, según técnica de descrubrimiento\n",
        "planetas.groupby('pl_discmethod')[\"pl_orbper\"].mean()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "-Bw_6pme8kU-",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Masking\n",
        "obs = planetas[planetas[\"pl_trandep\"]>0.35]\n",
        "print(obs.shape)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "fD2OPYL19jp7",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Plots\n",
        "from matplotlib.pyplot import rcParams\n",
        "plt.rc('font', family='serif',size=15)\n",
        "params = {'legend.fontsize': 'x-large',\n",
        "         'axes.labelsize': 'x-large',\n",
        "         'axes.titlesize':'x-large',\n",
        "         'xtick.labelsize':'x-large',\n",
        "         'ytick.labelsize':'x-large'}\n",
        "rcParams.update(params)\n",
        "\n",
        "\n",
        "\n",
        "plt.scatter(planetas[\"pl_orbper\"],planetas[\"pl_bmassj\"])\n",
        "plt.xlabel(\"Periodo\")\n",
        "plt.ylabel(\"Masa\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "md6J0u2d_K9H",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Aplicamos logaritmo a los ejes:\n",
        "\n",
        "plt.figure(figsize=(20,10))\n",
        "\n",
        "plt.xlabel(\"Periodo\")\n",
        "plt.ylabel(\"Masa\")\n",
        "plt.plot(np.log(planetas[\"pl_orbper\"]),np.log(planetas[\"pl_bmassj\"]), \".\", color=\"black\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "lk1yUCClAS0Y",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(20,10))\n",
        "\n",
        "plt.xlabel(\"Distancia\")\n",
        "plt.ylabel(\"Masa\")\n",
        "plt.plot(np.log(planetas[\"st_dist\"]),np.log(planetas[\"pl_bmassj\"]), \".\", color=\"black\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "s752wyymA00s",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}