prototype.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# First model for warehouse picking optimisation\n",
    "\n",
    "This notebook contains code to optimise the following problem.\n",
    "\n",
    "Suppose we have a warehouse with $n$ unique products, and $n$ pick faces ($n$ must be even). The pick faces are laid out as below, in a single aisle on shelves with no shelves on top of each other, with odd number increasing on the left, and even numbers increasing from bottom up on the right. The diagram is viewed from the air, looking down, and let's say up is \"north\".\n",
    "\n",
    "```\n",
    "+---+    >.....v    +---+\n",
    "|n-1|    :     :    | n |\n",
    "+---+    ^.>...v    +---+\n",
    "|   |    :     :    |   |\n",
    "\n",
    "           ...\n",
    "\n",
    "|   |    :     :    |   |\n",
    "+---+    ^.>...v    +---+\n",
    "| 7 |    :     :    | 8 |\n",
    "+---+    ^.>...v    +---+\n",
    "| 5 |    :     :    | 6 |\n",
    "+---+    ^.>...v    +---+\n",
    "| 3 |    :     :    | 4 |\n",
    "+---+    ^.>...v    +---+\n",
    "| 1 |    :     :    | 2 |\n",
    "+---+    .     v    +---+\n",
    "     @...^     :\n",
    " PC  #.<       >.. Sorting\n",
    "       :              v\n",
    "       ^..............<\n",
    "```\n",
    "\n",
    "The picking procedure (a single \"pick wave\") works as follows:\n",
    "\n",
    "1. The picker starts at the PC, marked with an at sign (`@`) on the map\n",
    "2. The picker prints out a flow path from the WMS+optimiser at the computer (`PC`)\n",
    "3. The picker then starts walking up on the left hand side of the aisle, next to the odd pick faces.\n",
    "4. If the picker has nothing to pick north of the current location, they can move to the right and start picking products in even pick faces, and walk south along the right side of the aisle.\n",
    "5. Once the picker has picked all items from their shelves, they move down to the sorting facility (`Sorting` on the diagram)\n",
    "6. The picker sorts and packs all orders into their correct shipping packages, and drops them off at the same location\n",
    "7. The picker moves back to the PC and finishes at the hash sign (`#`) on the map\n",
    "\n",
    "## The cost structure\n",
    "\n",
    "We model the time taken to pick an order as the cost for this problem.\n",
    "\n",
    "It's relatively difficult to estimate the actual time taken to complete each step of a pick wave, so we leave this in a highly modular and customisable system.\n",
    "\n",
    "We basically assume the cost of a pick wave is a linear function of the following steps which may have more difficult, non-linear cost functions:\n",
    "\n",
    "* $c_{\\text{fixed}}$: A fixed cost of one pick wave (e.g. printing, moving from computer to first shelf, last shelf to sorting, sorting to computer, rest)\n",
    "* $c_{\\text{move}}$: Moving one shelf up or down the aisle (note that there are always an even number of these steps)\n",
    "* $c_{\\text{across}}$: Moving across the aisle from left to right\n",
    "* $c_{\\text{picking}}$: Picking objects from a shelf into containers, this is encoded as $p_1$, $p_2$, $\\dots$, $p_q$ where $q$ is the number of containers, and $p_i$ is the number of identical objects picked form a shelf into container $i$. The cost for this tuple is a function $c_{\\text{picking}}(q, (p_1, p_2, \\dots, p_q))$.\n",
    "* $c_{\\text{sorting}}$: Sorting objects in $q$ containers to $r$ shipping \"packages\" (note the terminology: containers are used for picking from shelves, packages for final postable boxes), this is encoded as $g_{ij}$ with $i=1,\\dots,q$ and $j=1,\\dots,r$ for the number of items from container $i$ being sorted into package $j$, so the cost function is $c_{\\text{sorting}}(q, r, ((g_{11}, g_{12}, \\dots, g_{1r}), (g_{21}, g_{22}, \\dots, g_{2r}), \\dots, (g_{q1}, g_{q2}, \\dots, g_{qr})))$\n",
    "\n",
    "The total cost, $C:=c_{\\text{total}}$, is then given by the sum of these costs:\n",
    "\n",
    "$$\n",
    "C=n_{\\text{fixed}}\\times c_{\\text{fixed}}+n_{\\text{move}}\\times c_{\\text{move}}+n_{\\text{across}}\\times c_{\\text{across}}+\\sum_{q,p_1,p_2,\\dots,p_q}n_{\\text{picking}}(q, (p_1, p_2, \\dots, p_q))\\times c_{\\text{picking}}(q, (p_1, p_2, \\dots, p_q))+\\sum_{q,r,g_1,g_2,\\dots,g_q,g_{11},\\dots,g_{qr}}n_{\\text{sorting}}(q, r, ((g_{11}, g_{12}, \\dots, g_{1r}), (g_{21}, g_{22}, \\dots, g_{2r}), \\dots, (g_{q1}, g_{q2}, \\dots, g_{qr})))c_{\\text{sorting}}(q, r, ((g_{11}, g_{12}, \\dots, g_{1r}), (g_{21}, g_{22}, \\dots, g_{2r}), \\dots, (g_{q1}, g_{q2}, \\dots, g_{qr})))\n",
    "$$\n",
    "\n",
    "Where the $n_{\\text{fixed}}$, $n_{\\text{move}}$, and $n_{\\text{across}}$ are the number of pick waves, the number of times a picker moved up or down, and the number of times a picker moved across the aisle, respectively.\n",
    "\n",
    "$n_{\\text{picking}}(q, (p_1, p_2, \\dots, p_q))$ is the number of times the same type of object was picked from a shelf into $q$ containers with the $q$ containers getting $p_1$, $p_2$, $\\dots$, $p_q$ items per container.\n",
    "\n",
    "$n_{\\text{sorting}}(q, r, ((g_{11}, g_{12}, \\dots, g_{1r}), (g_{21}, g_{22}, \\dots, g_{2r}), \\dots, (g_{q1}, g_{q2}, \\dots, g_{qr})))$ is the number of times that objects in $q$ containers were sorted into $r$ packages, with $g_{ij}$ objects being sorted from container $i$ into package $j$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import shuffle\n",
    "from scipy.stats import zipf, poisson\n",
    "from numpy.random import choice\n",
    "from numpy import reshape, count_nonzero\n",
    "from dataclasses import dataclass, field\n",
    "from typing import List, Tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_product_probabilities_pareto(zipf_shape, products):\n",
    "    # to get wikipedia zipf from scipy zipf, just truncate\n",
    "    distribution = zipf(zipf_shape)\n",
    "    freqs = [distribution.pmf(n+1) for n in range(len(products))]\n",
    "    freqs = freqs / sum(freqs)\n",
    "    shuffle(freqs)\n",
    "\n",
    "    return dict(zip(products, freqs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# assignment of products to pick faces\n",
    "def assign_products_to_pick_faces_random(products, pick_faces):\n",
    "    # random\n",
    "    pick_face_assignments = pick_faces.copy()\n",
    "    shuffle(pick_face_assignments)\n",
    "\n",
    "    product_to_pick_face = dict(zip(products, pick_face_assignments))\n",
    "    pick_face_to_product = dict(zip(product_to_pick_face.values(), product_to_pick_face.keys()))\n",
    "    \n",
    "    return product_to_pick_face, pick_face_to_product\n",
    "\n",
    "def assign_products_to_pick_faces_pareto(products, pick_faces, product_probabilities):\n",
    "    # according to freq (akin to Andrew's pareto method)\n",
    "    product_probs_for_assignment = list(product_probabilities.items())\n",
    "    product_probs_for_assignment.sort(key=lambda x: -x[1])\n",
    "    product_to_pick_face = dict(zip(map(lambda x: x[0], product_probs_for_assignment), pick_faces))\n",
    "    pick_face_to_product = dict(zip(product_to_pick_face.values(), product_to_pick_face.keys()))\n",
    "    \n",
    "    return product_to_pick_face, pick_face_to_product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@dataclass\n",
    "class PickingCost:\n",
    "    \"\"\"\n",
    "    Class to keep track of the individual actions done during\n",
    "    picking, and computing the cost (at the moment time) required\n",
    "    to perform them\n",
    "    \"\"\"\n",
    "\n",
    "    n_fixed: int = 0\n",
    "    n_move: int = 0\n",
    "    n_across: int = 0\n",
    "    n_picking: List[Tuple] = field(default_factory=list)\n",
    "    n_sorting: List[Tuple] = field(default_factory=list)\n",
    "\n",
    "    def __add__(self, other):\n",
    "        return PickingCost(self.n_fixed + other.n_fixed,\n",
    "                            self.n_move + other.n_move,\n",
    "                            self.n_across + other.n_across,\n",
    "                            self.n_picking + other.n_picking,\n",
    "                            self.n_sorting + other.n_sorting)\n",
    "    def __len__(self):\n",
    "        \"\"\"The \"length\" of the picking cost is the number of the picks\"\"\"\n",
    "        return len(self.n_picking)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_picking_costs(costs):\n",
    "    total = costs[0]\n",
    "    for cost in costs[1:]:\n",
    "        total += cost\n",
    "    return total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Some sample cost functions\n",
    "\n",
    "def _cost_picking(n_picking):\n",
    "    \"\"\"\n",
    "    We use this picking cost:\n",
    "    \n",
    "    * It costs 2 seconds to pick something from a shelf\n",
    "    * Plus 1 second for each item\n",
    "    * Plus 0.4 seconds for each extra container we have (presumably it takes a moment to figure\n",
    "        out which container to place the item in)\n",
    "    \"\"\"\n",
    "    return 3 + 1 * sum(n_picking[1:]) + 0.4 * n_picking[0]\n",
    "\n",
    "def _cost_sorting(n_sorting):\n",
    "    \"\"\"\n",
    "    We use this sorting cost:\n",
    "    \n",
    "    For each container, it costs a quadratic amount of time in the largest outgoing package\n",
    "        size, except if all items are put into the same package\n",
    "    \"\"\"\n",
    "\n",
    "    def _cost_sorting_per_container(container):\n",
    "        # if we just move from the container to the package, there's no sorting cost\n",
    "        if count_nonzero(container) <= 1:\n",
    "            return 0\n",
    "        \n",
    "        m = max(container)\n",
    "        \n",
    "        return 2 + m + m*m/10\n",
    "\n",
    "    q, r = n_sorting[:2]\n",
    "    \n",
    "    # turn it into a list of lists\n",
    "    containers = reshape(n_sorting[2:], (q, r))\n",
    "\n",
    "    return sum(map(_cost_sorting_per_container, containers))\n",
    "\n",
    "def total_time(c, *, pick_cost_fn=_cost_picking, sort_cost_fn=_cost_sorting):\n",
    "    # say it takes 2 minutes to print and walk around as fixed cost\n",
    "    cost_fixed = 8 * c.n_fixed\n",
    "    # 5 seconds to move from one shelf to another\n",
    "    cost_move = 3 * c.n_move\n",
    "    # 10 seconds to move across the aisle\n",
    "    cost_across = 3 * c.n_across\n",
    "\n",
    "    cost_picking = sum(map(_cost_picking, c.n_picking))\n",
    "    cost_sorting = sum(map(_cost_sorting, c.n_sorting))\n",
    "\n",
    "    return cost_fixed + cost_move + cost_across + cost_picking + cost_sorting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Product:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def __repr__(self):\n",
    "        return \"product {}\".format(self.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PickFace:\n",
    "    def __init__(self, number):\n",
    "        self.number = number\n",
    "\n",
    "    def location(self):\n",
    "        \"\"\"\n",
    "        We'll just use some (x,y) where x is 0 or 1 (side of aisle) and y is height starting from 0\n",
    "        \"\"\"\n",
    "        \n",
    "        return (self.number % 2, self.number // 2)\n",
    "\n",
    "    def __repr__(self):\n",
    "        return \"face {}\".format(self.number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Order:\n",
    "    def __init__(self, product_list):\n",
    "        self._products = product_list\n",
    "        \n",
    "    def products(self):\n",
    "        return self._products\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return \"Order with {} products\".format(len(self._products))\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self._products)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_new_order(number_of_products, product_probabilities):\n",
    "    labels, weights = zip(*product_probabilities.items())\n",
    "    return Order(list(choice(labels, number_of_products, p=weights)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PickWave:\n",
    "    \"\"\"\n",
    "    This class represents a run through the warehouse.\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, products, containers):\n",
    "        # number of containers\n",
    "        self.n_containers = containers\n",
    "        # a dictionary that for each product contains how many times that's picked into each container\n",
    "        self.product_picks = dict(zip(products, [[0] * containers for n in products]))\n",
    "        # a list for each container, which tells which products are in that container\n",
    "        self.products_in_containers = [[] for n in range(containers)]\n",
    "        # list of packages, as (container, order) tuples\n",
    "        self.packages = []\n",
    "    \n",
    "    def add_order(self, order, container):\n",
    "        \"\"\"\n",
    "        Adds an order to the pick wave.\n",
    "        \n",
    "        Container is the container to which this order will be picked into.\n",
    "        \"\"\"\n",
    "        if container < 0 or container >= self.n_containers:\n",
    "            raise Exception(\"No such container\")\n",
    "        \n",
    "        for product in order.products():\n",
    "            self.product_picks[product][container] += 1\n",
    "        \n",
    "        self.products_in_containers[container].extend(order.products())\n",
    "        \n",
    "        self.packages.append((container, order))\n",
    "    \n",
    "    def compute_picking_cost(self, product_to_pick_face):\n",
    "        # single pick face\n",
    "        n_fixed = 1\n",
    "        \n",
    "        # compute number of up or down steps, note they come in pairs\n",
    "        n_move = 2 * max([product_to_pick_face[product].location()[1] for product, picks in self.product_picks.items() if count_nonzero(picks) > 0])\n",
    "        \n",
    "        # move across once\n",
    "        n_across = 1\n",
    "        \n",
    "        # this is basically the same but needs number of containers\n",
    "        n_picking = [[self.n_containers] + pick for product, pick in self.product_picks.items() if count_nonzero(pick) > 0]\n",
    "        \n",
    "        # computer sorting operations\n",
    "        q = self.n_containers\n",
    "        r = len(self.packages)\n",
    "        n_sorting_1 = [q, r]\n",
    "        for container in range(self.n_containers):\n",
    "            n_sorting_1 += [len(package[1].products()) if package[0] == container else  0 for package in self.packages]\n",
    "        \n",
    "        return PickingCost(n_fixed, n_move, n_across, n_picking, [n_sorting_1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class OptPickWave:\n",
    "    \"\"\"\n",
    "    This is slightly cleverer version of the above, for optimisation, but not so nice to read, probably.\n",
    "    \n",
    "    Also includes other bits and pieces to make local optimisation algorithms work easier.\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, products):\n",
    "        # each element of this list is a container and contains a list of orders\n",
    "        self.container_orders = []\n",
    "        self._cost = 0\n",
    "        self._cost_stale = False\n",
    "        self.products = products\n",
    "    \n",
    "    def add_order_to_new_container(self, order):\n",
    "        self._cost_stale = True\n",
    "        self.container_orders.append([order])\n",
    "\n",
    "    def add_order(self, order, container):\n",
    "        self._cost_stale = True\n",
    "        if container < 0 or container >= len(self.container_orders):\n",
    "            raise Exception(\"Invalid container\")\n",
    "        self.container_orders[container].append(order)\n",
    "\n",
    "    def remove_order(self, order):\n",
    "        self._cost_stale = True\n",
    "        self.container_orders = [[other_order for other_order in orders if other_order != order] for orders in self.container_orders]\n",
    "        self.container_orders = [orders for orders in self.container_orders if len(orders) > 0]\n",
    "    \n",
    "    def move_order(self, order, container):\n",
    "        current_container = -1\n",
    "        for container, orders in enumerate(self.container_orders):\n",
    "            if order in orders:\n",
    "                current_container = container\n",
    "                break\n",
    "\n",
    "        if current_container == -1:\n",
    "            raise ValueError(\"Order not found\")\n",
    "        \n",
    "        if current_container != container:\n",
    "            self._cost_stale = True\n",
    "            remove_order(order)\n",
    "            self.container_orders[container].append(order)\n",
    "    \n",
    "    def compute_picking_cost(self, product_to_pick_face):\n",
    "        if self._cost_stale:\n",
    "            # number of containers\n",
    "            self.n_containers = len(self.container_orders)\n",
    "            # a dictionary that for each product contains how many times that's picked into each container\n",
    "            self.product_picks = dict(zip(self.products, [[0] * self.n_containers for n in self.products]))\n",
    "            # a list for each container, which tells which products are in that container\n",
    "            self.products_in_containers = [[] for n in range(self.n_containers)]\n",
    "            # list of packages, as (container, order) tuples\n",
    "            self.packages = []\n",
    "\n",
    "            for container, orders in enumerate(self.container_orders):\n",
    "                for order in orders:\n",
    "                    for product in order.products():\n",
    "                        self.product_picks[product][container] += 1\n",
    "                    self.products_in_containers[container].extend(order.products())\n",
    "                    self.packages.append((container, order))\n",
    "\n",
    "            # single pick face\n",
    "            n_fixed = 1\n",
    "\n",
    "            # compute number of up or down steps, note they come in pairs\n",
    "            n_move = 2 * max([product_to_pick_face[product].location()[1] for product, picks in self.product_picks.items() if count_nonzero(picks) > 0])\n",
    "\n",
    "            # move across once\n",
    "            n_across = 1\n",
    "\n",
    "            # this is basically the same but needs number of containers\n",
    "            n_picking = [[self.n_containers] + pick for product, pick in self.product_picks.items() if count_nonzero(pick) > 0]\n",
    "\n",
    "            # computer sorting operations\n",
    "            q = self.n_containers\n",
    "            r = len(self.packages)\n",
    "            n_sorting_1 = [q, r]\n",
    "            for container in range(self.n_containers):\n",
    "                n_sorting_1 += [len(package[1].products()) if package[0] == container else  0 for package in self.packages]\n",
    "\n",
    "            self._cost = PickingCost(n_fixed, n_move, n_across, n_picking, [n_sorting_1])\n",
    "            self._cost_stale = False\n",
    "        \n",
    "        return self._cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_singleton_waves_opt(batch, products):\n",
    "    pick_waves = []\n",
    "    \n",
    "    for order in batch:\n",
    "        pick_wave = OptPickWave(products)\n",
    "        pick_wave.add_order_to_new_container(order)\n",
    "        pick_waves.append(pick_wave)\n",
    "    \n",
    "    return pick_waves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_singleton_waves(batch, products):\n",
    "    \"\"\"\n",
    "    This function generates pick waves where each order is just picked by itself\n",
    "    \"\"\"\n",
    "    pick_waves = []\n",
    "    \n",
    "    for order in batch:\n",
    "        pick_wave = PickWave(products, 1)\n",
    "        pick_wave.add_order(order, 0)\n",
    "        pick_waves.append(pick_wave)\n",
    "    \n",
    "    return pick_waves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_multi_order_waves(batch, products):\n",
    "    \"\"\"\n",
    "    Pick each order into its own container\n",
    "    \"\"\"\n",
    "    pick_waves = []\n",
    "    \n",
    "    pick_wave = PickWave(products, len(batch))\n",
    "\n",
    "    for container, order in enumerate(batch):\n",
    "        pick_wave.add_order(order, container)\n",
    "    \n",
    "    pick_waves.append(pick_wave)\n",
    "    \n",
    "    return pick_waves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_batch_order_waves(batch, products):\n",
    "    \"\"\"\n",
    "    Pick each order into its own container\n",
    "    \"\"\"\n",
    "    pick_waves = []\n",
    "    \n",
    "    pick_wave = PickWave(products, 1)\n",
    "\n",
    "    for order in batch:\n",
    "        pick_wave.add_order(order, 0)\n",
    "    \n",
    "    pick_waves.append(pick_wave)\n",
    "    \n",
    "    return pick_waves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_multi_batch_order_waves(batch, containers, products):\n",
    "    \"\"\"\n",
    "    Pick each order into its own container\n",
    "    \"\"\"\n",
    "    pick_waves = []\n",
    "    \n",
    "    pick_wave = PickWave(products, containers)\n",
    "\n",
    "    for container, order in enumerate(batch):\n",
    "        pick_wave.add_order(order, container % containers)\n",
    "    \n",
    "    pick_waves.append(pick_wave)\n",
    "    \n",
    "    return pick_waves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# number of pick faces\n",
    "no_pick_faces = 100\n",
    "\n",
    "# zipf's law shape parameter\n",
    "zipf_shape = 1.07"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# the pick face labels\n",
    "pick_faces = [PickFace(n) for n in range(no_pick_faces)]\n",
    "\n",
    "# there's the same number of products as pick faces\n",
    "products = [Product(n) for n in range(no_pick_faces)]\n",
    "\n",
    "product_probabilities = generate_product_probabilities_pareto(zipf_shape, products)\n",
    "product_to_pick_face, pick_face_to_product = assign_products_to_pick_faces_pareto(products, pick_faces, product_probabilities)\n",
    "\n",
    "pick_faces, products, product_probabilities, product_to_pick_face, pick_face_to_product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate a batch of orders\n",
    "batch = [generate_new_order(poisson(25).rvs(), product_probabilities) for n in range(60)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Picking orders individually\n",
    "singleton_waves = generate_singleton_waves_opt(batch, products)\n",
    "total = PickingCost()\n",
    "for wave in singleton_waves:\n",
    "    total += wave.compute_picking_cost(product_to_pick_face)\n",
    "total_time(total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Picking orders individually\n",
    "singleton_waves = generate_singleton_waves(batch, products)\n",
    "total = PickingCost()\n",
    "for wave in singleton_waves:\n",
    "    total += wave.compute_picking_cost(product_to_pick_face)\n",
    "total_time(total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Picking all orders at the same time\n",
    "multi_order_waves = generate_multi_order_waves(batch, products)\n",
    "total = PickingCost()\n",
    "for wave in multi_order_waves:\n",
    "    total += wave.compute_picking_cost(product_to_pick_face)\n",
    "total_time(total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Picking all orders at the same time but sort at end\n",
    "multi_order_waves = generate_batch_order_waves(batch, products)\n",
    "total = PickingCost()\n",
    "for wave in multi_order_waves:\n",
    "    total += wave.compute_picking_cost(product_to_pick_face)\n",
    "total_time(total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Picking all orders at the same time into at most 5 containers but sort at end\n",
    "multi_order_waves = generate_multi_batch_order_waves(batch, 5, products)\n",
    "total = PickingCost()\n",
    "for wave in multi_order_waves:\n",
    "    total += wave.compute_picking_cost(product_to_pick_face)\n",
    "total_time(total)"
   ]
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}