tutorials/robot-marbles-part-3/robot-marbles-part-3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# cadCAD Tutorials: The Robot and the Marbles, part 3\n",
    "In parts [1](../robot-marbles-part-1/robot-marbles-part-1.ipynb) and [2](../robot-marbles-part-2/robot-marbles-part-2.ipynb) we introduced the 'language' in which a system must be described in order for it to be interpretable by cadCAD and some of the basic concepts of the library:\n",
    "* State Variables\n",
    "* Timestep\n",
    "* State Update Functions\n",
    "* Partial State Update Blocks\n",
    "* Simulation Configuration Parameters\n",
    "* Policies\n",
    "\n",
    "In this notebook we'll look at how subsystems within a system can operate in different frequencies. But first let's copy the base configuration with which we ended Part 2. Here's the description of that system:\n",
    "\n",
    "__The robot and the marbles__  \n",
    "* Picture a box (`box_A`) with ten marbles in it; an empty box (`box_B`) next to the first one; and __two__ robot arms capable of taking a marble from any one of the boxes and dropping it into the other one. \n",
    "* The robots are programmed to take one marble at a time from the box containing the largest number of marbles and drop it in the other box. They repeat that process until the boxes contain an equal number of marbles.\n",
    "* The robots act simultaneously; in other words, they assess the state of the system at the exact same time, and decide what their action will be based on that information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "\n",
    "\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "# List of all the state variables in the system and their initial values\n",
    "initial_conditions = {\n",
    "    'box_A': 10, # as per the description of the example, box_A starts out with 10 marbles in it\n",
    "    'box_B': 0 # as per the description of the example, box_B starts out empty\n",
    "}\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "\n",
    "\n",
    "\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "# Settings of general simulation parameters, unrelated to the system itself\n",
    "# `T` is a range with the number of discrete units of time the simulation will run for;\n",
    "# `N` is the number of times the simulation will be run (Monte Carlo runs)\n",
    "# In this example, we'll run the simulation once (N=1) and its duration will be of 10 timesteps\n",
    "# We'll cover the `M` key in a future article. For now, let's leave it empty\n",
    "simulation_parameters = {\n",
    "    'T': range(10),\n",
    "    'N': 1,\n",
    "    'M': {}\n",
    "}\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "# We specify the robot arm's logic in a Policy Function\n",
    "def robot_arm(params, step, sL, s):\n",
    "    add_to_A = 0\n",
    "    if (s['box_A'] > s['box_B']):\n",
    "        add_to_A = -1\n",
    "    elif (s['box_A'] < s['box_B']):\n",
    "        add_to_A = 1\n",
    "    return({'add_to_A': add_to_A, 'add_to_B': -add_to_A})\n",
    "    \n",
    "\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "# We make the state update functions less \"intelligent\",\n",
    "# ie. they simply add the number of marbles specified in _input \n",
    "# (which, per the policy function definition, may be negative)\n",
    "def increment_A(params, step, sL, s, _input):\n",
    "    y = 'box_A'\n",
    "    x = s['box_A'] + _input['add_to_A']\n",
    "    return (y, x)\n",
    "\n",
    "def increment_B(params, step, sL, s, _input):\n",
    "    y = 'box_B'\n",
    "    x = s['box_B'] + _input['add_to_B']\n",
    "    return (y, x)\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "\n",
    "\n",
    "\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "# In the Partial State Update Blocks, \n",
    "# the user specifies if state update functions will be run in series or in parallel\n",
    "# and the policy functions that will be evaluated in that block\n",
    "partial_state_update_blocks = [\n",
    "    { \n",
    "        'policies': { # The following policy functions will be evaluated and their returns will be passed to the state update functions\n",
    "            'robot_arm_1': robot_arm,\n",
    "            'robot_arm_2': robot_arm\n",
    "        },\n",
    "        'variables': { # The following state variables will be updated simultaneously\n",
    "            'box_A': increment_A,\n",
    "            'box_B': increment_B\n",
    "        }\n",
    "    }\n",
    "]\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "from cadCAD.configuration import Configuration\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "# The configurations above are then packaged into a `Configuration` object\n",
    "config = Configuration(initial_state=initial_conditions, #dict containing variable names and initial values\n",
    "                       partial_state_update_blocks=partial_state_update_blocks, #dict containing state update functions\n",
    "                       sim_config=simulation_parameters #dict containing simulation parameters\n",
    "                      )\n",
    "\n",
    "from cadCAD.engine import ExecutionMode, ExecutionContext, Executor\n",
    "exec_mode = ExecutionMode()\n",
    "exec_context = ExecutionContext(exec_mode.single_proc)\n",
    "executor = Executor(exec_context, [config]) # Pass the configuration object inside an array\n",
    "raw_result, tensor = executor.execute() # The `execute()` method returns a tuple; its first elements contains the raw results\n",
    "\n",
    "%matplotlib inline\n",
    "import pandas as pd\n",
    "df = pd.DataFrame(raw_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df.plot('timestep', ['box_A', 'box_B'], grid=True, \n",
    "        xticks=list(df['timestep'].drop_duplicates()), \n",
    "        colormap = 'RdYlGn',\n",
    "        yticks=list(range(1+(df['box_A']+df['box_B']).max())));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Asynchronous Subsystems\n",
    "We have defined that the robots operate simultaneously on the boxes of marbles. But it is often the case that agents within a system operate asynchronously, each having their own operation frequencies or conditions.\n",
    "\n",
    "Suppose that instead of acting simultaneously, the robots in our examples operated in the following manner:\n",
    "* Robot 1: acts once every 2 timesteps\n",
    "* Robot 2: acts once every 3 timesteps\n",
    "\n",
    "One way to simulate the system with this change is to introduce a check of the current timestep before the robots act, with the definition of separate policy functions for each robot arm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "# We specify each of the robots logic in a Policy Function\n",
    "robots_periods = [2,3] # Robot 1 acts once every 2 timesteps; Robot 2 acts once every 3 timesteps\n",
    "\n",
    "def get_current_timestep(cur_substep, s):\n",
    "    if cur_substep == 1:\n",
    "        return s['timestep']+1\n",
    "    return s['timestep']\n",
    "\n",
    "def robot_arm_1(params, step, sL, s):\n",
    "    _robotId = 1\n",
    "    if get_current_timestep(step, s)%robots_periods[_robotId-1]==0: # on timesteps that are multiple of 2, Robot 1 acts\n",
    "        return robot_arm(params, step, sL, s)\n",
    "    else:\n",
    "        return({'add_to_A': 0, 'add_to_B': 0}) # for all other timesteps, Robot 1 doesn't interfere with the system\n",
    "\n",
    "def robot_arm_2(params, step, sL, s):\n",
    "    _robotId = 2\n",
    "    if get_current_timestep(step, s)%robots_periods[_robotId-1]==0: # on timesteps that are multiple of 3, Robot 2 acts\n",
    "        return robot_arm(params, step, sL, s)\n",
    "    else:\n",
    "        return({'add_to_A': 0, 'add_to_B': 0}) # for all other timesteps, Robot 2 doesn't interfere with the system\n",
    "\n",
    "\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "# In the Partial State Update Blocks, \n",
    "# the user specifies if state update functions will be run in series or in parallel\n",
    "# and the policy functions that will be evaluated in that block\n",
    "partial_state_update_blocks = [\n",
    "    { \n",
    "        'policies': { # The following policy functions will be evaluated and their returns will be passed to the state update functions\n",
    "            'robot_arm_1': robot_arm_1,\n",
    "            'robot_arm_2': robot_arm_2\n",
    "        },\n",
    "        'variables': { # The following state variables will be updated simultaneously\n",
    "            'box_A': increment_A,\n",
    "            'box_B': increment_B\n",
    "        }\n",
    "    }\n",
    "]\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "\n",
    "\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "# The configurations above are then packaged into a `Configuration` object\n",
    "config = Configuration(initial_state=initial_conditions, #dict containing variable names and initial values\n",
    "                       partial_state_update_blocks=partial_state_update_blocks, #dict containing state update functions\n",
    "                       sim_config=simulation_parameters #dict containing simulation parameters\n",
    "                      )\n",
    "\n",
    "exec_mode = ExecutionMode()\n",
    "exec_context = ExecutionContext(exec_mode.single_proc)\n",
    "executor = Executor(exec_context, [config]) # Pass the configuration object inside an array\n",
    "raw_result, tensor = executor.execute() # The `execute()` method returns a tuple; its first elements contains the raw results\n",
    "\n",
    "df = pd.DataFrame(raw_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x104c52320>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df.plot('timestep', ['box_A', 'box_B'], \n",
    "        grid=True, \n",
    "        xticks=list(df['timestep'].drop_duplicates()), \n",
    "        yticks=list(range(1+max(df['box_A'].max(),df['box_B'].max()))),\n",
    "        colormap = 'RdYlGn'\n",
    "       )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a step-by-step look at what the simulation tells us:\n",
    "* Timestep 1: the number of marbles in the boxes does not change, as none of the robots act\n",
    "* Timestep 2: Robot 1 acts, Robot 2 doesn't; resulting in one marble being moved from box A to box B\n",
    "* Timestep 3: Robot 2 acts, Robot 1 doesn't; resulting in one marble being moved from box A to box B\n",
    "* Timestep 4: Robot 1 acts, Robot 2 doesn't; resulting in one marble being moved from box A to box B\n",
    "* Timestep 5: the number of marbles in the boxes does not change, as none of the robots act\n",
    "* Timestep 6: Robots 1 __and__ 2 act, as 6 is a multiple of 2 __and__ 3; resulting in two marbles being moved from box A to box B and an equilibrium being reached."
   ]
  }
 ],
 "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
}