diff --git a/astropy-coordinates/1-Coordinates-Intro.ipynb b/astropy-coordinates/1-Coordinates-Intro.ipynb
new file mode 100644
index 0000000..c4f1278
--- /dev/null
+++ b/astropy-coordinates/1-Coordinates-Intro.ipynb
@@ -0,0 +1,778 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "view-in-github",
+        "colab_type": "text"
+      },
+      "source": [
+        "<a href=\"https://colab.research.google.com/github/GabrielCalcada/astropytutorialsptbr/blob/main/astropy-coordinates/1-Coordinates-Intro.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "LKKSxi985bLE"
+      },
+      "source": [
+        "# Coordenadas Astronômicas 1: Introdução com astropy.coordinates\n",
+        "\n",
+        "## Autores\n",
+        "Adrian Price-Whelan\n",
+        "\n",
+        "## Tradução para o Português\n",
+        "Gabriel Valim Calçada\n",
+        "\n",
+        "## Metas de aprendizagem\n",
+        "* Criar objetos `astropy.coordinates.SkyCoord` usando dados de coordenadas e nomes de objetos\n",
+        "* Use objetos SkyCoord para se familiarizar com a programação orientada a objetos (object oriented programming (OOP))\n",
+        "* Use o objeto `SkyCoord` para consultar o arquivo *Gaia* usando `astroquery`\n",
+        "* Dados de coordenadas de saída em diferentes representações de string\n",
+        "* Demonstrar como trabalhar com coordenadas do céu 3D (incluindo informações de distância para objetos)\n",
+        "\n",
+        "## Keywords - Palavras-chave\n",
+        "coordenadas, OOP, astroconsulta, gaia\n",
+        "\n",
+        "\n",
+        "## Resumo\n",
+        "\n",
+        "Os astrônomos usam uma ampla variedade de sistemas de coordenadas e formatos para representar as coordenadas do céu de objetos celestes. Por exemplo, você pode ter visto termos como \"right ascension\" e \"declination\" ou \"galactic latitude and longitude,\" e pode ter visto componentes de coordenadas angulares representados como \"0h39m15.9s\", \"00:39:15.9\" ou 9,81625º. O subpacote `astropy.coordinates` fornece ferramentas para representar as coordenadas de objetos e transformá-las entre diferentes sistemas.\n",
+        "\n",
+        "Neste tutorial, vamos explorar como o pacote `astropy.coordinates` pode ser usado para trabalhar com coordenadas astronômicas. Você pode achar útil manter [a documentação do Astropy para o pacote de coordenadas](http://docs.astropy.org/en/stable/coordinates/index.html) aberta junto com este tutorial para referência ou leitura adicional. No texto abaixo, você também pode ver alguns links que se parecem com ([docs](http://docs.astropy.org/en/stable/coordinates/index.html)). Esses links levarão você a partes da documentação diretamente relevantes para as células das quais eles se vinculam.\n",
+        "\n",
+        "*Obs: Este é o primeiro tutorial de uma série de tutoriais sobre astropy.coordinates.*\n",
+        "- [Próximo tutorial: Coordenadas Astronômicas 2: Transformando Sistemas e Representações de Coordenadas](2-Coordinates-Transforms)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "5cmIRhDc5bLI"
+      },
+      "source": [
+        "## Imports\n",
+        "\n",
+        "Começamos importando alguns pacotes que precisaremos abaixo:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "F8LwlpIm5bLI"
+      },
+      "outputs": [],
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "%matplotlib inline\n",
+        "import numpy as np\n",
+        "\n",
+        "from astropy import units as u\n",
+        "from astropy.coordinates import SkyCoord, Distance\n",
+        "from astropy.io import fits\n",
+        "from astropy.table import QTable\n",
+        "from astropy.utils.data import download_file\n",
+        "\n",
+        "from astroquery.gaia import Gaia\n",
+        "Gaia.ROW_LIMIT = 10000  # Set the row limit for returned data"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "kt7C1Gvu5bLK"
+      },
+      "source": [
+        "## Representando posições no céu com `astropy.coordinates`\n",
+        "\n",
+        "No Astropy, a maneira mais comum de representar e trabalhar com coordenadas do céu é usar o objeto `SkyCoord` ([docs](https://docs.astropy.org/en/stable/coordinates/skycoord.html)). Um `SkyCoord` pode ser criado diretamente a partir de ângulos ou matrizes de ângulos com unidades associadas, conforme demonstrado abaixo.\n",
+        "\n",
+        "Para começar, vamos supor que queremos criar um objeto `SkyCoord` para o centro do aglomerado de estrelas aberto NGC 188 para que mais tarde possamos consultar e recuperar estrelas que possam ser membros do aglomerado. Vamos supor também, por enquanto, que já sabemos que as coordenadas no céu do aglomerado são (12,11, 85,26) graus no frame de coordenadas do ICRS. O ICRS — às vezes referido como coordenadas \"equatoriais\" ou \"J2000\" ([mais informações sobre o ICRS](https://arxiv.org/abs/astro-ph/0602086)) — é atualmente o frame de coordenadas astronômicas mais comum para astronomia estelar ou extragaláctica, e é o frame de coordenadas padrão para `SkyCoord`. Como já sabemos a posição do ICRS do NGC 188 (veja acima), podemos criar um objeto `SkyCoord` para o cluster passando os dados para o inicializador `SkyCoord`:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "KjVmI-NH5bLL"
+      },
+      "outputs": [],
+      "source": [
+        "ngc188_center = SkyCoord(12.11*u.deg, 85.26*u.deg)\n",
+        "ngc188_center"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "tWzA3zEw5bLL"
+      },
+      "source": [
+        "Mesmo que o frame padrão seja ICRS, geralmente é recomendado especificar explicitamente o quadro em que suas coordenadas estão. Neste caso, esta seria uma maneira equivalente de criar nosso objeto `SkyCoord` para NGC 188:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "zc_UFhnK5bLM"
+      },
+      "outputs": [],
+      "source": [
+        "ngc188_center = SkyCoord(12.11*u.deg, 85.26*u.deg, frame='icrs')\n",
+        "ngc188_center"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ME83tjnj5bLM"
+      },
+      "source": [
+        "Como veremos mais adiante nesta série, existem muitos outros frame de coordenadas suportados, por isso ajuda a adquirir o hábito de passar o nome de um frame de coordenadas.\n",
+        "\n",
+        "Nas inicializações acima, passamos objetos `astropy.units.Quantity` com unidades angulares para especificar os componentes angulares de nossas coordenadas do céu. O inicializador `SkyCoord` também aceitará coordenadas formatadas em strings como strings separadas para Right Ascension  (RA) e Declination  (Dec) ou uma única string. Por exemplo, se tivermos dados de coordenadas do céu sexagesimais: neste caso, a representação dos dados inclui especificações das unidades (o \"hms\" para \"hora minuto segundo\" e o \"dms\" para \"graus minuto segundo\" (degrees minute second)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "u4_9DuOS5bLN"
+      },
+      "outputs": [],
+      "source": [
+        "SkyCoord('00h48m26.4s', '85d15m36s', frame='icrs')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "wB8njHQ35bLO"
+      },
+      "source": [
+        "Algumas representações de string não definem explicitamente as unidades, então às vezes é necessário especificar as unidades dos dados de coordenadas da string explicitamente se elas não estiverem incluídas implicitamente:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "alh1HESk5bLO"
+      },
+      "outputs": [],
+      "source": [
+        "SkyCoord('00:48:26.4 85:15:36', unit=(u.hour, u.deg), \n",
+        "         frame='icrs')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Kn-XQfpQ5bLO"
+      },
+      "source": [
+        "Para obter mais informações e exemplos sobre como inicializar objetos `SkyCoord`, [consulte esta documentação](http://docs.astropy.org/en/latest/coordinates/skycoord.html)."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "vIZmg1sh5bLP"
+      },
+      "source": [
+        "Para as inicializações do `SkyCoord` demonstradas acima, assumimos que já tínhamos os valores dos componentes de coordenadas prontos. Se você não conhece os valores das coordenadas e o objeto que você está interessado está em [SESAME](http://cdsweb.u-strasbg.fr/cgi-bin/Sesame), você também pode procurar e carregar valores de coordenadas automaticamente do nome do objeto usando o método de classe `SkyCoord.from_name()`<sup>1</sup> ([docs](http://docs.astropy.org/en/latest/coordinates/index.html# métodos de conveniência)). Observe, no entanto, que isso requer uma conexão com a Internet. É seguro pular esta célula se você não estiver conectado à internet porque já definimos o objeto `ngc188_center` nas células acima.\n",
+        "\n",
+        "<sub> <sup>1</sup>Se você não sabe o que é um método de classe, pense nele como um construtor alternativo para um objeto `SkyCoord` — chamar `SkyCoord.from_name()` com um nome lhe dá um novo objeto `SkyCoord`. Para obter informações mais detalhadas sobre o que são métodos de classe e quando são úteis, consulte [esta página](https://julien.danjou.info/blog/2013/guide-python-static-class-abstract-methods).</sub>"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "5XPzVNKv5bLP"
+      },
+      "outputs": [],
+      "source": [
+        "ngc188_center = SkyCoord.from_name('NGC 188')\n",
+        "ngc188_center"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "PbDA0UB-5bLQ"
+      },
+      "source": [
+        "O objeto `SkyCoord` que definimos agora tem várias maneiras de acessar as informações de coordenadas contidas nele. Todos os objetos `SkyCoord` possuem atributos que permitem que você recupere os dados do componente de coordenadas, mas os nomes dos componentes mudarão dependendo do quadro de coordenadas do `SkyCoord` que você possui. Em nossos exemplos, criamos um `SkyCoord` no quadro ICRS, então os nomes dos componentes são abreviações em minúsculas de Right Ascension, `.ra`, e Declination, `.dec`:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "1rBsI0nn5bLQ"
+      },
+      "outputs": [],
+      "source": [
+        "ngc188_center.ra, ngc188_center.dec"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "aBHb-kYV5bLR"
+      },
+      "source": [
+        "Os atributos do componente `SkyCoord` (aqui ``ra`` e ``dec``) retornam objetos especializados do tipo `Quantity` que facilitam o trabalho com dados angulares. Enquanto `Quantity` ([docs](http://docs.astropy.org/en/stable/units/index.html)) é uma classe geral que representa valores numéricos e unidades físicas de qualquer tipo, `astropy.coordinates` define subclasses de `Quantity` que são projetadas especificamente para trabalhar com ângulos, como o `Angle` ([docs](http://docs.astropy.org/en/stable/api/astropy.coordinates.Angle.html) ) classe. A classe `Angle` tem subclasses adicionais e mais especializadas `Latitude` ([docs](http://docs.astropy.org/en/stable/api/astropy.coordinates.Latitude.html)) e `Longitude` ( [docs](http://docs.astropy.org/en/stable/api/astropy.coordinates.Longitude.html)). Esses objetos armazenam ângulos, fornecem atributos úteis para converter rapidamente em unidades angulares comuns e permitem a formatação dos valores numéricos em vários formatos. Por exemplo, em um notebook Jupyter, esses objetos sabem como se representar usando LaTeX:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "2Dt2QhbF5bLR"
+      },
+      "outputs": [],
+      "source": [
+        "ngc188_center.ra"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "nkYqDsKY5bLR"
+      },
+      "outputs": [],
+      "source": [
+        "ngc188_center.dec"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "BZpZVhNL5bLS"
+      },
+      "outputs": [],
+      "source": [
+        "type(ngc188_center.ra), type(ngc188_center.dec)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ZPFxTCHm5bLS"
+      },
+      "source": [
+        "Com esses objetos, podemos recuperar os componentes de coordenadas em diferentes unidades usando o método `Quantity.to()`:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "crvhWUcu5bLT"
+      },
+      "outputs": [],
+      "source": [
+        "(ngc188_center.ra.to(u.hourangle), \n",
+        " ngc188_center.ra.to(u.radian),\n",
+        " ngc188_center.ra.to(u.degree))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "1uqBnux85bLT"
+      },
+      "source": [
+        "Ou usando os atributos abreviados, que retornam apenas os valores dos componentes:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "oFi9KOLQ5bLU"
+      },
+      "outputs": [],
+      "source": [
+        "(ngc188_center.ra.hour, \n",
+        " ngc188_center.ra.radian, \n",
+        " ngc188_center.ra.degree)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "YHlQd-Qm5bLU"
+      },
+      "source": [
+        "Também podemos formatar os valores em strings com unidades especificadas ([docs](http://docs.astropy.org/en/latest/coordinates/formatting.html)), por exemplo:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "jtXNjl2k5bLU"
+      },
+      "outputs": [],
+      "source": [
+        "ngc188_center.ra.to_string(unit=u.hourangle, sep=':', pad=True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "RU_bi8v95bLU"
+      },
+      "source": [
+        "## Consultando o arquivo *Gaia* para recuperar as coordenadas das estrelas no NGC 188"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "_wtOD00c5bLV"
+      },
+      "source": [
+        "Agora que temos um objeto `SkyCoord` para o centro de NGC 188, podemos usar este objeto com o pacote `astroquery` para consultar diversos bancos de dados astronômicos (veja uma lista completa de [serviços disponíveis na documentação do astroquery](https: //astroquery.readthedocs.io/en/latest/#available-services)). Aqui, usaremos o objeto `SkyCoord` `ngc188_center` para selecionar fontes do catálogo *Gaia* Data Release 2 em torno da posição do centro de NGC 188 para procurar estrelas que possam ser membros do aglomerado estelar. Para isso, usaremos o subpacote `astroquery.gaia` ([docs](https://astroquery.readthedocs.io/en/latest/gaia/gaia.html)).\n",
+        "\n",
+        "Isso requer uma conexão com a Internet, mas se falhar, o arquivo de catálogo é incluído no repositório para que você possa carregá-lo localmente (pule a próxima célula se não tiver uma conexão com a Internet):"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "YkQXMwwR5bLV"
+      },
+      "outputs": [],
+      "source": [
+        "job = Gaia.cone_search_async(ngc188_center, radius=0.5*u.deg)\n",
+        "ngc188_table = job.get_results()\n",
+        "\n",
+        "# only keep stars brighter than G=19 magnitude\n",
+        "ngc188_table = ngc188_table[ngc188_table['phot_g_mean_mag'] < 19*u.mag]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "eFt4Rnxl5bLV"
+      },
+      "outputs": [],
+      "source": [
+        "cols = [\n",
+        "    'source_id',\n",
+        "    'ra',\n",
+        "    'dec',\n",
+        "    'parallax',\n",
+        "    'parallax_error',\n",
+        "    'pmra',\n",
+        "    'pmdec',\n",
+        "    'radial_velocity',\n",
+        "    'phot_g_mean_mag',\n",
+        "    'phot_bp_mean_mag',\n",
+        "    'phot_rp_mean_mag'\n",
+        "]\n",
+        "ngc188_table[cols].write('gaia_results.fits', overwrite=True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "63eEPUnx5bLW"
+      },
+      "source": [
+        "A célula acima pode não funcionar se você não tiver conexão com a internet, por isso incluímos a tabela de resultados junto com o notebook:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "UjbemZDq5bLW"
+      },
+      "outputs": [],
+      "source": [
+        "ngc188_table = QTable.read('gaia_results.fits')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Q6uLv6Zn5bLW"
+      },
+      "outputs": [],
+      "source": [
+        "len(ngc188_table)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "f21Dh79x5bLW"
+      },
+      "source": [
+        "O objeto `astropy.table` `Table` retornado agora contém cerca de 5000 estrelas de *Gaia* DR2 em torno da posição coordenada do centro de NGC 188. Vamos agora construir um objeto `SkyCoord` com a tabela de resultados. No arquivo de dados *Gaia*, as coordenadas ICRS de uma fonte são fornecidas como nomes de coluna `\"ra\"` e `\"dec\"`:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "3blS-wFw5bLX"
+      },
+      "outputs": [],
+      "source": [
+        "ngc188_table['ra']"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "3-6DARVF5bLX"
+      },
+      "outputs": [],
+      "source": [
+        "ngc188_table['dec']"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "1Jke_cmN5bLY"
+      },
+      "source": [
+        "Observe que, como o arquivo *Gaia* fornece tabelas de dados com unidades associadas, e lemos essa tabela usando o objeto `QTable` ([docs](http://docs.astropy.org/en/latest/table/mixin_columns. html#quantity-and-qtable)), as colunas da tabela acima são representadas como objetos `Quantity` com unidades de graus. Observe também que essas colunas contêm muitos valores de coordenadas (>5000!). Podemos passá-los diretamente para `SkyCoord` para obter um único objeto `SkyCoord` para representar todas essas coordenadas:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "fGRVaGnt5bLY"
+      },
+      "outputs": [],
+      "source": [
+        "ngc188_gaia_coords = SkyCoord(ngc188_table['ra'], ngc188_table['dec'])\n",
+        "ngc188_gaia_coords"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "MoTkzYMY5bLZ"
+      },
+      "source": [
+        "### Exercícios"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "CBf42Yzo5bLZ"
+      },
+      "source": [
+        "Crie um 'SkyCoord' para o centro do aglomerado aberto das Plêiades (olhando as coordenadas e passando-as, ou usando o método de conveniência que aprendemos acima):"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "szBO-xef5bLa"
+      },
+      "outputs": [],
+      "source": [
+        "ngc188_center = SkyCoord.from_name('NGC 188')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "8DT0XNdn5bLa"
+      },
+      "source": [
+        "Usando apenas uma única chamada de método/função no objeto `SkyCoord` representando o centro de NGC 188, imprima uma string com o RA/Dec no formato 'HH:MM:SS.S DD:MM:SS.S'. Verifique sua resposta no [SIMBAD](http://simbad.u-strasbg.fr/simbad/), que mostrará as coordenadas sexagesimais do objeto.\n",
+        "\n",
+        "<sub>(Dica: `SkyCoord.to_string()` pode ser útil)</sub>"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "8TH71w515bLa"
+      },
+      "outputs": [],
+      "source": [
+        "ngc188_center.to_string(style=\"hmsdms\", sep=\":\", precision=1)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "MXK1r-uE5bLb"
+      },
+      "source": [
+        "Usando uma única chamada de método/função no objeto `SkyCoord` contendo os resultados de nossa consulta *Gaia*, calcule a separação angular entre cada estrela resultante e as coordenadas do centro do cluster para NGC 188.\n",
+        "\n",
+        "<sub>(Dica: `SkyCoord.separation()` pode ser útil)</sub>"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "_t2VOSLq5bLb"
+      },
+      "outputs": [],
+      "source": [
+        "ngc188_gaia_coords.separation(ngc188_center)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "8QM-knFj5bLb"
+      },
+      "source": [
+        "## Mais do que apenas posições no céu: incluindo informações de distância no `SkyCoord` `Código in-line`\n",
+        "\n",
+        "Até agora, usamos `SkyCoord` para representar posições angulares do céu (ou seja, `ra` e `dec` apenas). Às vezes é útil incluir informações de distância com as coordenadas do céu de uma fonte, especificando assim a posição 3D completa de um objeto. Para passar informações de distância, `SkyCoord` aceita o argumento de palavra-chave \"`distance`\". Então, se soubéssemos que a distância para NGC 188 é 1,96 kpc, também poderíamos passar uma distância (como um objeto `Quantity`) usando este argumento:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "9ndk90cf5bLb"
+      },
+      "outputs": [],
+      "source": [
+        "ngc188_center_3d = SkyCoord(12.11*u.deg, 85.26*u.deg,\n",
+        "                            distance=1.96*u.kpc)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "d1BTyUz15bLc"
+      },
+      "source": [
+        "Com a tabela de dados de *Gaia* que recuperamos acima para estrelas ao redor de NGC 188, `ngc188_table`, também temos medições de paralaxe para cada estrela. Para uma paralaxe $\\varpi$ medida com precisão, a distância $d$ até uma estrela pode ser obtida aproximadamente como $d \\approx 1/\\varpi$. Isso só funciona se o erro de paralaxe for pequeno em relação à paralaxe ([veja a discussão neste artigo](https://arxiv.org/abs/1507.02105)), então, se quisermos usar essas paralaxes para obter distâncias, primeiro tem que filtrar as estrelas que têm baixa paralaxe sinal-ruído:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "T5aXc5W95bLc"
+      },
+      "outputs": [],
+      "source": [
+        "parallax_snr = ngc188_table['parallax'] / ngc188_table['parallax_error']\n",
+        "ngc188_table_3d = ngc188_table[parallax_snr > 10] \n",
+        "len(ngc188_table_3d)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "7vPWuTDy5bLc"
+      },
+      "source": [
+        "A seleção acima em `parallax_snr` mantém estrelas que têm uma medida de paralaxe de ~10 sigma, mas este é um limite de seleção arbitrário que você pode querer ajustar ou remover em seus próprios casos de uso. Essa seleção removeu mais da metade das estrelas em nossa tabela original, mas para as estrelas restantes podemos ter certeza de que converter as medidas de paralaxe em distâncias é mais seguro.\n",
+        "\n",
+        "A maneira padrão de passar uma distância para um objeto `SkyCoord`, como acima, é passar uma `Quantidade` com uma unidade de comprimento. No entanto, `astropy.coordinates` também fornece um objeto especializado, `Distance`, para lidar com transformações comuns de diferentes representações de distância ([docs](http://docs.astropy.org/en/latest/coordinates/index.html# distância)). Entre outras coisas, esta classe suporta passar um valor de paralaxe:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "2JiVM5DV5bLc"
+      },
+      "outputs": [],
+      "source": [
+        "Distance(parallax=1*u.mas)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "177nvhO45bLd"
+      },
+      "source": [
+        "O catálogo de estrelas que consultamos em *Gaia* contém informações de paralaxe em unidades de milissegundos, para que possamos criar um objeto `Distance` diretamente desses valores:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "xvxT4NX05bLd"
+      },
+      "outputs": [],
+      "source": [
+        "gaia_dist = Distance(parallax=ngc188_table_3d['parallax'].filled(np.nan))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "EBWgwXsV5bLd"
+      },
+      "source": [
+        "Podemos então criar um objeto `SkyCoord` para representar as posições 3D de todas as estrelas *Gaia* passando este objeto de distância para o inicializador `SkyCoord`:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "dgyi2rE55bLd"
+      },
+      "outputs": [],
+      "source": [
+        "ngc188_coords_3d = SkyCoord(ra=ngc188_table_3d['ra'], \n",
+        "                            dec=ngc188_table_3d['dec'],\n",
+        "                            distance=gaia_dist)\n",
+        "ngc188_coords_3d"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "pgDi2-jH5bLe"
+      },
+      "source": [
+        "Vamos agora usar `matplotlib` para traçar as posições do céu de todas essas fontes, coloridas pela distância para enfatizar as estrelas do aglomerado:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "_SwOedzw5bLe"
+      },
+      "outputs": [],
+      "source": [
+        "fig, ax = plt.subplots(figsize=(6.5, 5.2),\n",
+        "                       constrained_layout=True)\n",
+        "cs = ax.scatter(ngc188_coords_3d.ra.degree, \n",
+        "                ngc188_coords_3d.dec.degree, \n",
+        "                c=ngc188_coords_3d.distance.kpc, \n",
+        "                s=5, vmin=1.5, vmax=2.5, cmap='twilight')\n",
+        "cb = fig.colorbar(cs)\n",
+        "cb.set_label(f'distance [{u.kpc:latex_inline}]')\n",
+        "\n",
+        "ax.set_xlabel('RA [deg]')\n",
+        "ax.set_ylabel('Dec [deg]')\n",
+        "\n",
+        "ax.set_title('Gaia DR2 sources near NGC 188', fontsize=18)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "tJ6W9yO05bLf"
+      },
+      "source": [
+        "Agora que temos informações de posição 3D para o centro do cluster e para as estrelas que consultamos em *Gaia*, podemos calcular a separação 3D (distância) entre todas as fontes de *Gaia* e o centro do cluster:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "p6MabBcq5bLf"
+      },
+      "outputs": [],
+      "source": [
+        "sep3d = ngc188_coords_3d.separation_3d(ngc188_center_3d)\n",
+        "sep3d"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "tnGP2IBG5bLf"
+      },
+      "source": [
+        "### Exercícios\n",
+        "\n",
+        "Usando os valores de separação 3D, defina uma máscara booleana para selecionar os membros candidatos do cluster. Selecione todas as estrelas dentro de 50 pc do centro do cluster. Quantos membros candidatos da NGC 188 temos, com base em suas posições 3D?"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "bBKjAXMy5bLf"
+      },
+      "outputs": [],
+      "source": [
+        "ngc188_3d_mask = sep3d < 50*u.pc\n",
+        "ngc188_3d_mask.sum()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "CAySlDcW5bLg"
+      },
+      "source": [
+        "Neste tutorial, introduzimos `astropy.coordinates` como uma forma de armazenar e representar as coordenadas astronômicas do céu. Usamos objetos de coordenadas, por meio da interface de classe `SkyCoord`, para analisar e alterar as representações e unidades de coordenadas. Também demonstramos como usar um objeto `SkyCoord` com o pacote `astroquery` para consultar um banco de dados astronômico, o arquivo científico *Gaia*. Em seguida, criamos um único objeto `SkyCoord` com os dados consultados que representam as coordenadas do céu de muitos objetos. Finalmente, introduzimos o conceito de usar `astropy.coordinates` para representar uma posição 3D de um objeto ou conjunto de objetos."
+      ]
+    }
+  ],
+  "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.8.3"
+    },
+    "toc": {
+      "base_numbering": 1,
+      "nav_menu": {},
+      "number_sections": true,
+      "sideBar": true,
+      "skip_h1_title": false,
+      "title_cell": "Table of Contents",
+      "title_sidebar": "Contents",
+      "toc_cell": false,
+      "toc_position": {},
+      "toc_section_display": true,
+      "toc_window_display": false
+    },
+    "colab": {
+      "name": "1-Coordinates-Intro.ipynb",
+      "provenance": [],
+      "include_colab_link": true
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file