Ants Diffusion.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import math \n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from plotnine import * \n",
    "import pandas as pd\n",
    "%matplotlib inline\n",
    "\n",
    "from mesa import Model, Agent\n",
    "from mesa.time import SimultaneousActivation\n",
    "from mesa.space import MultiGrid\n",
    "from mesa.datacollection import DataCollector\n",
    "from mesa.batchrunner import BatchRunner"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Environment(Agent):\n",
    "    \"\"\"\n",
    "    A cell representing the Environment that will hold the chemical being\n",
    "    disbursed, and then reduce that amount through diffusion and evaporation.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, unique_id, pos, model):\n",
    "        \"\"\"\n",
    "        Create a new cell.\n",
    "        Args:\n",
    "            unique_id: a unique value to distinguish the agent\n",
    "            pos: The cell's coordinates on the grid.\n",
    "            model: standard model reference for agent.\n",
    "        \"\"\"\n",
    "        super().__init__(unique_id, model)\n",
    "        self.pos = pos\n",
    "        self.amount = 0.0\n",
    "\n",
    "    def step(self):\n",
    "        \"\"\"\n",
    "        Find the sum of chemical in the neighboring environment, including this\n",
    "        cell, then set this cell to be the diffused and evaporated amount.\n",
    "        \"\"\"\n",
    "        all_p = self.amount\n",
    "        neighbors = [n for n in self.model.grid.get_neighbors(self.pos, True) if type(n) is Environment]\n",
    "        for n in neighbors:\n",
    "            all_p += n.amount\n",
    "        ave_p = all_p / (len(neighbors) + 1)\n",
    "\n",
    "        self._nextAmount = (1 - self.model.evaporate) * \\\n",
    "            (self.amount + (self.model.diffusion * \\\n",
    "                                (ave_p - self.amount)))\n",
    "\n",
    "        if self._nextAmount < self.model.lowerbound:\n",
    "            self._nextAmount = 0\n",
    "\n",
    "    def advance(self):\n",
    "        \"\"\"\n",
    "        Set the state to the new computed state -- computed in step().\n",
    "        \"\"\"\n",
    "        self.amount = self._nextAmount\n",
    "\n",
    "    def add(self, amount):\n",
    "        \"\"\"\n",
    "        Add the amount to the cell's amount\n",
    "        \"\"\"\n",
    "        self.amount += amount\n",
    "\n",
    "    def get_pos(self):\n",
    "        return self.pos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Home(Agent):\n",
    "    \"\"\"\n",
    "    The home of the ants, recording how much food has been harvested.\n",
    "    \"\"\"\n",
    "    def __init__(self, unique_id, pos, model):\n",
    "        \"\"\"\n",
    "        Records the unique_id with the super, and saves the pos.\n",
    "        Initializes the food amount to 0.\n",
    "        \"\"\"\n",
    "        super().__init__(unique_id, model)\n",
    "        self.pos = pos\n",
    "        self.amount = 0\n",
    "\n",
    "    def add(self, amount):\n",
    "        \"\"\"\n",
    "        Add the amount to the home amount\n",
    "        \"\"\"\n",
    "        self.amount += amount"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Food(Agent):\n",
    "    \"\"\"\n",
    "    A food cache for the ants, recording how much food is available.\n",
    "    \"\"\"\n",
    "    def __init__(self, unique_id, model):\n",
    "        \"\"\"\n",
    "        Records the unique_id with the super.\n",
    "        Initializes the food amount to 0.\n",
    "        \"\"\"\n",
    "        super().__init__(unique_id, model)\n",
    "        self.amount = 0\n",
    "\n",
    "    def add(self, amount):\n",
    "        \"\"\"\n",
    "        Add the amount to the food amount\n",
    "        \"\"\"\n",
    "        self.amount += amount\n",
    "\n",
    "    def eaten(self):\n",
    "        \"\"\"\n",
    "        Removes one food if there are any available\n",
    "        \"\"\"\n",
    "        if self.any_food():\n",
    "            self.amount -= 1\n",
    "\n",
    "    def any_food(self):\n",
    "        \"\"\"\n",
    "        Returns a bool to show if there is food available\n",
    "        \"\"\"\n",
    "        return self.amount > 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from sugarscape_cg\n",
    "def get_distance(pos_1, pos_2):\n",
    "    \"\"\" Get the distance between two point\n",
    "\n",
    "    Args:\n",
    "        pos_1, pos_2: Coordinate tuples for both points.\n",
    "\n",
    "    \"\"\"\n",
    "    x1, y1 = pos_1\n",
    "    x2, y2 = pos_2\n",
    "    dx = x1 - x2\n",
    "    dy = y1 - y2\n",
    "    return math.sqrt(dx ** 2 + dy ** 2)\n",
    "\n",
    "class Ant(Agent):\n",
    "    \"\"\"\n",
    "    The ants wander around the world in search of food. Upon finding food,\n",
    "    they drop a pheremone trail while heading home to store the food. When\n",
    "    wandering, they either follow the strongest gradient of pheremone, or move randomly.\n",
    "    \"\"\"\n",
    "    def __init__(self, unique_id, home, model, moore=True):\n",
    "        super().__init__(unique_id, model)\n",
    "        self.pos = home.pos\n",
    "        self.state = \"FORAGING\"\n",
    "        self.drop = 0\n",
    "        self.home = home\n",
    "        self.moore = moore\n",
    "\n",
    "    # derived from Sugarscape get_sugar()\n",
    "    def get_item(self, item):\n",
    "        \"\"\"\n",
    "        Finds the Agent of type item at this location in the Grid\n",
    "        \"\"\"\n",
    "        this_cell = self.model.grid.get_cell_list_contents([self.pos])\n",
    "        for agent in this_cell:\n",
    "            if type(agent) is item:\n",
    "                return agent\n",
    "\n",
    "    def step(self):\n",
    "        \"\"\"\n",
    "        Ants will either be FORAGING for food or HOMING in on the home location.\n",
    "        If a FORAGING ant finds food, they eat it and begin HOMING, otherwise they\n",
    "        wander either randomly or following the pheromone gradient.\n",
    "        If a HOMING agent is home, they deposit their food and return FORAGING,\n",
    "        otherwise they drop pheromone and take one step closer to home.\n",
    "        \"\"\"\n",
    "        if self.state == \"FORAGING\":\n",
    "            # Look for Food\n",
    "            food = self.get_item(Food)\n",
    "\n",
    "            if food is not None and food.any_food(): # Eat the food and then head home\n",
    "                food.eaten()\n",
    "                self.state = \"HOMING\"\n",
    "                self.drop = self.model.initdrop\n",
    "\n",
    "            else: # Not on food, move (up gradient or wander)\n",
    "                if self.random.random() < self.model.prob_random:\n",
    "                    self.random_move()\n",
    "                else:\n",
    "                    self.gradient_move()\n",
    "\n",
    "\n",
    "        else: #HOMING\n",
    "            # If Home, then go back to FORAGING\n",
    "            if self.pos == self.home.pos:\n",
    "                home = self.get_item(Home)\n",
    "                home.add(1)\n",
    "                self.state = \"FORAGING\"\n",
    "                self.drop = 0\n",
    "            else: #drop pheremone, and move toward home\n",
    "                self.drop_pheromone()\n",
    "                self.home_move()\n",
    "\n",
    "    def drop_pheromone(self):\n",
    "        \"\"\"\n",
    "        Leave pheromone in the Environment and reduce the phermone drop\n",
    "        \"\"\"\n",
    "        env = self.get_item(Environment)\n",
    "        env.add(self.drop)\n",
    "        self.drop *= self.model.drop_rate\n",
    "\n",
    "    # from wolf_sheep RandomWalker\n",
    "    def random_move(self):\n",
    "        \"\"\"\n",
    "        Step one cell in any allowable direction.\n",
    "        \"\"\"\n",
    "        # Pick the next cell from the adjacent cells.\n",
    "        next_moves = self.model.grid.get_neighborhood(self.pos, self.moore, True)\n",
    "        next_move = self.random.choice(next_moves)\n",
    "        # Now move:\n",
    "        self.model.grid.move_agent(self, next_move)\n",
    "\n",
    "    # adapted from Sugarscape\n",
    "    def home_move(self):\n",
    "        \"\"\"\n",
    "        Step one cell toward self.home.pos.\n",
    "        \"\"\"\n",
    "        # Get neighborhood within vision\n",
    "        neighbors = [n.get_pos() for n in self.model.grid.get_neighbors(self.pos, self.moore) if type(n) is Environment]\n",
    "\n",
    "        # Narrow down to the nearest ones to home\n",
    "        min_dist = min([get_distance(self.home.pos, pos) for pos in neighbors])\n",
    "        final_candidates = [\n",
    "            pos for pos in neighbors if get_distance(self.home.pos, pos) == min_dist\n",
    "        ]\n",
    "        self.random.shuffle(final_candidates)\n",
    "        self.model.grid.move_agent(self, final_candidates[0])\n",
    "\n",
    "    def gradient_move(self):\n",
    "        \"\"\"\n",
    "        Step one cell to the pheromone gradient in the Environment\n",
    "        \"\"\"\n",
    "        # Find the neighbor Environment cell that has the highest phermone amount\n",
    "        where = (0, 0)\n",
    "        max = self.model.lowerbound\n",
    "        neighbors = [n for n in self.model.grid.get_neighbors(self.pos, self.moore) if type(n) is Environment]\n",
    "        for n in neighbors:\n",
    "            if n.amount > max:\n",
    "                max = n.amount\n",
    "                where = n.get_pos()\n",
    "\n",
    "        # When something looks interesting, move there, otherwise randomly move\n",
    "        if max > self.model.lowerbound:\n",
    "            self.model.grid.move_agent(self, where)\n",
    "        else:\n",
    "            self.random_move()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# derived from ConwaysGameOfLife\n",
    "class AntWorld(Model):\n",
    "    \"\"\"\n",
    "    Represents the ants foraging for food.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, height=50, width=50, evaporate=0.5, diffusion=1, initdrop=100, lowerbound=0.01, prob_random=0.1, drop_rate=0.9):\n",
    "        \"\"\"\n",
    "        Create a new playing area of (height, width) cells.\n",
    "        \"\"\"\n",
    "\n",
    "        super().__init__()\n",
    "        self.evaporate = evaporate\n",
    "        self.diffusion = diffusion\n",
    "        self.initdrop = initdrop\n",
    "        self.lowerbound = lowerbound\n",
    "        self.prob_random = prob_random\n",
    "        self.drop_rate = drop_rate\n",
    "\n",
    "        # Set up the grid and schedule.\n",
    "\n",
    "        # Use SimultaneousActivation which simulates all the cells\n",
    "        # computing their next state simultaneously.  This needs to\n",
    "        # be done because each cell's next state depends on the current\n",
    "        # state of all its neighbors -- before they've changed.\n",
    "        self.schedule = SimultaneousActivation(self)\n",
    "\n",
    "        # Use a simple grid, where edges wrap around.\n",
    "        self.grid = MultiGrid(height, width, torus=True)\n",
    "        \n",
    "        # Define pos for the initial home and food locations\n",
    "        homeloc = (25, 25)\n",
    "        food_locs = ((22, 11), (35, 8), (18, 33))\n",
    "\n",
    "        self.home = Home(self.next_id(), homeloc, self)\n",
    "        self.foods = []\n",
    "        self.grid.place_agent(self.home, homeloc)\n",
    "        self.schedule.add(self.home)\n",
    "\n",
    "        # Add in the ants\n",
    "        # Need to do this first, or it won't affect the cells, consequence of SimultaneousActivation\n",
    "        for i in range(100):\n",
    "            ant = Ant(self.next_id(), self.home, self)\n",
    "            self.grid.place_agent(ant, self.home.pos)\n",
    "            self.schedule.add(ant)\n",
    "\n",
    "        # Add the food locations\n",
    "        for loc in food_locs:\n",
    "            food = Food(self.next_id(), self)\n",
    "            food.add(100)\n",
    "            self.foods.append(food)\n",
    "            self.grid.place_agent(food, loc)\n",
    "            self.schedule.add(food)\n",
    "\n",
    "        # Place an environment cell at each location\n",
    "        for (contents, x, y) in self.grid.coord_iter():\n",
    "            cell = Environment(self.next_id(), (x, y), self)\n",
    "            self.grid.place_agent(cell, (x, y))\n",
    "            self.schedule.add(cell)\n",
    "\n",
    "        self.running = True\n",
    "        \n",
    "        # Recording of the data\n",
    "        self.dc = DataCollector({\"Home\": lambda m: self.home.amount,\n",
    "                        \"Loc 1\": lambda m: self.foods[0].amount,\n",
    "                        \"Loc 2\": lambda m: self.foods[1].amount,\n",
    "                        \"Loc 3\": lambda m: self.foods[2].amount\n",
    "                        })\n",
    "\n",
    "    def step(self):\n",
    "        \"\"\"\n",
    "        Have the scheduler advance each cell by one step\n",
    "        \"\"\"\n",
    "        self.schedule.step()\n",
    "        self.dc.collect(self)\n",
    "\n",
    "\n",
    "        # stop when all the food is collected\n",
    "        if self.home.amount == 300 or self.schedule.time > 1000:\n",
    "            self.running = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "ants = AntWorld()\n",
    "ants.run_model()\n",
    "results = ants.dc.get_model_vars_dataframe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Home</th>\n",
       "      <th>Loc 1</th>\n",
       "      <th>Loc 2</th>\n",
       "      <th>Loc 3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>100</td>\n",
       "      <td>100</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>100</td>\n",
       "      <td>100</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>100</td>\n",
       "      <td>100</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>100</td>\n",
       "      <td>100</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>100</td>\n",
       "      <td>100</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>996</th>\n",
       "      <td>60</td>\n",
       "      <td>89</td>\n",
       "      <td>90</td>\n",
       "      <td>61</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>997</th>\n",
       "      <td>60</td>\n",
       "      <td>89</td>\n",
       "      <td>90</td>\n",
       "      <td>61</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>998</th>\n",
       "      <td>60</td>\n",
       "      <td>89</td>\n",
       "      <td>90</td>\n",
       "      <td>61</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>999</th>\n",
       "      <td>60</td>\n",
       "      <td>89</td>\n",
       "      <td>90</td>\n",
       "      <td>61</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1000</th>\n",
       "      <td>60</td>\n",
       "      <td>89</td>\n",
       "      <td>90</td>\n",
       "      <td>61</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1001 rows × 4 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      Home  Loc 1  Loc 2  Loc 3\n",
       "0        0    100    100    100\n",
       "1        0    100    100    100\n",
       "2        0    100    100    100\n",
       "3        0    100    100    100\n",
       "4        0    100    100    100\n",
       "...    ...    ...    ...    ...\n",
       "996     60     89     90     61\n",
       "997     60     89     90     61\n",
       "998     60     89     90     61\n",
       "999     60     89     90     61\n",
       "1000    60     89     90     61\n",
       "\n",
       "[1001 rows x 4 columns]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<ggplot: (8786759983201)>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results[\"time\"] = np.linspace(0, len(results) - 1, len(results))\n",
    "resultsmelt = pd.melt(results, id_vars=[\"time\"], value_vars=[\"Home\",\"Loc 1\",\"Loc 2\",\"Loc 3\"])\n",
    "ggplot(resultsmelt, aes(x=\"time\", y=\"value\", color=\"variable\")) \\\n",
    "+ geom_line()"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}