2.b Hard disks simulation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# *2D Hard Sphere (Hard Disk) Problem*\n",
    "`Doruk Efe Gökmen -- 26/07/2018 -- Ankara`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Event Driven Hard Disks Simulation (Molecular Dynamics Simulation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Solves the Newtonian dynamics of a 4 hard disk system exactly. Spheres move in straight lines between collisions and the collision events are calculated by finding the minimum of 6 time values until the walls and the other disks.\n",
    "\n",
    "Note that this algorithm is exact assuming that the numbers for the velocity and the times are calculated with infinite precision. However this is not the case for computers where the numbers are truncated at a finite value. By definition, chaotic systems are characterised by the vas differences in the final states despite having only marginal differences in their initial conditions. Therefore, although the numbers calculated by the molecular dynamics algorithm have millions of digits, the simulation is valid only for a limited number of iterations. (The chaoticity of the system is caused by the negative curvature of the surface of the disk.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/envs/python2/lib/python2.7/site-packages/IPython/core/magics/pylab.py:161: UserWarning: pylab import has clobbered these variables: ['random']\n",
      "`%matplotlib` prevents importing * from pylab and numpy\n",
      "  \"\\n`%matplotlib` prevents importing * from pylab and numpy\"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Producing animation.gif using ImageMagick...\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "32512"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%pylab qt\n",
    "import os, math, pylab\n",
    "\n",
    "output_dir = \"event_disks_box_movie\"\n",
    "colors = ['r', 'b', 'g', 'orange']\n",
    "\n",
    "def wall_time(pos_a, vel_a, sigma):\n",
    "    if vel_a > 0.0:\n",
    "        del_t = (1.0 - sigma - pos_a) / vel_a\n",
    "    elif vel_a < 0.0:\n",
    "        del_t = (pos_a - sigma) / abs(vel_a)\n",
    "    else:\n",
    "        del_t = float('inf')\n",
    "    return del_t\n",
    "\n",
    "def pair_time(pos_a, vel_a, pos_b, vel_b, sigma):\n",
    "    del_x = [pos_b[0] - pos_a[0], pos_b[1] - pos_a[1]]\n",
    "    del_x_sq = del_x[0] ** 2 + del_x[1] ** 2\n",
    "    del_v = [vel_b[0] - vel_a[0], vel_b[1] - vel_a[1]]\n",
    "    del_v_sq = del_v[0] ** 2 + del_v[1] ** 2\n",
    "    scal = del_v[0] * del_x[0] + del_v[1] * del_x[1]\n",
    "    Upsilon = scal ** 2 - del_v_sq * (del_x_sq - 4.0 * sigma ** 2)\n",
    "    if Upsilon > 0.0 and scal < 0.0:\n",
    "        del_t = - (scal + math.sqrt(Upsilon)) / del_v_sq\n",
    "    else:\n",
    "        del_t = float('inf')\n",
    "    return del_t\n",
    "\n",
    "def min_arg(l):\n",
    "    return min(zip(l, range(len(l))))\n",
    "\n",
    "def compute_next_event(pos, vel):\n",
    "    wall_times = [wall_time(pos[k][l], vel[k][l], sigma) for k, l in singles]\n",
    "    pair_times = [pair_time(pos[k], vel[k], pos[l], vel[l], sigma) for k, l in pairs]\n",
    "    return min_arg(wall_times + pair_times)\n",
    "\n",
    "def compute_new_velocities(pos, vel, next_event_arg):\n",
    "    if next_event_arg < len(singles):\n",
    "        collision_disk, direction = singles[next_event_arg]\n",
    "        vel[collision_disk][direction] *= -1.0\n",
    "    else:\n",
    "        a, b = pairs[next_event_arg - len(singles)]\n",
    "        del_x = [pos[b][0] - pos[a][0], pos[b][1] - pos[a][1]]\n",
    "        abs_x = math.sqrt(del_x[0] ** 2 + del_x[1] ** 2)\n",
    "        e_perp = [c / abs_x for c in del_x]\n",
    "        del_v = [vel[b][0] - vel[a][0], vel[b][1] - vel[a][1]]\n",
    "        scal = del_v[0] * e_perp[0] + del_v[1] * e_perp[1]\n",
    "        for k in range(2):\n",
    "            vel[a][k] += e_perp[k] * scal\n",
    "            vel[b][k] -= e_perp[k] * scal\n",
    "\n",
    "pylab.subplots_adjust(left=0.10, right=0.90, top=0.90, bottom=0.10)\n",
    "pylab.gcf().set_size_inches(6, 6)\n",
    "img = 0\n",
    "if not os.path.exists(output_dir): os.makedirs(output_dir)\n",
    "def snapshot(t, pos, vel, colors, arrow_scale=.2):\n",
    "    global img\n",
    "    pylab.cla()\n",
    "    pylab.axis([0, 1, 0, 1])\n",
    "    pylab.setp(pylab.gca(), xticks=[0, 1], yticks=[0, 1])\n",
    "    for (x, y), (dx, dy), c in zip(pos, vel, colors):\n",
    "        dx *= arrow_scale\n",
    "        dy *= arrow_scale\n",
    "        circle = pylab.Circle((x, y), radius=sigma, fc=c)\n",
    "        pylab.gca().add_patch(circle)\n",
    "        pylab.arrow( x, y, dx, dy, fc=\"k\", ec=\"k\", head_width=0.05, head_length=0.05 )\n",
    "    pylab.text(.5, 1.03, 't = %.2f' % t, ha='center')\n",
    "    pylab.savefig(os.path.join(output_dir, '%04i.png' % img))\n",
    "    pylab.pause(0.00001)\n",
    "    pylab.show()\n",
    "    img += 1\n",
    "\n",
    "pos = [[0.25, 0.25], [0.75, 0.25], [0.25, 0.75], [0.75, 0.75]]\n",
    "vel = [[0.21, 0.12], [0.71, 0.18], [-0.23, -0.79], [0.78, 0.1177]]\n",
    "singles = [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (3, 0), (3, 1)]\n",
    "pairs = [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]\n",
    "sigma = 0.15\n",
    "t = 0.0\n",
    "dt = 0.02     # dt=0 corresponds to event-to-event animation\n",
    "n_steps = 100\n",
    "next_event, next_event_arg = compute_next_event(pos, vel)\n",
    "snapshot(t, pos, vel, colors)\n",
    "for step in range(n_steps):\n",
    "    pylab.clf()\n",
    "    if dt:\n",
    "        next_t = t + dt\n",
    "    else:\n",
    "        next_t = t + next_event\n",
    "    while t + next_event <= next_t:\n",
    "        t += next_event\n",
    "        for k, l in singles: pos[k][l] += vel[k][l] * next_event\n",
    "        compute_new_velocities(pos, vel, next_event_arg)\n",
    "        next_event, next_event_arg = compute_next_event(pos, vel)\n",
    "    remain_t = next_t - t\n",
    "    for k, l in singles: pos[k][l] += vel[k][l] * remain_t\n",
    "    t += remain_t\n",
    "    next_event -= remain_t\n",
    "    snapshot(t, pos, vel, colors)\n",
    "    #print 'time',t\n",
    "\n",
    "print('Producing animation.gif using ImageMagick...')\n",
    "os.system(\"convert -delay 1 -dispose Background +page \" + str(output_dir)\n",
    "          + \"/*.png -loop 0 \" + str(output_dir) + \"/animation.gif\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Direct Sampling Hard Disks\n",
    "By Boltzmann's equiprobability hypothesis and ergodic hypothesis, given infinite time, the system explores all of its possible configurations with equal probability. This key idea leads to the following algorithm that samples possible configurations of 4 hard disk system through direct sampling. For an infinitely large sampling, the resulting frames of the system constitute a \"time scrambled\" version of the actual dynamics of the system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "%pylab qt\n",
    "import random, math, os, pylab\n",
    "\n",
    "output_dir = 'direct_disks_box_movie'\n",
    "\n",
    "def direct_disks_box(N, sigma):\n",
    "    condition = False\n",
    "    while condition == False:\n",
    "        L = [(random.uniform(sigma, 1.0 - sigma), random.uniform(sigma, 1.0 - sigma))]\n",
    "        for k in range(1, N):\n",
    "            a = (random.uniform(sigma, 1.0 - sigma), random.uniform(sigma, 1.0 - sigma))\n",
    "            min_dist = min(math.sqrt((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2) for b in L) \n",
    "            if min_dist < 2.0 * sigma: \n",
    "                condition = False\n",
    "                break\n",
    "            else:\n",
    "                L.append(a)\n",
    "                condition = True\n",
    "    return L\n",
    "\n",
    "img = 0\n",
    "if not os.path.exists(output_dir): os.makedirs(output_dir)\n",
    "def snapshot(pos, colors):\n",
    "    global img\n",
    "    pylab.subplots_adjust(left=0.10, right=0.90, top=0.90, bottom=0.10)\n",
    "    pylab.gcf().set_size_inches(6, 6)\n",
    "    pylab.axis([0, 1, 0, 1])\n",
    "    pylab.setp(pylab.gca(), xticks=[0, 1], yticks=[0, 1])\n",
    "    for (x, y), c in zip(pos, colors):\n",
    "        circle = pylab.Circle((x, y), radius=sigma, fc=c)\n",
    "        pylab.gca().add_patch(circle)\n",
    "    #pylab.savefig(os.path.join(output_dir, '%d.png' % img), transparent=True)\n",
    "    pylab.pause(0.01)\n",
    "    pylab.show()\n",
    "    img += 1\n",
    "\n",
    "N = 4 #the number of disks\n",
    "colors = ['r', 'b', 'g', 'orange']\n",
    "sigma = 0.2 #the radii of the disks\n",
    "n_runs = 8\n",
    "for run in range(n_runs):\n",
    "    pos = direct_disks_box(N, sigma)\n",
    "    snapshot(pos, colors)\n",
    "    pylab.clf()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Direct sampling with periodic boundary conditions. Notice that for $N=16$ disks of radii $\\sigma=\\sqrt{\\frac{\\eta}{\\pi N}}$, where $\\eta=0.26$ is the density of the disks, it is found that it usually occurred thousands of rejections before producing a legitimate configuration! It turns out that the acceptance ratio in the case of $\\eta=0.3$ and $N=16$, the acceptance ratio $p_{\\text{acceptance}}=5\\times 10^{-6}$. The accepted cases strictly characterise the portion of the $32$-dimensional configuration space that corresponds to the $16$ hard disk system. In other words, the rejection probability can be used to calculate the partition function $Z(\\eta)$ of the system.\n",
    "\n",
    "For a $2$-D box of volume V, the $32$-dimensional configuration space has the volume $V^{16}$. If the radius of the disk is $\\sigma=0 \\implies \\eta=0$, i.e. the density of the box is $0$, then all the points of the configuration space are legal configurations of the system. Hence the partition function of that system is $Z(N,\\eta=0)=V^N$. On the other hand $Z(N,\\eta)=Z(N,\\eta=0)p_{\\text{acceptance}}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n",
      "run 0\n",
      "30036 tabula rasa wipe-outs before producing the following configuration\n",
      "[(0.5290863088869059, 0.026602165942082534), (0.7068861913834033, 0.841765426057141), (0.350246769636395, 0.5691655942222656), (0.5645476848710024, 0.25386832218349087), (0.04798050921429031, 0.35387875591009954), (0.7908119383793827, 0.016254686601902435), (0.9999214172719869, 0.4952435341395388), (0.14324225234241617, 0.7544997761130654), (0.790845238067139, 0.6926598186347003), (0.6603863557473032, 0.424173085826433), (0.5231276402387884, 0.7180344838877797), (0.3431909675284315, 0.025476194822818043), (0.34948072471303104, 0.3231388243348168), (0.958008437682202, 0.7639663257620449), (0.8479799683835139, 0.35298926296288435), (0.2538594432886999, 0.18606330998718656)]\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "run 1\n",
      "16547 tabula rasa wipe-outs before producing the following configuration\n",
      "[(0.820775802536151, 0.6382203875836991), (0.4994876147259021, 0.6944488152203134), (0.8262359021855195, 0.015628632683440946), (0.9371208419822434, 0.8968165824312339), (0.17126203609104784, 0.5847827680049164), (0.14538249802057335, 0.8095048871852456), (0.6514025090157548, 0.24049746233092262), (0.8444344838268607, 0.3206571424503102), (0.4309482077730372, 0.4158203150383223), (0.6118328659936254, 0.4489655140103994), (0.26674751156518983, 0.07280573592629969), (0.3367265167647999, 0.5685097793003173), (0.44624884853100755, 0.8332232581634768), (0.6291172175885347, 0.903243985050751), (0.30286450459953096, 0.29800677302308276), (0.7924321388459232, 0.7967320275977108)]\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "run 2\n",
      "7516 tabula rasa wipe-outs before producing the following configuration\n",
      "[(0.997011476912311, 0.23823009873908463), (0.20621709483185124, 0.5891035784239245), (0.10118350467709525, 0.07907699087981945), (0.4716465280346849, 0.417454687405741), (0.4678218946283592, 0.7141723043275596), (0.3147159813855247, 0.7210526639527041), (0.9952703671930787, 0.6922178099114037), (0.35585010258529315, 0.5649069148664847), (0.6609343694723954, 0.5163412127065151), (0.5608111707904527, 0.2627446089358014), (0.24357655441213055, 0.9462511646654779), (0.28150850754722967, 0.3405060330435056), (0.9018256207654266, 0.10565325251846991), (0.6224147643203051, 0.6670379720594759), (0.5510108953783537, 0.0866724260029228), (0.7678616786480671, 0.9479731188795825)]\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "run 3\n",
      "26138 tabula rasa wipe-outs before producing the following configuration\n",
      "[(0.9434199654999524, 0.15218440298230407), (0.09745669212185293, 0.6460152193667532), (0.27098153940391645, 0.2922309691987671), (0.3188707740561313, 0.5554249964405475), (0.7312006374701823, 0.7166516747159463), (0.15511726616813903, 0.14901876055716923), (0.9306327850845793, 0.5145610011161166), (0.3417698978206465, 0.7565287669956946), (0.5230768300029479, 0.6176798382811663), (0.5923745591850242, 0.3794954882057897), (0.501353747848843, 0.7822898246983823), (0.37901538349632535, 0.12374150475647527), (0.002423264837273287, 0.3230211686176111), (0.20415136567818648, 0.8777440359462632), (0.8520738693427051, 0.8339903634866587), (0.8022041186441675, 0.05433996145526898)]\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "run 4\n",
      "6084 tabula rasa wipe-outs before producing the following configuration\n",
      "[(0.7590878221547396, 0.38609759080933814), (0.7785486579710811, 0.5892174114517533), (0.5732064268778967, 0.3005173238565446), (0.5168950312242604, 0.7537428959811848), (0.4195615209396405, 0.9178446574429164), (0.20762995655358862, 0.5829254689199423), (0.765030883264898, 0.8155794809216419), (0.33782792836027997, 0.33804887534482286), (0.16593128400739898, 0.9556577252452482), (0.1015162527233131, 0.3432614494975966), (0.20573498888013464, 0.7501051776901527), (0.9916406419116316, 0.5596533897780842), (0.4981527878862717, 0.4537827964280835), (0.6059255756849841, 0.10226042014195891), (0.13771319471837562, 0.15787588170708022), (0.38774080885250817, 0.16451894627990304)]\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%pylab inline\n",
    "import random, math, pylab, os\n",
    "\n",
    "#Introduce the periodic boundary conditions via the modular distance function between two 2D vectors x, y:\n",
    "def dist(x,y):\n",
    "    d_x = abs(x[0] - y[0]) % 1.0 #distance between the first compononents of two vectors in modulo 1\n",
    "    d_x = min(d_x, 1.0 - d_x) #the modular distance is the minimum of cases due to periodicity\n",
    "    d_y = abs(x[1] - y[1]) % 1.0 #distance between the second compononents of two vectors in modulo 1\n",
    "    d_y = min(d_y, 1.0 - d_y)\n",
    "    return  math.sqrt(d_x**2 + d_y**2) #returns the modular distance\n",
    "    \n",
    "def direct_disks(N, sigma): #constructs a legal sample in the 2N-dimensional unit hypercube\n",
    "    n_iter = 0\n",
    "    condition = False\n",
    "    while condition == False:\n",
    "        n_iter += 1 #increases in the case of failure to find non-overlapping disk coordinates\n",
    "        L = [(random.random(), random.random())] #random vector in 2N-dimensional hypercube\n",
    "        for k in range(1, N):\n",
    "            a = (random.random(), random.random()) #random vector in the 2D square\n",
    "            min_dist = min(dist(a, b) for b in L) #minimum of the distances between any two disks\n",
    "    #if the modular distance between any two disks is less than their radii, then breaks and tries again\n",
    "            if min_dist < 2.0 * sigma:\n",
    "                condition = False\n",
    "                break\n",
    "            else:\n",
    "                L.append(a) #if no overlap occurs, then adds a new disk with coordinates a to the system\n",
    "                condition = True\n",
    "    return n_iter, L #the number of iterations required to find a legal configuration and its coordinates\n",
    "\n",
    "img = 0\n",
    "output_dir = 'direct_disks_multirun_movie'\n",
    "if not os.path.exists(output_dir): os.makedirs(output_dir)\n",
    "def snapshot(pos, colors, border_color = 'k'):\n",
    "    global img\n",
    "    pylab.figure()\n",
    "    pylab.axis([0, 1, 0, 1])\n",
    "    [i.set_linewidth(2) for i in pylab.gca().spines.itervalues()]\n",
    "    [i.set_color(border_color) for i in pylab.gca().spines.itervalues()]\n",
    "    pylab.setp(pylab.gca(), xticks = [0, 1], yticks = [0, 1], aspect = 'equal')\n",
    "    for (x, y), c in zip(pos, colors):\n",
    "        circle = pylab.Circle((x, y), radius = sigma, fc = c)\n",
    "        pylab.gca().add_patch(circle)\n",
    "    pylab.savefig(output_dir+'/snapshot_%03i.png'%img)\n",
    "    pylab.pause(0.001)\n",
    "    pylab.close()\n",
    "    img += 1\n",
    "\n",
    "def periodicize(config):\n",
    "    images = [-1.0, 0.0, 1.0]\n",
    "    return [(x + dx, y + dy) for (x,y) in config for dx in images for dy in images]\n",
    "\n",
    "N = 16 #the number of the disks\n",
    "eta = 0.26 #the disk density of the system (fraction of space occupied by the disks)\n",
    "sigma = math.sqrt(eta / N / math.pi) #the radii of the disks\n",
    "n_runs = 5 #number of runs\n",
    "colors = ['r' for i in range(8 * N)]\n",
    "for run in range(n_runs):\n",
    "    pylab.clf()\n",
    "    iterations, config =  direct_disks(N, sigma)\n",
    "    print 'run',run\n",
    "    print iterations - 1, 'tabula rasa wipe-outs before producing the following configuration'\n",
    "    print config\n",
    "    print \n",
    "    config_per = periodicize(config)\n",
    "    snapshot(config_per, colors, border_color = 'k')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The acceptance probability $p_{\\text{acceptance}}(\\eta)$ is calculated by the following code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%pylab inline\n",
    "import random, math, pylab\n",
    "\n",
    "def dist(x, y): #periodic boundary conditions as before\n",
    "    d_x = abs(x[0] - y[0]) % 1.0\n",
    "    d_x = min(d_x, 1.0 - d_x)\n",
    "    d_y = abs(x[1] - y[1]) % 1.0\n",
    "    d_y = min(d_y, 1.0 - d_y)\n",
    "    return  math.sqrt(d_x**2 + d_y**2)\n",
    "    \n",
    "N = 16 #number of disks\n",
    "n_confs = 10 ** 5 #number of configurations\n",
    "pairs = [(i, j) for i in range(N - 1) for j in range(i + 1, N)]\n",
    "eta_max_list = [] #initialise the allowed maximum densities\n",
    "for conf in xrange(n_confs):\n",
    "    #sample a random configuration -- overlapping/non-overlapping\n",
    "    #i.e. pick a random vector in 2N-D unit hypercube\n",
    "    L = [(random.random(), random.random()) for k in range(N)]\n",
    "    #determine the maximum possible radius so that any of the two disks in the configuration overlap\n",
    "    sigma_max = min(dist(L[i], L[j]) for i, j in pairs) / 2.0 \n",
    "    eta_max = N * math.pi * sigma_max ** 2 #calculate the corresponding maximum density\n",
    "    eta_max_list.append(eta_max)\n",
    "    #The histogram of these maximum densities corresponds to the acceptance probability!\n",
    "\n",
    "# Begin of graphics output\n",
    "pylab.figure()\n",
    "n, bins, patches = pylab.hist(eta_max_list, 100, histtype='step', cumulative=-1, \n",
    "                   log=True, normed=True, label=\"numerical evaluation of $p_{accept}$\")\n",
    "explaw = [math.exp( - 2.0 * (N - 1) * eta) for eta in bins] #first term in Virial expansion\n",
    "pylab.plot(bins, explaw, 'r--', linewidth=1.5, label=\"1st order virial expansion\")\n",
    "pylab.xlabel('density \\eta')\n",
    "pylab.ylabel('$p_{accept}(\\eta)$')\n",
    "pylab.legend()\n",
    "pylab.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Markov-Chain Sampling Hard Disks\n",
    "Direct sampling for hard disks works only at low densities and small particle numbers, and we thus switch to a more general Markov-chain Monte Carlo algorithm. Similar approach as direct sampling but this time the sampling is done through the Markov-chains, i.e. the location of a particular disk is updated from where it was at the previous frame. The rejection cases are the cases where any two of the disks overlap. The necessary conditions are aperiodicity and irreducibility. Aperiodicity is trivial in this case. Here, reducibility corresponds to the case where the radii of the disks are so large, so that they stuck and vibrate at their initial locations. There, the system can be reduced into four independent systems. Hence, irreducibility is a condition on the size of the radii of the disks.\n",
    "\n",
    "There is a link between the acceptance probability of the system and the partition function as seen in the previous section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x864 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%pylab qt\n",
    "import random, os, pylab\n",
    "\n",
    "output_dir = 'markov_disks_box_movie'\n",
    "\n",
    "img = 0\n",
    "if not os.path.exists(output_dir): os.makedirs(output_dir)\n",
    "def snapshot(pos, colors):\n",
    "    global img\n",
    "    pylab.subplots_adjust(left=0.10, right=0.90, top=0.90, bottom=0.10)\n",
    "    pylab.gcf().set_size_inches(6, 6)\n",
    "    pylab.axis([0, 1, 0, 1])\n",
    "    pylab.setp(pylab.gca(), xticks=[0, 1], yticks=[0, 1])\n",
    "    for (x, y), c in zip(pos, colors):\n",
    "        circle = pylab.Circle((x, y), radius=sigma, fc=c)\n",
    "        pylab.gca().add_patch(circle)\n",
    "    #pylab.savefig(os.path.join(output_dir, '%d.png' % img), transparent=True)\n",
    "    pylab.pause(0.0001)\n",
    "    pylab.show()\n",
    "    img += 1\n",
    "\n",
    "L = [[0.25, 0.25], [0.75, 0.25], [0.25, 0.75], [0.75, 0.75]] #initial positions of the disks\n",
    "sigma = 0.15 #the radii of disks\n",
    "sigma_sq = sigma ** 2\n",
    "delta = 0.1\n",
    "colors = ['r', 'b', 'g', 'orange']\n",
    "n_steps = 50\n",
    "for step in range(n_steps):\n",
    "    pylab.clf()\n",
    "    snapshot(L, colors)\n",
    "    a = random.choice(L)\n",
    "    b = [a[0] + random.uniform(-delta, delta), a[1] + random.uniform(-delta, delta)]\n",
    "    min_dist = min((b[0] - c[0]) ** 2 + (b[1] - c[1]) ** 2 for c in L if c != a) \n",
    "    box_cond = min(b[0], b[1]) < sigma or max(b[0], b[1]) > 1.0 - sigma\n",
    "    if not (box_cond or min_dist < 4.0 * sigma ** 2):\n",
    "        a[:] = b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The \"tabula rasa\" strategy explained:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0.3029469955941781, 0.7670627214525076), (0.7129377088143414, 0.7693773660570689), (0.32291343374765724, 0.2737530107568247), (0.7867778045636022, 0.25558665751782333)]\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "N = 4\n",
    "sigma = 0.2 #the radii of disks\n",
    "pairs = [(i, j) for i in range(N - 1) for j in range(i + 1, N)]\n",
    "while True:\n",
    "    #place four disks at randomly chosen positions: uniform vector in an 8D hypercube\n",
    "    L = [(random.uniform(sigma, 1.0 - sigma), random.uniform(sigma, 1.0 - sigma)) for k in range(N)]\n",
    "    #check for an overlap between the disks by calculating the distance in between all disks\n",
    "    if  min((L[i][0] - L[j][0]) ** 2 + (L[i][1] - L[j][1]) ** 2 for i, j in pairs) > 4.0 * sigma ** 2: \n",
    "        break #if overlap occurs, the algorithm breaks\n",
    "print L #Sample coordinates of the four disks are outputted"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On the other hand, it is crucial to note that *random sequential deposition* is forbidden since it yields inequal probabilities. The following example illustrates this in a 1D discrete example where two rods are placed on a grid of size 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n",
      "a 0.1\n",
      "c 0.2\n",
      "b 0.0\n",
      "e 0.0\n",
      "d 0.4\n",
      "f 0.3\n"
     ]
    }
   ],
   "source": [
    "%pylab qt\n",
    "import random, pylab, os\n",
    "\n",
    "output_dir = 'random_sequential_discrete_movie'\n",
    "if not os.path.exists(output_dir): os.makedirs(output_dir)\n",
    "def show_rods(red_rod, blue_rod, run, trial, frame):\n",
    "    fig, ax = pylab.subplots()\n",
    "    ax.set_xticks([0, 1, 2, 3, 4])\n",
    "    ax.set_yticks([])\n",
    "    height = 1.0\n",
    "    redrect = pylab.Rectangle((red_rod - 1.5, 0.0), 3.0, 1.1 * height,  fc = 'r')\n",
    "    pylab.gca().add_patch(redrect)\n",
    "    bluerect = pylab.Rectangle((blue_rod-1.5,0.0), 3.0, height,  fc = 'b')\n",
    "    pylab.gca().add_patch(bluerect)\n",
    "    pylab.axis('scaled')\n",
    "    pylab.axis([-1.5, 5.5, 0.0, 2.5*height])\n",
    "    pylab.xlabel(\"x\")\n",
    "    if abs(red_rod - blue_rod) > 2:\n",
    "        pylab.title('run %d, trial %d (ACCEPTED!)' % (run, trial))\n",
    "    else:\n",
    "        pylab.title('run %d, trial %d (REJECTED!)' % (run, trial))\n",
    "    pylab.savefig(output_dir+'/random_sequential_discrete_frame%04i.png' % (frame))\n",
    "    pylab.pause(0.0001)\n",
    "    pylab.close()\n",
    "\n",
    "configurations = {(0, 3): 'a', (0, 4): 'b', (1, 4): 'c', \n",
    "                  (3, 0): 'd', (4, 0): 'e', (4, 1): 'f'}\n",
    "counts = {'a': 0, 'b': 0, 'c': 0, 'd': 0, 'e': 0, 'f': 0}\n",
    "n_runs = 10\n",
    "frame = 0\n",
    "trial = 0\n",
    "for run in range(n_runs):\n",
    "    pylab.clf()\n",
    "    red_rod = random.randint(0, 3)\n",
    "    if red_rod >= 2: red_rod += 1\n",
    "    trial = 0\n",
    "    while True:\n",
    "        blue_rod = random.randint(0, 4)\n",
    "        show_rods(red_rod, blue_rod, run, trial, frame)\n",
    "        trial += 1\n",
    "        frame += 1\n",
    "        if abs(red_rod - blue_rod) > 2: break\n",
    "    conf = configurations[(red_rod, blue_rod)]\n",
    "    counts[conf] += 1\n",
    "for conf in counts:\n",
    "    print conf, counts[conf] / float(n_runs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Equiprobability\n",
    "![caption](equiprob.png)\n",
    "\n",
    "Using small boxes [x - del_xy, x + del_xy], etc, we can show that the probability to sample the following \"marked\" configurations a, b, and c (given in the code) are the same (within the numerical precision), with the following codes for direct sampling, Markov-chain sampling, and simulation of Newtonian mechanics via the event driven algorithm."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Direct sampling:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((0.3, 0.3), (0.3, 0.7), (0.7, 0.3), (0.7, 0.7)) 110\n",
      "((0.2, 0.2), (0.2, 0.8), (0.75, 0.25), (0.75, 0.75)) 114\n",
      "((0.3, 0.2), (0.3, 0.8), (0.7, 0.2), (0.7, 0.7)) 115\n"
     ]
    }
   ],
   "source": [
    "import random, math\n",
    "def direct_disks_box(N, sigma): #same direct sampling as in the second section\n",
    "    condition = False\n",
    "    while condition == False:\n",
    "        L = [(random.uniform(sigma, 1.0 - sigma), random.uniform(sigma, 1.0 - sigma))]\n",
    "        for k in range(1, N):\n",
    "            a = (random.uniform(sigma, 1.0 - sigma), random.uniform(sigma, 1.0 - sigma))\n",
    "            min_dist = min(math.sqrt((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2) for b in L)\n",
    "            if min_dist < 2.0 * sigma:\n",
    "                condition = False\n",
    "                break\n",
    "            else:\n",
    "                L.append(a)\n",
    "                condition = True\n",
    "    return L\n",
    "\n",
    "sigma = 0.15 #radius\n",
    "del_xy = 0.05 #\"uncertainty\"\n",
    "n_runs = 1000000\n",
    "\n",
    "#Define the \"marked\" configurations:\n",
    "conf_a = ((0.30, 0.30), (0.30, 0.70), (0.70, 0.30), (0.70,0.70))\n",
    "conf_b = ((0.20, 0.20), (0.20, 0.80), (0.75, 0.25), (0.75,0.75))\n",
    "conf_c = ((0.30, 0.20), (0.30, 0.80), (0.70, 0.20), (0.70,0.70))\n",
    "configurations = [conf_a, conf_b, conf_c] #list the configurations\n",
    "\n",
    "hits = {conf_a: 0, conf_b: 0, conf_c: 0} #initialise the number of times each marked configuration occurs\n",
    "\n",
    "for run in range(n_runs):\n",
    "    x_vec = direct_disks_box(4, sigma) #generates a random sample by direct sampling\n",
    "    for conf in configurations: #run a loop iterating over the given 3 configurations\n",
    "    #condition that a randomly generated configuration L is the same as a, b or c up to uncertainty of del_xy\n",
    "        condition_hit = True\n",
    "        for b in conf: #run a loop iterating over the 4 disk coordinates in a specific configuration\n",
    "            #If the max(x distance and y distance between a disk in L and a disk in conf_a,b,c) \n",
    "            #is less than the given uncertainty del_xy, then we treat the two disks as in the same location.\n",
    "            #Note that the \"any two disks\" condition is realised by minimising over all 4 disks in a \n",
    "            #randomly sampled configuration L.\n",
    "            condition_b = min(max(abs(a[0] - b[0]), abs(a[1] - b[1])) for a in x_vec) < del_xy  \n",
    "            #The following logical variable is 1 only if there exists 4 disk pairs are within del_xy range.\n",
    "            #If at least any one of the disks does not have a pair within del_xy, then it is 0.\n",
    "            condition_hit *= condition_b #multiplies condition_b's (for all 4 disks)\n",
    "        #If the current L and a, b or c are the same up to uncertainty del_xy, then increase:\n",
    "        if condition_hit:\n",
    "            hits[conf] += 1\n",
    "\n",
    "for conf in configurations:\n",
    "    print conf, hits[conf] #Print the configurations and the number of times they occured."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Markov-chain sampling:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((0.3, 0.3), (0.3, 0.7), (0.7, 0.3), (0.7, 0.7)) 3\n",
      "((0.2, 0.2), (0.2, 0.8), (0.75, 0.25), (0.75, 0.75)) 1\n",
      "((0.3, 0.2), (0.3, 0.8), (0.7, 0.2), (0.7, 0.7)) 0\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "def markov_disks_box(L, delta, sigma):\n",
    "    condition = True\n",
    "    while condition == True:\n",
    "        a = random.choice(L)\n",
    "        b = [a[0] + random.uniform(-delta, delta), a[1] + random.uniform(-delta, delta)]\n",
    "        min_dist = min((b[0] - c[0]) ** 2 + (b[1] - c[1]) ** 2 for c in L if c != a)\n",
    "        box_cond = min(b[0], b[1]) < sigma or max(b[0], b[1]) > 1.0 - sigma\n",
    "        if not (box_cond or min_dist < 4.0 * sigma ** 2):\n",
    "            a[:] = b\n",
    "            condition = False\n",
    "            break\n",
    "    return L\n",
    "\n",
    "#inputs of the markov_disks_box function:\n",
    "#initial positions of the disks to startup the Markov-chain\n",
    "L = [[0.25, 0.25], [0.75, 0.25], [0.25, 0.75], [0.75, 0.75]] \n",
    "delta = 0.1\n",
    "sigma = 0.15 #radius\n",
    "\n",
    "n_steps = 10000\n",
    "del_xy = 0.05 #\"uncertainty\"\n",
    "\n",
    "#Define the \"marked\" configurations:\n",
    "conf_a = ((0.30, 0.30), (0.30, 0.70), (0.70, 0.30), (0.70,0.70))\n",
    "conf_b = ((0.20, 0.20), (0.20, 0.80), (0.75, 0.25), (0.75,0.75))\n",
    "conf_c = ((0.30, 0.20), (0.30, 0.80), (0.70, 0.20), (0.70,0.70))\n",
    "configurations = [conf_a, conf_b, conf_c] #list the configurations\n",
    "\n",
    "hits = {conf_a: 0, conf_b: 0, conf_c: 0} #initialise the number of times each marked configuration occurs\n",
    "\n",
    "for run in range(n_steps):\n",
    "    x_vec = markov_disks_box(L, delta, sigma) #generates a random sample by direct sampling\n",
    "    for conf in configurations: #run a loop iterating over the given 3 configurations\n",
    "    #condition that a randomly generated configuration L is the same as a, b or c up to uncertainty of del_xy\n",
    "        condition_hit = True\n",
    "        for b in conf: #run a loop iterating over the 4 disk coordinates in a specific configuration\n",
    "            #If the max(x distance and y distance between a disk in L and a disk in conf_a,b,c) \n",
    "            #is less than the given uncertainty del_xy, then we treat the two disks as in the same location.\n",
    "            #Note that the \"any two disks\" condition is realised by minimising over all 4 disks in a \n",
    "            #randomly sampled configuration L.\n",
    "            condition_b = min(max(abs(a[0] - b[0]), abs(a[1] - b[1])) for a in x_vec) < del_xy  \n",
    "            #The following logical variable is 1 only if there exists 4 disk pairs are within del_xy range.\n",
    "            #If at least any one of the disks does not have a pair within del_xy, then it is 0.\n",
    "            condition_hit *= condition_b #multiplies condition_b's (for all 4 disks)\n",
    "        #If the current L and a, b or c are the same up to uncertainty del_xy, then increase:\n",
    "        if condition_hit:\n",
    "            hits[conf] += 1\n",
    "\n",
    "for conf in configurations:\n",
    "    print conf, hits[conf] #Print the configurations and the number of times they occured."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Newtonian dynamics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "100000\n",
      "200000\n",
      "300000\n",
      "400000\n",
      "500000\n",
      "600000\n",
      "700000\n",
      "800000\n",
      "900000\n",
      "1000000\n",
      "1100000\n",
      "1200000\n",
      "1300000\n",
      "1400000\n",
      "1500000\n",
      "1600000\n",
      "1700000\n",
      "1800000\n",
      "1900000\n",
      "2000000\n",
      "2100000\n",
      "2200000\n",
      "2300000\n",
      "2400000\n",
      "2500000\n",
      "2600000\n",
      "2700000\n",
      "2800000\n",
      "2900000\n",
      "3000000\n",
      "3100000\n",
      "3200000\n",
      "3300000\n",
      "3400000\n",
      "3500000\n",
      "3600000\n",
      "3700000\n",
      "3800000\n",
      "3900000\n",
      "4000000\n",
      "4100000\n",
      "4200000\n",
      "4300000\n",
      "4400000\n",
      "4500000\n",
      "4600000\n",
      "4700000\n",
      "4800000\n",
      "4900000\n",
      "611527.898476\n",
      "((0.3, 0.3), (0.3, 0.7), (0.7, 0.3), (0.7, 0.7)) 668\n",
      "((0.2, 0.2), (0.2, 0.8), (0.75, 0.25), (0.75, 0.75)) 690\n",
      "((0.3, 0.2), (0.3, 0.8), (0.7, 0.2), (0.7, 0.7)) 655\n"
     ]
    }
   ],
   "source": [
    "import math, pylab\n",
    "\n",
    "def wall_time(pos_a, vel_a, sigma):\n",
    "    if vel_a > 0.0:\n",
    "        del_t = (1.0 - sigma - pos_a) / vel_a\n",
    "    elif vel_a < 0.0:\n",
    "        del_t = (pos_a - sigma) / abs(vel_a)\n",
    "    else:\n",
    "        del_t = float('inf')\n",
    "    return del_t\n",
    "\n",
    "def pair_time(pos_a, vel_a, pos_b, vel_b, sigma):\n",
    "    del_x = [pos_b[0] - pos_a[0], pos_b[1] - pos_a[1]]\n",
    "    del_x_sq = del_x[0] ** 2 + del_x[1] ** 2\n",
    "    del_v = [vel_b[0] - vel_a[0], vel_b[1] - vel_a[1]]\n",
    "    del_v_sq = del_v[0] ** 2 + del_v[1] ** 2\n",
    "    scal = del_v[0] * del_x[0] + del_v[1] * del_x[1]\n",
    "    Upsilon = scal ** 2 - del_v_sq * ( del_x_sq - 4.0 * sigma **2)\n",
    "    if Upsilon > 0.0 and scal < 0.0:\n",
    "        del_t = - (scal + math.sqrt(Upsilon)) / del_v_sq\n",
    "    else:\n",
    "        del_t = float('inf')\n",
    "    return del_t\n",
    "\n",
    "conf_a = ((0.30, 0.30), (0.30, 0.70), (0.70, 0.30), (0.70,0.70))\n",
    "conf_b = ((0.20, 0.20), (0.20, 0.80), (0.75, 0.25), (0.75,0.75))\n",
    "conf_c = ((0.30, 0.20), (0.30, 0.80), (0.70, 0.20), (0.70,0.70))\n",
    "configurations = [conf_a, conf_b, conf_c]\n",
    "hits = {conf_a: 0, conf_b: 0, conf_c: 0}\n",
    "del_xy = 0.10\n",
    "pos = [[0.25, 0.25], [0.75, 0.25], [0.25, 0.75], [0.75, 0.75]]\n",
    "vel = [[0.21, 0.12], [0.71, 0.18], [-0.23, -0.79], [0.78, 0.1177]]\n",
    "singles = [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (3, 0), (3, 1)]\n",
    "pairs = [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]\n",
    "sigma = 0.10\n",
    "t = 0.0\n",
    "n_events = 5000000\n",
    "for event in range(n_events):\n",
    "    if event % 100000 == 0:\n",
    "        print event\n",
    "    wall_times = [wall_time(pos[k][l], vel[k][l], sigma) for k, l  in singles]\n",
    "    pair_times = [pair_time(pos[k], vel[k], pos[l], vel[l], sigma) for k, l in pairs]\n",
    "    next_event = min(wall_times + pair_times)\n",
    "    t_previous = t\n",
    "    for inter_times in range(int(t + 1), int(t + next_event + 1)):\n",
    "        del_t = inter_times - t_previous\n",
    "        for k, l in singles:\n",
    "            pos[k][l] += vel[k][l] * del_t\n",
    "        t_previous = inter_times\n",
    "        #print t \"Configuration analysis is done\"\n",
    "        for conf in configurations:\n",
    "            condition_hit = True\n",
    "            for b in conf:\n",
    "                condition_b = min(max(abs(a[0] - b[0]), abs(a[1] - b[1])) for a in pos) < del_xy\n",
    "                condition_hit *= condition_b\n",
    "            if condition_hit:\n",
    "                hits[conf] += 1\n",
    "    t += next_event\n",
    "    del_t = t - t_previous\n",
    "    for k, l in singles:\n",
    "        pos[k][l] += vel[k][l] * del_t\n",
    "    if min(wall_times) < min(pair_times):\n",
    "        collision_disk, direction = singles[wall_times.index(next_event)]\n",
    "        vel[collision_disk][direction] *= -1.0\n",
    "    else:\n",
    "        a, b = pairs[pair_times.index(next_event)]\n",
    "        del_x = [pos[b][0] - pos[a][0], pos[b][1] - pos[a][1]]\n",
    "        abs_x = math.sqrt(del_x[0] ** 2 + del_x[1] ** 2)\n",
    "        e_perp = [c / abs_x for c in del_x]\n",
    "        del_v = [vel[b][0] - vel[a][0], vel[b][1] - vel[a][1]]\n",
    "        scal = del_v[0] * e_perp[0] + del_v[1] * e_perp[1]\n",
    "        for k in range(2):\n",
    "            vel[a][k] += e_perp[k] * scal\n",
    "            vel[b][k] -= e_perp[k] * scal\n",
    "            \n",
    "print t, \"The total running time of the program\"\n",
    "\n",
    "for conf in configurations:\n",
    "    print conf, hits[conf]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculations in terms of observables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of the configurations themselves, and their probability distribution, we now consider an observable, in fact a particularly simple one, the position x: the x-coordinate of the center of a disk. We will compute its probability distribution, as the normed histogram of x-positions. This histogram is the same for all disks, so we can collect data for one disk or for all of them.\n",
    "\n",
    "*Direct sampling:* "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/envs/python2/lib/python2.7/site-packages/IPython/core/magics/pylab.py:161: UserWarning: pylab import has clobbered these variables: ['pylab', 'random']\n",
      "`%matplotlib` prevents importing * from pylab and numpy\n",
      "  \"\\n`%matplotlib` prevents importing * from pylab and numpy\"\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%pylab inline\n",
    "import random, pylab\n",
    "\n",
    "N = 4\n",
    "sigma = 0.1197\n",
    "n_runs = 1000000\n",
    "\n",
    "histo_data = []\n",
    "for run in range(n_runs):\n",
    "    pos = direct_disks_box(N, sigma) #this function was defined in the previous section\n",
    "    for k in range(N):\n",
    "        histo_data.append(pos[k][0])\n",
    "pylab.hist(histo_data, bins=100, normed=True)\n",
    "pylab.xlabel('x')\n",
    "pylab.ylabel('frequency')\n",
    "pylab.title('Direct sampling: x coordinate histogram (density eta=0.18)')\n",
    "pylab.grid()\n",
    "pylab.savefig('direct_disks_histo.png')\n",
    "pylab.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Markov-chain sampling:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/envs/python2/lib/python2.7/site-packages/matplotlib/axes/_axes.py:6462: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n",
      "  warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%pylab inline\n",
    "import random, pylab\n",
    "\n",
    "L = [[0.25, 0.25], [0.75, 0.25], [0.25, 0.75], [0.75, 0.75]] \n",
    "delta = 0.2 #may need to be varied\n",
    "sigma = 0.1197\n",
    "N=4\n",
    "\n",
    "n_steps = 2000000\n",
    "\n",
    "histo_data = []\n",
    "for steps in range(n_steps):\n",
    "    pos = markov_disks_box(L, delta, sigma) #this function was defined in the previous section\n",
    "    for k in range(N):\n",
    "        histo_data.append(pos[k][0])\n",
    "pylab.hist(histo_data, bins=100, normed=True)\n",
    "pylab.xlabel('x')\n",
    "pylab.ylabel('frequency')\n",
    "pylab.title('Markov sampling: x coordinate histogram (density eta=0.18)')\n",
    "pylab.grid()\n",
    "pylab.savefig('markov_disks_histo.png')\n",
    "pylab.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Event drivent Newtonian dynamics:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "100000\n",
      "200000\n",
      "300000\n",
      "400000\n",
      "500000\n",
      "600000\n",
      "700000\n",
      "800000\n",
      "900000\n",
      "1000000\n",
      "1100000\n",
      "1200000\n",
      "1300000\n",
      "1400000\n",
      "1500000\n",
      "1600000\n",
      "1700000\n",
      "1800000\n",
      "1900000\n",
      "2000000\n",
      "2100000\n",
      "2200000\n",
      "2300000\n",
      "2400000\n",
      "2500000\n",
      "2600000\n",
      "2700000\n",
      "2800000\n",
      "2900000\n",
      "3000000\n",
      "3100000\n",
      "3200000\n",
      "3300000\n",
      "3400000\n",
      "3500000\n",
      "3600000\n",
      "3700000\n",
      "3800000\n",
      "3900000\n",
      "4000000\n",
      "4100000\n",
      "4200000\n",
      "4300000\n",
      "4400000\n",
      "4500000\n",
      "4600000\n",
      "4700000\n",
      "4800000\n",
      "4900000\n",
      "485918.792042 The total running time of the program\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import math, pylab\n",
    "\n",
    "def wall_time(pos_a, vel_a, sigma):\n",
    "    if vel_a > 0.0:\n",
    "        del_t = (1.0 - sigma - pos_a) / vel_a\n",
    "    elif vel_a < 0.0:\n",
    "        del_t = (pos_a - sigma) / abs(vel_a)\n",
    "    else:\n",
    "        del_t = float('inf')\n",
    "    return del_t\n",
    "\n",
    "def pair_time(pos_a, vel_a, pos_b, vel_b, sigma):\n",
    "    del_x = [pos_b[0] - pos_a[0], pos_b[1] - pos_a[1]]\n",
    "    del_x_sq = del_x[0] ** 2 + del_x[1] ** 2\n",
    "    del_v = [vel_b[0] - vel_a[0], vel_b[1] - vel_a[1]]\n",
    "    del_v_sq = del_v[0] ** 2 + del_v[1] ** 2\n",
    "    scal = del_v[0] * del_x[0] + del_v[1] * del_x[1]\n",
    "    Upsilon = scal ** 2 - del_v_sq * ( del_x_sq - 4.0 * sigma **2)\n",
    "    if Upsilon > 0.0 and scal < 0.0:\n",
    "        del_t = - (scal + math.sqrt(Upsilon)) / del_v_sq\n",
    "    else:\n",
    "        del_t = float('inf')\n",
    "    return del_t\n",
    "\n",
    "#define the marked conditions\n",
    "conf_a = ((0.30, 0.30), (0.30, 0.70), (0.70, 0.30), (0.70,0.70))\n",
    "conf_b = ((0.20, 0.20), (0.20, 0.80), (0.75, 0.25), (0.75,0.75))\n",
    "conf_c = ((0.30, 0.20), (0.30, 0.80), (0.70, 0.20), (0.70,0.70))\n",
    "configurations = [conf_a, conf_b, conf_c]\n",
    "\n",
    "#initial conditions\n",
    "pos = [[0.25, 0.25], [0.75, 0.25], [0.25, 0.75], [0.75, 0.75]] \n",
    "vel = [[0.21, 0.12], [0.71, 0.18], [-0.23, -0.79], [0.78, 0.1177]]\n",
    "\n",
    "singles = [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (3, 0), (3, 1)]\n",
    "pairs = [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]\n",
    "\n",
    "sigma = 0.1197 #radius\n",
    "n_events = 5000000 \n",
    "\n",
    "t = 0.0 #initialise time\n",
    "histo_data = [] #initialise histogram\n",
    "for event in range(n_events):\n",
    "    if event % 100000 == 0:\n",
    "        print event\n",
    "    wall_times = [wall_time(pos[k][l], vel[k][l], sigma) for k, l  in singles]\n",
    "    pair_times = [pair_time(pos[k], vel[k], pos[l], vel[l], sigma) for k, l in pairs]\n",
    "    next_event = min(wall_times + pair_times)\n",
    "    t_previous = t\n",
    "    for inter_times in range(int(t + 1), int(t + next_event + 1)):\n",
    "        del_t = inter_times - t_previous\n",
    "        for k, l in singles:\n",
    "            pos[k][l] += vel[k][l] * del_t\n",
    "        t_previous = inter_times\n",
    "        \n",
    "        #histogram update\n",
    "        for k in range(N):\n",
    "            histo_data.append(pos[k][0]) #take the histogram of the x (0th) coordinate\n",
    "        \n",
    "    t += next_event\n",
    "    del_t = t - t_previous\n",
    "    for k, l in singles:\n",
    "        pos[k][l] += vel[k][l] * del_t\n",
    "    if min(wall_times) < min(pair_times):\n",
    "        collision_disk, direction = singles[wall_times.index(next_event)]\n",
    "        vel[collision_disk][direction] *= -1.0\n",
    "    else:\n",
    "        a, b = pairs[pair_times.index(next_event)]\n",
    "        del_x = [pos[b][0] - pos[a][0], pos[b][1] - pos[a][1]]\n",
    "        abs_x = math.sqrt(del_x[0] ** 2 + del_x[1] ** 2)\n",
    "        e_perp = [c / abs_x for c in del_x]\n",
    "        del_v = [vel[b][0] - vel[a][0], vel[b][1] - vel[a][1]]\n",
    "        scal = del_v[0] * e_perp[0] + del_v[1] * e_perp[1]\n",
    "        for k in range(2):\n",
    "            vel[a][k] += e_perp[k] * scal\n",
    "            vel[b][k] -= e_perp[k] * scal\n",
    "            \n",
    "print t, \"The total running time of the program\"\n",
    "\n",
    "#figure output\n",
    "pylab.hist(histo_data, bins=100, normed=True)\n",
    "pylab.xlabel('x')\n",
    "pylab.ylabel('frequency')\n",
    "pylab.title('Event driven Newtonian simulation: x coordinate histogram (density eta=0.18)')\n",
    "pylab.grid()\n",
    "pylab.savefig('event_disks_histo.png')\n",
    "pylab.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that event driven Newtonian dynamics, direct and Markov-chain sampling give the same histogram for the x-position of the disks. *This is a hint for the equivalence between statistical mechanics and Newtonian mechanics.*"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}