Initial commit

Author: Martin Vo

.gitignore

@@ -0,0 +1,5 @@
+.simulation
+__pycache__
+*pyc
+.DS_Store
+.ipynb_checkpoints

README.md

@@ -1,2 +1,2 @@
-# transtycoon
+# Transtycoon
 Optimization  for transports logistic -warehouses location, transport types, waiting policy etc.

notebooks/optimal_warehouse_position.ipynb

@@ -0,0 +1,132 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "\n",
+    "sys.path.insert(0, \"..\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transtycoon.entities import Field, Warehouse, Position, Transporter\n",
+    "from transtycoon.simulation import OneWayGathering, Simulation\n",
+    "from transtycoon.report import plot_objects"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "log = False\n",
+    "\n",
+    "field1 = Field(Position(10, -10), 70, name=\"Field1\")\n",
+    "field2 = Field(Position(-5, 20), 70, name=\"Field2\")\n",
+    "inter_warehouse = Warehouse(Position(-5, 10))\n",
+    "final_warehouse = Warehouse(Position(-20, 0))\n",
+    "transporter1 = Transporter(Position(0, 0), speed=1, max_capacity=30, name=\"Field truck 1\", log=log)\n",
+    "transporter2 = Transporter(Position(0, 0), speed=1, max_capacity=30, name=\"Field truck 2\", log=log)\n",
+    "transporter3 = Transporter(Position(0, 0), speed=1, max_capacity=50, name=\"Warehouse truck 1\", log=log)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "field1_to_warehouse_task = OneWayGathering(gather_from=field1, deliver_to=inter_warehouse)\n",
+    "field2_to_warehouse_task = OneWayGathering(gather_from=field2, deliver_to=inter_warehouse)\n",
+    "warehouse_to_warehouse = OneWayGathering(gather_from=inter_warehouse,\n",
+    "                                         deliver_to=final_warehouse,\n",
+    "                                         wait_for=[transporter1, transporter2],\n",
+    "                                        min_amount=40)\n",
+    "\n",
+    "transporter1.assign_task_queue([field1_to_warehouse_task, field2_to_warehouse_task])\n",
+    "transporter2.assign_task_queue([field2_to_warehouse_task, field1_to_warehouse_task])\n",
+    "transporter3.assign_task_queue([warehouse_to_warehouse])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "animate_objects = {\"warehouses\": [inter_warehouse, final_warehouse],\n",
+    "                   \"transports\": [transporter1, transporter2, transporter3],\n",
+    "                   \"fields\": [field1, field2]\n",
+    "                  }\n",
+    "simulation = Simulation(transports=[transporter1, transporter2, transporter3], captured_objects=animate_objects)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.6/site-packages/matplotlib/pyplot.py:524: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`).\n",
+      "  max_open_warning, RuntimeWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Video created at .simulation/12c3e61e21784240ba46d6b303bce04d/animation.avi\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'simulation_steps': 149,\n",
+       " 'total_work_steps': 395,\n",
+       " 'transport_steps': [119, 128, 148]}"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "simulation.make_turns()"
+   ]
+  }
+ ],
+ "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
+}

notebooks/transport_logistic-intro.ipynb

