hw7_python_practice.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# This lab requires you to fork then clone the repository. 5min\n",
    "\n",
    "## HW7 will require you to numerically calculate trajectories of charged particles in electric and magnetic fields"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np                         # numpy is a library that includes most of the numerical function you will need\n",
    "import matplotlib.pyplot as plt            # this is the library we use to plot   \n",
    "from mpl_toolkits.mplot3d import Axes3D    # this is a library to plot in 3d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions 10 min\n",
    "- When to use a function (when to construct a function, when to use a constructed function) \n",
    "- Function anatomy (args, kwargs, docstrings, return values)\n",
    "- Scope of variables in functions\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generic_function(*args, **kwargs) :\n",
    "    ''' Let us examine what args (arguments) and kwargs (key word arguments) do'''\n",
    "    for arg in args: \n",
    "        print(arg)\n",
    "        \n",
    "    for kwarg in kwargs:\n",
    "        print(kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Let's run the above function to figure out what is in arg and kwargs\n",
    "generic_function(1, 3, 'blah', ['a', 'list'], first_val = 22, second_word='yay')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modify generic function by adding in lines that print what `type` of object args and kwargs are.  What is happening"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generic_function_unpacked(*args, **kwargs) :\n",
    "    ''' Let us examine how to unpack kwargs (key word arguments) and see what a return statement does'''\n",
    "    for arg in args: \n",
    "        print(arg)\n",
    "        \n",
    "    for keyword, arg in kwargs.items():\n",
    "        print('keyword: ',keyword)\n",
    "        print('arg: ', arg)\n",
    "        \n",
    "    return args[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "generic_function_unpacked(1, 3, 'blah', ['a', 'list'], first_val = 22, second_word='yay')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Observations\n",
    "- The args component of a function input is seen as a tuple inside the function.  You can similarly give an explicit first argument, second argument, etc. \n",
    "- The kwargs component of a function input is seen as a dictionary.  This is a keyword-argument pair.  Dictionaries, in general, are key-value paired objects.  You access each value by knowing what it's key is in the dictionary.  For arrays, you access each value by knowing its index in the array. \n",
    "- Note - there was no return value in `generic_function`, but there was a return value in `generic_function_unpacked`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def force_on_charge_by_efield(electric_field, q=1.6e-19) :\n",
    "    ''' We have one argument, and a key-word argument.  q has a DEFAULT value of the charge of the electron in C'''\n",
    "    force = q*electric_field\n",
    "    return force"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's find out the force on an electron due to an E-field that is constant and parallel to the x-axis: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "efield = np.array([4,0,0])\n",
    "force_on_charge_by_efield(efield)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What kind of an error do you get if you try to print the variable force in the next cell?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try to print force here.  Try to also print electric_field. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This shows that force is not in the \"scope\" of the whole notebook.  The scope of a variable is the part of a program that can ‘see’ that variable.  In this case, the variable's scope is just in the function where it is defined."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Below, construct your own function to calculate the force on a charged particle (e.g. electron) moving at a given velocity due to a B-field that is constant and parallel to the x-axis.  First, let's examine what the method np.cross() does."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  Examine what np.cross does - hint, use google or the help built-in function of python.  Test this out with a velocity vector parallel to the y-axis, and a magnetic field parallel to the x-axis.  Do you get what you expect? 2 min"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Test out here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now, fill out the function below.  Test it out.  3min"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def force_on_charge_by_bfield() :\n",
    "    ''' Fill out description of appropriate arguments and/or keyword arguments.  You will need to use np.cross\n",
    "    from above. '''\n",
    "    #  Fill out code here\n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Test your function here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bonus:  Use both the force functions in a **new** function that calculates the acceleration on a a charged particle due to both an electric and magnetic field."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Acceleration function here - if you run out of time, it will be useful to do this at home as it will be used in\n",
    "#    the pre-flight.\n",
    "def acceleration_of_charged_in_ebfields() :\n",
    "    ''' Fill out description....'''\n",
    "    # Fill out code\n",
    "    return"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting (different ways) with matplotlib 5 min\n",
    "- You can straight up plot with plt.<methodname\\>, or \"paint\" on an axis.  The latter is a bit more pythonic, and the former more similar to matlab (if you've used that before).\n",
    "- Also, see stackoverflow answer to this: https://stackoverflow.com/questions/37970424/what-is-the-difference-between-drawing-plots-using-plot-axes-or-figure-in-matpl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_of_sine_and_cosine(theta, phi) :\n",
    "    ''' Easy to plot function '''\n",
    "    return np.sin(theta)+np.cos(phi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "theta = np.arange(0,10)\n",
    "phi = np.arange(5,15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Straight up plotting\n",
    "plt.plot(theta, sum_of_sine_and_cosine(theta, phi))\n",
    "plt.ylabel('sin($\\\\theta$)+cos($\\\\phi$)',fontsize='xx-large')\n",
    "plt.xlabel('$\\\\theta$',fontsize='xx-large')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Change the above line from plt.plot to plt.scatter.  What happened?  Is there something else you can make? (1 min)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  \"Painting\" on an axis - you can make multiple subplots on the same figure with this by changing subplot->subplots.\n",
    "fig, ax = plt.subplots(1)\n",
    "ax.plot(theta, sum_of_sine_and_cosine(theta, phi))\n",
    "ax.set_ylabel('sin($\\\\theta$)+cos($\\\\phi$)',fontsize='xx-large')\n",
    "ax.set_xlabel('$\\\\theta$',fontsize='xx-large')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### What is a key difference in the above cell compared with using plt.plot (or plt.scatter)?\n",
    "\n",
    "#### Now, create two side-by-side subplots, one that has $\\theta$ on the x-axis and the other that has $\\phi$ on the x-axis. First line started below.  Try executing this, then comment out `figsize` to see what happens `figsize` is a keyword argument, so you don't actually need this for the line of code to run.)  2min"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Plotting code here.  \n",
    "fig, (ax1, ax2) = plt.subplots(1,2, figsize=(12,6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Now, let's remind ourselves of plotting in 3-d.  You will have particle trajectories in 3-d.\n",
    "- For this, you will need to separately initiate the figure `fig`, \n",
    "- Then you will need to get an axis on that figure that you specify as a 3-d projection\n",
    "- Note, here we use the plt.gca() method, which is gca=\"Get Current Axis\"\n",
    "- Then, we need the key word argument projection='3d' to tell the method **how** to get that axis (as a projection)\n",
    "\n",
    "####  Try executing the below code, and modify the arguments to view_init to see how that changes (1min).   \n",
    "#### You can now plot $\\theta$, $\\phi$, and $\\sin(\\theta)+\\cos(\\phi)$ on the same axis.  Plot all three below.  (1 min)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure() # you can specify figsize as a kwarg here\n",
    "ax = plt.gca(projection='3d')\n",
    "ax.view_init(60,-75)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basics of \"control flow\" 5 min\n",
    "- booleans (?!) 2min\n",
    "- if, elif, else statements 2min\n",
    "- while 1min"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Let's do a brief review of booleans (true false statements)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "example_booleans = [(1 > 2), (1 <= 2), (4 == 5), (4 != 5)]  # List of boolean statements\n",
    "for example_boolean in example_booleans :\n",
    "    print(example_boolean)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Booleans in if/else statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for example_boolean in example_booleans :\n",
    "    if example_boolean :\n",
    "        print('I am True!!!')\n",
    "    else :\n",
    "        print('I am not True :-/')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Values (numbers or strings of text) can be treated as True/False also. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "values_to_check = [1, 0, 'string as my boolean', 100]\n",
    "for value in values_to_check :\n",
    "    if value :\n",
    "        print(value, \" counts as True\")\n",
    "    else :\n",
    "        print(value, \" counts as False\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use elif to check for additional statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for value in values_to_check :\n",
    "    if type(value) == str :  # str is a \"string\" type in python.  Essentially, a string of characters.\n",
    "        print('I found a string!  It is: ', value)\n",
    "    elif value :\n",
    "        print(value, \" counts as True\")\n",
    "    else :\n",
    "        print(value, \" counts as False\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### In the cell below, write a modified if/elif/else statement that prints when you find a 100.  2 min"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Modified if/elif/else here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Once you understand if/elif/else statements, other aspects of control flow are easier to follow. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array slicing 5 min\n",
    "- In the past, we looked at the time evolution of **single dimensional quantities** such as current, charge, or voltage drops.  \n",
    "- For HW 7, you will need to look at the time evolution of **three dimensional quantities**, such as the position and velocity of a charged particle.\n",
    "- You can either treat this as 3 single dimensional quantities, or one three dimensional quantity.  The latter makes cleaner code for doing something like taking the vector norm, or doing a dot product."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Array slicing for 3-d (for x, y, z arrays)\n",
    "num_timesteps = 1000\n",
    "position_evolution = np.zeros([num_timesteps,3])\n",
    "print(position_evolution.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The variable position_evolution has shape of 1000x3.  This can hold the x, y, z positions for 1000 timesteps.   Currently, they are just filled with zeros.  In the cell below, write how you might set the y position to $y=1$ at all timesteps (you happen to be traveling parallel to the zx plane), and plot the y position as a function of timestep."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Example code to set the y position at all timesteps, and plot only the y position vs. timesteps \n",
    "#    This should look like a straight line.... you are at the same y position at all times.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy tools for HW 7 5min\n",
    "- dot\n",
    "- linalg.norm\n",
    "- crossproduct\n",
    "\n",
    "\n",
    "#### You've tested out how to use crossproduct in an exercise above.  Now, let's see how the numpy method linalg.norm works.  You should be able to do this in one line for all timesteps.  Take a look at the  documentation on google or the built-in help method to figure out how to find the distance of all positions at each timestep from the origin.   This illustrates the use of the keyword argument `axis`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code here"
   ]
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}