docs/notebooks/input_distributions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "07456c75-42fa-4e85-b837-8a4299999d21",
   "metadata": {},
   "source": [
    "# Input Distributions\n",
    "\n",
    "In this chapter, the default input distributions are presented.\n",
    "These are automatically seeded when a new database is created.\n",
    "They can be simply overwritten with your use-case specific assumptions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed1eb6b8-1b8e-4257-bc97-c7bcd36eefa6",
   "metadata": {},
   "source": [
    "First, the required modules are imported."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35fa184c-5fce-4ae0-a242-687f9fc48d13",
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "import itertools\n",
    "\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from IPython.display import Markdown\n",
    "\n",
    "import conflowgen"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad5437f7-55ce-4221-b233-aed64898eb6e",
   "metadata": {},
   "source": [
    "Set a style for matplotlib."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8839c6b-1c75-4e8c-9556-6c7035cb7978",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.style.use(\"seaborn-v0_8-colorblind\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08ce369e-319f-4e5a-aaa7-fd38a313d7e4",
   "metadata": {},
   "source": [
    "Next, an\n",
    "[in-memory SQLite database](https://www.sqlite.org/inmemorydb.html)\n",
    "is opened.\n",
    "This is a fresh database without any content.\n",
    "While creating the database, it is automatically seeded with the default values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5fe2e34-0e9d-4bee-a888-bb6b81f67e08",
   "metadata": {},
   "outputs": [],
   "source": [
    "database_chooser = conflowgen.DatabaseChooser()\n",
    "database_chooser.create_new_sqlite_database(\":memory:\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85d86600-0b70-4a09-beba-2f3a6ecc915f",
   "metadata": {},
   "source": [
    "If that was too fast, you can switch on logging to have a look behind the scenes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "193b9742-ae07-4e93-8595-f8c1c6d5d11e",
   "metadata": {},
   "outputs": [],
   "source": [
    "conflowgen.setup_logger(\n",
    "    logging_directory=\"./data/logger\",  # use data subdirectory relative to Jupyter Notebook\n",
    "    format_string=\"%(message)s\",  # only show log messages, no timestamps etc.\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82258968-a3df-4e8d-8940-10e6772a95c8",
   "metadata": {},
   "source": [
    "Now you can see the same output like in the demo scripts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "63c7b5bb-8e54-48d5-bb13-c0adc28df33f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "database_chooser.create_new_sqlite_database(\":memory:\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89b826ce-df9c-4782-bd61-7265bc1a679b",
   "metadata": {},
   "source": [
    "Once the database is set up, we can use the different distribution managers to have a look at the distributions which were automatically seeded."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97040c59-fcf7-4e5d-bb36-9ae052e7ec63",
   "metadata": {},
   "source": [
    "## Container Length Distribution\n",
    "\n",
    "For each container length, the container length distribution determines its frequency among the containers.\n",
    "The numbers have been determined by the following reasoning:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "b1f7e7ba-e454-40bb-844b-5a4d3e37fd28",
   "metadata": {
    "raw_mimetype": "text/restructuredtext",
    "tags": []
   },
   "source": [
    ".. note::\n",
    "    .. autodata:: conflowgen.domain_models.distribution_seeders.container_length_distribution_seeder.DEFAULT_CONTAINER_LENGTH_FREQUENCIES"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "799e4da9-e531-4fee-8285-1c3c5bc26e52",
   "metadata": {},
   "source": [
    "The container length distribution is obtained with the following lines of code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68469615-7d7f-4f30-a410-66faf5c7d05b",
   "metadata": {},
   "outputs": [],
   "source": [
    "container_length_manager = conflowgen.ContainerLengthDistributionManager()\n",
    "\n",
    "length_distribution = container_length_manager.get_container_length_distribution()\n",
    "\n",
    "length_distribution"
   ]
  },
  {
   "cell_type": "raw",
   "id": "f9f1e548",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    "We can see that all the keys are enum values of the enum\n",
    ":class:`.ContainerLength`.\n",
    "For a nicer visualization, we can circumvent that by converting the enum values into strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1885b94a-fa39-4d57-b2b4-050c39b6ac27",
   "metadata": {},
   "outputs": [],
   "source": [
    "length_distribution_with_key_as_str = {\n",
    "    str(key): value for (key, value) in length_distribution.items()\n",
    "}\n",
    "\n",
    "length_distribution_with_key_as_str"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8349e97-9e68-48e4-80c3-7e90d0c076f0",
   "metadata": {},
   "source": [
    "Now we can also plot the same information as a pie chart."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15913868-8008-464a-a65d-3d6ac8a1e843",
   "metadata": {},
   "outputs": [],
   "source": [
    "length_distribution_with_key_as_str_without_zeros = {\n",
    "    key: value\n",
    "    for (key, value) in length_distribution_with_key_as_str.items()\n",
    "    if value > 0\n",
    "}\n",
    "\n",
    "plt.title(\"Frequency of container lengths\")\n",
    "plt.pie(\n",
    "    list(length_distribution_with_key_as_str_without_zeros.values()),\n",
    "    labels=list(length_distribution_with_key_as_str_without_zeros.keys()),\n",
    "    autopct=\"%1.0f%%\",\n",
    ")\n",
    "plt.gcf().set_size_inches(5, 5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "raw",
   "id": "ca64224b",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    "More information on setting and getting the distribution can be found at\n",
    ":class:`.ContainerLengthDistributionManager`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90eb47a7",
   "metadata": {},
   "source": [
    "## Container Weight Distribution\n",
    "\n",
    "The container weight of each container is drawn from a distribution.\n",
    "For each container length, a different weight distribution can be provided."
   ]
  },
  {
   "cell_type": "raw",
   "id": "f0b638cd",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    ".. note::\n",
    "    .. autodata:: conflowgen.domain_models.distribution_seeders.container_weight_distribution_seeder.DEFAULT_CONTAINER_WEIGHT_DISTRIBUTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77e7df00",
   "metadata": {},
   "outputs": [],
   "source": [
    "container_weight_distribution_manager = conflowgen.ContainerWeightDistributionManager()\n",
    "\n",
    "weight_distribution = (\n",
    "    container_weight_distribution_manager.get_container_weight_distribution()\n",
    ")\n",
    "\n",
    "weight_distribution"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "454adce9-3a93-4157-8079-9bdff31015fd",
   "metadata": {},
   "source": [
    "By visualizing the previous distribution with matplotlib, it is easier to make sense of it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a67494b4-fd1c-4bd3-8689-6f012453eaa7",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(nrows=4, sharex=True, sharey=True, figsize=(5, 12))\n",
    "\n",
    "for ax, container_length in zip(axes, list(conflowgen.ContainerLength)):\n",
    "    x, y = zip(*weight_distribution[container_length].items())\n",
    "    ax.title.set_text(str(container_length))\n",
    "    ax.bar(x, [i * 100 for i in y])\n",
    "    ax.set_ylabel(\"Share (in percentage)\")\n",
    "\n",
    "plt.xlabel(\"Weight (in metric tonnes)\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6118fc5",
   "metadata": {},
   "source": [
    "The container weight distributions can only be overwritten all at once.\n",
    "The values are automatically normalized by default."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59e56289",
   "metadata": {},
   "outputs": [],
   "source": [
    "container_weight_distribution_manager.set_container_weight_distribution(\n",
    "    {\n",
    "        conflowgen.ContainerLength.twenty_feet: {10: 20, 20: 50, 30: 30},\n",
    "        conflowgen.ContainerLength.forty_feet: {10: 15, 20: 50, 30: 35},\n",
    "        conflowgen.ContainerLength.forty_five_feet: {10: 10, 20: 5, 30: 85},\n",
    "        conflowgen.ContainerLength.other: {10: 1, 20: 1, 30: 1},\n",
    "    }\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f37a2998",
   "metadata": {},
   "source": [
    "From now on, ConFlowGen uses the new container weight distribution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bccbdebf",
   "metadata": {},
   "outputs": [],
   "source": [
    "container_weight_distribution_manager.get_container_weight_distribution()"
   ]
  },
  {
   "cell_type": "raw",
   "id": "43ed1407",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    "More information on setting and getting the distribution can be found at\n",
    ":class:`.ContainerWeightDistributionManager`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "239fbbe0-a348-44c9-883e-728364f08603",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Container Storage Requirement Distribution"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8ebea55-6032-4558-b9ab-ea1de8b81596",
   "metadata": {},
   "source": [
    "The storage requirement of each container is drawn from a distribution. For each container length, a different storage requirement distribution can be provided."
   ]
  },
  {
   "cell_type": "raw",
   "id": "e8ae6af3-2bd2-4555-b520-39733c5884bb",
   "metadata": {
    "raw_mimetype": "text/restructuredtext",
    "tags": []
   },
   "source": [
    ".. note::\n",
    "    .. autodata:: conflowgen.domain_models.distribution_seeders.storage_requirement_distribution_seeder.DEFAULT_STORAGE_REQUIREMENT_DISTRIBUTION"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b180a0b5-3179-44fe-9457-a4fd9b72cbb1",
   "metadata": {},
   "source": [
    "The container storage requirement distribution is obtained with the following lines of code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16db754c-3e83-4fdd-b662-753b01a21384",
   "metadata": {},
   "outputs": [],
   "source": [
    "storage_manager = conflowgen.StorageRequirementDistributionManager()\n",
    "\n",
    "storage_requirement_distribution = (\n",
    "    storage_manager.get_storage_requirement_distribution()\n",
    ")\n",
    "\n",
    "storage_requirement_distribution"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c3569ac-f1e6-4236-8261-9f095b1f411e",
   "metadata": {},
   "source": [
    "This can be visualized e.g. with the help of one pie chart for each container length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf0fe96c-1b6a-4a9d-b693-f08c59e06ed4",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(8, 8))\n",
    "\n",
    "axes = list(itertools.chain(*axes))\n",
    "\n",
    "for ax, container_length in zip(axes, list(conflowgen.ContainerLength)):\n",
    "    keys, values = zip(*storage_requirement_distribution[container_length].items())\n",
    "    labels = list(map(lambda x: str(x).replace(\"_\", \"\\n\"), keys))\n",
    "    ax.title.set_text(str(container_length))\n",
    "    ax.pie(\n",
    "        [i * 100 for i in values],\n",
    "        labels=labels,\n",
    "        autopct=\"%1.0f%%\",\n",
    "        pctdistance=0.7,\n",
    "        labeldistance=1.18,\n",
    "        startangle=45,\n",
    "    )\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fc00054-d072-4a8e-b97d-e2f0060a925a",
   "metadata": {},
   "source": [
    "The container storage distributions can only be overwritten all at once. The values are automatically normalized by default."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f73adacc-af40-4d37-9191-78b3e8e5f7aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "storage_manager.set_storage_requirement_distribution(\n",
    "    {\n",
    "        conflowgen.ContainerLength.twenty_feet: {\n",
    "            conflowgen.StorageRequirement.empty: 0.3,\n",
    "            conflowgen.StorageRequirement.standard: 0.5,\n",
    "            conflowgen.StorageRequirement.reefer: 0.1,\n",
    "            conflowgen.StorageRequirement.dangerous_goods: 0.1,\n",
    "        },\n",
    "        conflowgen.ContainerLength.forty_feet: {\n",
    "            conflowgen.StorageRequirement.empty: 0.2,\n",
    "            conflowgen.StorageRequirement.standard: 0.45,\n",
    "            conflowgen.StorageRequirement.reefer: 0.2,\n",
    "            conflowgen.StorageRequirement.dangerous_goods: 0.15,\n",
    "        },\n",
    "        conflowgen.ContainerLength.forty_five_feet: {\n",
    "            conflowgen.StorageRequirement.empty: 0.2,\n",
    "            conflowgen.StorageRequirement.standard: 0.7,\n",
    "            conflowgen.StorageRequirement.reefer: 0.05,\n",
    "            conflowgen.StorageRequirement.dangerous_goods: 0.05,\n",
    "        },\n",
    "        conflowgen.ContainerLength.other: {\n",
    "            conflowgen.StorageRequirement.empty: 0.25,\n",
    "            conflowgen.StorageRequirement.standard: 0.4,\n",
    "            conflowgen.StorageRequirement.reefer: 0.25,\n",
    "            conflowgen.StorageRequirement.dangerous_goods: 0.1,\n",
    "        },\n",
    "    }\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36db8d2d-c1ff-42e7-89d9-1b38c91091a2",
   "metadata": {},
   "source": [
    "From now on, ConFlowGen uses the new distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3e1f7a6-cb7d-4887-ae63-4827df095432",
   "metadata": {},
   "outputs": [],
   "source": [
    "storage_manager.get_storage_requirement_distribution()"
   ]
  },
  {
   "cell_type": "raw",
   "id": "63203b05-ea58-4b68-82d9-401bd2ce2ca0",
   "metadata": {
    "raw_mimetype": "text/restructuredtext",
    "tags": []
   },
   "source": [
    "More information on setting and getting the distribution can be found at\n",
    ":class:`.StorageRequirementDistributionManager`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8b2697e-6d8e-40ae-a1c5-d5d34a015c57",
   "metadata": {},
   "source": [
    "## Mode of Transport Distribution"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52d24a91-1039-41a1-84b6-ebce0d867264",
   "metadata": {},
   "source": [
    "The mode of transport for each container is drawn from a distribution."
   ]
  },
  {
   "cell_type": "raw",
   "id": "55748574-56dc-4c4d-a758-d68b6d82c53d",
   "metadata": {
    "raw_mimetype": "text/restructuredtext",
    "tags": []
   },
   "source": [
    ".. note::\n",
    "    .. autodata:: conflowgen.domain_models.distribution_seeders.mode_of_transport_distribution_seeder.DEFAULT_MODE_OF_TRANSPORT_DISTRIBUTION"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "899007bc-199a-49da-9d77-9a76770b8a29",
   "metadata": {},
   "source": [
    "The mode of transport distribution is obtained by the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55f3e707-4cc4-4766-b867-c632a955287d",
   "metadata": {},
   "outputs": [],
   "source": [
    "mode_of_transport = conflowgen.ModeOfTransportDistributionManager()\n",
    "\n",
    "mode_of_transport_distribution = mode_of_transport.get_mode_of_transport_distribution()\n",
    "\n",
    "mode_of_transport_distribution"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1448b71f-e4b2-4081-a17d-a4e78253c6dc",
   "metadata": {},
   "source": [
    "The mode of transport distributions can only be overwritten all at once. The values are automatically normalized by default."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "345eaece-086a-4a57-80e2-64d98dd16972",
   "metadata": {},
   "outputs": [],
   "source": [
    "mode_of_transport.set_mode_of_transport_distribution(\n",
    "    {\n",
    "        conflowgen.ModeOfTransport.feeder: {\n",
    "            conflowgen.ModeOfTransport.train: 0.2,\n",
    "            conflowgen.ModeOfTransport.truck: 0.1,\n",
    "            conflowgen.ModeOfTransport.barge: 0.1,\n",
    "            conflowgen.ModeOfTransport.feeder: 0.4,\n",
    "            conflowgen.ModeOfTransport.deep_sea_vessel: 0.2,\n",
    "        },\n",
    "        conflowgen.ModeOfTransport.truck: {\n",
    "            conflowgen.ModeOfTransport.train: 0.15,\n",
    "            conflowgen.ModeOfTransport.truck: 0.45,\n",
    "            conflowgen.ModeOfTransport.barge: 0.1,\n",
    "            conflowgen.ModeOfTransport.feeder: 0.2,\n",
    "            conflowgen.ModeOfTransport.deep_sea_vessel: 0.1,\n",
    "        },\n",
    "        conflowgen.ModeOfTransport.barge: {\n",
    "            conflowgen.ModeOfTransport.train: 0.2,\n",
    "            conflowgen.ModeOfTransport.truck: 0.15,\n",
    "            conflowgen.ModeOfTransport.barge: 0.25,\n",
    "            conflowgen.ModeOfTransport.feeder: 0.1,\n",
    "            conflowgen.ModeOfTransport.deep_sea_vessel: 0.3,\n",
    "        },\n",
    "        conflowgen.ModeOfTransport.deep_sea_vessel: {\n",
    "            conflowgen.ModeOfTransport.train: 0.25,\n",
    "            conflowgen.ModeOfTransport.truck: 0.1,\n",
    "            conflowgen.ModeOfTransport.barge: 0.2,\n",
    "            conflowgen.ModeOfTransport.feeder: 0.15,\n",
    "            conflowgen.ModeOfTransport.deep_sea_vessel: 0.3,\n",
    "        },\n",
    "        conflowgen.ModeOfTransport.train: {\n",
    "            conflowgen.ModeOfTransport.train: 0.3,\n",
    "            conflowgen.ModeOfTransport.truck: 0.1,\n",
    "            conflowgen.ModeOfTransport.barge: 0.15,\n",
    "            conflowgen.ModeOfTransport.feeder: 0.2,\n",
    "            conflowgen.ModeOfTransport.deep_sea_vessel: 0.25,\n",
    "        },\n",
    "    }\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1f753ef-8791-43c2-b3a2-3b8f46d1f11e",
   "metadata": {},
   "source": [
    "From now on, ConFlowGen uses the new distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01fb1f7a-0db5-4143-abe4-56ff53e8c476",
   "metadata": {},
   "outputs": [],
   "source": [
    "mode_of_transport.get_mode_of_transport_distribution()"
   ]
  },
  {
   "cell_type": "raw",
   "id": "f0548dd3-3840-4488-9c08-3755ce3d879b",
   "metadata": {
    "raw_mimetype": "text/restructuredtext",
    "tags": []
   },
   "source": [
    "More information on setting and getting the distribution can be found at\n",
    ":class:`.ModeOfTransportDistributionManager`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d6c26f9-89a9-4053-9151-e7361814600d",
   "metadata": {},
   "source": [
    "## Truck Arrival Distribution Manager"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ece24a00-d77d-432d-aba0-4970af7b2218",
   "metadata": {},
   "source": [
    "Each truck arrival time is drawn from a distribution."
   ]
  },
  {
   "cell_type": "raw",
   "id": "67d1fc6a-c4d4-4b49-a9ca-efff85e3472e",
   "metadata": {
    "raw_mimetype": "text/restructuredtext",
    "tags": []
   },
   "source": [
    ".. note::\n",
    "    .. autodata:: conflowgen.domain_models.distribution_seeders.truck_arrival_distribution_seeder.DEFAULT_TRUCK_ARRIVAL_DISTRIBUTION_WITH_NO_ARRIVAL_MANAGEMENT\n",
    "        :no-value:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0047438-9943-4e2c-8436-883b4c2f0760",
   "metadata": {},
   "source": [
    "Truck arrival distribution is obtained by the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a9847206-537e-42c3-a3ee-393bea249076",
   "metadata": {},
   "outputs": [],
   "source": [
    "truck_arrival_distribution_manager = conflowgen.TruckArrivalDistributionManager()\n",
    "\n",
    "truck_arrival_distribution = (\n",
    "    truck_arrival_distribution_manager.get_truck_arrival_distribution()\n",
    ")\n",
    "\n",
    "truck_arrival_distribution"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa0afa2d-d752-4398-add9-3f746c6bffd3",
   "metadata": {},
   "source": [
    "With a few lines of matplotlib code, the truck arrival pattern is visualized."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c6db712-f272-421f-aaf7-36a8bfbdf384",
   "metadata": {},
   "outputs": [],
   "source": [
    "hour_in_week, fraction = zip(*list(sorted(truck_arrival_distribution.items())))\n",
    "weekday_in_week = [x / 24 + 1 for x in hour_in_week]\n",
    "percentage = [x * 100 for x in fraction]\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(15, 3))\n",
    "plt.plot(weekday_in_week, percentage)\n",
    "plt.xlim([1, 7])  # plot from Monday to Sunday\n",
    "ax.xaxis.grid(True, which=\"minor\", color=\"lightgray\")  # every hour\n",
    "ax.xaxis.grid(True, which=\"major\", color=\"k\")  # every day\n",
    "ax.xaxis.set_minor_locator(matplotlib.ticker.MultipleLocator(1 / 24))  # every hour\n",
    "\n",
    "plt.title(\"Truck arrival distribution\")\n",
    "ax.set_xticks([i for i in range(1, 8)])  # every day\n",
    "ax.set_xticklabels(\n",
    "    [\"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\", \"Sunday\"]\n",
    ")\n",
    "plt.xlabel(\"Week day\")\n",
    "plt.ylabel(\"Share (as percentage overall)\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3ef93ef-aa67-4c9d-a792-b280572dc8f9",
   "metadata": {},
   "source": [
    "A second default distribution exists.\n",
    "You need to provide the corresponding keyword when creating the new SQLite database to use it."
   ]
  },
  {
   "cell_type": "raw",
   "id": "8536606b-db27-43e3-9ee1-851f9b8c899d",
   "metadata": {
    "raw_mimetype": "text/restructuredtext",
    "tags": []
   },
   "source": [
    ".. note::\n",
    "    .. autodata:: conflowgen.domain_models.distribution_seeders.truck_arrival_distribution_seeder.DEFAULT_TRUCK_ARRIVAL_DISTRIBUTION_WITH_SLOT_BOOKING\n",
    "        :no-value:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4953ad5a-fbe2-4b60-9a90-4ad121cd1822",
   "metadata": {},
   "source": [
    "Thee pattern looks slightly different - the peaks during lunch time are smoothened."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6bc5a92-44ba-4b33-898a-fdcb390087b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "database_chooser.close_current_connection()\n",
    "\n",
    "database_chooser.create_new_sqlite_database(\":memory:\", assume_tas=True)\n",
    "\n",
    "truck_arrival_distribution = (\n",
    "    truck_arrival_distribution_manager.get_truck_arrival_distribution()\n",
    ")\n",
    "\n",
    "hour_in_week, fraction = zip(*list(sorted(truck_arrival_distribution.items())))\n",
    "weekday_in_week = [x / 24 + 1 for x in hour_in_week]\n",
    "percentage = [x * 100 for x in fraction]\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(15, 3))\n",
    "plt.plot(weekday_in_week, percentage)\n",
    "plt.xlim([1, 7])  # plot from Monday to Sunday\n",
    "ax.xaxis.grid(True, which=\"minor\", color=\"lightgray\")  # every hour\n",
    "ax.xaxis.grid(True, which=\"major\", color=\"k\")  # every day\n",
    "ax.xaxis.set_minor_locator(matplotlib.ticker.MultipleLocator(1 / 24))  # every hour\n",
    "\n",
    "plt.title(\"Truck arrival distribution\")\n",
    "ax.set_xticks([i for i in range(1, 8)])  # every day\n",
    "ax.set_xticklabels(\n",
    "    [\"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\", \"Sunday\"]\n",
    ")\n",
    "plt.xlabel(\"Week day\")\n",
    "plt.ylabel(\"Share (as percentage overall)\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "591bc88f-9ee7-4a57-ac32-974c26bbc877",
   "metadata": {},
   "source": [
    "The truck arrival distributions can only be overwritten for the whole week at once.\n",
    "Each key represents the hour in the week and each value represents the probability of a truck to arrive between that hour and the start of the next time slot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a033ef9-77bc-4acb-b82b-13a8d89c9dc5",
   "metadata": {},
   "outputs": [],
   "source": [
    "truck_arrival_distribution_manager.set_truck_arrival_distribution(\n",
    "    {\n",
    "        0: 0.006944444444444444,\n",
    "        1: 0.006944444444444444,\n",
    "        2: 0.006944444444444444,\n",
    "        3: 0.006944444444444444,\n",
    "        4: 0.006944444444444444,\n",
    "        5: 0.006944444444444444,\n",
    "        6: 0.006944444444444444,\n",
    "        7: 0.006944444444444444,\n",
    "        8: 0.006944444444444444,\n",
    "        9: 0.006944444444444444,\n",
    "        10: 0.006944444444444444,\n",
    "        11: 0.006944444444444444,\n",
    "        12: 0.006944444444444444,\n",
    "        13: 0.006944444444444444,\n",
    "        14: 0.006944444444444444,\n",
    "        15: 0.006944444444444444,\n",
    "        16: 0.006944444444444444,\n",
    "        17: 0.006944444444444444,\n",
    "        18: 0.006944444444444444,\n",
    "        19: 0.006944444444444444,\n",
    "        20: 0.006944444444444444,\n",
    "        21: 0.006944444444444444,\n",
    "        22: 0.006944444444444444,\n",
    "        23: 0.006944444444444444,\n",
    "        24: 0.006944444444444444,\n",
    "        25: 0.006944444444444444,\n",
    "        26: 0.006944444444444444,\n",
    "        27: 0.006944444444444444,\n",
    "        28: 0.006944444444444444,\n",
    "        29: 0.006944444444444444,\n",
    "        30: 0.006944444444444444,\n",
    "        31: 0.006944444444444444,\n",
    "        32: 0.006944444444444444,\n",
    "        33: 0.006944444444444444,\n",
    "        34: 0.006944444444444444,\n",
    "        35: 0.006944444444444444,\n",
    "        36: 0.006944444444444444,\n",
    "        37: 0.006944444444444444,\n",
    "        38: 0.006944444444444444,\n",
    "        39: 0.006944444444444444,\n",
    "        40: 0.006944444444444444,\n",
    "        41: 0.006944444444444444,\n",
    "        42: 0.006944444444444444,\n",
    "        43: 0.006944444444444444,\n",
    "        44: 0.006944444444444444,\n",
    "        45: 0.006944444444444444,\n",
    "        46: 0.006944444444444444,\n",
    "        47: 0.006944444444444444,\n",
    "        48: 0.006944444444444444,\n",
    "        49: 0.006944444444444444,\n",
    "        50: 0.006944444444444444,\n",
    "        51: 0.006944444444444444,\n",
    "        52: 0.006944444444444444,\n",
    "        53: 0.006944444444444444,\n",
    "        54: 0.006944444444444444,\n",
    "        55: 0.006944444444444444,\n",
    "        56: 0.006944444444444444,\n",
    "        57: 0.006944444444444444,\n",
    "        58: 0.006944444444444444,\n",
    "        59: 0.006944444444444444,\n",
    "        60: 0.006944444444444444,\n",
    "        61: 0.006944444444444444,\n",
    "        62: 0.006944444444444444,\n",
    "        63: 0.006944444444444444,\n",
    "        64: 0.006944444444444444,\n",
    "        65: 0.006944444444444444,\n",
    "        66: 0.006944444444444444,\n",
    "        67: 0.006944444444444444,\n",
    "        68: 0.006944444444444444,\n",
    "        69: 0.006944444444444444,\n",
    "        70: 0.006944444444444444,\n",
    "        71: 0.006944444444444444,\n",
    "        72: 0.006944444444444444,\n",
    "        73: 0.006944444444444444,\n",
    "        74: 0.006944444444444444,\n",
    "        75: 0.006944444444444444,\n",
    "        76: 0.006944444444444444,\n",
    "        77: 0.006944444444444444,\n",
    "        78: 0.006944444444444444,\n",
    "        79: 0.006944444444444444,\n",
    "        80: 0.006944444444444444,\n",
    "        81: 0.006944444444444444,\n",
    "        82: 0.006944444444444444,\n",
    "        83: 0.006944444444444444,\n",
    "        84: 0.006944444444444444,\n",
    "        85: 0.006944444444444444,\n",
    "        86: 0.006944444444444444,\n",
    "        87: 0.006944444444444444,\n",
    "        88: 0.006944444444444444,\n",
    "        89: 0.006944444444444444,\n",
    "        90: 0.006944444444444444,\n",
    "        91: 0.006944444444444444,\n",
    "        92: 0.006944444444444444,\n",
    "        93: 0.006944444444444444,\n",
    "        94: 0.006944444444444444,\n",
    "        95: 0.006944444444444444,\n",
    "        96: 0.006944444444444444,\n",
    "        97: 0.006944444444444444,\n",
    "        98: 0.006944444444444444,\n",
    "        99: 0.006944444444444444,\n",
    "        100: 0.006944444444444444,\n",
    "        101: 0.006944444444444444,\n",
    "        102: 0.006944444444444444,\n",
    "        103: 0.006944444444444444,\n",
    "        104: 0.006944444444444444,\n",
    "        105: 0.006944444444444444,\n",
    "        106: 0.006944444444444444,\n",
    "        107: 0.006944444444444444,\n",
    "        108: 0.006944444444444444,\n",
    "        109: 0.006944444444444444,\n",
    "        110: 0.006944444444444444,\n",
    "        111: 0.006944444444444444,\n",
    "        112: 0.006944444444444444,\n",
    "        113: 0.006944444444444444,\n",
    "        114: 0.006944444444444444,\n",
    "        115: 0.006944444444444444,\n",
    "        116: 0.006944444444444444,\n",
    "        117: 0.006944444444444444,\n",
    "        118: 0.006944444444444444,\n",
    "        119: 0.006944444444444444,\n",
    "        120: 0.006944444444444444,\n",
    "        121: 0.006944444444444444,\n",
    "        122: 0.006944444444444444,\n",
    "        123: 0.006944444444444444,\n",
    "        124: 0.006944444444444444,\n",
    "        125: 0.006944444444444444,\n",
    "        126: 0.006944444444444444,\n",
    "        127: 0.006944444444444444,\n",
    "        128: 0.006944444444444444,\n",
    "        129: 0.006944444444444444,\n",
    "        130: 0.006944444444444444,\n",
    "        131: 0.006944444444444444,\n",
    "        132: 0.006944444444444444,\n",
    "        133: 0.006944444444444444,\n",
    "        134: 0.006944444444444444,\n",
    "        135: 0.006944444444444444,\n",
    "        136: 0.006944444444444444,\n",
    "        137: 0.006944444444444444,\n",
    "        138: 0.006944444444444444,\n",
    "        139: 0.006944444444444444,\n",
    "        140: 0.006944444444444444,\n",
    "        141: 0.006944444444444444,\n",
    "        142: 0.006944444444444444,\n",
    "        143: 0.006944444444444444,\n",
    "        144: 0.0,\n",
    "        145: 0.0,\n",
    "        146: 0.0,\n",
    "        147: 0.0,\n",
    "        148: 0.0,\n",
    "        149: 0.0,\n",
    "        150: 0.0,\n",
    "        151: 0.0,\n",
    "        152: 0.0,\n",
    "        153: 0.0,\n",
    "        154: 0.0,\n",
    "        155: 0.0,\n",
    "        156: 0.0,\n",
    "        157: 0.0,\n",
    "        158: 0.0,\n",
    "        159: 0.0,\n",
    "        160: 0.0,\n",
    "        161: 0.0,\n",
    "        162: 0.0,\n",
    "        163: 0.0,\n",
    "        164: 0.0,\n",
    "        165: 0.0,\n",
    "        166: 0.0,\n",
    "        167: 0.0,\n",
    "    }\n",
    ")"
   ]
  },
  {
   "cell_type": "raw",
   "id": "de696cf1-af84-44d6-8cbe-52f145005696",
   "metadata": {
    "raw_mimetype": "text/restructuredtext",
    "tags": []
   },
   "source": [
    "More information on setting and getting the distribution can be found at\n",
    ":class:`.TruckArrivalDistributionManager`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21bbffb9-5e2c-4ff8-9759-fdef6afad68e",
   "metadata": {},
   "source": [
    "## Container Dwell Time Distribution"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ddbfdcec-afcd-4542-8f65-991fd40484fc",
   "metadata": {},
   "source": [
    "The container dwell time distribution is used in two cases.\n",
    "First, the truck arrivals are made more likely whenever the container dwell time is close to its expected duration.\n",
    "Second, a vehicle that arrives at the terminal close to the expected container dwell time is more likely to pick up the container."
   ]
  },
  {
   "cell_type": "raw",
   "id": "58b165fd-7541-46fc-9e4e-e46cbdbbbd45",
   "metadata": {
    "raw_mimetype": "text/restructuredtext",
    "tags": []
   },
   "source": [
    ".. note::\n",
    "    .. autodata:: conflowgen.domain_models.distribution_seeders.container_dwell_time_distribution_seeder.DEFAULT_MINIMUM_DWELL_TIME_OF_IMPORT_CONTAINERS_IN_HOURS\n",
    "    .. autodata:: conflowgen.domain_models.distribution_seeders.container_dwell_time_distribution_seeder.DEFAULT_MINIMUM_DWELL_TIME_OF_EXPORT_CONTAINERS_IN_HOURS   \n",
    "    .. autodata:: conflowgen.domain_models.distribution_seeders.container_dwell_time_distribution_seeder.DEFAULT_MINIMUM_DWELL_TIME_OF_TRANSSHIPMENT_CONTAINERS_IN_HOURS\n",
    "    .. autodata:: conflowgen.domain_models.distribution_seeders.container_dwell_time_distribution_seeder.DEFAULT_AVERAGE_CONTAINER_DWELL_TIMES\n",
    "        :no-value:\n",
    "\n",
    "The default values can be overwritten with the help of :meth:`.ContainerDwellTimeDistributionManager.set_container_dwell_time_distribution`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9dffd81e-453a-4020-be20-5ae486b7f196",
   "metadata": {},
   "outputs": [],
   "source": [
    "container_dwell_time_distribution_manager = (\n",
    "    conflowgen.ContainerDwellTimeDistributionManager()\n",
    ")\n",
    "\n",
    "distributions = (\n",
    "    container_dwell_time_distribution_manager.get_container_dwell_time_distribution()\n",
    ")\n",
    "\n",
    "number_days_in_hours = 30 * 24\n",
    "x = np.linspace(0, number_days_in_hours, number_days_in_hours)\n",
    "locator = matplotlib.ticker.MultipleLocator(24)\n",
    "\n",
    "for storage_requirement in [\n",
    "    conflowgen.StorageRequirement.standard,\n",
    "    conflowgen.StorageRequirement.empty,\n",
    "]:\n",
    "\n",
    "    display(Markdown(f\"### {str(storage_requirement).capitalize()} container\"))\n",
    "\n",
    "    for inbound_vehicle in conflowgen.ModeOfTransport:\n",
    "\n",
    "        display(\n",
    "            Markdown(\n",
    "                f\"#### {str(inbound_vehicle).replace('_', ' ').capitalize()} delivering a \"\n",
    "                f\"{str(storage_requirement)} container\"\n",
    "            )\n",
    "        )\n",
    "\n",
    "        for outbound_vehicle in conflowgen.ModeOfTransport:\n",
    "\n",
    "            distribution = distributions[inbound_vehicle][outbound_vehicle][\n",
    "                storage_requirement\n",
    "            ]\n",
    "\n",
    "            plt.figure(figsize=(20, 5))\n",
    "            plt.axvline(distribution.minimum, color=\"dimgray\")\n",
    "            if distribution.maximum < number_days_in_hours:\n",
    "                plt.axvline(distribution.maximum, color=\"dimgray\")\n",
    "\n",
    "            x_in_range = x[\n",
    "                np.where((distribution.minimum < x) & (x < distribution.maximum))\n",
    "            ]\n",
    "\n",
    "            plt.plot(\n",
    "                x_in_range,\n",
    "                distribution.get_probabilities(x_in_range),\n",
    "                color=\"gray\",\n",
    "                lw=5,\n",
    "                alpha=0.6,\n",
    "            )\n",
    "            plt.xlabel(\"Container Dwell Time (h)\")\n",
    "            plt.gca().xaxis.set_major_locator(locator)\n",
    "            title = (\n",
    "                f'Container dwell time from {str(inbound_vehicle).replace(\"_\", \" \")} to {str(outbound_vehicle).replace(\"_\", \" \")} '\n",
    "                f'for a(n) {str(storage_requirement).replace(\"_\", \" \")} container\\n'\n",
    "                f\"avg={distribution.average:.1f}h={distribution.average / 24:.1f}d, var={distribution.variance:.1f}h², \"\n",
    "                f\"{distribution.minimum:.1f}h ≤ x ≤ {distribution.maximum:.1f}h or in other terms \"\n",
    "                f\"{distribution.minimum / 24:.1f}d ≤ x ≤ {distribution.maximum / 24:.1f}d\"\n",
    "            )\n",
    "            plt.title(title)\n",
    "            plt.show()"
   ]
  },
  {
   "cell_type": "raw",
   "id": "f3833069-6100-4a1a-bec5-d327b13c161f",
   "metadata": {
    "raw_mimetype": "text/restructuredtext",
    "tags": []
   },
   "source": [
    "More information on setting and getting the distribution can be found at\n",
    ":class:`.ContainerDwellTimeDistributionManager`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60afb2c6-a1c9-435a-92f7-b942bc072314",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Default Values\n",
    "\n",
    "In addition to the input distributions, also some default values are defined.\n",
    "All of them are currently some kind of minimum or maximum value.\n",
    "Thus, they directly influence other distributions."
   ]
  },
  {
   "cell_type": "raw",
   "id": "52264b18-e29c-4395-a899-4a391f1ad498",
   "metadata": {
    "raw_mimetype": "text/restructuredtext",
    "tags": []
   },
   "source": [
    ".. note::\n",
    "    .. autodata:: conflowgen.domain_models.seeders.DEFAULT_TRANSPORTATION_BUFFER\n",
    "\n",
    "The default values can be overwritten with the help of :meth:`.ContainerFlowGenerationManager.set_properties`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92aa124e-eebc-463d-9701-817c0613829c",
   "metadata": {},
   "source": [
    "All default values are optional.\n",
    "They are only overwritten if provided.\n",
    "The parameters `start_date` and `end_date` are obligatory though and no default values are provided."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e403f077-5f10-4527-9da4-7828504a5367",
   "metadata": {},
   "outputs": [],
   "source": [
    "container_flow_generation_manager = conflowgen.ContainerFlowGenerationManager()\n",
    "\n",
    "container_flow_generation_manager.set_properties(\n",
    "    start_date=datetime.date(2021, 1, 15),\n",
    "    end_date=datetime.date(2021, 1, 31),\n",
    "    transportation_buffer=0.4,\n",
    ")\n",
    "container_flow_generation_manager.get_properties()"
   ]
  },
  {
   "cell_type": "raw",
   "id": "81cc4641",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    "More information on setting and getting the values can be found at\n",
    ":class:`.ContainerFlowGenerationManager`."
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}