@@ -0,0 +1,178 @@
+from mock import Mock
+
+from transtycoon import exceptions
+from transtycoon.report import get_logger
+
+
+class Field:
+
+    def __init__(self, position, resources, name=None):
+        self.position = position
+        self.resources = resources
+        self.name = name or "Field"
+
+    def __repr__(self):
+        return "{} (resources = {} position = {}".format(self.name, self.resources, self.position)
+
+
+class Warehouse:
+
+    # Capacity = None means unlimited capacity
+    def __init__(self, position, capacity=None, name=None):
+        self.position = position
+        self.capacity = capacity
+        self.name = name or "Warehouse"
+
+        self.resources = 0
+
+    def __repr__(self):
+        return "{} (resources = {} position = {}".format(self.name, self.resources, self.position)
+
+    def has_free_space(self):
+        if self.capacity is None:
+            return True
+
+        if self.get_free_capacity() > 0:
+            return True
+
+        return False
+
+    def get_free_capacity(self):
+        return self.capacity - self.resources if self.capacity is not None else None
+
+
+class Position:
+    EPS = 1e-3
+
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+
+    def get_distance(self, other):
+        # Doesnt have to euclidian distance, but rather distance dependent on the real routes
+        return ((self.x - other.x) ** 2 + (self.y - other.y) ** 2) ** 0.5
+
+    def __eq__(self, other):
+        if isinstance(other, Position):
+            return abs(self.x - other.x) < self.EPS and abs(self.y - other.y) < self.EPS
+        return False
+
+    def __repr__(self):
+        return "[{0:.1f}, {0:.1f}]".format(self.x, self.y)
+
+
+class Transporter:
+
+    def __init__(self, position, max_capacity=10, speed=1, name=None, log=True):
+        self.position = position
+        self.speed = speed
+        self.max_capacity = max_capacity
+        self.name = name or "Truck"
+
+        self.loaded = 0
+        self.distance_travelled = 0
+        self.tasks = []
+        self.historical_tasks = []
+        self.work_steps = 0
+        self.transported = 0
+
+        self.log = get_logger().bind(name=self.name, position=self.position) if log else Mock()
+
+    def __repr__(self):
+        return "[{}] position: {} loaded: {}/{}".format(self.name or "Unknown", self.position, self.loaded,
+                                                        self.max_capacity)
+
+    def can_load(self, field, min_amount=0):
+        if self.position != field.position:
+            return exceptions.NotInPlaceException()
+
+        elif not field.resources > 0:
+            return exceptions.NothingToLoadException()
+
+        elif self.max_capacity - self.loaded < min_amount:
+            return exceptions.TruckIsAlredyFullException()
+
+        elif not field.resources > min_amount:
+            return exceptions.NotEnoughResources()
+
+        return True
+
+    def load(self, field):
+        if self.can_load(field) is not True:
+            raise self.can_load(field)
+
+        to_load = min(field.resources, self.max_capacity - self.loaded)
+
+        field.resources -= to_load
+        self.loaded += to_load
+        return to_load
+
+    def can_unload(self, warehouse):
+        if self.position != warehouse.position:
+            return exceptions.NotInPlaceException()
+
+        elif not warehouse.has_free_space():
+            return exceptions.StorageIsFullException()
+        return True
+
+    def unload(self, warehouse):
+        if self.can_unload(warehouse) is not True:
+            raise self.can_unload(warehouse)
+
+        cap = warehouse.get_free_capacity()
+        to_unload = min(self.loaded, cap) if cap is not None else self.loaded
+
+        self.loaded -= to_unload
+        warehouse.resources += to_unload
+
+        self.transported += to_unload
+        return to_unload
+
+    def is_on_position(self, position):
+        return self.position == position
+
+    def get_steps_to_postion(self, position):
+        return self.position.get_distance(position) / self.speed
+
+    def go_to_position(self, position):
+        assert not self.is_on_position(position)
+
+        steps_needed = self.get_steps_to_postion(position)
+
+        if steps_needed < 1:
+            self.distance_travelled += self.speed * steps_needed
+
+            self.position.x = position.x
+            self.position.y = position.y
+            return 0
+
+        else:
+            self.distance_travelled += self.speed
+
+            self.position.x += (position.x - self.position.x) / steps_needed
+            self.position.y += (position.y - self.position.y) / steps_needed
+            return steps_needed - 1
+
+    def assign_task_queue(self, tasks):
+        self.tasks = tasks
+
+    def work(self):
+        if self.is_working():
+
+            self.work_steps += 1
+            if not self.tasks[0].work(self):
+                while len(self.tasks):
+                    if self.tasks[0].completed:
+                        self.historical_tasks.append(self.tasks[0])
+                        self.tasks.pop(0)
+                        self.log.info("Task is finished", finished=len(self.historical_tasks), remaining=len(self.tasks))
+                    else:
+                        break
+
+            if len(self.tasks):
+                return True
+        self.log.info("All tasks is finished")
+        return False
+
+    def is_working(self):
+        return len(self.tasks) > 0 or self.loaded > 0

notebooks/transport_logistic_simulation.ipynb

@@ -0,0 +1,24 @@
+
+
+class NotInPlaceException(Exception):
+    pass
+
+
+class NothingToLoadException(Exception):
+    pass
+
+
+class TruckIsAlredyFullException(Exception):
+    pass
+
+
+class StorageIsFullException(Exception):
+    pass
+
+
+class RoutineFinished(StopIteration):
+    pass
+
+
+class NotEnoughResources(Exception):
+    pass

samples/animation_sample1.avi

@@ -0,0 +1,48 @@
+import structlog
+from matplotlib import pyplot as plt
+
+
+def renderer(logger, name, event_dict, **kwargs):
+
+    t = "Time {}".format(event_dict.pop("time")) if "time" in event_dict else ""
+
+    event = event_dict.pop("event") if "event" in event_dict else ""
+    name = ", {}".format(event_dict.pop("name")) if "name" in event_dict else ""
+
+    return "[{}{}] {} : {}".format(t, name, event,
+                                      "  ".join(["{}={}".format(key, value) for key, value in event_dict.items()]))
+
+
+def get_logger():
+    structlog.configure(processors=[renderer])
+    return structlog.get_logger()
+
+
+def plot_objects(warehouses=None, fields=None, transports=None, ax=None, scale=20, min_size=20, shift=None):
+    fig = None
+    if not ax:
+        fig, ax = plt.subplots(figsize=(13, 8))
+
+    if shift is None:
+        shift = [0, 0]
+
+    for field in fields or []:
+        ax.scatter(field.position.x + shift[0], field.position.y + shift[1], s=field.resources * scale + min_size,
+                   marker=r'$\clubsuit$')
+        ax.annotate(field.name, (field.position.x + shift[0], field.position.y + shift[1]))
+
+    for warehouse in warehouses or []:
+        ax.scatter(warehouse.position.x + shift[0], warehouse.position.y + shift[1],
+                   s=warehouse.resources * scale + min_size)
+        ax.annotate(warehouse.name, (warehouse.position.x + shift[0], warehouse.position.y + shift[1]))
+
+    for transport in transports or []:
+        ax.scatter(transport.position.x + shift[0], transport.position.y + shift[1],
+                   s=transport.loaded * scale + min_size, marker='^')
+        ax.scatter(transport.position.x + shift[0], transport.position.y + shift[1],
+                   s=transport.max_capacity * scale + min_size, marker='^',
+                   alpha=0.5)
+
+        ax.annotate(transport.name, (transport.position.x, transport.position.y))
+
+    return fig, ax