Session_17_Traders_Trade_part_4.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "XAnII-29m3r2",
        "wp0VWkylOKr9",
        "BkX5GqjSnAu0"
      ],
      "authorship_tag": "ABX9TyNsbPAl0e3NkPPO2Oo2VQdH",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/SFIComplexityExplorer/Mesa-ABM-Tutorial/blob/main/Session_17_Traders_Trade_part_4.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Import Dependencies"
      ],
      "metadata": {
        "id": "XAnII-29m3r2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "\n",
        "\n",
        "try:\n",
        "  import mesa\n",
        "except:\n",
        "  !pip install mesa --quiet\n",
        "import mesa\n",
        "import numpy as np\n",
        "import math\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "%matplotlib inline"
      ],
      "metadata": {
        "id": "ikSl2Mz0m252",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f9853f2d-0fe1-42ba-9df5-b791a8eb41f1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.8/1.8 MB\u001b[0m \u001b[31m23.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m66.4/66.4 kB\u001b[0m \u001b[31m8.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Helper Functions"
      ],
      "metadata": {
        "id": "wp0VWkylOKr9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def get_distance(pos_1, pos_2):\n",
        "  '''\n",
        "  Calculate the Euclidean distance between two positions\n",
        "\n",
        "  used in trade.move()\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)"
      ],
      "metadata": {
        "id": "kg-JVcwzON_b"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Resource Classes"
      ],
      "metadata": {
        "id": "BkX5GqjSnAu0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Sugar(mesa.Agent):\n",
        "  \"\"\"\n",
        "  Sugar:\n",
        "  - contains an amount of sugar\n",
        "  - grows 1 amount of sugar at each turn\n",
        "  \"\"\"\n",
        "\n",
        "  def __init__(self, unique_id, model, pos, max_sugar):\n",
        "    super().__init__(unique_id, model)\n",
        "    self.pos = pos\n",
        "    self.amount = max_sugar\n",
        "    self.max_sugar = max_sugar\n",
        "\n",
        "\n",
        "  def step(self):\n",
        "    '''\n",
        "    Sugar growth function, adds one unit of sugar each step until\n",
        "    max amount\n",
        "    '''\n",
        "    self.amount = min([self.max_sugar, self.amount+1])"
      ],
      "metadata": {
        "id": "o1EOk5KMnC55"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Spice(mesa.Agent):\n",
        "  \"\"\"\n",
        "  Spice:\n",
        "  - contains an amount of spice\n",
        "  - grows 1 amount of spice at each turn\n",
        "  \"\"\"\n",
        "\n",
        "  def __init__(self, unique_id, model, pos, max_spice):\n",
        "    super().__init__(unique_id, model)\n",
        "    self.pos = pos\n",
        "    self.amount = max_spice\n",
        "    self.max_spice = max_spice\n",
        "\n",
        "  def step(self):\n",
        "    '''\n",
        "    Spice growth function, adds one unit of spice each step until\n",
        "    max amout\n",
        "    '''\n",
        "    self.amount = min([self.max_spice, self.amount+1])"
      ],
      "metadata": {
        "id": "-oJ35Mx7nXmK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Trader Agent"
      ],
      "metadata": {
        "id": "XYcwNrHqnrPt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Trader(mesa.Agent):\n",
        "  \"\"\"\n",
        "  Trader:\n",
        "  - has a metabolism of sugar and spice\n",
        "  - harvest and trade sugar and spice to survive\n",
        "  \"\"\"\n",
        "\n",
        "\n",
        "  def __init__(self, unique_id, model, pos, moore=False, sugar=0,\n",
        "               spice=0, metabolism_sugar=0, metabolism_spice=0,\n",
        "               vision=0):\n",
        "    super().__init__(unique_id, model)\n",
        "    self.pos = pos\n",
        "    self.moore = moore\n",
        "    self.sugar = sugar\n",
        "    self.spice = spice\n",
        "    self.metabolism_sugar = metabolism_sugar\n",
        "    self.metabolism_spice = metabolism_spice\n",
        "    self.vision = vision\n",
        "    self.prices = []\n",
        "    self.trade_partners = []\n",
        "\n",
        "\n",
        "  def get_sugar(self, pos):\n",
        "    '''\n",
        "    used in self.get_sugar_amount()\n",
        "    '''\n",
        "\n",
        "    this_cell = self.model.grid.get_cell_list_contents(pos)\n",
        "    for agent in this_cell:\n",
        "      if type(agent) is Sugar:\n",
        "        return agent\n",
        "    return None\n",
        "\n",
        "\n",
        "  def get_sugar_amount(self,pos):\n",
        "    '''\n",
        "    used in self.move() as part of self.calculate_welfare()\n",
        "    '''\n",
        "\n",
        "    sugar_patch = self.get_sugar(pos)\n",
        "    if sugar_patch:\n",
        "      return sugar_patch.amount\n",
        "    return 0\n",
        "\n",
        "  def get_spice(self, pos):\n",
        "    '''\n",
        "    used in self.get_spice_amount()\n",
        "    '''\n",
        "\n",
        "    this_cell = self.model.grid.get_cell_list_contents(pos)\n",
        "    for agent in this_cell:\n",
        "      if type(agent) is Spice:\n",
        "        return agent\n",
        "    return None\n",
        "\n",
        "  def get_spice_amount(self, pos):\n",
        "    '''\n",
        "    used in self.move() as part of self.calculate_welfare()\n",
        "    '''\n",
        "\n",
        "    spice_patch = self.get_spice(pos)\n",
        "    if spice_patch:\n",
        "      return spice_patch.amount\n",
        "    return 0\n",
        "\n",
        "  def get_trader(self, pos):\n",
        "      '''\n",
        "      helper function used in self.trade_with_neighbors()\n",
        "      '''\n",
        "\n",
        "      this_cell = self.model.grid.get_cell_list_contents(pos)\n",
        "\n",
        "      for agent in this_cell:\n",
        "        if isinstance(agent, Trader):\n",
        "          return agent\n",
        "\n",
        "\n",
        "  def is_occupied_by_other(self,pos):\n",
        "    '''\n",
        "    helper function part 1 of self.move()\n",
        "    '''\n",
        "\n",
        "    if pos == self.pos:\n",
        "      # agent's position is considered unoccupied as agent can stay there\n",
        "      return False\n",
        "    # get contents of each cell in neighborhood\n",
        "    this_cell = self.model.grid.get_cell_list_contents(pos)\n",
        "    for a in this_cell:\n",
        "      # see if occupied by another agent\n",
        "      if isinstance(a, Trader):\n",
        "        return True\n",
        "    return False\n",
        "\n",
        "  def calculate_welfare(self, sugar, spice):\n",
        "    '''\n",
        "    helper function\n",
        "\n",
        "    part 2 self.move()\n",
        "    self.trade()\n",
        "    '''\n",
        "\n",
        "    # calculate total resources\n",
        "    m_total = self.metabolism_sugar + self.metabolism_spice\n",
        "    # Cobb-Douglas functional form; starting on p. 97 on Growing Artificial Societies\n",
        "    return sugar**(self.metabolism_sugar/m_total) * spice**(\n",
        "        self.metabolism_spice/m_total)\n",
        "\n",
        "\n",
        "  def is_starved(self):\n",
        "    '''\n",
        "    Helper function for self.maybe_die()\n",
        "    '''\n",
        "\n",
        "    return (self.sugar <= 0) or (self.spice <= 0)\n",
        "\n",
        "  def calculate_MRS(self, sugar, spice):\n",
        "    '''\n",
        "    Helper function for\n",
        "    - self.trade()\n",
        "    - self.maybe_sell_spice()\n",
        "\n",
        "    Determines what trader agent is needs and can give up\n",
        "    '''\n",
        "\n",
        "    return (spice/self.metabolism_spice) / (sugar/self.metabolism_sugar)\n",
        "\n",
        "  def calculate_sell_spice_amount(self, price):\n",
        "    '''\n",
        "    helper function for self.maybe_sell_spice() which is called from\n",
        "    self.trade()\n",
        "    '''\n",
        "\n",
        "    if price >= 1:\n",
        "      sugar = 1\n",
        "      spice = int(price)\n",
        "    else:\n",
        "      sugar = int(1/price)\n",
        "      spice = 1\n",
        "    return sugar, spice\n",
        "\n",
        "  def sell_spice(self, other, sugar, spice):\n",
        "    '''\n",
        "    used in self.maybe_sell_spice()\n",
        "\n",
        "    exchanges sugar and spice between traders\n",
        "    '''\n",
        "\n",
        "    self.sugar += sugar\n",
        "    other.sugar -= sugar\n",
        "    self.spice -= spice\n",
        "    other.spice += spice\n",
        "\n",
        "\n",
        "  def maybe_sell_spice(self, other, price, welfare_self, welfare_other):\n",
        "    '''\n",
        "    helper function for self.trade()\n",
        "    '''\n",
        "\n",
        "    sugar_exchanged, spice_exchanged = self.calculate_sell_spice_amount(price)\n",
        "\n",
        "    # Assess new sugar and spice amount - what if change did occur\n",
        "    self_sugar = self.sugar + sugar_exchanged\n",
        "    other_sugar = other.sugar - sugar_exchanged\n",
        "    self_spice = self.spice - spice_exchanged\n",
        "    other_spice = other.spice + spice_exchanged\n",
        "\n",
        "    # double check to ensure agents have resources\n",
        "\n",
        "    if ((self_sugar <= 0) or\n",
        "        (other_sugar <=0) or\n",
        "        (self_spice <= 0) or\n",
        "        (other_spice <= 0)):\n",
        "      return False\n",
        "\n",
        "    # trade criteria #1 - are both agents better off?\n",
        "    both_agents_better_off = (\n",
        "        (welfare_self < self.calculate_welfare(self_sugar, self_spice)) and\n",
        "        (welfare_other < other.calculate_welfare(other_sugar, other_spice)))\n",
        "\n",
        "    # trade criteria #2 is their mrs crossing\n",
        "    mrs_not_crossing = self.calculate_MRS(self_sugar, self_spice\n",
        "                                          ) > other.calculate_MRS(\n",
        "                                              other_sugar, other_spice\n",
        "                                          )\n",
        "\n",
        "    if not (both_agents_better_off and mrs_not_crossing):\n",
        "      return False\n",
        "\n",
        "    # criteria met, execute trade\n",
        "    self.sell_spice(other, sugar_exchanged, spice_exchanged)\n",
        "\n",
        "    return True\n",
        "\n",
        "\n",
        "  def trade(self, other):\n",
        "    '''\n",
        "    helper function used in trade_with_neighbors()\n",
        "\n",
        "    other is a trader agent object\n",
        "    '''\n",
        "\n",
        "    # sanity check to verify code is working as expected\n",
        "    assert self.sugar > 0\n",
        "    assert self.spice > 0\n",
        "    assert other.sugar > 0\n",
        "    assert other.spice > 0\n",
        "\n",
        "    # calculate marginal rate of subsitution in Growing Artificial Socieites p. 101\n",
        "    mrs_self = self.calculate_MRS(self.sugar, self.spice)\n",
        "    mrs_other = other.calculate_MRS(other.sugar, other.spice)\n",
        "\n",
        "    #calculate each agents welfare\n",
        "    welfare_self = self.calculate_welfare(self.sugar, self.spice)\n",
        "    welfare_other = other.calculate_welfare(other.sugar, other.spice)\n",
        "\n",
        "    if math.isclose(mrs_self, mrs_other):\n",
        "      return\n",
        "\n",
        "    # calcualte price\n",
        "    price = math.sqrt(mrs_self*mrs_other)\n",
        "\n",
        "    if mrs_self > mrs_other:\n",
        "      # self is a sugar buyer, spice seller\n",
        "      sold = self.maybe_sell_spice(other, price, welfare_self, welfare_other)\n",
        "      # no trade - criteria not met\n",
        "      if not sold:\n",
        "        return\n",
        "    else:\n",
        "      # self is a spice buyer, sugar seller\n",
        "      sold = other.maybe_sell_spice(self, price, welfare_other, welfare_self)\n",
        "      # no trade - criteria not met\n",
        "      if not sold:\n",
        "        return\n",
        "\n",
        "    # Capture data\n",
        "    self.prices.append(price)\n",
        "    self.trade_partners.append(other.unique_id)\n",
        "\n",
        "    # continue trading\n",
        "    self.trade(other)\n",
        "\n",
        "  ######################################################################\n",
        "  #                                                                    #\n",
        "  #                      MAIN TRADE FUNCTIONS                          #\n",
        "  #                                                                    #\n",
        "  ######################################################################\n",
        "\n",
        "\n",
        "  def move(self):\n",
        "    '''\n",
        "    Function for trader agent to identify optimal move for each step in 4 parts\n",
        "    1 - identify all possible moves\n",
        "    2 - determine which move maximizes welfare\n",
        "    3 - find closest best option\n",
        "    4 - move\n",
        "    '''\n",
        "\n",
        "    # 1. identify all possible moves\n",
        "\n",
        "    neighbors = [i\n",
        "                 for i in self.model.grid.get_neighborhood(\n",
        "                   self.pos, self.moore, True, self.vision\n",
        "                 ) if not self.is_occupied_by_other(i)]\n",
        "\n",
        "    # 2. determine which move maximizes welfare\n",
        "\n",
        "    welfares = [\n",
        "        self.calculate_welfare(\n",
        "            self.sugar + self.get_sugar_amount(pos),\n",
        "            self.spice + self.get_spice_amount(pos))\n",
        "        for pos in neighbors\n",
        "    ]\n",
        "\n",
        "    # 3. Find closest best option\n",
        "\n",
        "    # find the highest welfare in welfares\n",
        "    max_welfare = max(welfares)\n",
        "    # get the index of max welfare cells\n",
        "    candidate_indices = [i for i in range(len(welfares))\n",
        "                        if math.isclose(welfares[i], max_welfare)]\n",
        "\n",
        "    # convert index to positions of those cells\n",
        "    candidates = [neighbors[i] for i in candidate_indices]\n",
        "\n",
        "    min_dist = min(get_distance(self.pos, pos) for pos in candidates)\n",
        "\n",
        "    final_candidates = [ pos for pos in candidates\n",
        "                       if math.isclose(get_distance(self.pos, pos), min_dist, rel_tol=1e-02\n",
        "                                       )]\n",
        "    self.random.shuffle(final_candidates)\n",
        "\n",
        "    # 4. Move Agent\n",
        "    self.model.grid.move_agent(self, final_candidates[0])\n",
        "\n",
        "  def eat(self):\n",
        "    # get sugar\n",
        "    sugar_patch = self.get_sugar(self.pos)\n",
        "\n",
        "    if sugar_patch:\n",
        "        self.sugar += sugar_patch.amount\n",
        "        sugar_patch.amount = 0\n",
        "    self.sugar -= self.metabolism_sugar\n",
        "\n",
        "    # get_spice\n",
        "    spice_patch = self.get_spice(self.pos)\n",
        "\n",
        "    if spice_patch:\n",
        "        self.spice += spice_patch.amount\n",
        "        spice_patch.amount = 0\n",
        "    self.spice -= self.metabolism_spice\n",
        "\n",
        "  def maybe_die(self):\n",
        "    '''\n",
        "    Function to remove Traders who have consumed all their sugar or spice\n",
        "    '''\n",
        "\n",
        "    if self.is_starved():\n",
        "      self.model.grid.remove_agent(self)\n",
        "      self.model.schedule.remove(self)\n",
        "\n",
        "  def trade_with_neighbors(self):\n",
        "    '''\n",
        "    Function for trader agents to decide who to trade with in three parts\n",
        "\n",
        "    1- identify neighbors who can trade\n",
        "    2- trade (2 sessions)\n",
        "    3- collect data\n",
        "    '''\n",
        "\n",
        "    neighbor_agents = [self.get_trader(pos) for pos in self.model.grid.get_neighborhood(\n",
        "        self.pos, self.moore, False, self.vision) if self.is_occupied_by_other(pos)\n",
        "    ]\n",
        "\n",
        "    if len(neighbor_agents) == 0:\n",
        "      return\n",
        "\n",
        "\n",
        "    # iterate through traders in neighboring cells and trade\n",
        "    for a in neighbor_agents:\n",
        "      if a:\n",
        "        self.trade(a)\n",
        "\n",
        "    return"
      ],
      "metadata": {
        "id": "t51BNfwUnt53"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Model Class"
      ],
      "metadata": {
        "id": "SRrU2ABBoF0i"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class SugarscapeG1mt(mesa.Model):\n",
        "  \"\"\"\n",
        "  Manager class to run Sugarscape with Traders\n",
        "  \"\"\"\n",
        "\n",
        "\n",
        "  def __init__(self, width=50,height=50, initial_population=200,\n",
        "               endowment_min=25, endowment_max=50, metabolism_min=1,\n",
        "               metabolism_max=5, vision_min=1, vision_max=5):\n",
        "\n",
        "    #Initiate width and heigh of sugarscape\n",
        "    self.width = width\n",
        "    self.height = height\n",
        "    #Initiate population attributes\n",
        "    self.initial_population = initial_population\n",
        "    self.endowment_min = endowment_min\n",
        "    self.endowment_max = endowment_max\n",
        "    self.metabolism_min = metabolism_min\n",
        "    self.metabolism_max = metabolism_max\n",
        "    self.vision_min = vision_min\n",
        "    self.vision_max = vision_max\n",
        "\n",
        "    #initiate activation schedule\n",
        "    self.schedule = mesa.time.RandomActivationByType(self)\n",
        "    #initiate mesa grid class\n",
        "    self.grid = mesa.space.MultiGrid(self.width, self.height, torus=False)\n",
        "\n",
        "    #read in landscape file from supplmentary material\n",
        "    sugar_distribution =np.genfromtxt(\"/content/drive/MyDrive/sugar-map.txt\")\n",
        "    spice_distribution = np.flip(sugar_distribution, 1)\n",
        "\n",
        "    agent_id = 0\n",
        "    for _,(x,y) in self.grid.coord_iter():\n",
        "      max_sugar = sugar_distribution[x,y]\n",
        "      if max_sugar > 0:\n",
        "        sugar = Sugar(agent_id, self, (x,y), max_sugar)\n",
        "        self.schedule.add(sugar)\n",
        "        self.grid.place_agent(sugar, (x,y))\n",
        "        agent_id += 1\n",
        "\n",
        "      max_spice = spice_distribution[x,y]\n",
        "      if max_spice > 0:\n",
        "        spice = Spice(agent_id, self, (x,y), max_spice)\n",
        "        self.schedule.add(spice)\n",
        "        self.grid.place_agent(spice, (x,y))\n",
        "        agent_id += 1\n",
        "\n",
        "    for i in range(self.initial_population):\n",
        "      #get agent position\n",
        "      x = self.random.randrange(self.width)\n",
        "      y = self.random.randrange(self.height)\n",
        "      #see Growing Artificial Societies p. 108 for initialization\n",
        "      #give agents initial endowment\n",
        "      sugar = int(self.random.uniform(self.endowment_min, self.endowment_max+1))\n",
        "      spice = int(self.random.uniform(self.endowment_min, self.endowment_max+1))\n",
        "      #give agents initial metabolism\n",
        "      metabolism_sugar = int(self.random.uniform(self.metabolism_min, self.metabolism_max+1))\n",
        "      metabolism_spice = int(self.random.uniform(self.metabolism_min, self.metabolism_max+1))\n",
        "      #give agents vision\n",
        "      vision = int(self.random.uniform(self.vision_min, self.vision_max+1))\n",
        "      #create Trader object\n",
        "      trader = Trader(agent_id,\n",
        "                      self,\n",
        "                      (x,y),\n",
        "                      moore = False,\n",
        "                      sugar = sugar,\n",
        "                      spice = spice,\n",
        "                      metabolism_sugar = metabolism_sugar,\n",
        "                      metabolism_spice = metabolism_spice,\n",
        "                      vision = vision)\n",
        "      #place agent\n",
        "      self.grid.place_agent(trader, (x,y))\n",
        "      self.schedule.add(trader)\n",
        "      agent_id += 1\n",
        "\n",
        "  def randomize_traders(self):\n",
        "    '''\n",
        "    helper function for self.step()\n",
        "\n",
        "    puts traders in randomized list for step function\n",
        "    '''\n",
        "\n",
        "    trader_shuffle = list(self.schedule.agents_by_type[Trader].values())\n",
        "    self.random.shuffle(trader_shuffle)\n",
        "\n",
        "    return trader_shuffle\n",
        "\n",
        "\n",
        "  def step(self):\n",
        "    '''\n",
        "    Unique step function that does staged activation of sugar and spice\n",
        "    and then randomly activates traders\n",
        "    '''\n",
        "    # step Sugar agents\n",
        "    for sugar in self.schedule.agents_by_type[Sugar].values():\n",
        "      sugar.step()\n",
        "\n",
        "    # step Spice agents\n",
        "    for spice in self.schedule.agents_by_type[Spice].values():\n",
        "      spice.step()\n",
        "\n",
        "    # step trader agents\n",
        "    # to account for agent death and removal we need a seperate data strcuture to\n",
        "    # iterate\n",
        "    trader_shuffle = self.randomize_traders()\n",
        "\n",
        "    for agent in trader_shuffle:\n",
        "      agent.prices = []\n",
        "      agent.trade_partners = []\n",
        "      agent.move()\n",
        "      agent.eat()\n",
        "      agent.maybe_die()\n",
        "\n",
        "    trader_shuffle = self.randomize_traders()\n",
        "\n",
        "    for agent in trader_shuffle:\n",
        "      agent.trade_with_neighbors()\n",
        "      print(agent.prices, agent.trade_partners)\n",
        "\n",
        "    self.schedule.steps += 1 #important for data collector to track number of steps\n",
        "\n",
        "  def run_model(self, step_count=1000):\n",
        "\n",
        "    for i in range(step_count):\n",
        "      self.step()"
      ],
      "metadata": {
        "id": "7DTonjahn2BT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Run Sugarscape"
      ],
      "metadata": {
        "id": "_KHKfeD9oiYo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model = SugarscapeG1mt()\n",
        "model.run_model(step_count=1)\n"
      ],
      "metadata": {
        "id": "at455urSol7b"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "vemquyVptT3Z"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}