Trip_To_Mars_Solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE:** This is the solutions document. All code has been filled in, all lines that were meant to be uncommented have been uncommented, and you can run every cell as is. Rememeber to still run every cell in order!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " # Section 1: Beginning Tasks - Diagnostics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Welcome to mission control! We're going to start off by performing a few diagnostic tasks to make sure all of our systems are functioning, and along the way we will be learning the basics of coding."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Much like spoken languages, different programming languages have different syntax and sematics. Syntax refers to the set of rules, principles, and processes that govern the structure of a given language. Semantics refers to the meaning of a word, phrase, sentence, or text.\n",
    "\n",
    "An interface is any device or program that allows a user to communicate with a computer. The interface we are working in right now, Jupyter notebooks, is based on a programming language called Python. In a Jupyter notebook, code is written within cells, which can be executed separately. As per the setup instructions, you should have already activated line numbers, which show up on the left hand side of the cell below; these are handy and allow for easy reference to parts of your code. We will proceed cell by cell.\n",
    "\n",
    "Run the cell below by clicking within the cell (you will see a box show up around the cell), and then pressing the run button located on the toolbar at the top. Note that when you run a cell, the program is going through each line of code and executing the lines in order. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## *** CELL 1.1 *** ##\n",
    "\n",
    "import numpy as np\n",
    "import astropy as ap\n",
    "import math\n",
    "from matplotlib import pyplot as plt\n",
    "import HelperFunctions as h"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you ran the cell above, it might have seemed as though nothing happened. That is because the code within that cell is working behind the scenes importing external content that will allow you to do cool stuff later on! You don't need to know the specifics of that right now, so let's move on to some coding basics.\n",
    "\n",
    "Read through the cell below and then run it. This time, you will see an output below the cell. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## *** CELL 1.2 *** ##\n",
    "\n",
    "# You'll notice this text is a different color. This is a comment. Comments are started with the # sign.\n",
    "# Comments do not execute within your code, and have no output. \n",
    "# Comments are used to make notes throughout your code.\n",
    "# You can also comment out lines of code that you don't want to run by adding the # symbol at the start of the line.\n",
    "\n",
    "# The print() function (shown below on line 11) prints the input to the screen. \n",
    "# Below our input is the sentence \"Hello world!\"\n",
    "\n",
    "print(\"Hello world!\")\n",
    "\n",
    "# You'll notice that \"Hello world!\" is highlighted red above. \n",
    "# This is because the double quotes describe a string. \n",
    "\n",
    "# Strings are a data type that represent characters.\n",
    "# Examples of strings include \"Let's go to mars!\", \"abcde\", and \"12345\". Just remember the double quotes.\n",
    "\n",
    "# After you run this cell, uncomment the line below by deleting the # at the start of line 20, then run it again. \n",
    "print(\"Coding is fun!\")\n",
    "\n",
    "# Feel free to change the string content in line 11 or line 20!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we are going to introduce the concept of a variable. Variables are a very important part of coding. A variable is a storage location that is represented by a symbolic name.\n",
    "\n",
    "The variable name needs to start with a letter, can only contain alpha-numeric characters, and is case sensitive. Variable names can be 1 letter long, or whole words! Underscores are also useful for ease of reading the variable name. Read through the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## *** CELL 1.3  *** ##\n",
    "## *** INITIALIZATION *** ## \n",
    "############################\n",
    "\n",
    "# Variables often contain numeric values (integers - another data type!).\n",
    "# You assign values to variables using the equals sign. For example...\n",
    "\n",
    "x = 2\n",
    "y = 6\n",
    "\n",
    "# We can add our two variables together using the plus sign. \n",
    "our_sum = x + y\n",
    "\n",
    "# You can also divide with the / symbol, and multiply using the * symbol, as shown below:\n",
    "our_quotient = y/x\n",
    "our_product = x*y\n",
    "\n",
    "# If you would like to use an exponent, you would use '**' to represent the exponent, as shown below:\n",
    "our_exponent = y**x \n",
    "\n",
    "# Subtraction is done using the minus sign. \n",
    "# Can you complete the line of code (line 25) that calculates the difference between our two variables?\n",
    "# Once you have replaced the <<INSERT CODE HERE>> section with your code, run the cell.\n",
    "\n",
    "our_difference = y - x\n",
    "\n",
    "# If you run this cell as is, you will print the sum of the two variables we defined.\n",
    "# You can change the variable being printed by editing line 30 (change the variable input), and running the cell again. \n",
    "\n",
    "print(our_sum) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alright, it seems our system is initialized. Next up is checking the temperature of the systems board."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## *** CELL 1.4  *** ##\n",
    "## *** TEMPERATURE OF SYSTEMS BOARD *** ## \n",
    "##########################################\n",
    "\n",
    "# Here we are defining two variables that represent our systems board temperature, and the target temperature.\n",
    "Temp_SystemsBoard = 40   # degrees Celsius\n",
    "Temp_Target = 40         # degrees Celsius\n",
    "\n",
    "# Let's compare the temperature of our systems board (Temp_SystemsBoard) to our target temperature (Temp_Target).\n",
    "# Lines 15-31 are an if/else conditional statement, which is a very important concept in coding.\n",
    "# We use if/else statements when we want to execute code only if a certain condition is satisfied.\n",
    "\n",
    "# The 'if' command starts our if/else statement. We have to define a condition.\n",
    "# The next line will check if the value of the variable Temp_SystemsBoard is greater than the value of Temp_Target.\n",
    "if Temp_SystemsBoard > Temp_Target:\n",
    "    \n",
    "    # If the above statement is true, the following line of code will execute. If it's not true, nothing will happen,\n",
    "    # and we will move on to our next line of code, line 23.\n",
    "    print(\"The systems board is too hot.\")\n",
    "\n",
    "    # The command \"elif\" is short form for else if. For this command we have to define another condition. \n",
    "    # The next line will check if the value of Temp_SystemsBoard is less than Temp_Target.\n",
    "elif Temp_SystemsBoard < Temp_Target:\n",
    "    \n",
    "    # If this is true, the following line of code will execute. Otherwise, we will move on to our next line of code.\n",
    "    print(\"The systems board is too cold.\")\n",
    "\n",
    "    # Finally, if the two previous conditions did not execute, meaning that Temp_SystemsBoard is neither greater,\n",
    "    # nor less than Temp_Target, the following code will execute. For the else command, no condition is defined.\n",
    "else:\n",
    "    print(\"Systems board is ready to go!\")\n",
    "    \n",
    "# Try changing the value of Temp_SystemsBoard (line 6) and see how that affects the output of this cell when you run it.\n",
    "# What happens when the two temperatures have equal values?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Did you get a message that the systems board is ready to go? If yes, great! So far you have learned what a string is, how to define variables, and how to print strings and variables to your screen! You have even gone through an if/else statement. \n",
    "\n",
    "We'll continue checking our systems are working properly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## *** CELL 1.5  *** ##\n",
    "## *** SPEED OF SPACECRAFT *** ## \n",
    "#################################\n",
    "\n",
    "# We want to calculate the required speed of our spacecraft for a given distance and time.\n",
    "# Assign values to the two variables below on line 9 and 12. \n",
    "\n",
    "# How far are we travelling? \n",
    "Distance_Travelled = 450000 # kilometres\n",
    "\n",
    "# How long do you want it to take?\n",
    "Time_Elapsed = 32 # hours\n",
    "\n",
    "# Now we calculate our speed. \n",
    "Speed_Spacecraft = Distance_Travelled/Time_Elapsed # kilometres/hour\n",
    "\n",
    "# Let's convert our speed to metres/seconds, and round the final value to the nearest integer.\n",
    "Speed_Spacecraft = round(Speed_Spacecraft*1000/(60*60))\n",
    "\n",
    "# We would like to print our variables to make sure the entire mission crew is aware of the distance, time and speed. \n",
    "# Recall the print function, and while we're at it, let's make it a full sentence! \n",
    "\n",
    "# First we need to convert our numeric values to strings. \n",
    "Distance_Travelled = str(Distance_Travelled)\n",
    "Time_Elapsed = str(Time_Elapsed)\n",
    "Speed_Spacecraft = str(Speed_Spacecraft)\n",
    "\n",
    "print(\"We are travelling \" + Distance_Travelled + \" km, and it should take \" + Time_Elapsed + \" hours\")\n",
    "\n",
    "# What we have done in line 28 is concatenate (link together multiple strings).\n",
    "# The plus sign is used for concatenation.\n",
    "# Some of these strings we wrote outright in line 28, while other strings we stored in our variables. \n",
    "\n",
    "# You can only concatenate the same data type,\n",
    "# which is why we converted our three numeric variables to strings in lines 24-26.\n",
    "\n",
    "# Can you write a line of code below that prints 'The speed of the spacecraft needs to be __ m/s.' to the screen?\n",
    "# Hint 1: Remember to use double quotes to define a string. \n",
    "# Hint 2: Our Speed_Spacecraft variable has already been converted to a string.\n",
    "\n",
    "print(\"The speed of the spacecraft needs to be \" + Speed_Spacecraft + \" m/s\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You have completed the diagnostics! If you find you have finished this section early, you can take a peek at the advanced part of Section 1 below. Otherwise we will be moving on to Section 2 as a group. After the workshop feel free to look through the advanced sections on your own! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ADVANCED: the following five cells introduce several advanced topics that are not explicitly needed for this workshop, but are very important for coding!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## *** Pilot Check *** ##\n",
    "#########################\n",
    "\n",
    "# We will now be checking our list of pilots. \n",
    "# To do this, we will be introducing 'for' loops. These can be incredibly powerful but also dangerous! \n",
    "\n",
    "# The following code shows how we can use 'for' loops:\n",
    "for i in range(5):\n",
    "    num = str(i)\n",
    "    print(\"i = \" + num)\n",
    "\n",
    "# Run this cell and see what is output:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# As we can see, the 'print' was called 5 times, but each time the 'i' value changed. \n",
    "# This allows us to do repeated computations with changing values! \n",
    "\n",
    "# Next, let's look at arrays and lists. A list is exactly what it sounds like, a list of values! \n",
    "Pilots = [\"Akanksha\", \"Sonja\", \"Yilda\", \"Olivera\", \"Simran\", \"Jasmine\"]\n",
    "\n",
    "# We see there are currently 6 pilots, so we define a variable for this number\n",
    "pilot_num = 6\n",
    "\n",
    "# We can look into this list entry by entry. Let's look at the first entry:\n",
    "print(Pilots[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Wait, why do we see Sonja but not Akanksha? As you may have noticed when we introduced the 'for' loop,\n",
    "# referencing in Python starts at 0. So, the first entry is actually the zeroth entry! Weird, but let's test it:\n",
    "print(Pilots[0])\n",
    "\n",
    "# Run the cell! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Okay, now that we know how that works, let's check in on the pilots:\n",
    "for i in range(pilot_num):\n",
    "    print(Pilots[i] + \" is ready to train for launch!\")\n",
    "    \n",
    "# Run the cell and see what they think!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try adding yourself to the Pilots list and modify the for loop accordingly:\n",
    "\n",
    "# Pilot info\n",
    "pilot_num = 7\n",
    "Pilots = [\"Akanksha\", \"Sonja\", \"Yilda\", \"Olivera\", \"Simran\", \"Jasmine\", \"One More\"]\n",
    "\n",
    "for i in range(pilot_num):\n",
    "    print(Pilots[i] + \" is ready to train for launch!\")\n",
    "    \n",
    "# Hint: Remember that adding yourself to the list increases the number of pilots! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Section 2: Preparation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How does the Earth orbit the Sun?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Johannes Kepler discovered that the planets orbit the Sun in ellipses! (with the Sun at the \"focus\" of the ellipse). This is known as Kepler's first law.\n",
    "\n",
    "Ellipses are like squashed circles -> the amount they are \"squashed\" is given by their eccentricity, $e$. (Where $e$ is a number between 0 and 1). The eccentricity of the Earth's orbit is $e=0.0167$. \n",
    "\n",
    "The Earth's distance from the sun is 1AU (Astronominal units - these are the units we use to measure distance in our solar system).\n",
    "\n",
    "*Note we have ignored 'inclination' (the slant of the orbit relative to the horizontal) of the orbits for simplicity.\n",
    "\n",
    "Now we will plot Earth's orbit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## *** CELL 2.1  *** ##\n",
    "#1) First Run the cell to see Earth's orbit!\n",
    "\n",
    "# This parameter is intialitizing the plot axis limits (see 'HelperFunctions.py' file to see how it's used)\n",
    "max_major=0 \n",
    "# Here we are calling to the python plotting library 'matplotlib' to intialize an empty figure of size 8x8\n",
    "fig, ax = plt.subplots(figsize=[8,8])\n",
    "\n",
    "# Now we will call on helper code from our HelperFunctions, 'h' library.\n",
    "\n",
    "# 2) Try playing around with the 'e' parameter. REMEMBER: e has to be a number between 0 and 1\n",
    "# For example: you can try e=0.2, 0.4, 0.6, 0.8, 0.999, 1\n",
    "h.plot_orbit(major=1, e=0.0167, color='cyan', ax=ax, max_major=max_major) \n",
    "# What value of e gives a perfect circle? What about a line?\n",
    "\n",
    "# 3) Try playing around with the 'major' parameter\n",
    "# 4) Uncomment the line below. For example: you can try major=0, 0.5, 1, 5, 10 \n",
    "h.plot_orbit(major=1, e=0, color='indigo', ax=ax, max_major=max_major) \n",
    "# What does the parameter 'major' control? (Hint: make sure to look at the axis values when you change major)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "True or False:\n",
    "\n",
    "1) The Earth's orbit is almost a circle\n",
    "\n",
    "2) During summer, the Earth is 3 AU away from the sun\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What about the other planets?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The distance and eccentricity for all planets are shown below:\n",
    "\n",
    "We have also included the time it takes each planet to orbit the sun (orbital period) in days. This will be useful in later sections. \n",
    "\n",
    "| **Planet**  | **Distance (AU)** | **Eccentricity ($e$)** | **Orbital Period (days)** |\n",
    "|---------|---------------|--------------|--------------|\n",
    "| Mercury | 0.387         | 0.2056       | 88           |\n",
    "| Venus   | 0.723         | 0.0068       | 225          |\n",
    "| Earth   | 1.000         | 0.0167       | 365.24       |\n",
    "| Mars    | 1.524         | 0.0934       | 686.68       |\n",
    "| Jupiter | 5.203         | 0.0484       | 4380 (12 years)      |\n",
    "| Saturn  | 9.537         | 0.0542       | 10585 (29 years)       |\n",
    "| Uranus  | 19.191        | 0.0472       | 30660 (84 years)     |\n",
    "| Neptune | 30.069        | 0.0086       | 60225 (165 years)      |\n",
    "\n",
    "*NOTE - The further away the planet, the longer its period. This is known as Kepler's Third Law!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## *** CELL 2.2  *** ##\n",
    "# Now we will succesively plot all the planet's orbits in order. \n",
    "# This is done to scale so you can see how far Mercury and Neptune are!\n",
    "\n",
    "# We want a new figure so we have to re-intialize our plotting parameters as before\n",
    "max_major=0\n",
    "fig, ax = plt.subplots(figsize=[8,8])\n",
    "\n",
    "# Plot Mercury: Example given\n",
    "h.plot_orbit(major=0.387, e=0.2056, color='lightpink', ax=ax, max_major=max_major, label='Mercury') \n",
    "# 1) Run the cell to see Mercury's orbit!\n",
    "\n",
    "# 2) Plot Venus: Uncomment line below fill in the major and e values using table above\n",
    "h.plot_orbit(major=0.723, e=0.0068, color='indigo', ax=ax, max_major=max_major, label='Venus')\n",
    "# 3) Run the cell to add Venus's orbit. How does it compare to Mercury's?\n",
    "\n",
    "# 4) Plot Earth: Uncomment line below fill in the major and e values using table above\n",
    "h.plot_orbit(major=1, e=0.0167, color='cyan', ax=ax, max_major=max_major, label='Earth') \n",
    "# 5) Run the cell to add Earth's orbit. How does it compare to others?\n",
    "\n",
    "# 6) Plot Mars: Uncomment line below fill in the major and e values using table above\n",
    "h.plot_orbit(major=1.524, e=0.0934, color='red', ax=ax, max_major=max_major, label='Mars') \n",
    "# 7) Run the cell to add Mars' orbit. How does it compare to others?\n",
    "\n",
    "# 8) Plot Jupiter: Uncomment line below fill in the major and e values using table above\n",
    "h.plot_orbit(major=5.203, e=0.0484, color='tan', ax=ax, max_major=max_major, label='Jupiter') \n",
    "# 9) Run the cell to add Jupiter's orbit. How does it compare to others?\n",
    "\n",
    "# 10) Plot Saturn: Uncomment line below fill in the major and e values using table above\n",
    "h.plot_orbit(major=9.537, e=0.0542, color='fuchsia', ax=ax, max_major=max_major, label='Saturn')\n",
    "# 11) Run the cell to add Saturn's orbit. How does it compare to others?\n",
    "\n",
    "# 12) Plot Uranus: Uncomment line below fill in the major and e values using table above\n",
    "h.plot_orbit(major=19.191, e=0.0472, color='orange', ax=ax, max_major=max_major, label='Uranus') \n",
    "# 13) Run the cell to add Uranus' orbit. How does it compare to others?\n",
    "\n",
    "# 14) Plot Neptune: Uncomment line below fill in the major and e values using table above\n",
    "h.plot_orbit(major=30.069, e=0.0086, color='gray', ax=ax, max_major=max_major, label='Neptune') \n",
    "# 15) Run the cell to add Neptune's orbit. How does it compare to others?\n",
    "\n",
    "#adding the plot legend\n",
    "plt.legend(loc='upper right')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's move on to our final section."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Section 3: Final Mission - Going to Mars!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to get to Mars, we need to figure out how to leave Earth's orbit and arrive at Mars' orbit. Let's first do some trajectory planning."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 1: Our Path To Mars"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Run the code below to plot our ship's trajectory to Mars' orbit.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## *** CELL 3.1  *** ##\n",
    "\n",
    "# Here we are defining subplots for plotting the planets' orbits. \n",
    "fig, ax = plt.subplots(figsize=[8,8])\n",
    "\n",
    "# Plot the Earth's orbit\n",
    "h.plot_orbit(major=1, e=0, color=\"cyan\", ax=ax, label='Earth')\n",
    "# Plot Mars' orbit \n",
    "h.plot_orbit(major=1.524, e=0, color=\"red\", ax=ax, label='Mars') #mars\n",
    "\n",
    "# The function below allows us to plot our trajectory to Mars. \n",
    "# It returns two values that allow us to plot an ellipse: \n",
    "#   - a, the length of the semi-major axis (the distance from the Sun to the furthest\n",
    "#     point on the ellipse)\n",
    "#   - the eccentricity of the ellipse (which we learned about during our preparation). \n",
    "#     as a reminder, it is the amount the ellipse is \"squashed\" compared to a circle\n",
    "\n",
    "def plot_trajectory():\n",
    "    R_Mars = 1.524 # the distance between Mars and the Sun, in AU\n",
    "    R_Earth = 1 # the distance between Earth and the Sun, in AU\n",
    "\n",
    "    a = (R_Mars + R_Earth)/2 # calculate the length of the semi-major axis\n",
    "    focus = 0.26 # the location of the focus of the ellipse (the other focus is the Sun)\n",
    "    eccentricity = focus/a # the eccentricity\n",
    "    \n",
    "    return a, eccentricity\n",
    "\n",
    "a, eccentricity = plot_trajectory()\n",
    "\n",
    "h.plot_orbit(major=a, e=eccentricity, color=\"indigo\", ax=ax, label='Transfer Orbit')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ADVANCED: consider the \"plot_trajectory\" function. This is a function that allows us to draw the ellipse of our trajectory by determining the focal length and semi-major axis length. Can you figure out how we can find the focal length and semi-major axis length of the new ellipse, knowing what we already know about Earth's and Mars' orbits?**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ADVANCED ANSWER**\n",
    "The value of the focus point for our solar system is 0.26 AU - this is an accepted value that can be found online.\n",
    "\n",
    "The length of the semi-major axis is half of the distance between Earth and Mars when they are most separated. This is because our elliptical orbit goes through both these locations, and they are the points on our ellipse that are the furthest from each other. Then we can calculate:\n",
    "\n",
    "$2a = \\text{distance between Earth and Mars} = \\text{Earth-Sun distance + Mars-Sun distance} $\n",
    "\n",
    "$2a = r_{earth} + r_{mars} = 1.524 + 1 (AU)= 2.524 AU$\n",
    "\n",
    "$a = 1.262 AU$\n",
    "\n",
    "The animations in this link illustrate this quite well ([Source: NASA JPL](https://www.jpl.nasa.gov/edu/teach/activity/lets-go-to-mars-calculating-launch-windows/))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From our trajectory plan above, we can see that our rocket will start in Earth's orbit, exit Earth's orbit, reach Mars' orbit and remain in that orbit. This path follows an elliptical shape - it is called a \"Hohmann Transfer Orbit\".\n",
    "\n",
    "The drawing below illustrates this trajectory:\n",
    "<img src=\"Trajectory_Diagram.png\" alt=\"Trajectory\" width=\"700\"/>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You might be asking yourself - why do we need to go in an ellipse? Why can’t we go in a straight line to Mars? The reason for this is the gravitational pull from the Sun. Going in a straight line is less energy-efficient than more elliptical paths. (This is why planets orbit in ellipses).\n",
    "\n",
    "It turns out that this ellipse is the most efficient path - it allows us to use the Sun’s gravitational pull and not fight against it.\n",
    "Now, let's figure out how to launch our spaceship so that it follows this path!\n",
    "\n",
    "Leaving Earth's atmosphere requires a certain speed, or we will not be able to escape Earth's gravity. In order to leave Earth's atmosphere and get to Mars, we need to go even faster!\n",
    "\n",
    "We need to determine the speed we need to leave Earth's atmosphere and start our elliptical trajectory. We also need to determine the speed that we need to slow down to, once we arrive at Mars' orbit - otherwise, we will be launched too far out into space!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Fill in the information below from the table in Section 2, then run the next two cells to calculate these changes in velocity.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## *** CELL 3.2  *** ##\n",
    "\n",
    "# Fill in the distance between the Earth and the Sun, in AU:\n",
    "earth_sun_distance = 1\n",
    "\n",
    "# Fill in the distance between Mars and the Sun, in AU:\n",
    "mars_sun_distance = 1.524\n",
    "\n",
    "# What is the period of the Earth's orbit around the Sun, in days?\n",
    "P_earth = 365.24\n",
    "\n",
    "# What is the period of Mars's orbit around the Sun, in days?\n",
    "P_mars = 686.68"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## *** CELL 3.3  *** ##\n",
    "\n",
    "# This cell will calculate the speeds! There is a lot going on here, but it \n",
    "# is all explained thoroughly in the second \"Advanced Section\" after this cell,\n",
    "# so don't worry for now. You can run this cell as is. \n",
    "\n",
    "# Define important values\n",
    "G = 6.67*10**(-11)      # the gravitational constant\n",
    "M_sun = 1.989*10**(30)  # the mass of the Sun\n",
    "\n",
    "# We define the following function to calculate the necessary speeds:\n",
    "def Hohmann_velocities(earth_sun_distance, mars_sun_distance, P_earth, P_mars, M_sun):\n",
    "  # First we define some useful constants to use in our calculations:\n",
    "    P_1 = P_earth*86400 # the period of the Earth, in seconds\n",
    "    P_2 = P_mars*86400 # the period of Mars, in seconds\n",
    "    r_1 = earth_sun_distance*1.496*10**(11) # the Earth-Sun distance, in m\n",
    "    r_2 = mars_sun_distance *1.496*10**(11) # the Mars-Sun distance, in m\n",
    "  \n",
    "  # Next we calculate the semi-major axis of our transfer orbit ellipse:\n",
    "    a = (r_1 + r_2)/2\n",
    "  \n",
    "  # We use this value as well as M_sun, G to calculate the period of our transfer orbit from Kepler's 3rd Law\n",
    "    P_transfer = np.sqrt(4*(math.pi)**2*a**3/(G*M_sun))\n",
    "  \n",
    "  # Now we need to find the speed our spaceship would have if it were in Earth's orbit and in Mars' orbit.\n",
    "    v_earth = 2*math.pi*r_1/P_1\n",
    "    v_mars = 2*math.pi*r_2/P_2\n",
    "  \n",
    "  # We also find the speed of our spaceship at the points in our transfer orbit that intersect Earth and Mars.\n",
    "    v_perihelion = 2*math.pi*a/P_transfer * np.sqrt((2*a/r_1)-1) #this intersects Earth's orbit\n",
    "  \n",
    "    v_aphelion = 2*math.pi*a/P_transfer * np.sqrt((2*a/r_2)-1) # this intersects Mars' orbit\n",
    "  \n",
    "  # Finally we find the difference between the speeds to determine by how much we need to slow down and speed up at each point\n",
    "    delta_v_perihelion = v_perihelion - v_earth\n",
    "  \n",
    "    delta_v_aphelion = v_mars - v_perihelion\n",
    "  \n",
    "    print(\"The amount we need to speed up by to leave Earth's orbit is\", round(delta_v_perihelion, 1), \"m/s.\")\n",
    "\n",
    "    print(\"The amount we need to slow down by to stay in Mars' orbit is\", round(-1*delta_v_aphelion, 1), \"m/s.\")\n",
    "\n",
    "# We can now call our defined function using our values from Cell 3.2\n",
    "Hohmann_velocities(earth_sun_distance, mars_sun_distance, P_earth, P_mars, M_sun)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ADVANCED: These equations will work for any planet further out than Earth! Change up the parameters to see where else you can travel. Do you think it will require a greater speed to reach Jupiter, or a slower speed?**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*It will require a greater speed! This is because the distance to be travelled is larger, so our ellipse must also be larger. The faster we go, the larger our elliptical path can be.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ADVANCED: You can write out your own code to calculate these velocities, or solve it by hand. Here are some hints if you would like to try it out:**\n",
    "\n",
    "1. First, you must figure out the speed of Earth in its orbit. This will be the initial speed of your spaceship, because it is in Earth's atmosphere. Remember circular motion, and the time it takes for Earth to go around the Sun!\n",
    "\n",
    "*Speed is distance over time, so the speed of Earth as it goes around its circular orbit is $v_{earth} = \\frac{2 \\pi r_{earth}}{P_{earth}}$.*\n",
    "\n",
    "2. Then, you must figure out the speed the spaceship should have, if it were in this location but following the *indigo* transfer orbit. This location is called the \"perihelion.\" It is the point on the ellipse that is closest to the Sun. To do this, you must use Kepler's Laws and conservation of energy. You may also need the fact that the total energy of an object orbiting in an elliptical path is is $E_{tot} = -\\frac{GM_{sun}M_{earth}}{2a}$. \n",
    "\n",
    "*The period of our transfer orbit is, using Kepler's Third Law: $P = \\sqrt{\\frac{4 \\pi a^{3}}{GM}}$.*\n",
    "\n",
    "*From conservation of energy, the total energy of the Earth is equal to its potential energy plus its kinetic energy. Thus, $E_{tot} = \\frac{M_{earth}v^2}{2} - \\frac{GM_{sun}M_{earth}}{r_{earth}}$*. \n",
    "\n",
    "*From a theorem, the total energy of Earth is also equal to half of its potential energy at the semi-major axis distance a. So, $E_{tot} = -\\frac{GM_{sun}M_{earth}}{2a}$*.\n",
    "\n",
    "We can set the two equations for $E_{tot}$ equal to each other and solve for v. We will then get:\n",
    "\n",
    "$v_{perihelion} = \\sqrt{GM}\\sqrt{\\frac{2}{r_{earth}}-\\frac{1}{a}}$\n",
    "\n",
    "We can solve this right away, but we can also use our value of P to do so. From our equation for $P$, we can write $GM = \\frac{4 \\pi^2 a^3}{P^2}$, and so we can finally get:\n",
    "\n",
    "$v_{perihelion} = \\frac{2\\pi a}{P_{transfer}} \\sqrt{\\frac{2a}{r_{earth}}-1}$\n",
    "\n",
    "3. The difference between the two speeds will be the amount by which you need to speed up to enter the indigo orbit!\n",
    "\n",
    "$\\Delta v  = v_{perihelion} - v_{earth}$\n",
    "\n",
    "4. At the other side of the indigo transfer orbit, you will need to slow down in order to stay in Mars' orbit. This point is called the \"aphelion\" - the point furthest from the Sun. Once again, use Kepler's Laws to determine the speed your spaceship will have at this point.\n",
    "\n",
    "*This is the same procedure as in step 2, except we are using Mars' data. We get:* \n",
    "\n",
    "$v_{aphelion} = \\frac{2\\pi a}{P_{transfer}} \\sqrt{\\frac{2a}{r_{mars}}-1}$\n",
    "\n",
    "5. Like before, determine the speed your spaceship would have if it were in Mars' orbit - using circular motion again! \n",
    "\n",
    "*This is the same procedure as in step 1, except we are using Mars' data. We get:* \n",
    "\n",
    "$v_{earth} = \\frac{2 \\pi r_{earth}}{P_{earth}}$\n",
    "\n",
    "6. The difference between these two speeds is the amount by which you would need to slow down to get on Mars' orbit.\n",
    "\n",
    "$\\Delta v  = v_{mars} - v_{aphelion}$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2: Arriving On Time!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! We have figured out how to get to Mars' orbit with our spaceship! However, we still need to make sure that we will intersect Mars once we arrive - otherwise we will have an unpleasant surprise upon arriving...\n",
    "\n",
    "To do this, we need to plan ahead and determine how long it will take us to complete our journey to Mars' orbit. We can use Kepler's Laws to do this. Kepler's Third Law is:\n",
    "\n",
    "$$\\mathrm{P}^2 = \\frac{4\\pi a^3}{GM}$$\n",
    "\n",
    "\n",
    "- **P** is the period of the transfer - the total amount of time it would take to go all the way around the green ellipse of our trajectory. \n",
    "\n",
    "- **a** is the semi-major axis length of our elliptical trajectory\n",
    "\n",
    "- **M** is the mass of the Sun\n",
    "\n",
    "- **G** is the gravitational constant\n",
    "\n",
    "Remember that we are not looking for the entire period P, because we are only following this path to get to Mars, and not to come back. Our travel time will be only a percentage of the period: time = (decimal percentage)*P."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Fill in the value of the decimal percentage below, and the number of seconds in a day, and then run the cell to calculate the time it will take to reach Mars, in seconds and in days.**\n",
    "\n",
    "*Hint: look back at our trajectory diagram to help determine the percentage!*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## *** CELL 3.4  *** ##\n",
    "\n",
    "# Fill in the following two values:\n",
    "decimal_percentage = 0.5\n",
    "seconds_per_day = 86400\n",
    "\n",
    "# This is the equation for the period of our transfer orbit, from Kepler's Third Law\n",
    "P = np.sqrt(4*(math.pi)**2*(a*1.496*10**(11))**3/(G*M_sun))\n",
    "\n",
    "# Now we can calculate the time it takes us to reach Mars by following this orbit.\n",
    "time = decimal_percentage*P\n",
    "\n",
    "# We will convert this time from seconds to days\n",
    "time_in_days = time/seconds_per_day\n",
    "\n",
    "print(\"It would take\", round(time, 1), \"seconds to reach Mars using this trajectory. \\n This is equivalent to\", round(time_in_days,0), \"days.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now know how long it will take us to reach Mars on this journey. How can we use this to plan our departure date from Earth?\n",
    "\n",
    "**Think about this, then enter your plan in the text box below for your fellow astronauts.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*We know that it will take us 259 days to travel to Mars along our elliptical orbit. We must choose a departure time such that, after 259 days, Mars will be at the opposite end of the elliptical orbit from where we launched our ship. This sounds daunting, but with observations of Mars' orbits, and some calculations, our engineers will be able to pinpoint an exact date!*"
   ]
  }
 ],
 "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}