galton_board_manual_en.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### galton board\n",
    "\n",
    "\n",
    "** Concept: ** (https://en.wikipedia.org/wiki/Bean_machine):\n",
    "\n",
    "\"The Galton Board consists of a vertical board with interleaved rows of pegs. Beads are dropped from the top and, when the device is level, bounce either left or right as they hit the pegs. Eventually they are collected into bins at the bottom, where the height of bead columns accumulated in the bins approximate a bell curve. Overlaying Pascal's triangle onto the pins shows the number of different paths that can be taken to get to each bin.\"\n",
    "\n",
    "**Simulation:**\n",
    "With the classes 'board', 'ball' and 'galton-board' a simulation of the Galton board can be started. \n",
    "The 'board' draws the containers and the corresponding obstacles in a triangular shape. Each sphere-object contains a random Bernoulli chain which determines the way through the obstacles. The way right past the obstacle is 1, the way left past the obstacle is 0.\n",
    "The length of the chain is determined by the number of slots: lChain = nSlots -1\n",
    "The number of obstacle rows corresponds to the length of the bernoulli chain.\n",
    " \n",
    "**Parameter**\n",
    "\n",
    "- nSlots = number of containers (standard = 10)\n",
    "- nBalls = number of balls (standard = 100)\n",
    "- nInterval = interval speed (standard = 1 ms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %matplotlib notebook\n",
    "%matplotlib widget\n",
    "\n",
    "import numpy as np\n",
    "import ipywidgets as widgets\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.animation import FuncAnimation\n",
    "from scipy.stats import bernoulli, norm\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class board:\n",
    "    def __init__(self, nSlots, ax, y0, xInterval, yInterval):\n",
    "        self.ax = ax\n",
    "        self.nSlots = nSlots\n",
    "        self.res = np.zeros(nSlots)\n",
    "        self.lenChain = nSlots - 1\n",
    "        self.indexM = np.zeros([self.lenChain, (self.lenChain * 2 - 1)])\n",
    "        #\n",
    "        self.markerSize = 5\n",
    "        self.xInterval = xInterval\n",
    "        self.yInterval = yInterval\n",
    "        self.xOffset = 5\n",
    "        self.y_0 = y0\n",
    "        #\n",
    "        #\n",
    "        self.xLim = [0, (self.xOffset + self.lenChain + self.xOffset -1)]\n",
    "        self.yLim = [0, (self.y_0 * 1.20)]\n",
    "        self.xm = 5\n",
    "    #--------------------------------------------------------------------\n",
    "    def initBoard(self):\n",
    "        \"\"\" \n",
    "        Form matrix for triangle:\n",
    "        the evenly distributed obstacles form a triangle.\n",
    "        The matrix has the following size: chain length x (2* chain length -1), [2x3, 3x5, 4x7] etc.\n",
    "        \n",
    "                    ***+***  -> fill matrix line by line. \n",
    "                    **+*+**  -> start with last line and decrease \n",
    "                    *+*+*+*  -> index vector line by ine\n",
    "                    +*+*+*+\n",
    "        \n",
    "         with the help of this matrix, the obstacles are drawn as circular markings in the figure\n",
    "        \"\"\"\n",
    "        rowIndex = np.arange(0, self.indexM.shape[-1], 2)\n",
    "        for i in list(range((self.lenChain - 1), -1, -1)):\n",
    "            if i == (len(self.indexM)-1):\n",
    "                self.indexM[i][rowIndex] = 1\n",
    "                continue\n",
    "            rowIndex = rowIndex[0:-1] +1\n",
    "            self.indexM[i][rowIndex] = 1\n",
    "        #\n",
    "        # draw marks\n",
    "        #\n",
    "        x = self.xOffset\n",
    "        y = self.y_0\n",
    "        for i in range(0, len(self.indexM)):\n",
    "            x = self.xOffset\n",
    "            for c in range(0, self.indexM.shape[-1]):\n",
    "                if self.indexM[i][c]:\n",
    "                    self.ax.plot(x, y, 'ok', markersize=str(self.markerSize))\n",
    "                x += self.xInterval\n",
    "            y -= self.yInterval\n",
    "\n",
    "        self.ax.set_xlim(self.xLim)\n",
    "        self.ax.set_ylim(self.yLim)\n",
    "        #\n",
    "        # vertical lines to indicate the containers\n",
    "#         ymax = 2\n",
    "#         self.ax.vlines(x=(self.xOffset - self.xInterval), ymin=0, ymax= ymax, ls=\"-\", lw=3)\n",
    "#         self.ax.vlines(x=(self.xOffset + self.lenChain + self.xInterval - 1), ymin=0, ymax= ymax, ls=\"-\", lw=3)\n",
    "#         vx = np.arange(self.xOffset - 1, self.xOffset + self.lenChain, 1)\n",
    "#         self.ax.vlines(x=vx, ymin=0, ymax =ymax, ls=\"-\", lw=3)\n",
    "        #\n",
    "        # middle of figure in x-direction:\n",
    "        self.xm = (self.ax.get_xlim()[-1] / 2)\n",
    "        # No ticks\n",
    "        self.ax.set_xticks([])\n",
    "        self.ax.set_yticks([])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ball:\n",
    "    \"\"\"\n",
    "    A galton board contains x balls, which randomly fall through the obstacles and end up\n",
    "    in a container. The path of the balls is given by a random Bernoulli series. The balls run\n",
    "    one after the other through the board.\n",
    "\n",
    "    Members:\n",
    "    - x: x-coordinate of ball\n",
    "    - y: y-coordinate of ball\n",
    "    - xInterval: value of distance between obstacles in x direction \n",
    "    - yInterval: value of distance between obstacles in y direction \n",
    "    - color: line color\n",
    "    - line: lin2D objekt das die Kugel im Diagram representiert\n",
    "    - gltWay: Bernoulli-series with lenght: nSlots-1\n",
    "    - gltLen: size of Bernoullie-series\n",
    "        \n",
    "    Methods:\n",
    "    - move_right(): move ball right\n",
    "    - move_left(): move ball left\n",
    "    \"\"\"\n",
    "    def __init__(self, ax, gltWay, y0, xInterval, yInterval):\n",
    "        self.x = (ax.get_xlim()[-1] / 2)\n",
    "        self.y = y0 + yInterval\n",
    "        self.xInterval = xInterval\n",
    "        self.yInterval = yInterval\n",
    "        self.line, = ax.plot(self.x, self.y, 'or', markersize=\"8\")\n",
    "        self.color = 'red'\n",
    "        self.gltWay = gltWay\n",
    "        self.gltLen = len(gltWay)\n",
    "        self.runIndex = 0\n",
    "    #\n",
    "    def move_right(self):\n",
    "        if isinstance(self.line.get_data()[0], np.ndarray):\n",
    "            self.x = self.line.get_data()[0][0]\n",
    "            self.y = self.line.get_data()[-1][0]\n",
    "            self.line.set_data(self.x + self.xInterval, self.y - 2)\n",
    "            return\n",
    "        if not isinstance(self.line.get_data()[0], np.ndarray):\n",
    "            self.x = self.line.get_data()[0]\n",
    "            self.y = self.line.get_data()[-1]\n",
    "            self.line.set_data(self.x + self.xInterval, self.y - self.yInterval)\n",
    "        return\n",
    "    #\n",
    "    def move_left(self):\n",
    "        if isinstance(self.line.get_data()[0], np.ndarray):\n",
    "            self.x = self.line.get_data()[0][0]\n",
    "            self.y = self.line.get_data()[-1][0]\n",
    "            self.line.set_data(self.x - self.xInterval, self.y - 2)\n",
    "            return\n",
    "        if not isinstance(self.line.get_data()[0], np.ndarray):\n",
    "            self.x = self.line.get_data()[0]\n",
    "            self.y = self.line.get_data()[-1]\n",
    "            self.line.set_data(self.x - self.xInterval, self.y - self.yInterval)\n",
    "        return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#-----------------------------------------------------------------------------------\n",
    "class GaltonBoard:\n",
    "    \"\"\" \n",
    "    class GaltonBoard: Parent class to make the control of the animation more clearly arranged.\n",
    "                        Class contains as member the board and the balls.\n",
    "    \n",
    "    Members:\n",
    "    - board:      board-objekt \n",
    "    - balls:      ball-objekt\n",
    "    - activeBall: index value of the current ball runningn through the board\n",
    "    - ax:         ax-objekt of diagram\n",
    "    - ax2:        2nd ax-objekt für 2nd y-axis. used for fitting. \n",
    "    \n",
    "    Methods:\n",
    "    - getBall(iBall):  return specific ball\n",
    "    - getBallsCount(): return total number of balls\n",
    "    - getSlotsCount(): return number of containers\n",
    "    - getAxis():       return ax-objeckt of figure\n",
    "    - clearBall(iBall):    let ball disappear from figure\n",
    "    - AddBallResult(iResult): increment the container wher the ball falls in\n",
    "    - DrawFittingFunction(x,y): draw a normal distribution fitted to the containers content\n",
    "    \n",
    "    \"\"\" \n",
    "    def __init__(self, ax, nSlots, nBalls):\n",
    "        self.balls = []\n",
    "        self.activeBall = 0\n",
    "        self.ax = ax\n",
    "        \n",
    "        props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)\n",
    "        self.text = ax.text(0.05, 0.15,'0', transform=self.ax.transAxes, fontsize=10,verticalalignment='top', bbox=props)\n",
    "        self.ax2 = self.ax.twinx()\n",
    "        self.ax2.set_yticks([])\n",
    "        self.xInterval = 0.5\n",
    "        self.yInterval = 1.5\n",
    "        #\n",
    "        if nSlots > 10:\n",
    "            y0 = 15 * self.yInterval\n",
    "        else:\n",
    "            y0 = 15       \n",
    "        #\n",
    "        if nSlots > 10 or nBalls > 20:\n",
    "            y0 = 15 + 0.30*nBalls\n",
    "        #\n",
    "        self.board = board(nSlots, ax, y0, self.xInterval, self.yInterval)\n",
    "        #\n",
    "        # initialize figure:\n",
    "        self.board.initBoard()\n",
    "        #\n",
    "        # save balls in a list\n",
    "        lenWay = nSlots-1\n",
    "        self.result = []\n",
    "        for i in range(nBalls):\n",
    "            self.balls.append(ball(ax, bernoulli.rvs(0.5, size = lenWay), self.board.y_0, self.board.xInterval, self.board.yInterval))\n",
    "            self.result.append(np.sum(self.balls[i].gltWay))\n",
    "    #\n",
    "    def getBall(self, index):\n",
    "        return self.balls[index]\n",
    "    #\n",
    "    def getBallsCount(self):\n",
    "        return len(self.balls)\n",
    "    #\n",
    "    def getSlotsCount(self):\n",
    "        return self.board.nSlots\n",
    "    #\n",
    "    def getAxis(self):\n",
    "        return self.board.ax\n",
    "    #\n",
    "    def clearBall(self, iBall):\n",
    "        self.balls[iBall].line.remove()\n",
    "    #\n",
    "    def AddBallResult(self, iResult):\n",
    "        self.board.res[iResult] += 1\n",
    "        iMax = self.board.lenChain + self.board.xOffset\n",
    "        x = np.arange(self.board.xOffset -1, iMax, 1)\n",
    "        self.rects = self.board.ax.bar(x, self.board.res , color=\"blue\")\n",
    "#         self.board.ax.bar(self.board.xOffset - self.board.xInterval, self.board.res[0], color=\"blue\" )\n",
    "#         self.board.ax.bar(x, self.board.res[1:len(x)+1] , color=\"blue\")\n",
    "#         self.board.ax.bar(iMax - self.board.xInterval, self.board.res[-1],color=\"blue\")\n",
    "        #\n",
    "    #\n",
    "    def DrawFittingFunction(self, x, y):\n",
    "        # draw fitting with a second y-axis\n",
    "        #\n",
    "        # höhe der einzelnen behälter anzeigen:\n",
    "        #\n",
    "        for rect in self.rects:\n",
    "            height = rect.get_height()\n",
    "            self.board.ax.text(rect.get_x() + rect.get_width()/2., 1.05*height,'%d' % int(height),ha='center', va='bottom')\n",
    "        #\n",
    "        self.ax2.plot(x, y, 'C1')        \n",
    "        self.ax2.set_ylim(0, np.amax(y) * 1.5)\n",
    "#-----------------------------------------------------------------------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_galton(*args):\n",
    "    \"\"\"\n",
    "  update function of the animation\n",
    "    - leads each ball through the obstacles and stores the result as a bar-plot\n",
    "    - ends the animation when all balls have passed through the obstacles and\n",
    "      fits a normal distribution from the result\n",
    "    \"\"\"\n",
    "    #\n",
    "    # end of animation when all balls have run through the obstacles\n",
    "    if galton.activeBall >= galton.getBallsCount(): \n",
    "        #\n",
    "        #fit result (container contents) with a normal distribution\n",
    "        #\n",
    "        # - the resulting distribution is set to the middle of the diagram (x-direction).\n",
    "        #\n",
    "        fitting = norm.fit(galton.result)\n",
    "        \n",
    "        xFit =  np.arange(galton.ax.get_xlim()[0], galton.ax.get_xlim()[-1], 1/200)\n",
    "        # wenn mu eine ganze Zahl ist, wird die Normalverteilung in der Mitte angezeigt, andernfalls +/- xIntervall versetzt.\n",
    "        #\n",
    "#         if (galton.board.nSlots/2 - fitting[0]) == 0:\n",
    "#             pdfFit = norm.pdf(xFit, galton.board.xm, fitting[1])\n",
    "#         #\n",
    "#         if (galton.board.nSlots/2 - fitting[0]) > 0:\n",
    "#             pdfFit = norm.pdf(xFit, galton.board.xm - galton.board.xInterval, fitting[1])\n",
    "#         #\n",
    "#         if (galton.board.nSlots/2 - fitting[0]) < 0:\n",
    "#             pdfFit = norm.pdf(xFit, galton.board.xm + galton.board.xInterval, fitting[1])\n",
    "        #\n",
    "        pdfFit = norm.pdf(xFit, galton.board.xm, fitting[1])\n",
    "        #\n",
    "        textstr = '\\n'.join((\\\n",
    "                             \"parameter of gauss distribution\",\n",
    "                             r'$\\mu=%.2f$' % (fitting[0], ),\n",
    "                             r'$\\mathrm{\\sigma}=%.2f$' % (fitting[1], ),\n",
    "                             r'$\\mathrm{max =}%.2f$' %(np.amax(pdfFit), )\n",
    "                             ))\n",
    "        props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)\n",
    "        galton.ax.text(0.05, 0.95, textstr, transform=galton.ax.transAxes, fontsize=10,\\\n",
    "                       verticalalignment='top', bbox=props)\n",
    "        #\n",
    "        galton.DrawFittingFunction(xFit, pdfFit)\n",
    "        #\n",
    "        #\n",
    "        anim.event_source.stop()\n",
    "        return galton\n",
    "        #\n",
    "    #\n",
    "    # get balls object which should run \n",
    "    ActBall = galton.getBall(galton.activeBall)\n",
    "    #\n",
    "    # is current ball already through the obstacles?\n",
    "    if ActBall.runIndex >= (ActBall.gltLen - 1):\n",
    "    #\n",
    "        # increase containers content. \n",
    "        galton.AddBallResult(np.sum(ActBall.gltWay))\n",
    "        # delete ball from diagram\n",
    "        galton.clearBall(galton.activeBall)\n",
    "        # increase balls counter index\n",
    "        galton.activeBall += 1\n",
    "        return ActBall.line\n",
    "    #\n",
    "    # move balls left/right around the obstacles\n",
    "    if ActBall.runIndex < ActBall.gltLen:\n",
    "        if ActBall.gltWay[ActBall.runIndex] > 0:\n",
    "            ActBall.move_right()\n",
    "        #\n",
    "        if ActBall.gltWay[ActBall.runIndex] == 0:\n",
    "            ActBall.move_left()\n",
    "        #\n",
    "    ActBall.runIndex += 1\n",
    "    galton.text.set_text(r'$\\Sigma = %d$' %(galton.activeBall +1, ))\n",
    "\n",
    "    \n",
    "    return ActBall.line\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# parameter of simulation\n",
    "#\n",
    "nSlots = 13\n",
    "nBalls = 200\n",
    "nInterval = 1\n",
    "#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f076dd43c49b4c55944e0a5118e47a2b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# start animation with given parameters\n",
    "# \n",
    "fig, axes = plt.subplots(nrows=1, ncols=1, figsize=(10,6))\n",
    "#\n",
    "galton = GaltonBoard(axes, nSlots, nBalls)\n",
    "#\n",
    "anim = FuncAnimation(fig, run_galton, interval=nInterval, blit=True)\n",
    "#\n",
    "# historgram and gaussian-fit\n",
    "#\n",
    "# axes[1].hist(galton.result, bins=nSlots, density=True, label='experiment')\n",
    "#\n",
    "fitting = norm.fit(galton.result)\n",
    "# xLim = axes[1].get_xlim()\n",
    "# x2 = np.arange(xLim[0], xLim[-1], 1/200)\n",
    "# axes[1].plot(x2, norm.pdf(x2, fitting[0], fitting[1]), label='gaussian fit')\n",
    "#\n",
    "# axes[1].set_xticks([])\n",
    "# axes[1].set_yticks([])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copyright © 2020 IUBH Internationale Hochschule"
   ]
  }
 ],
 "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.2"
  },
  "nbTranslate": {
   "displayLangs": [
    "*"
   ],
   "hotkey": "alt-t",
   "langInMainMenu": true,
   "sourceLang": "en",
   "targetLang": "fr",
   "useGoogleTranslate": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}