Keplers_3rd_Law_Activity.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "anaconda-cloud": {},
    "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.7.4"
    },
    "colab": {
      "name": "Keplers 3rd Law Activity.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/jimmynewland/colabnotebooks/blob/main/Keplers_3rd_Law_Activity.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3JDakeShaAQH"
      },
      "source": [
        "# Kepler's 3rd Law Activity\n",
        "This coding activity let's us explore some data gathered by the [Kepler spacecraft](https://archive.stsci.edu/missions-and-data/kepler) of a single set of planets orbiting a star a lot like the sun.\n",
        "\n",
        "<img src=\"https://jimmynewland.com/astronomy/kepler-11b.png\" width=650 />\n",
        "\n",
        "The Kepler Spacecraft has help uncovered many exoplanets. When a planet passes in front of the host star, the Kepler photometer and camera measure the tiny drop in light. We are going to explore one of these planetary systems.  With the data about an exoplanetary system, you must determine the approximate mass of the central star of the system. The units given are in terms of astronomical units and days. You should report the mass of the star in solar mass units. In other words what factor of the sun's mass is this star?\n",
        "\n",
        "<img src=\"https://jimmynewland.com/astronomy/kepler-11-system.png\" width=650 />\n",
        "\n",
        "\n",
        "The planetary data (period, T, in days and average distance from the star, a, in AU) is given in the table linked below. The period, T, is given in Earth days (not Earth years!) and the semi-major axis, a, is given in astronomical units. Using Kepler’s 3rd law of planetary motion, linearize the data with appropriate units to determine the mass of the central star of the given system as a ratio of solar mass. \n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mzRt4wYUXmnr"
      },
      "source": [
        "## Question 1\n",
        "**Put your name and period and include anyone working with you as well.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lwYsOqYNXwTX"
      },
      "source": [
        "Double click here to answer: "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kq_1DmVTb8ft"
      },
      "source": [
        "**Don't forget to run each block as you scroll!**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6No7X6TC9KNo"
      },
      "source": [
        "# Import modules that contain functions we need\n",
        "import pandas as pd # pandas is common for data science\n",
        "import numpy as np #N umPy is used a lot in science\n",
        "import math # we need the math class for pi\n",
        "%matplotlib inline \n",
        "import matplotlib.pyplot as plt # MatPlotLib is the plotting standard\n",
        "import seaborn as sns # makes regression plot easy\n",
        "from scipy import stats # lets us do a linear regression"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z72DEuJGVg7F"
      },
      "source": [
        "## Constants\n",
        "The distance from the Earth to the Sun is known as an astromical unit but we will need to convert those distances to meters. The constant, G, is the universal gravitational constant. We will also need the mass of the sun in kilograms to round out our dependence on SI units.\n",
        "$$\n",
        "d_{au}=1.5\\times10^{11} \\mathrm{m} \\\\\n",
        "G=6.67\\times10^{-11} \\mathrm{Nm^2/kg^2} \\\\\n",
        "M_{sun}=1.989\\times10^{30} \\mathrm{kg}\n",
        "$$\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xUfovvQpLYJN"
      },
      "source": [
        "# Type the constants here.\n",
        "# Example: 3*10^8 in Python would be 3e8\n",
        "d_au =\n",
        "G = \n",
        "m_sun = "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cwT7EtBIX6P8"
      },
      "source": [
        "# Kepler Exoplanet Data\n",
        "This dataset is based on the discovery of an exolplanet system by the Kepler Spacecraft, named after Johannes Kepler, who, in the seventeenth century, determined the planetary motion relationships using data collected by Tycho."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q3lG6Kle9KNp"
      },
      "source": [
        "# Read in data that will be used for the calculations.\n",
        "data1 = pd.read_csv(\"https://jimmynewland.com/astronomy/kepler-planetary-data.csv\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qtILmt8NZVbV"
      },
      "source": [
        "# Column Headings\n",
        "We need to use the <code>head()</code> command to take a peek at the data but also to know the names of the column headings so we access the data. When we load a datafile using <code>pandas</code>, the data is stored in a thing called a <code>DataFrame</code>. Here <code>data1</code> is a <code>DataFrame</code>."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QquuPgqt9KNp"
      },
      "source": [
        "# We wish to look at the first 5 rows of our data set\n",
        "data1.head(5)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i0clFzF7H2xs"
      },
      "source": [
        "A <code>DataFrame</code> is kind of like a spreadsheet. There are rows and columns of data so it is a 2d data structure."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S4gayXWq9KNp"
      },
      "source": [
        "# The .shape command displays the (number of rows , number of columns) in a file.\n",
        "data1.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RfzuC0f29KNp"
      },
      "source": [
        "## Question 2\n",
        "Let's get acquainted with this data set. Look at the cells above to find the answers to the following questions:\n",
        "- In the table above, what do you think each of the column headings represent?\n",
        "- How many planets are included in this data set?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fSIdlLg1YQMt"
      },
      "source": [
        "Double click here to answer:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OnGodmN8Y8Ax"
      },
      "source": [
        "\n",
        "These lines store all the distances in AU in a list called <code>r_au</code> and all the periods in a list called <code>t_days</code>. Don't forget to run this block like the other blocks before this."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1_gTK9FxK_WN"
      },
      "source": [
        "r_au = np.array(data1['Semi Major Axis (AU)'])\n",
        "t_days = np.array(data1['Orbital Period (days)'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "htdjMoxZaxOV"
      },
      "source": [
        "This is a very stripped down plot using <code>MatPlotLib</code>. You need to fix the title and the labels on the x- and y-axes."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h-L2gXo79KNp"
      },
      "source": [
        "# plt is our plot object which handles plotting data\n",
        "# For physics and astronomy, you probably want a scatter plot\n",
        "\n",
        "# plt.scatter uses the 1st thing for the horizontal axis\n",
        "# and the 2nd thing for the vertical axis so (x,y)\n",
        "plt.scatter(r_au, t_days)\n",
        "plt.title(\"title?\")\n",
        "plt.xlabel(\"Label me!\")\n",
        "plt.ylabel(\"Me, too!\");"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U7LaBcMw5v0K"
      },
      "source": [
        "# Convert Distances and Times\n",
        "Convert the orbital radii from AU to meters using the constant above. Also convert the times from days into seconds. This is straightforward dimensional analysis."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "piMmulxkL1K4"
      },
      "source": [
        "# Convert AU to m using one of the constants above\n",
        "r_m = \n",
        "\n",
        "# How many seconds are in a day?\n",
        "t_s = "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sVC5h1la5vfM"
      },
      "source": [
        "# Linearize the Data\n",
        "Using Kepler's 3rd law, linearize your data. Kepler's 3rd law:\n",
        "$$ t^2=\\frac{4\\pi^2}{GM}r^3 $$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y3FV1CsFbUmB"
      },
      "source": [
        "Store the linearized distances in the list called <code>x</code> and the linearized times in the list called <code>y</code>. \n",
        "\n",
        "**This part is important! The data won't be linear if you don't apply the correct mathematical process to your various lists of data.**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0kuccApsNVMC"
      },
      "source": [
        "# Hint: In Python, exponents work like this\n",
        "# a^2 (a squared) would be a**2\n",
        "x = \n",
        "y = "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vMunIR5XNkQx"
      },
      "source": [
        "plt.scatter(x,y)\n",
        "plt.title(\"title?\")\n",
        "plt.xlabel(\"Label me!\")\n",
        "plt.ylabel(\"Me, too!\");"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "stW4WSuYcSTe"
      },
      "source": [
        "# Linear Regression\n",
        "This line of code uses our data in the lists x and y to find the various parameters for a linear regression. We ultimately only will need the slope here. Remember, a linear regression is asking how close to linear is the mathematical relationship between our x and y variables.\n",
        "\n",
        "For someone new to this python notation, the command (or method or function) called <code>linregress(...)</code> takes as one input our list of linearized distances as the list <code>x</code> and takes as the other input our list of linearized times as the list <code>y</code>. But it is all the stuff on the left of the <code>=</code> that's likely weird to you. The linregress command returns 5 things by default: the slope of our linear fit, the intercept of our linear fit, and some statistics about the quality of the fit. The *r*, *p*, and *standard error* values help us decide of the fit is trustworthy in a statical sense. We will ignore them here."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gv4eOvWVPVZf"
      },
      "source": [
        "# get coefficients of our linear fit\n",
        "slope, intercept, r_value, p_value, std_err = stats.linregress(x,y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vhipzmtHcfH3"
      },
      "source": [
        "# Make a New DataFrame\n",
        "By putting the linearized data in a new DataFrame, we can easily plot a linear regression using Seaborn. This is a common data science technique. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yQGwuHaozWUs"
      },
      "source": [
        "# Make a new DataFrame and take a look at it.\n",
        "data2 = pd.DataFrame({'r^3':x, 't^2':y})\n",
        "\n",
        "# Most of time, in python, a variable by itself\n",
        "# like this just prints the contents of the variable.\n",
        "data2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I88m3YWXJuiO"
      },
      "source": [
        "If you've done the rest of this process correctly, here you need to recognize which parts of Kepler's 3rd Law is the *slope* of our linear relationship. The slope of a line should a constant so which parts are constant here?\n",
        "$$ t^2=\\frac{4\\pi^2}{GM}r^3 $$\n",
        "\n",
        "Using the <code>slope</code> from the regression above, if you set the slope equal to the constants from Kepler's 3rd Law, rearrange algebraically (on paper likely) the expression such that you can find the mass of the star in the center of this exoplanet solar system.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A3SfsnYJwlJl"
      },
      "source": [
        "# Use the algebraically rearranged slope expression\n",
        "# to find the mass of the star in this system.\n",
        "m_star = \n",
        "\n",
        "# Find the ratio of this star's mass to that of the sun, given above.\n",
        "ratio = \n",
        "\n",
        "# Display the ratio.\n",
        "ratio"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qUAGvQ7XLV6p"
      },
      "source": [
        "# Plot Linear Regression\n",
        "This last step uses the Seaborn library to plot linear regression and to overplot the data points. This is a very common visualization technique and allows for a visual confirmation of the relationship. Seaborn is not the only way to plot a linear regression but it is very popular and quite visually appealing."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TS8L4GbdwvdV"
      },
      "source": [
        "plt.scatter(x,y)\n",
        "sns.regplot(x=\"r^3\", y=\"t^2\", data=data2)"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}