4_AnimationAndGIFs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Making animations of planetary systems!\n",
    "\n",
    "In the last workbook, we ended by having you each make a plot of the outer planets orbiting around the Sun. So we'll start from there!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import rebound\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import imageio # this is new! We're going to be saving our animations as gifs!\n",
    "\n",
    "# so we can make plots\n",
    "%matplotlib inline \n",
    "%run tools.ipynb # Some behind-the-scenes tools to simplify some complicated code\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember we have to redefine the function we made last time that allows us to start a new simulation. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def start_new_sim(star_mass, star_name): # We have to give our def a unique name, and we can pass parameters to it\n",
    "    sim = rebound.Simulation()\n",
    "    sim.G = 4.*pi**2.\n",
    "    sim.units = ('yr', 'AU', 'Msun')\n",
    "    sim.add(m=star_mass, hash=star_name)  # Here, we use the variables we passed to the definition to initialize our star\n",
    "    return sim # We always need to return from our definition; here, we want to pass back our simulation\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll start with the plot that I asked you to make last time! A secret trick is that Rebound can search for the input parameters of some well known objects, like the planets. It does take a little longer though! Rebound gets the data from [this website](https://ssd.jpl.nasa.gov/horizons.cgi#top). You can try finding objects on this page yourself, if you are interested. Ask me if you need help! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "t_final = 5 # Length of simulation in years\n",
    "N_frames = 200 # Number of frames in the animation\n",
    "\n",
    "# Start new simulation - you only get 1 widget per simulation, so if you want a new widget, you need a new simulation\n",
    "sim = start_new_sim(1.,'Sun') # We call the definition, and we must pass the required elements\n",
    "addOuterPlanets(sim) # this function adds Jupiter, Saturn, Uranus, and Neptune!\n",
    "addPluto(sim)\n",
    "sim.move_to_com()\n",
    "\n",
    "\n",
    "# And now integrate!\n",
    "integrate_with_widget(sim, t_final, N_frames, 22) # the 22 stands for the scale used. Increase this number if you want to zoom out!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a good example of an inclined orbit! Pluto got knocked around a lot by the large outer planets when it was a young dwarf planet, so it's orbit is very different than those of the planets. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='maroon'>Can you tell if Pluto could ever accidentally run into Neptune?</font>\n",
    "<br><br><br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now,\n",
    "I'm going to also show you a plot with all the inner and outer planets, pluto, *and* Asbolus, which is a large asteroid that has an unstable out by the outer planets! Move the image around until you have a good understanding of where each planet is, and how the orbits of pluto and asbolus compare to the orbits of the planets!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This plot will include all the inner planets and the \n",
    "\n",
    "t_final = 5 # Length of simulation in years\n",
    "N_frames = 200 # Number of frames in the animation\n",
    "\n",
    "# Start new simulation - you only get 1 widget per simulation, so if you want a new widget, you need a new simulation\n",
    "sim = start_new_sim(1.,'Sun') # We call the definition, and we must pass the required elements\n",
    "addInnerPlanets(sim)\n",
    "addEarth(sim) # a function I made to add earth!\n",
    "addOuterPlanets(sim) # this function adds Jupiter, Saturn, Uranus, and Neptune!\n",
    "addPluto(sim)\n",
    "addAsbolus(sim)\n",
    "sim.move_to_com()\n",
    "\n",
    "\n",
    "# And now integrate!\n",
    "integrate_with_widget(sim, t_final, N_frames, 22) # the 22 stands for the scale used. Increase this number if you want to zoom out!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now that we can run a simulation, let's explore a bit more about _how_ they work. \n",
    "This simulation takes small steps forward in time. At each step, the integrator will use the laws of gravity to estimate how the positions and velocities of **every** body in the simulation change. At the next step, it will build from the positions and velocities of the star and planets calculated in the previous step.\n",
    "\n",
    "To mimic this behavior ourselves,the cell below uses a ```for``` loop to incrementally evolve our simulation forward in time. We achieve this by specifying a time step (```dt```) and the number of steps in our loop (```N_steps```). At each step, we add ```dt``` to the simulation's current time and integrate to this new time. Remember that ```sim.integrate``` takes the end time, which we have assigned to the variable ```new_time```. We also generate an animation frame at each step, which will then be stitched together into an animation similar to the widget above. \n",
    "\n",
    "Note that we name our animation ```ani``` - the word ```animation``` belongs to a package we imported, so we can't use it as a variable name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture \n",
    "# This cell produces a lot of unnecessary output, so we'll capture that output instead of printing it out.\n",
    "# The next code cell will actually display the animation.\n",
    "\n",
    "dt = 0.1 # Let's go forward a tenth of a year each step\n",
    "N_steps = 20 # Let's integrate it forward for 20 steps, so 20*0.1 = 2 years\n",
    "\n",
    "# Start a fresh simulation\n",
    "sim = start_new_sim(1, 'Sun') # We call the definition, and we must pass the required elements\n",
    "sim.add(m=3.E-6, a=2., e=0.8, inc=radians(20.), f=radians(45.), hash='Planet')\n",
    "sim.move_to_com()\n",
    "\n",
    "# We need to create a figure (fig) and axes (ax) for the animation\n",
    "fig,ax = plt.subplots(1,1,figsize=(5,5))\n",
    "\n",
    "# The animation is created from a list of frames\n",
    "frames = []\n",
    "\n",
    "for i in range(N_steps):\n",
    "    \n",
    "    new_time = sim.t+dt # The time we want to integrate to\n",
    "    sim.integrate(new_time) # And integrate!\n",
    "    \n",
    "    frames.append(make_rebound_frame(ax,sim)) # Add the new frame to the list for animation\n",
    "       \n",
    "# Create the animation\n",
    "ani = animation.ArtistAnimation(fig, frames)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's display our animation! Use the row of control buttons below the animation to adjust the animation speed and move forward/backward through the integration steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ani"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Your turn:\n",
    "<font color='maroon'>Make an animation with 20 frames again, but use the orbits of the outer planets and pluto, like in the first plot of this notebook. *Be warned: the more planets you add, the longer the integration will take! It will take about 30 seconds for this to run.* </font>\n",
    "\n",
    "<font color='maroon'>Take the following steps to complete this: \n",
    "1. change the time steps to be one year long, since the outer planets do not move very far in one year.\n",
    "2. start a new simulation, with the Sun, Jupiter, Saturn, Uranus, Neptune, and Pluto. Remember how I added all of these planets! See the above cells if you forget! Or ask me for help. \n",
    "3. Run for ~30 seconds, then run the cell that shows the animation</font>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gifs\n",
    "\n",
    "Alternatively, we can turn this animation into a gif that we can use to show our friends! We want to go through a series of time steps, make a plot for each time step, and save a picture at each step. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "# this for loop will print out the image that we're saving. if you'd like to see them, uncomment the line above\n",
    "\n",
    "dt = 1 # Let's go forward a full year each step\n",
    "N_steps = 100 # Let's integrate it forward for 20 steps, so 20 years\n",
    "\n",
    "sim = start_new_sim(1, 'Sun') # We call the definition, and we must pass the required elements\n",
    "addOuterPlanets(sim)\n",
    "addPluto(sim)\n",
    "\n",
    "# As before, we have to re-center the simulation before evolving it forward in time\n",
    "sim.move_to_com()\n",
    "\n",
    "for i in range(N_steps):\n",
    "    \n",
    "    new_time = sim.t+dt # The time we want to integrate to\n",
    "    sim.integrate(new_time) # And integrate!\n",
    "    \n",
    "    rebound.OrbitPlot(sim, unitlabel=\"(AU)\", color=True)\n",
    "    plt.savefig('figs/step_'+str(i)+'.png')\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you go back to the tab that says 'Home', you'll see a folder listed that reads 'figs/'. If you open that folder, you'll see a list of a bunch of figures! If you open one, you'll see an image of an orbit we simulated. Now, we have to stitch all of those images into a gif! \n",
    "\n",
    "We can do that by running the cell below, which goes through each image and stitches it to the previous one, and then exports the movie as a gif!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "images = []\n",
    "filenames = ['figs/step_'+str(i)+'.png' for i in range(N_steps)]\n",
    "for filename in filenames:\n",
    "    images.append(imageio.imread(filename))\n",
    "imageio.mimsave('movie.gif', images)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can find this 'movie.gif' file in the other table where you saw the single image. You can download this image by clicking on the check box, and going to the top and pressing 'Download'. Let me know if you have trouble with this! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}