tutorialhw4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Phys 260: Python assignment header\n",
    "\n",
    "### (1) Fill out the cell below.  \n",
    "The cell below is a **code cell**.  Fill out your University of Michigan uniqname, then your name, and collaborators in the cell below **inside the quotes**.  \n",
    "\n",
    "**Do not delete the quotes.**  We will use this information to organize your assignments.  To edit and execute cells, double click inside the cell, type, and press \\<shift\\>+\\<enter\\> to execute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "UNIQNAME = \"\"\n",
    "NAME = \"\"\n",
    "COLLABORATORS = \"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### (2) Check your python version.  \n",
    "**Execute the cell below** (double click in the cell and press \\<shift\\>+\\<enter\\>, or click in the cell and press the Run button) to check that you are using a version of python that is compatible with the tool we are using to grade your assignments.  If your ```IPython``` version is too old, we will *not* be able to grade your assignments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import IPython\n",
    "assert IPython.version_info[0] >= 3, \"Your version of IPython is too old, please update it.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### (3) Do your best to answer all questions in the assignment.  \n",
    "To answer questions, **replace** anything that says either\n",
    "- \"YOUR ANSWER HERE\" \n",
    "- \n",
    "```\n",
    "YOUR CODE HERE\n",
    "raise NotImplementedError\n",
    "``` \n",
    "\n",
    "with your answer/code.  Cells with either of the two bullet points above are cells of the notebook that will be graded.\n",
    "\n",
    "**To edit markdown** cells (e.g. this one),  *double click in the cell to type*.  Press \\<shift\\>+\\<enter\\> to execute the cell.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### (4) Make sure your notebook runs sequentially.\n",
    "After you complete this assignment, make sure everything runs as expected. First, **restart the kernel** (in the menubar, select Kernel$\\rightarrow$Restart) and then **run all cells** (in the menubar, select Cell$\\rightarrow$Run All)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction -- Reminder\n",
    "\n",
    "Each Python lab will start with a pre-flight exercise that walks through building some of the set up and tools ($\\sim$ 30 min), followed by an in-class tutorial with time for Q+A (50 min) so you can walk through steps that will be necessary for the homework assignment you will submit ($\\sim$ 3 hrs).  Each lab will contain starter code, similar to what you see below.  Please fill in the code to complete the pre-flight assignment in preparation for the in-class tutorial.  \n",
    "\n",
    "Preflight ($\\sim$30-60 min, 10 points) **Typically due: Thursdays 3pm EST**\n",
    "\n",
    "*Preflight typically graded by Wednesday 5p EST*\n",
    "\n",
    "In-class tutorial and Q+A ($\\sim$ 50 min, 10 points) **Typically occurs: Fridays 12pm EST**\n",
    "\n",
    "Homework assignment ($\\sim$ 3-5 hrs, 30 points) **Typically due: Tuesdays 12pm EST**  \n",
    "\n",
    "\n",
    "When we grade your homework, we will not run your code. Once submitted, your notebook should have the outputs for all of your results.  Please do not include long outputs from debugging, beyond a few print statements and the requested visualimzations (i.e. plots).\n",
    "\n",
    "**Grading:** When we grade your notebook, we will convert the .ipynb file to an HTML file.  We will be using [nbgrader](https://nbgrader.readthedocs.io/en/stable/) to grade your notebooks.  **Note:** Execute the cell below (click in the cell and press shift+enter, or click in the cell and press the Run button) to check that you are using a version of python that is compatible with the tool we are using to grade your assignments.  If your ```IPython``` version is too old, we will *not* be able to grade your assignments."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Phys 260 Python Lab 4: Simulating the Capacitor (30 points total)\n",
    "\n",
    "## Tutorial/HW summary\n",
    "- Code review exercise:  relax_2d_potential\n",
    "- Define boolean statements to identify plate positions\n",
    "- Visualizing electric fields and potential\n",
    "- Model the capacitor with a function to allow variations in configuration (i.e. d/L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numerical approaches -- when analytic approaches no longer hold\n",
    "\n",
    "In the last tutorial/hw, you used the method of relaxation to find the potential inside a rectangular box, where the potential was specified on the sides. While that particular problem can be solved analytically (you will learn how to do this in Physics 405), the method of relaxation allows us to study problems that do not have an analytical solution. \n",
    "\n",
    "Consider the familiar example of a parallel-plate capacitor. In most physics classes, we pretend that the electric field between the plates can be approximated by the field of two infinite charged planes, so it's constant in between the plates and zero everywhere outside. Here's a typical illustration of this approximation:\n",
    "\n",
    "<img src=\"capacitor.gif\" alt=\"Parallel-plate capacitor\" style=\"width: 200px;\"/>\n",
    "\n",
    "This is an idealization, like frictionless surfaces and masssless springs. The approximation works as long as the linear dimensions of the plates are large compared to the separation: $A\\gg d^2$. In this assignment we'll apply this technique to understand what the electric field of a parallel-plate capacitor *really* looks like, and learn how the usual approximation starts to break down as the plate separation increases.\n",
    "\n",
    "Much of the code in this assignment overlaps with the last tutorial/hw and the recent preflight."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "import matplotlib.patches as patches"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Quick class exercise** (2 points -- 2 min):  You'll notice that we define the meshgrid below in terms of the number of points, `num_points_1d`, the indexing, and the `grid_extent` to the left/right, top/bottom.  Define `grid_spacing` in terms of the extent and number of points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "dd5984d1a56a010673627a55e444230e",
     "grade": false,
     "grade_id": "cell-e8f629d51af73118",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "#  Generate x,y coordinates on the rectangular grid.\n",
    "num_points_1d = 100\n",
    "indexing = 'ij'\n",
    "grid_extent = 4\n",
    "x_positions, y_positions = np.meshgrid(np.linspace(-grid_extent,grid_extent,num_points_1d), \n",
    "                                       np.linspace(-grid_extent,grid_extent,num_points_1d),\n",
    "                                       indexing=indexing) \n",
    "position_array = np.array([x_positions,y_positions])\n",
    "potential_array = np.zeros(x_positions.shape)\n",
    "\n",
    "# Define grid_spacing below\n",
    "grid_spacing = 2*grid_extent / num_points_1d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "bd32047cd1ec93739dd56e4181f14d84",
     "grade": true,
     "grade_id": "Tutorial_grid_spacing",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "\"\"\"Execute to make sure you're on the right track\"\"\"\n",
    "assert(grid_spacing<1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Review of relevant functions and code:  Exercise in code review\n",
    "\n",
    "[*Code review*](https://medium.com/palantir/code-review-best-practices-19e02780015f) is an important component of any software development.  Briefly, code review is the process by which another person (or people) review code for the purposes of helping to debug, make more readable, or otherwise. \n",
    "\n",
    "Super aside, the term \"bug\" in a code comes from the [first incident](https://www.computerhistory.org/tdih/september/9/) when an actual bug was found in a computer (a moth was trapped).  The incident was logged by, and later popularized by, computer-language pioneer Grace Hopper: [Grace Hopper's Bug](https://www.nationalgeographic.org/thisday/sep9/worlds-first-computer-bug/).\n",
    "\n",
    "Aside from improving code, code review is also a nice opportunity to pick up on tips, tricks, more efficient coding habits, etc.  Like asking and answering questions, it is yet another way to learn from one another."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Group exercise** (5 min -- 2 points): Below are the definitions of functions `set_boundary_conditions_rectangle` (you saw this previously as `set_boundary_conditions`) and `relax_potential_2d`.  I have inserted bugs in the code for the functions.  Try executing the next three code cells.  You'll find that the `while` loop is stuck.  The bug in `set_boundary_conditions_rectangle` is more of a redundancy (not quite a bug).  \n",
    "\n",
    "First, identify the redundancy in `set_boundary_conditions_rectangle`, and remove it.  Hint:  The first exercise from the preflight, where we look at how different python objects change (or don't change) when passed to a function, is relevant.  Also, recall how we used `set_boundary_conditions` in the preflight.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "2b5440c2cd227992268bfa95ef5e0aab",
     "grade": false,
     "grade_id": "cell-34c52008b0cf7507",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def set_boundary_conditions_rectangle(potential_array, pts_in_meshgrid, \n",
    "                                        bounds_left=0, bounds_right=0, \n",
    "                                        bounds_top=100, bounds_bottom=-100) :\n",
    "    \"\"\" Returns potential array with set boundary conditions.  Sets in order of x edges, y edges, then z edges (if 3-d)\n",
    "\n",
    "    Inputs:\n",
    "    potential_array (n by m-darray) : array containing the potential at each sampled point \n",
    "    pts_in_meshgrid (n by m-darray) : x, y coordinates from the grid\n",
    "    bounds_right (float) : value of potential on right edge\n",
    "    bounds_left (float) : value of potential on left edge\n",
    "    bounds_top (float) : value of potential on top edge\n",
    "    bounds_bottom (float) : value of potential on bottom edge\n",
    "\n",
    "    Outputs:\n",
    "    potential_array (n by m-darray) : array containing the potential at each sampled point with boundary conditions set \n",
    "    \"\"\"\n",
    "    \n",
    "    assert(potential_array.shape == pts_in_meshgrid[0].shape)\n",
    "    \n",
    "    # Separate out the position arrays along each axis for readability\n",
    "    x_positions = pts_in_meshgrid[0]\n",
    "    y_positions = pts_in_meshgrid[1]\n",
    "\n",
    "    # Identify the edges\n",
    "    right_edge_mask = np.nonzero(x_positions == x_positions.max())\n",
    "    left_edge_mask = np.nonzero(x_positions == x_positions.min())\n",
    "    top_edge_mask = np.nonzero(y_positions == y_positions.max())\n",
    "    bottom_edge_mask = np.nonzero(y_positions == y_positions.min())\n",
    "    \n",
    "    # Set the bounds\n",
    "    potential_array[right_edge_mask] = bounds_right    \n",
    "    potential_array[left_edge_mask] = bounds_left\n",
    "    potential_array[top_edge_mask] = bounds_top\n",
    "    potential_array[bottom_edge_mask] = bounds_bottom\n",
    "\n",
    "    return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b95b6a6c29fa41c42d69e3072bcb37a6",
     "grade": true,
     "grade_id": "cell-19b87930a07938af",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "\"\"\"Execute to check you're on the right track\"\"\"\n",
    "test_potential_array = potential_array\n",
    "set_boundary_conditions_rectangle(test_potential_array, np.array([x_positions, y_positions]))\n",
    "assert(test_potential_array.shape == potential_array.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Open question** (2 points -- take home): Why was the original code redundant?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "838447c571e95035d69e80c121b33ff3",
     "grade": true,
     "grade_id": "Tutorial_redundant_code",
     "locked": false,
     "points": 2,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "source": [
    "YOUR ANSWER HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Group exercise** (5 min -- 2 points): There are two bugs in the function below.  The first bug is related to the adjustment we made when we removed the redundancy in `set_boundary_conditions`, which assumes `set_boundary_conditions` will be used a certain way.  See what happens before you fix that bug and after you fix that bug.  The second bug will affect how the `while` loop proceeds.  Fix that bug as well.  *Note*: You'll notice some other key differences in this version of `relax_potential_2d`.  Namely, it takes in the boundary conditions function as an argument, and also takes in a generalization of keyword arguments for that function with the `**`.  These are not bugs, but we will talk about these differences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "0252024ae5c7e1c25ff9fe3e873257f9",
     "grade": false,
     "grade_id": "cell-8a2693f906d478cf",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def relax_potential_2d( potential_array, pts_in_meshgrid, \n",
    "                           bc_func=set_boundary_conditions_rectangle,\n",
    "                            **bc_func_kwargs ) :\n",
    "    \"\"\"Returns relaxed 2-d potential array with set boundary conditions.  \n",
    "\n",
    "    Inputs:\n",
    "    potential_array (n-darray) : array containing the potential at each sampled point \n",
    "    pts_in_meshgrid (n by m-darray) : x, y coordinates from the grid \n",
    "    bc_func (function) : function that sets boundary conditions, default set_boundary_conditions_rectangle\n",
    "    **bc_func_kwarg : any key word arguments for bc_func\n",
    "\n",
    "    Outputs:\n",
    "    relaxed_potential (n-darray) : array containing the relaxed potential at each sampled point with boundary conditions set     \n",
    "    \"\"\"\n",
    "    \n",
    "    # Define potential_left, right, top, and bottom\n",
    "    potential_bottom = np.roll(potential_array, -1, axis=0)\n",
    "    potential_top = np.roll(potential_array, 1, axis=0)\n",
    "    potential_left = np.roll(potential_array, -1, axis=1)\n",
    "    potential_right = np.roll(potential_array, 1, axis=1)\n",
    "\n",
    "    relaxed_potential = np.mean(np.array([potential_left, potential_right, \n",
    "                                          potential_top, potential_bottom]),axis=0)\n",
    "    assert(relaxed_potential.shape == potential_array.shape)\n",
    "    \n",
    "    bc_func(relaxed_potential, pts_in_meshgrid, **bc_func_kwargs)\n",
    "    \n",
    "    \n",
    "    return relaxed_potential"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Open question** (2 points -- take home):  Describe why you needed to change `relax_potential_2d` given the change in `set_boundary_conditions`.  What happened in the loop below?  What was the second change you made?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "50150fbc7953931c4c27c9c26aa9e129",
     "grade": true,
     "grade_id": "Tutorial_boundary_conditions_bug",
     "locked": false,
     "points": 2,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "source": [
    "YOUR ANSWER HERE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "convergence_criterion = 0.01\n",
    "largest_iteration_difference = 1 # initialize\n",
    "\n",
    "# Initialize the potential\n",
    "potential_2d = np.zeros(x_positions.shape) # or set_boundary_conditions_2d(np.zeros(x_positions.shape))\n",
    "\n",
    "# Collect the largest_iteration_difference\n",
    "largest_iteration_differences = []\n",
    "\n",
    "while largest_iteration_difference > convergence_criterion :\n",
    "    relaxed_potential = relax_potential_2d(potential_2d, position_array, \n",
    "                                            bc_func=set_boundary_conditions_rectangle,\n",
    "                                            bounds_left=0, bounds_right=0, \n",
    "                                            bounds_top=100, bounds_bottom=-100)\n",
    "\n",
    "    largest_iteration_difference = np.max(np.abs(relaxed_potential - potential_2d))\n",
    "    largest_iteration_differences.append(largest_iteration_difference)\n",
    "    potential_2d = relaxed_potential\n",
    "\n",
    "print(potential_2d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(len(largest_iteration_differences))\n",
    "plt.plot(largest_iteration_differences)\n",
    "plt.yscale('log')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Open question** (2 points): \n",
    "- Describe what the bug in the code would do in the while loop and why."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "c9e8c2460805845664fcf4755b9b6550",
     "grade": true,
     "grade_id": "Tutorial_describe_bug",
     "locked": false,
     "points": 2,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "source": [
    "YOUR ANSWER HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, we include the function to calculate the electric field for any potential."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc_efield_2d(potential_array) : \n",
    "    \"\"\"Calculate the electric field in one dimension\n",
    "\n",
    "    Inputs:\n",
    "    potential_array (nxm array) : array containing the potential at each sampled point \n",
    "\n",
    "    Outputs:\n",
    "    efield_array (2xnxm darray) : array containing the corresponding efield at each sampled point     \n",
    "    \"\"\"\n",
    "    \n",
    "    return -np.array([np.gradient(potential_array,axis=0),\n",
    "                     np.gradient(potential_array,axis=1)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The case of parallel plate capacitors\n",
    "\n",
    "The rest of this tutorial/hw will model a parallel-plate capacitor with width $L$ pixels and separation $d$. We will care about how the ratio, $d/L$, impacts the electric field.  So, (1) we will keep $L$ fixed to extend across 1/2 the total width of points sampled and (2) we will vary $d$.\n",
    "\n",
    "<img src=\"cap-illustration.png\" alt=\"parallel-plate capacitor\" style=\"width: 400px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define a boolean statement\n",
    "**Group exercise:** (2 points -- 5 min)  We will assume each plate is sampled by a line of points parallel to the x-axis.  Note, if $L$ is fixed to extend across 1/2 the total width of the points sampled and the plates lie parallel to the x-axis, the plates are sampled by points whose x coordinate values have absolute values less than or equal to half the maximum x coordinate value.  Write the boolean statement that picks out the `plate_x_boolean` of the plates.  `plate_x_boolean` should look like an array of True and False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "3ee7b9626e515d22aae0d82330c211dd",
     "grade": false,
     "grade_id": "cell-d368869ee4080a22",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Define plate_x_boolean here\n",
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "ca2a295a37bb2eb56cfec139c0d80242",
     "grade": true,
     "grade_id": "Tutorial_plate_x_boolean",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "\"\"\"Execute to check you're on the right track\"\"\"\n",
    "assert(plate_x_boolean.shape == x_positions.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Filling out a function**: (2 points -- take home) The previous exercise identified a 2-d swath containing the plates (where the x-coordinates matched those of the plates).  We will also assume that the plates are equidistant from the x-axis, with a distance as close to $d/2$ as possible (given the meshgrid spacing).  This will give us a line of points corresponding to each plate.  Below, we define a function that returns the `top_y_boolean` and the `bottom_y_boolean`. \n",
    "\n",
    "You will need to fill in `find_plate_points`: \n",
    "- Define plate_x_boolean using the kwarg `fractional_plate_width`.  In the exercise above, we assumed this is 1/2.  \n",
    "- Define `plate_y_boolean_top` and `plate_y_boolean_bottom` using the function `find_plate_y_booleans`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "63358838799e3efa2e598767aa671f46",
     "grade": false,
     "grade_id": "cell-2b6566dd183b97e0",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def find_plate_y_booleans(d, y_position_array) :\n",
    "    \"\"\"Returns the booleans corresponding to y positions that are a distance d/2 pixels above and below the x axis\n",
    "    \n",
    "    Inputs:\n",
    "    d (float) : distance separating capacitor plates \n",
    "    y_position_array (n by m-darray) : array of the y coordinates of the sampled points\n",
    "\n",
    "    Outputs:\n",
    "    top_y_boolean (n by m-darray) : array containing True for y coordinates closest to d/2 \n",
    "    bottom_y_boolean (n by m-darray) : array containing True for y coordinates closest to -d/2 \n",
    "    \"\"\"\n",
    "    \n",
    "    assert(d >= grid_spacing)\n",
    "    \n",
    "    top_y_boolean = np.abs(y_position_array-d/2) == np.min(np.abs(y_position_array-d/2))\n",
    "    bottom_y_boolean = np.abs(y_position_array+d/2) == np.min(np.abs(y_position_array+d/2))\n",
    "    \n",
    "    return top_y_boolean, bottom_y_boolean\n",
    "\n",
    "def find_plate_points(d, x_position_array, y_position_array, fractional_plate_width = 1/2) :\n",
    "    \"\"\"Returns the indices for top and bottom plates, given d and x/y coordinates.\n",
    "    \n",
    "    Inputs:\n",
    "    d (float) : number of grid points separating capacitor plates \n",
    "    x_position_array (n by m-darray) : array of the y coordinates of the sampled points\n",
    "    y_position_array (n by m-darray) : array of the y coordinates of the sampled points\n",
    "    fractional_plate_width (float) : fractional width of sampled points that the plate extends across\n",
    "\n",
    "    Outputs:\n",
    "    top_plate_indices (tuple) : tuple containing indices of top plate\n",
    "    bottom_plate_indices (tuple) : tuple containing indices of bottom plate\n",
    "    \"\"\"\n",
    "    \n",
    "    # Define plate_x_boolean using the kwarg fractional_plate_width below\n",
    "    # YOUR CODE HERE\n",
    "    raise NotImplementedError()\n",
    "    \n",
    "    # Define plate_y_boolean_top and plate_y_boolean_bottom using the function find_plate_y_booleans\n",
    "    # YOUR CODE HERE\n",
    "    raise NotImplementedError()\n",
    "\n",
    "    # Define top_plate_indices and bottom_plate_indices using np.where\n",
    "    top_plate_indices = np.nonzero(plate_x_boolean & plate_y_boolean_top)\n",
    "    bottom_plate_indices = np.nonzero(plate_x_boolean & plate_y_boolean_bottom)\n",
    "        \n",
    "    return top_plate_indices, bottom_plate_indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e0cab86ebd978a57725667eb8f7167b5",
     "grade": true,
     "grade_id": "Tutorial_find_plate_points",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "\"\"\"Execute to check you're on the right track\"\"\"\n",
    "assert(type(find_plate_points(0.1, x_positions, y_positions)) == tuple)\n",
    "assert(type(find_plate_points(0.1, x_positions, y_positions)[0]) == tuple)\n",
    "assert(len(find_plate_points(0.1, x_positions, y_positions)[0][1]) > \\\n",
    "        len(find_plate_points(0.1, x_positions, y_positions, fractional_plate_width=0.25)[0][1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Set capacitor conditions**: (2 points -- Take home) Fill out the missing line in `set_capacitor_conditions` below.  Make sure to use `find_plate_points` for full credit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "397e7998a915a520518cb3e15f4ee61e",
     "grade": false,
     "grade_id": "cell-60598b1a62217d6d",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def set_capacitor_conditions(potential_array, pts_in_meshgrid, \n",
    "                                 d=.5, bounds_top=100, bounds_bottom=-100, \n",
    "                                 fractional_plate_width=0.5,) :\n",
    "    \"\"\" Modifies potential array with set boundary conditions for a capacitor\n",
    "\n",
    "    Inputs:\n",
    "    potential_array (n by m-darray) : array containing the potential at each sampled point \n",
    "    pts_in_meshgrid (n by m-darray) : x, y coordinates from the grid \n",
    "    d (float) : distance separating capacitor plates \n",
    "    bounds_top (float) : value of potential on top plate\n",
    "    bounds_bottom (float) : value of potential on bottom plate\n",
    "    fractional_plate_width (float) : fractional width of sampled points that the plate extends across \n",
    "    \n",
    "    Outputs:\n",
    "    None\n",
    "    \"\"\"\n",
    "    \n",
    "    x_positions = pts_in_meshgrid[0]\n",
    "    y_positions = pts_in_meshgrid[1]\n",
    "    \n",
    "    assert(potential_array.shape == x_positions.shape)\n",
    "\n",
    "    # Identify the plate indices, top_plate_mask and bottom_plate_mask\n",
    "    # YOUR CODE HERE\n",
    "    raise NotImplementedError()\n",
    "    \n",
    "    # Set the bounds\n",
    "    potential_array[bottom_plate_mask] = bounds_bottom\n",
    "    potential_array[top_plate_mask] = bounds_top\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "5c48d3671bb908af454d7c4d8cbdc7a1",
     "grade": true,
     "grade_id": "Tutorial_set_capacitor_conditions",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "\"\"\"Execute to check you're on the right track\"\"\"\n",
    "test_potential = potential_2d\n",
    "set_capacitor_conditions(test_potential, position_array, d=.1, fractional_plate_width=0.25)\n",
    "assert(test_potential.shape == potential_2d.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Write a function to model the capacitor (5 points -- Take home)\n",
    "\n",
    "Below, we write a function to model the capacitor.  Note, we've essentially taken the contents of the cell with the `while` loop several cells above, and put that into a function.  The primary reason this is in a function is so we can vary over `d` by simply calling this function again with a different value for the key word argument `d`.  The crucial difference here is in how `relaxed_potential` gets defined in each iteration of the while loop. \n",
    "\n",
    "Fill in the necessary code below to define `relaxed_potential` in each iteration.  You'll need to properly call `relax_potential_2d` for the case of the capacitor.  *Hint*: Most of the key word arguments of `model_capacitor` are relevant to `set_capacitor_conditions`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "de60d0be0800b40889d459ddeff42ad3",
     "grade": false,
     "grade_id": "cell-7932b07e4f8a5fd1",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def model_capacitor(position_array, convergence_criterion = 0.01, \n",
    "                    d=.1, fractional_plate_width=0.5,\n",
    "                   bounds_top=100, bounds_bottom=-100) :\n",
    "    \"\"\" Models the capacitor with set boundary conditions for a capacitor\n",
    "\n",
    "    Inputs:\n",
    "    position_array (2 by n by m-darray) : x, y coordinates from the grid \n",
    "    convergence_criterion (float) : fractional width of sampled points that the plate extends across   \n",
    "    d (float) : distance separating capacitor plates \n",
    "    fractional_plate_width (float) : fractional width of sampled points that the plate extends across   \n",
    "    bounds_top (float) : value of potential on top plate\n",
    "    bounds_bottom (float) : value of potential on bottom plate\n",
    "    \n",
    "\n",
    "    Outputs:\n",
    "    potential_2d (n by m-darray) : Modeled 2d potential of the capacitor\n",
    "    \"\"\"\n",
    "\n",
    "    largest_iteration_difference = 1 # initialize\n",
    "\n",
    "    # Initialize the potential\n",
    "    potential_2d = np.zeros(x_positions.shape) \n",
    "\n",
    "    # Collect the largest_iteration_difference\n",
    "    largest_iteration_differences = []\n",
    "\n",
    "    while largest_iteration_difference > convergence_criterion :\n",
    "        # Define the relaxed potential below using relax_potential_2d with the appropriate args and kwargs\n",
    "        # YOUR CODE HERE\n",
    "        raise NotImplementedError()\n",
    "\n",
    "        largest_iteration_difference = np.max(np.abs(relaxed_potential - potential_2d))\n",
    "        largest_iteration_differences.append(largest_iteration_difference)\n",
    "        potential_2d = relaxed_potential\n",
    "    \n",
    "    print(\"Modeled with \", len(largest_iteration_differences), \"iterations\")\n",
    "    \n",
    "    return potential_2d\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f3eb148fc15dda2933fba4d6136d8f88",
     "grade": true,
     "grade_id": "HW_model_capacitor",
     "locked": true,
     "points": 5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "\"\"\"Execute to check you're on the right track\"\"\"\n",
    "test_capacitor = model_capacitor(position_array) \n",
    "assert(test_capacitor.shape == x_positions.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualize the capacitor \n",
    "\n",
    "Let's use stream and contour plots to visualize the potential and electric fields of the capacitor! First let's intialize a cosmetic function to make our electric field lines look closer to how we would draw them by hand. Don't worry too much about it for now, unless you are curious."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "def make_field_lines_start(capacitor_distance,position_array, eps = 0.1):\n",
    "\n",
    "    ######################### \n",
    "    #This function is trying to make streamplot look more like the intuitive electric field plots we can \n",
    "    #draw by hand for simple cases (with lines only starting and terminating on charges). Do not worry \n",
    "    #too much about how this is implemented, it is just a way to make the plots easier to interpret for now!\n",
    "    #\n",
    "\n",
    "    ##We are using the `start_points' kwarg to make streamplot behave itself. Ideally, this would be \n",
    "    #directly related to charge density on the plates, so that the density of charges is directly related\n",
    "    #to the number of field lines! There are some hack-y ways to get this to work for parallel plates.\n",
    "    #Here, I just define a rectangle around both plates to get reasonably spaced lines. \n",
    "\n",
    "    eps = 0.1 #space away from the plates to start the vectors of stream plot\n",
    "\n",
    "    #grabbing position of capacitor plates using find_plate_points\n",
    "    top_points, bottom_points = find_plate_points(capacitor_distance,position_array[0], position_array[1])\n",
    "\n",
    "    #grabbing points in a rectangle around the plates (density of points is tweaked to match the physics)\n",
    "    field_lines_top_out = np.array([position_array[1][top_points][::4]+eps,\n",
    "                                    position_array[0][top_points][::4]]).T\n",
    "    field_lines_bottom_in = np.array([position_array[1][bottom_points][::2]+eps,\n",
    "                                      position_array[0][bottom_points][::2]]).T\n",
    "    field_lines_bottom_out = np.array([position_array[1][bottom_points][::4]-eps,\n",
    "                                       position_array[0][bottom_points][::4]]).T\n",
    "\n",
    "    dx = field_lines_top_out[1,1]-field_lines_top_out[0,1]\n",
    "\n",
    "    #adding top and bottom sides of the rectangle to catch those field lines\n",
    "    x_caps = [-capacitor_distance/2-eps, -capacitor_distance/2-eps,\n",
    "              -capacitor_distance/2+eps, -capacitor_distance/2+eps,\n",
    "              capacitor_distance/2-eps, capacitor_distance/2-eps,\n",
    "              +capacitor_distance/2+eps, capacitor_distance/2+eps]\n",
    "\n",
    "    y_caps = [-grid_extent/2-dx, grid_extent/2+dx,\n",
    "              -grid_extent/2-dx, grid_extent/2+dx,\n",
    "              -grid_extent/2-dx, grid_extent/2+dx,\n",
    "              -grid_extent/2-dx, grid_extent/2+dx,]\n",
    "\n",
    "    field_lines_caps = np.array([x_caps,y_caps]).T\n",
    "\n",
    "\n",
    "    #concatenating all of these points into field_lines start, which we'll use in stream plot\n",
    "    field_lines_start = np.concatenate((field_lines_top_out,field_lines_bottom_out,\n",
    "                                        field_lines_bottom_in, field_lines_caps))\n",
    "\n",
    "    return field_lines_start"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting the potential and electric fields for a capacitor with arbitrary distance\n",
    "\n",
    "Here I've set up a plot of the potential and electric fields to visualize the results of the relaxation code you wrote. Now, we really see the power of this method, allowing us to solve for electric fields and potentials which are analytically impossible. Try playing around with the capacitor_distance and see how the field lines change."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## intiializing a figure to plot the potential and electric field lines\n",
    "fig, (ax,ax2) = plt.subplots(1,2, figsize=(16,8))\n",
    "\n",
    "capacitor_distance = 2.0 #defining the distance between capacitor plates\n",
    "\n",
    "capacitor_potential=model_capacitor(position_array,d = capacitor_distance)\n",
    "efield = calc_efield_2d(capacitor_potential)\n",
    "emagnitude = np.linalg.norm(efield,axis=0)\n",
    "\n",
    "## Plotting a contour plot of the potential\n",
    "levels = np.arange(-100,100,step=20) #defining levels of the contour plot\n",
    "contour1 = ax.contour(y_positions,x_positions,capacitor_potential, levels=levels,colors ='k',alpha = 0.8)\n",
    "ax.clabel(contour1, fontsize=10, colors='black')  # label the contours\n",
    "\n",
    "## adding voltage false color image to the plot\n",
    "img_plot = ax.imshow(capacitor_potential, extent = (-grid_extent,grid_extent,-grid_extent,grid_extent), cmap = plt.cm.RdBu)\n",
    "\n",
    "\n",
    "## Showing the plates of the capacitor as black rectangles using matplotlib.patches\n",
    "plate_width = 0.15 #defining the physical thickness of the capacitor plates for presentation purposes\n",
    "top_plate_patch = patches.Rectangle((capacitor_distance/2-plate_width/2,-grid_extent/2),\n",
    "                                    plate_width,grid_extent,\n",
    "                                   facecolor='k')\n",
    "bottom_plate_patch = patches.Rectangle((-capacitor_distance/2-plate_width/2,-grid_extent/2),\n",
    "                                       plate_width,grid_extent,\n",
    "                                       facecolor='k')\n",
    "ax.add_patch(bottom_plate_patch)\n",
    "ax.add_patch(top_plate_patch)\n",
    "\n",
    "#doing the same for the second subplot\n",
    "top_plate_patch2 = patches.Rectangle((capacitor_distance/2-plate_width/2,-grid_extent/2),\n",
    "                                    plate_width,grid_extent,\n",
    "                                    facecolor='k')\n",
    "\n",
    "bottom_plate_patch2 = patches.Rectangle((-capacitor_distance/2-plate_width/2,-grid_extent/2),\n",
    "                                       plate_width,grid_extent,\n",
    "                                       facecolor='k')\n",
    "ax2.add_patch(bottom_plate_patch2)\n",
    "ax2.add_patch(top_plate_patch2)\n",
    "\n",
    "## PHere we plot the electric field using our mysteriously generated_start point\n",
    "\n",
    "\n",
    "emagnitude = -np.log(np.linalg.norm(efield,axis = 0))\n",
    "field_lines_start = make_field_lines_start(capacitor_distance,position_array)\n",
    "\n",
    "ax2.streamplot(y_positions, x_positions,  \n",
    "              efield[1], efield[0], \n",
    "              color=emagnitude, linewidth=1.5, cmap = plt.cm.inferno,\n",
    "              density=25, arrowstyle='->', arrowsize=1.5,\n",
    "             start_points = field_lines_start)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "ax.set_aspect('equal')\n",
    "ax.set_xlabel('y-axis ', fontsize=16)\n",
    "ax.set_ylabel('x-axis ', fontsize=16)\n",
    "ax.set_title('Electric Potential (V)',fontsize=18)\n",
    "\n",
    "ax2.set_aspect('equal')\n",
    "ax2.set_xlabel('y-axis ', fontsize=16)\n",
    "ax2.set_ylabel('x-axis ', fontsize=16)\n",
    "ax2.set_title('Electric Field Lines (arbitrary units)',fontsize=18)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "**Open question** (2 points -- take home):  As a review, how do you expect the potential and electric field to behave inside an ideal (two infinite planes) capacitor? Where inside the capacitor is this ideal behavior closest to true? Where and how does it break down?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "e5112eadbe9afbebbd1a05b2011eabe8",
     "grade": true,
     "grade_id": "HW_capacitor_plot_questions",
     "locked": false,
     "points": 2,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "source": [
    "YOUR ANSWER HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualizing different configurations of the capacitor\n",
    "\n",
    "As we saw above, a realistic parallel plate capacitor behaves differently than the idealized infinite plane approximation. Now, we will try to quantify that difference by looking at the difference between the center and edges as a function of the capacitor distance.\n",
    "\n",
    "Recall, we had set $L$ to be half of the width of the meshgrid points, meaning it is as wide as the extent.  So, $d/L = d/$`grid_extent`.  We are interested in looking at how the field changes for a capacitor that is $d/L=0.1, 0.2, 0.3, 0.5, 1.0, 2.0$.  Below, define `capacitor_distances` such that `capacitor_distances` is an array of values of d that satisfy the different $d/L$.  This will need to be in terms of `grid_extent`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e5484f6045ae41ead3f0dbcf742c864d",
     "grade": false,
     "grade_id": "cell-ee6e007f421d5e13",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Define capacitor_distances here\n",
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "600031fc4a3a70aa5a79858f4105578b",
     "grade": true,
     "grade_id": "HW_capacitor_distances",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "\"\"\"Execute to check you're on the right track\"\"\"\n",
    "assert(capacitor_distances.shape == (6,))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculate capacitor potential for each configuration (2 points)\n",
    "\n",
    "Use a `for` loop to calculate the capacitor potential for each configuration.  Collect in a list called `capacitor_potentials`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9888e3a0c79bd9d1edc1ae8deb67682b",
     "grade": false,
     "grade_id": "cell-3aa97890f92f26d7",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Define capacitor_potentials here\n",
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "82fce78e7ac2c6034a522e89c95d1133",
     "grade": true,
     "grade_id": "HW_calculate_capacitor_potentials",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "\"\"\"Execute to check you're on the right track\"\"\"\n",
    "assert(type(capacitor_potentials) == list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### New trick:  A list comprehension\n",
    "Below, we use a *list comprehension* to collect the associated electric fields.  Can you see how we might have used this in the previous exercise?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "capacitor_efields = [calc_efield_2d(capacitor_potential) for capacitor_potential in capacitor_potentials]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Edges: Where the analytic assumptions break down\n",
    "When working analytically, we assumed that the parallel plate capacitors are close enough to two infinite plates.  That inherently assumes that the electric field between the center of both plates is the same as that on the edges.  Below, we write a boolean statement to identify the center and the edge of the plates along the x-axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "center_of_grid_index = np.where((np.abs(x_positions) == np.min(np.abs(x_positions))) & (np.abs(y_positions) == np.min(np.abs(y_positions))))\n",
    "\n",
    "edge_of_capacitor_index = np.where((np.abs(x_positions-grid_extent/2) == np.min(np.abs(x_positions-grid_extent/2))) & (np.abs(y_positions) == np.min(np.abs(y_positions))))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Collect the efield values\n",
    "\n",
    "Below, we completely take advantage of list comprehensions to collect the magnitude of the electric field for each configuration, the magnitudes at the center, and the magnitudes at the edge.       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "efield_magnitudes = [np.linalg.norm(efield, axis=0) for efield in capacitor_efields]\n",
    "center_efields = [efield_magnitude[center_of_grid_index] for efield_magnitude in efield_magnitudes]\n",
    "edge_efields = [efield_magnitude[edge_of_capacitor_index] for efield_magnitude in efield_magnitudes]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Plot deviation from ideal** (2 points):\n",
    "Plot the deviation from the ideal.  In the cell below, plot the ratio of the E field at the edge to the E field at the center as a function of d/L.  Label your figure, and make sure ratios are correct."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "6e0830a6d697b4b60a3a44ee62509bd7",
     "grade": true,
     "grade_id": "HW_plot_edge_center_ratio",
     "locked": false,
     "points": 2,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "#  Plot relationship here\n",
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Talk through your plots** (1 point) : Talk through your plot the Ratio vs. d/L plot through the two capacitor visualizations above. Going back to our plots of the potential and Electric field, how can we explain the trend we see in this plot?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "43ab72945ae96c29a802bd6c174504d4",
     "grade": true,
     "grade_id": "cell-cc7e2d72406c19bc",
     "locked": false,
     "points": 1,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "source": [
    "YOUR ANSWER HERE"
   ]
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}