brownian-assignment-template.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Template Jupyter notebook for 2D Brownian motion assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This Jupyter notebook is a template for the Brownian motion assignment for CHY1610. See the lecture material on Canvas for an introduction to this topic and an overview of this notebook. Some important points:\n",
    "* Do not stray too far from the set up in this notebook. E.g. use the function names and arguments suggested below, and do not add too many new cells. Ask if this is unclear.\n",
    "* We covered many of the important concepts that you'll need here, e.g. for loops and function calls in the earlier Workshops. I will be going through some of the assignment solutions in the final workshops.\n",
    "* In this assignment, make use of comments (#) and/or markdown cells to explain what your code is doing. Look back over the advice in Workshop 1 for variable names. The clarity of your code will be an important marking criterion (see Canvas for the others).\n",
    "* As before, remember to save and backup your notebook as you work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import some external libraries.\n",
    "# We have met all of these during the course.\n",
    "\n",
    "import math\n",
    "import random\n",
    "import pylab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Investigate behaviour of random.\n",
    "# Produces random number between 0 and 1.\n",
    "# Different random number each time it is called.\n",
    "\n",
    "rand_num = random.random()\n",
    "print(rand_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's begin by defining some functions that we'll make extensive use of later. The first one is used to calculate the distance between the origin and a single point in 2D space. This will be useful for calculating the distance the particle travels in a single step (and also overall) during the random walk. Your function should take as input two arguments (the 2D coordinates x,y) and return the distance of that point from the origin (0,0):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def norm(x, y):\n",
    "    \"\"\"Returns the distance (norm) of a point in 2D from the origin\"\"\"\n",
    "    # insert your code here:\n",
    "\n",
    "    return(norm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, write a function to take a step in a random direction in 2D space. The input arguments should be the initial coordinates (x,y) and the length of the step to take. The output should be the final coordinates (x,y)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def brownian(x, y, step):\n",
    "    \"\"\"Updates the x,y coordinates of a particle. Takes a \n",
    "    step (of length 'step') in a random direction.\"\"\"\n",
    "    # Insert your code here:\n",
    "    \n",
    "\n",
    "    return(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Getting the above functions correct is tricky, but crucial to the rest of our code. So let's check that the brownian function is working as expected. The test below sets the initial x,y coordinates to zero, and then takes a step of length 10 (using your brownian function above). We can then measure the distance of the new x,y coordinates from the origin, and check that the distance moved is the same as the expected step length. Note that if your function passes, the code below will not produce any error message when you run it. **Make sure your functions pass this test before continuing (ask for help if needed).**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_brownian():\n",
    "    \"\"\"Test for function brownian(x,y,step)\"\"\"\n",
    "    # initial x,y coordinates\n",
    "    x = 0.0\n",
    "    y = 0.0\n",
    "    # let's try taking a step of length 10\n",
    "    expected_step_length = 10\n",
    "    # use your brownian function to take a step\n",
    "    x, y = brownian(x, y, expected_step_length)\n",
    "    # use your norm function to calculate the distance moved\n",
    "    observed_step_length = norm(x, y)\n",
    "    # check that the distance moved from the origin is \n",
    "    # the same as the expected step length\n",
    "    assert int(observed_step_length) == expected_step_length, \\\n",
    "    'the observed step length is not as expected'\n",
    "    \n",
    "test_brownian()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 1. Single walk\n",
    "\n",
    "Begin by plotting the trajectory of a single random walk. Use a step length of 1 with a random direction in the x,y plane. Start at the origin (x = y = 0) and take a total of 1000 steps. Plot the trajectory of the walk in pylab, and highlight the start and end points (you do not need to save the plot to a file). Calculate the overall displacement (i.e. the distance in a straight line between the start and end points). **You will need to make use of both the functions we defined above, and a for loop to iterate over the number of steps.** Use a markdown cell to comment on your plot in relation to the scientific problem (Brownian motion in 2D)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "step = 1 # step length\n",
    "num_steps = 1000 # number of steps\n",
    "\n",
    "# starting coordinates\n",
    "x = 0.0\n",
    "y = 0.0\n",
    "\n",
    "# lists to store x,y positions at each step\n",
    "# make sure they are initialised with the first point\n",
    "xdata = [x]\n",
    "ydata = [y]\n",
    "\n",
    "# insert your code here:\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2. Test of Brownian motion equation\n",
    "\n",
    "We expect (see lecture material):\n",
    "\n",
    "$MSD = NL^2$\n",
    "\n",
    "where $MSD$ is the mean square displacement of the particle, $N$ is the number of steps taken, and $L$ is the step length. Show that this equation holds by computing $MSD$ for a range of different values of $N$. Plot $MSD$ against $N$ in pylab, and confirm that the gradient is as expected (for your chosen value of $L$).\n",
    "\n",
    "*Hint: note that since we are modelling a random process this equation only holds **on average**. If you only run a single experiment for each value of $N$ there will be significant scatter, so you will need to run many experiments (making use of loops, not by hand!).*\n",
    "\n",
    "Use a markdown cell to comment on the convergence and accuracy of your simulation in comparison to the expected result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# initialise a few variables, you will need to\n",
    "# choose sensible inputs:\n",
    "\n",
    "step =  # your step size, L\n",
    "steps = [] # list storing the number of steps, N, to be taken\n",
    "num_experiments =  # number of walks to compute for each value of N\n",
    "\n",
    "# insert your code here:\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}